dart Namespace Reference

Namespaces
namespace	bin
namespace	compiler
namespace	elf
namespace	embedder
namespace	internal
namespace	kernel
namespace	mach_o
namespace	observatory
namespace	pe
namespace	snapshot_analyzer

Classes
class	Aborted
class	AbstractCode
class	AbstractInstanceDeserializationCluster
class	AbstractType
class	AbstractTypeKeyValueTrait
class	AcqRelAtomic
struct	AcqRelStorageTraits
class	AcquiredData
class	ActionNode
class	ActivationFrame
class	ActiveIsolateScope
class	AliasedSet
class	AliasIdentity
struct	ALIGN16
class	AllocAndGCTask
struct	AllocateArrayABI
struct	AllocateBoxABI
struct	AllocateClosureABI
class	AllocateClosureInstr
class	AllocateContextInstr
class	AllocateGlobsOfMemoryTask
struct	AllocateMintABI
struct	AllocateObjectABI
class	AllocateObjectInstr
struct	AllocateRecordABI
class	AllocateRecordInstr
struct	AllocateSmallRecordABI
class	AllocateSmallRecordInstr
struct	AllocateTypedDataArrayABI
class	AllocateTypedDataInstr
class	AllocateUninitializedContextInstr
class	AllocationFilter
class	AllocationFinger
class	AllocationInstr
class	AllocationSampleFilter
class	AllocationSinking
class	AllocOnlyStackZone
class	AllStatic
struct	AlternativeGeneration
class	AlternativeGenerationList
class	Analysis
class	AotCallSpecializer
class	Api
class	ApiError
class	ApiGrowableArray
class	ApiLocalScope
class	ApiMessageDeserializer
class	ApiMessageSerializer
class	ApiNativeScope
class	ApiObjectConverter
class	ApiState
class	ApiZone
class	ArgumentsDescriptor
struct	ArgumentsInfo
class	Array
class	ArrayAllocationInstr
class	ArrayDeserializationCluster
class	ArrayKeyValueTrait
class	ArrayMessageDeserializationCluster
class	ArrayMessageSerializationCluster
class	ArrayOfTuplesView
class	ArraySerializationCluster
struct	ArrayStorageTraits
class	AssemblerTest
class	Assert
class	AssertAssignableInstr
struct	AssertAssignableStubABI
struct	AssertBooleanABI
class	AssertBooleanInstr
class	AssertionNode
class	AssertNoDeoptIdsAllocatedScope
struct	AssertSubtypeABI
class	AssertSubtypeInstr
class	AsThreadStackResource
struct	AsyncExceptionHandlerStubABI
class	AtomicBitFieldContainer
class	AtomicBitFieldContainerBase
class	BackgroundCompilationQueue
class	BackgroundCompiler
class	BackgroundCompilerTask
class	BackgroundGCTask
class	BackReferenceNode
class	BacktrackStack
class	BackwardInstructionIterator
class	BareSwitchableCallPattern
class	Base
struct	base_ptr_type
class	BaseCStringIntMap
class	BaseCStringSet
class	BaseDeserializer
class	BaseDirectChainedHashMap
class	BaseGrowableArray
class	BaseGrowableHandlePtrArray
class	BaseIsolate
class	BasePageIterator
class	BaseSerializer
class	BaseTextBuffer
class	BaseThread
class	BaseWriteStream
class	Become
class	Benchmark
class	BenchmarkIsolateScope
class	Bequest
class	BinaryDoubleOpInstr
class	BinaryFeedback
class	BinaryInt32OpInstr
class	BinaryInt64OpInstr
class	BinaryIntegerOpInstr
class	BinarySmiOpInstr
class	BinaryUint32OpInstr
class	BitCastInstr
class	BitField
class	BitField< S, T, position, size, false, typename std::enable_if< std::is_base_of< AtomicBitFieldContainerBase, S >::value, void >::type >
class	BitField< S, T, position, size, sign_extend, typename std::enable_if< std::is_base_of< AtomicBitFieldContainerBase, S >::value, void >::type >
class	BitmapBuilder
class	BitSet
class	BitVector
class	BlobImageWriter
class	BlockEntryInstr
class	BlockEntryWithInitialDefs
class	BlockIterator
class	BlockLabel
	Convenience wrapper around a BlockEntryInstr pointer. More...
class	BlockScheduler
class	BlockStack
class	BlockTraversalState
class	BlockWorkList
class	Bool
class	BoolCallable
class	BooleanNegateInstr
class	BoolField
class	BoolParameter
class	BoolToIntInstr
class	Bootstrap
struct	BootstrapLibProps
class	BootstrapNatives
class	BoundsCheckGeneralizer
class	BoxAllocationSlowPath
struct	BoxDoubleStubABI
struct	Boxing
class	BoxInstr
class	BoxInt32Instr
class	BoxInt64Instr
class	BoxInteger32Instr
class	BoxIntegerInstr
class	BoxLanesInstr
class	BoxSmallIntInstr
class	BoxUint32Instr
class	BoyerMooreLookahead
class	BoyerMoorePositionInfo
class	BranchInstr
struct	BranchLabels
class	BranchSimplifier
class	Breakpoint
class	BreakpointLocation
class	BSS
class	BufferFormatter
class	ByteBuffer
class	BytecodeRegExpMacroAssembler
class	CachableIdempotentCallInstr
class	CalculateElementAddressInstr
class	Call1ArgStubInstr
class	Callable
struct	CallbackTestData
class	CalleeGraphValidator
class	CallingConventions
class	CallPattern
class	CallSiteData
class	CallSiteInliner
class	CallSiteResetter
class	CallSites
class	CallSpecializer
class	CallTargets
struct	CanonicalFfiCallbackFunctionTraits
class	CanonicalFunctionTypeKey
class	CanonicalFunctionTypeTraits
class	CanonicalInstanceKey
class	CanonicalInstanceTraits
class	CanonicalRecordTypeKey
class	CanonicalRecordTypeTraits
class	CanonicalRegExpTraits
class	CanonicalSetDeserializationCluster
class	CanonicalSetSerializationCluster
class	CanonicalTypeArgumentsKey
class	CanonicalTypeArgumentsTraits
class	CanonicalTypeKey
class	CanonicalTypeParameterKey
class	CanonicalTypeParameterTraits
class	CanonicalTypeTraits
class	Capability
class	CapabilityMessageDeserializationCluster
class	CapabilityMessageSerializationCluster
class	CaseInsensitiveCompareInstr
class	CaseMapping
class	CatchBlockEntryInstr
class	CatchEntryMove
class	CatchEntryMoves
class	CatchEntryMovesMapBuilder
class	CatchEntryMovesMapReader
class	CatchEntryMovesRefPtr
class	CHA
class	CHACodeArray
struct	Chain
class	CharacterRange
class	CharacterSet
class	CharArray
class	CheckArrayBoundInstr
class	CheckBoundBaseInstr
class	CheckClassIdInstr
class	CheckClassInstr
class	CheckConditionInstr
class	CheckEitherNonSmiInstr
class	CheckinTask
class	CheckNullInstr
class	CheckSmiInstr
class	CheckStackOverflowElimination
class	CheckStackOverflowInstr
class	CheckStoreBufferVisitor
class	CheckWritableInstr
class	ChoiceNode
class	ChoiceTable
class	CidCheckerForRanges
struct	CidCount
class	CidCountingVisitor
class	CidIndexedTable
struct	CidRange
struct	CidRangeValue
class	CidRangeVectorUtils
class	CidRewriteVisitor
class	Cids
class	CInstr
class	Class
class	ClassAllocationSampleFilter
class	ClassDeserializationCluster
class	ClassDictionaryIterator
class	ClassFinalizer
class	ClassFunctionsTraits
class	ClassKeyValueTrait
class	ClassMapTraits
class	ClassMessageDeserializationCluster
class	ClassMessageSerializationCluster
class	ClassReasonForCancelling
class	ClassSerializationCluster
class	ClassTable
class	ClassTableAllocator
class	ClassVisitor
class	ClearProfileVisitor
class	ClearTypeHashVisitor
class	CloneContextInstr
struct	CloneSuspendStateStubABI
class	Closure
class	ClosureCallInstr
class	ClosureData
class	ClosureDataDeserializationCluster
class	ClosureDataSerializationCluster
class	ClosureDeserializationCluster
class	ClosureFunctionsCache
class	ClosureSerializationCluster
class	Code
class	CodeBreakpoint
class	CodeDescriptor
class	CodeDeserializationCluster
class	CodeLookupTable
class	CodeLookupTableBuilder
class	CodeObserver
class	CodeObservers
class	CodePatcher
class	CodeSerializationCluster
class	CodeSourceMap
class	CodeSourceMapBuilder
class	CodeSourceMapDeserializationCluster
class	CodeSourceMapKeyValueTrait
struct	CodeSourceMapOps
class	CodeSourceMapReader
class	CodeSourceMapSerializationCluster
class	CodeStatistics
class	CodeTestHelper
class	CodeTraits
class	CodeVisitor
class	CollectStoreBufferVisitor
class	CombinedCodeStatistics
class	CompactorTask
class	ComparisonInstr
class	CompilationPipeline
class	CompileParsedFunctionHelper
class	Compiler
class	CompilerDeoptInfo
class	CompilerDeoptInfoWithStub
class	CompilerPass
struct	CompilerPassState
class	CompilerState
class	CompilerTest
class	CompilerTimings
class	CompileType
class	CompressedStackMaps
class	CompressedStackMapsBuilder
class	CompressedStackMapsDeserializationCluster
class	CompressedStackMapsSerializationCluster
class	ConcatString
class	ConcurrentForceGrowthScopeTask
class	ConcurrentMarkTask
class	ConcurrentSweeperTask
struct	Cons
struct	ConstantAndRepresentation
class	ConstantInstr
struct	ConstantPoolTrait
class	ConstantPropagator
class	ConstantTemporaryAllocator
class	ConstClassFieldRemoved
class	ConstMap
class	ConstraintInstr
class	ConstSet
class	ConstToNonConstClass
class	Context
class	ContextDeserializationCluster
class	ContextScope
class	ContextScopeDeserializationCluster
class	ContextScopeSerializationCluster
class	ContextSerializationCluster
class	CounterVisitor
class	CPU
class	CpuId
class	CpuInfo
class	CreateArrayInstr
class	CSEInstructionSet
class	CStringIntMap
struct	CStringIntMapKeyValueTrait
class	CStringSetKeyValueTrait
class	Dart
struct	Dart_CodeLocation
struct	DartCallingConvention
class	DartCompilationPipeline
class	DartEntry
class	DartEntryScope
class	DartFrameIterator
class	DartInitializationState
class	DartLibraryCalls
class	DartListParameter
class	DartReturnInstr
class	DartStringParameter
class	DeadCodeElimination
class	DeadStoreElimination
class	Debugger
class	DebuggerKeyValueTrait
class	DebuggerSet
class	DebuggerStackTrace
class	DebugStepCheckInstr
class	Deduper
class	DeeplyImmutableChange
class	DefaultHashTraits
class	DeferredDouble
class	DeferredFloat32x4
class	DeferredFloat64x2
class	DeferredInt32x4
class	DeferredMint
class	DeferredObject
class	DeferredObjectRef
class	DeferredPcMarker
class	DeferredPp
class	DeferredRetAddr
class	DeferredSlot
class	Definition
class	DefinitionIndexPairTrait
class	DefinitionWorklist
class	DelayAllocations
class	DeltaEncodedTypedDataDeserializationCluster
class	DeltaEncodedTypedDataSerializationCluster
class	DeoptCallerFpInstr
class	DeoptCallerPcInstr
class	DeoptCallerPpInstr
class	DeoptConstantInstr
class	DeoptContext
class	DeoptFpuInstr
class	DeoptId
class	DeoptIdScope
class	DeoptimizeInstr
class	DeoptInfo
class	DeoptInfoBuilder
class	DeoptInstr
class	DeoptIntegerInstrBase
class	DeoptIntInstr
class	DeoptMaterializedObjectRefInstr
class	DeoptMaterializeObjectInstr
class	DeoptMintPairInstr
class	DeoptPcMarkerInstr
class	DeoptPpInstr
class	DeoptRetAddressInstr
class	DeoptSafepointOperationScope
class	DeoptTable
class	DeoptTask
class	DeoptWordInstr
class	DescriptorList
class	DeserializationCluster
class	DeserializationRoots
class	Deserializer
class	DictionaryIterator
class	DirectChainedHashMap
class	DisableBackgroundCompilationScope
class	DisableBreakpointsScope
class	DisableIdleTimerScope
class	DisableNativeProfileScope
class	DisableThreadInterruptsScope
class	Disassembler
class	DisassembleToJSONStream
class	DisassembleToMemory
class	DisassembleToStdout
class	DisassemblyFormatter
class	DispatcherKey
class	DispatcherTraits
class	DispatchTable
class	DispatchTableCallInstr
struct	DispatchTableNullErrorABI
class	DominatorBasedCSE
class	Double
class	DoubleDeserializationCluster
class	DoubleInternals
class	DoubleMessageDeserializationCluster
class	DoubleMessageSerializationCluster
class	DoubleSerializationCluster
class	DoubleTestOpInstr
class	DoubleToFloatInstr
class	DoubleToIntegerInstr
class	DoubleToIntegerSlowPath
struct	DoubleToIntegerStubABI
class	DoubleToSmiInstr
class	DropTempsInstr
class	DynamicAssertionHelper
class	DynamicLibrary
struct	Edge
class	EmbeddedArray
class	EmbeddedArray< T, 0 >
class	EmbedderServiceHandler
class	EndNode
class	EnsureFinalizedError
class	EnterCompilerScope
class	EnterIsolateGroupScope
class	EntryFrame
class	EnumClassConflict
class	EnumListParameter
class	EnumMapTraits
class	EnumParameter
class	Environment
class	EqualityCompareInstr
class	Error
class	Evaluator
class	Event
class	EventCounterRecorder
class	EventQueue
class	ExceptionHandlerFinder
struct	ExceptionHandlerInfo
class	ExceptionHandlerList
class	ExceptionHandlers
class	ExceptionHandlersDeserializationCluster
class	ExceptionHandlersSerializationCluster
class	Exceptions
class	ExclusiveCodePageIterator
class	ExclusivePageIterator
class	ExitFrame
class	Expect
class	ExternalCodeObserverAdapter
class	ExternalTypedData
class	ExternalTypedDataDeserializationCluster
class	ExternalTypedDataMessageDeserializationCluster
class	ExternalTypedDataMessageSerializationCluster
class	ExternalTypedDataSerializationCluster
class	ExtractNthOutputInstr
struct	ExtraLoopInfo
class	FactoryRecognizer
class	FakeMessageHandler
class	FakeSerializationCluster
class	FastForwardMap
class	FastFromTo
class	FastObjectCopy
class	FastObjectCopyBase
struct	FfiAsyncCallbackSendStubABI
class	FfiCallbackMetadata
class	FfiCallInstr
struct	FfiNativeEntries
class	FfiTrampolineData
class	FfiTrampolineDataDeserializationCluster
class	FfiTrampolineDataSerializationCluster
class	Field
class	FieldDependentArray
class	FieldDeserializationCluster
class	FieldGuardState
class	FieldGuardUpdater
class	FieldInvalidator
class	FieldKeyValueTrait
struct	FieldMapping
class	FieldSerializationCluster
class	FieldTable
struct	FinalizableData
class	FinalizablePersistentHandle
class	FinalizablePersistentHandles
class	Finalizer
class	FinalizerBase
class	FinalizerEntry
class	FinalizeVMIsolateVisitor
class	FinalizeWeakPersistentHandlesVisitor
struct	Fixed
class	FixedArray
class	FixedCache
class	FixedQRegisterView
class	Flag
class	Flags
union	float32_int32
class	Float32x4
class	Float64x2
class	FloatCompareInstr
class	FloatToDoubleInstr
class	FlowGraph
class	FlowGraphAllocator
class	FlowGraphBuilderHelper
class	FlowGraphCompiler
class	FlowGraphDeserializer
class	FlowGraphInliner
class	FlowGraphPrinter
class	FlowGraphSerializer
class	FlowGraphTypePropagator
class	FlowGraphVisitor
class	ForceGrowthSafepointOperationScope
class	ForceGrowthScope
class	ForwardHeapPointersHandleVisitor
class	ForwardHeapPointersVisitor
class	ForwardingBlock
class	ForwardingCorpse
class	ForwardingPage
class	ForwardInstructionIterator
class	ForwardMapBase
class	ForwardPointersVisitor
struct	FrameLayout
class	FreeList
class	FreeListElement
class	FrequencyCollator
class	FullSnapshotReader
class	FullSnapshotWriter
class	Function
class	FunctionDeserializationCluster
class	FunctionEntryInstr
class	FunctionHashMapTraits
struct	FunctionKeyTraits
class	FunctionName
class	FunctionSerializationCluster
class	FunctionsTraits
class	FunctionType
class	FunctionTypeDeserializationCluster
class	FunctionTypeKeyValueTrait
class	FunctionTypeMapping
class	FunctionTypeSerializationCluster
class	FunctionVisitor
class	FutureOr
class	FuzzTask
class	GCCompactor
class	GCLinkedList
struct	GCLinkedLists
class	GCMarker
class	GcSafepointOperationScope
class	GCSweeper
class	GcWithoutDeoptTask
class	GenericCheckBoundInstr
class	GetInstancesVisitor
class	GotoInstr
class	GraphEntryInstr
class	GraphInfoCollector
class	GraphIntrinsicCodeGenScope
class	GreedyLoopState
class	GroupDebugger
class	GrowableArray
class	GrowableHandlePtrArray
class	GrowableObjectArray
class	GrowableObjectArrayDeserializationCluster
class	GrowableObjectArrayMessageDeserializationCluster
class	GrowableObjectArrayMessageSerializationCluster
class	GrowableObjectArraySerializationCluster
class	Guard
class	GuardedAlternative
class	GuardFieldClassInstr
class	GuardFieldInstr
class	GuardFieldLengthInstr
class	GuardFieldTypeInstr
class	Handles
class	HandleScope
struct	HandleTypes
class	HandleVisitor
class	HashDoubleOpInstr
class	HashIntegerOpInstr
class	HashMap
class	HashSet
class	HashTable
class	HashTableBase
class	HashTables
class	Heap
class	HeapIterationScope
class	HeapLocker
class	HeapMapAsJSONVisitor
class	HeapProfileSampler
class	HeapTestHelper
struct	HelperThreadState
class	HierarchyInfo
class	HostCPUFeatures
class	ICCallPattern
class	ICData
class	ICDataDeserializationCluster
class	ICDataSerializationCluster
class	ICDataTestTask
class	IdentityMap
class	IdentitySetKeyValueTrait
class	IdleTimeHandler
class	IdParameter
class	IfConverter
class	IfThenElseInstr
class	ILMatcher
class	Image
class	ImageReader
class	ImageWriter
struct	ImageWriterCommand
class	ImmutableArray
class	ImmutableLinkedHashBase
class	IndirectEntryInstr
class	IndirectGotoInstr
class	InductionVar
class	InductionVarAnalysis
class	InfiniteLoopTask
struct	InitInstanceFieldABI
struct	InitLateInstanceFieldInternalRegs
struct	InitLateStaticFieldInternalRegs
struct	InitStaticFieldABI
struct	InitSuspendableFunctionStubABI
struct	InlinedCallData
class	InlinedFunctionsIterator
struct	InlinedInfo
class	InlineExitCollector
class	Instance
class	InstanceCallBaseInstr
class	InstanceCallInstr
class	InstanceDeserializationCluster
class	InstanceKeyValueTrait
class	InstanceMorpher
class	InstanceOfInstr
class	InstanceSerializationCluster
class	InstanceSizeConflict
struct	InstantiateTAVInternalRegs
struct	InstantiateTypeABI
class	InstantiateTypeArgumentsInstr
class	InstantiateTypeInstr
struct	InstantiationABI
class	Instr
struct	InstrAttrs
class	Instruction
class	InstructionIndexedPropertyIterable
class	InstructionPattern
class	Instructions
class	InstructionsKeyValueTrait
struct	InstructionSource
class	InstructionsSection
class	InstructionsTable
class	InstructionVisitor
class	Int32ToDoubleInstr
class	Int32x4
class	Int64Parameter
class	Int64ToDoubleInstr
class	IntConverterInstr
class	Integer
class	IntegerInstructionSelector
class	InterfaceFinder
class	InterruptChecker
struct	InterruptedThreadState
class	Interval
class	IntKeyRawPointerValueTrait
class	IntMap
class	IntptrPair
class	IntrusiveDList
class	IntrusiveDListEntry
class	IntSet
class	IntToBoolInstr
class	InvalidationCollector
class	InvocationMirror
class	InvokeMathCFunctionInstr
class	IrregexpCompilationPipeline
class	IrregexpInterpreter
class	IRRegExpMacroAssembler
struct	is_compressed_ptr
struct	is_double
struct	is_double< double >
struct	is_uncompressed_ptr
struct	is_uncompressed_ptr< T, typename std::enable_if< std::is_base_of< ObjectPtr, T >::value, void >::type >
struct	is_void
struct	is_void< void >
class	Isolate
class	IsolateExitScope
class	IsolateGroup
class	IsolateGroupReloadContext
class	IsolateGroupSource
class	IsolateKillerVisitor
class	IsolateLeaveScope
class	IsolateMessageHandler
class	IsolateObjectStore
class	IsolateSpawnState
class	IsolateVisitor
class	Item
class	JitCallSpecializer
class	JoinEntryInstr
class	JSONArray
class	JSONBase64String
class	JSONObject
class	JSONStream
class	JSONWriter
class	KernelBufferList
class	KernelCompilationRequest
class	KernelIsolate
class	KernelProgramInfo
class	KernelProgramInfoDeserializationCluster
class	KernelProgramInfoSerializationCluster
class	LambdaBoolCallable
class	LambdaCallable
class	LanguageError
class	LanguageErrorDeserializationCluster
class	LanguageErrorSerializationCluster
struct	LateInitializationErrorABI
class	LateInitializationErrorSlowPath
class	Latin1
class	LeafRuntimeCallInstr
class	LeaveCompilerScope
struct	LEB128Constants
class	Library
class	LibraryDeserializationCluster
class	LibraryLookupTraits
class	LibraryMapTraits
class	LibraryPrefix
class	LibraryPrefixDeserializationCluster
class	LibraryPrefixMapTraits
class	LibraryPrefixSerializationCluster
class	LibrarySerializationCluster
class	LICM
struct	Link
class	LinkedHashBase
struct	LinkRegister
class	LivenessAnalysis
class	LiveRange
class	LoadClassIdInstr
class	LoadCodeUnitsInstr
class	LoadFieldInstr
class	LoadIndexedInstr
class	LoadIndexedUnsafeInstr
class	LoadingUnit
class	LoadingUnitDeserializationCluster
class	LoadingUnitSerializationCluster
class	LoadingUnitSerializationData
class	LoadLocalInstr
class	LoadOptimizer
class	LoadStaticFieldInstr
class	LoadThreadInstr
class	LoadUntaggedInstr
class	LocalBlockWorkList
class	LocalHandle
class	LocalHandles
class	LocalScope
class	LocalVarDescriptors
class	LocalVarDescriptorsBuilder
class	LocalVariable
class	Location
class	LocationSummary
struct	LocationTrait
struct	LocationTrait< Fixed< R, reg > >
struct	LocationTrait< FixedQRegisterView< reg > >
struct	LocationTrait< FpuRegister >
struct	LocationTrait< NoLocation >
struct	LocationTrait< QRegisterView >
struct	LocationTrait< Register >
struct	LocationTrait< SameAsFirstInput >
struct	LocationTrait< Temp< RegisterType > >
class	Log
class	LogBlock
class	LogTestHelper
class	LongDeoptTask
class	LongJumpScope
class	LoopChoiceNode
class	LoopHierarchy
class	LoopInfo
class	MakePairInstr
class	MakeTempInstr
class	Malloc
class	MallocAllocated
class	MallocDirectChainedHashMap
class	MallocGrowableArray
class	MallocWriteStream
class	Map
class	MapDeserializationCluster
class	MapMessageDeserializationCluster
class	MapMessageSerializationCluster
class	MapSerializationCluster
class	MarkingStack
class	MarkingVisitorBase
class	MarkingWeakVisitor
class	MatchCode
class	MaterializeObjectInstr
class	MathMinMaxInstr
class	MaxMetric
class	MaxProfileDepthScope
class	MaybeOnStackBuffer
struct	MeasureCpu
struct	MeasureMonotonic
class	MegamorphicCache
class	MegamorphicCacheDeserializationCluster
class	MegamorphicCacheSerializationCluster
class	MegamorphicCacheTable
class	MemoryCopyInstr
class	MemoryRegion
class	Message
class	MessageDeserializationCluster
class	MessageDeserializer
class	MessageEvent
class	MessageFinalizableData
class	MessageHandler
class	MessageHandlerTask
class	MessageHandlerTestPeer
class	MessageQueue
class	MessageSerializationCluster
class	MessageSerializer
class	MetadataMapTraits
class	MethodParameter
class	MethodRecognizer
class	MethodTokenRecognizer
class	Metric
class	MetricCurrentRSS
class	MetricHeapNewCapacity
class	MetricHeapNewExternal
class	MetricHeapNewUsed
class	MetricHeapOldCapacity
class	MetricHeapOldExternal
class	MetricHeapOldUsed
class	MetricHeapUsed
class	MetricIsolateCount
class	MetricPeakRSS
class	MinMetric
class	Mint
class	MintDeserializationCluster
class	MintMessageDeserializationCluster
class	MintMessageSerializationCluster
class	MintSerializationCluster
class	MirrorReference
class	Mirrors
class	MockInstruction
class	Monitor
class	MonitorData
class	MonitorLeaveScope
class	MonitorLocker
class	MonomorphicSmiableCall
class	MoveArgumentInstr
class	MoveOperands
class	MoveSchedule
class	MutatorThreadPool
class	Mutex
class	MutexData
class	MutexLocker
class	MyMetric
struct	NamedArgument
struct	NameFormattingParams
class	Namespace
class	NamespaceDeserializationCluster
class	NamespaceSerializationCluster
class	NativeArguments
class	NativeAssetsMapTraits
class	NativeCallInstr
class	NativeCallPattern
struct	NativeEntries
class	NativeEntry
class	NativeEntryData
class	NativeEntryInstr
class	NativeFieldsConflict
class	NativeFinalizer
class	NativeMessageHandler
class	NativeParameterInstr
class	NativePointerMessageDeserializationCluster
class	NativePointerMessageSerializationCluster
class	NativeReturnInstr
class	NativeSymbolResolver
class	NegativeLookaroundChoiceNode
class	NegativeSubmatchSuccess
class	NoActiveIsolateScope
class	NoAllocationSampleFilter
class	NoBackgroundCompilerScope
struct	NoCSE
struct	NodeInfo
class	NodeVisitor
struct	NoLocation
class	NonStreamingWriteStream
class	NoReloadScope
class	NoSafepointScope
class	NoSuchParameter
class	NoTemporaryAllocator
struct	NoThrow
class	NullErrorSlowPath
class	Number
class	NumbersKeyValueTrait
class	Obfuscator
class	Object
class	ObjectAccumulator
struct	ObjectAlignment
class	ObjectCopy
class	ObjectCopyBase
class	ObjectCounter
class	ObjectGraphCopier
class	ObjectIdRing
class	ObjectIdRingClearPointerVisitor
class	ObjectIdRingTestHelper
class	ObjectLocator
struct	ObjectOffsetPair
class	ObjectOffsetTrait
class	ObjectPointerVisitor
class	ObjectPool
class	ObjectPoolDeserializationCluster
class	ObjectPoolSerializationCluster
class	ObjectPtr
class	ObjectSet
class	ObjectSetRegion
class	ObjectStore
class	ObjectVisitor
class	OffsetsExtractor
class	OffsetsTable
class	OneByteString
class	OneByteStringFromCharCodeInstr
class	OneByteStringMessageDeserializationCluster
class	OneByteStringMessageSerializationCluster
class	OS
class	OsrEntryInstr
class	OSThread
class	OSThreadIterator
class	OutSet
class	Page
class	PageSpace
class	PageSpaceController
class	PageSpaceGarbageCollectionHistory
class	PairLocation
class	ParallelMarkTask
class	ParallelMoveEmitter
class	ParallelMoveInstr
class	ParallelMoveResolver
class	ParallelScavengerTask
class	ParameterInstr
class	ParsedFunction
struct	ParsedUri
class	Parser
struct	Partition
class	PassiveObject
class	PatchableCallHandler
class	PatchClass
class	PatchClassDeserializationCluster
class	PatchClassSerializationCluster
class	PcDescriptors
class	PcDescriptorsDeserializationCluster
class	PcDescriptorsKeyValueTrait
class	PcDescriptorsSerializationCluster
class	PcRelativeCallPattern
class	PcRelativeCallPatternBase
class	PcRelativePatternBase
class	PcRelativeTailCallPattern
class	PcRelativeTrampolineJumpPattern
class	PendingCall
class	PendingDeopts
class	PendingLazyDeopt
class	PersistentHandle
class	PersistentHandles
class	PersistentHandleVisitor
class	PhiInstr
class	PhiIterator
class	PhiPlaceMoves
class	Place
class	Pointer
class	PointerBase
class	PointerBlock
class	PointerSetKeyValueTrait
class	PolymorphicInliner
class	PolymorphicInstanceCallInstr
class	PortMap
class	PortSet
class	PortTestMessageHandler
class	PreallocatedStackTraceBuilder
class	Precompiler
class	PredefinedCObjects
class	PreFinalizedConflict
struct	PreloadState
class	PrintObjectPointersVisitor
class	PrintTimeScope
class	PriorityQueue
class	ProcessedSample
class	ProcessedSampleBuffer
class	Profile
class	ProfileBuilder
class	ProfileCode
class	ProfileCodeAddress
class	ProfileCodeInlinedFunctionsCache
class	ProfileCodeTable
class	ProfileFunction
class	ProfileFunctionSourcePosition
class	ProfileFunctionTable
class	Profiler
struct	ProfilerCounters
class	ProfilerDartStackWalker
class	ProfilerNativeStackWalker
class	ProfilerService
class	ProfilerStackWalker
class	ProfileSampleBufferTestHelper
class	ProfileStackWalker
class	ProgramDeserializationRoots
class	ProgramElementKeyValueTrait
class	ProgramReloadContext
class	ProgramSerializationRoots
class	ProgramVisitor
class	ProgramWalker
struct	PrologueInfo
class	ProloguePattern
class	PromotionStack
struct	PtrTypes
struct	Pure
class	PureComparison
class	PureDefinition
class	PureInstruction
class	QRegisterView
class	QueueElement
class	QuickCheckDetails
class	Random
class	Range
class	RangeAnalysis
class	RangeBoundary
struct	RangeErrorABI
class	RangeErrorSlowPath
class	RangeUtils
class	RawPointerKeyValueTrait
class	RawReloadParticipationScope
class	RawTestCase
class	ReachabilityFenceInstr
class	ReachingDefs
struct	ReaderThreadState
class	ReadOnlyHandles
class	ReadRwLocker
class	ReadStream
class	ReasonForCancelling
class	ReceivePort
class	Record
class	RecordCoverageInstr
class	RecordDeserializationCluster
class	RecordFieldNamesMapTraits
class	RecordSerializationCluster
class	RecordShape
class	RecordType
class	RecordTypeDeserializationCluster
class	RecordTypeSerializationCluster
class	RecursionCheck
class	RedefinitionInstr
class	RegExp
class	RegExpAlternative
class	RegExpAssertion
class	RegExpAtom
class	RegExpBackReference
class	RegExpBuilder
class	RegExpCapture
class	RegExpCharacterClass
struct	RegExpCompileData
class	RegExpCompiler
class	RegExpDeserializationCluster
class	RegExpDisjunction
class	RegExpEmpty
class	RegExpEngine
class	RegExpExpansionLimiter
class	RegExpFlags
class	RegExpKey
class	RegExpLookaround
class	RegExpMacroAssembler
class	RegExpNode
class	RegExpParser
class	RegExpQuantifier
class	RegExpSerializationCluster
class	RegExpText
class	RegExpTree
class	RegExpUnparser
class	RegExpVisitor
class	RegisterNames
struct	RegisterReader
struct	RegisterReader< FpuRegister, double >
struct	RegisterReader< FpuRegister, float >
struct	RegisterReader< FpuRegister, simd128_value_t >
struct	RegisterReader< Register, T >
class	RegisterRunningIsolatesVisitor
class	RegisterSet
class	RegisterSource
class	RelationalOpInstr
class	RelaxedAtomic
class	ReloadSafepointOperationScope
class	ReloadTask
class	Report
struct	RepresentationUtils
class	Resolver
struct	Resource
class	RestoreWriteBarrierInvariantVisitor
struct	ResumeStubABI
class	RetainingPath
struct	ReThrowABI
class	ReThrowInstr
class	ReturnAddressLocator
class	ReturnBaseInstr
class	ReturnPattern
struct	ReturnStubABI
class	ReusableHandleStack
class	ReversePc
class	RingBuffer
class	RingServiceIdZone
class	RODataDeserializationCluster
class	RODataSerializationCluster
struct	RunInSafepointAndRWCodeArgs
class	RunKernelTask
struct	RunLoopData
class	RunnableIsolateParameter
class	RunServiceTask
class	RuntimeCallDeoptScope
class	RuntimeEntry
class	RwLock
class	SafepointHandler
class	SafepointMonitorLocker
class	SafepointMonitorUnlockScope
class	SafepointMutexLocker
class	SafepointOperationScope
class	SafepointPosition
class	SafepointReadRwLocker
class	SafepointRwLock
class	SafepointTestTask
class	SafepointWriteRwLocker
struct	SameAsFirstInput
class	Sample
class	SampleBlock
class	SampleBlockBuffer
class	SampleBlockBufferOverrideScope
class	SampleBlockCleanupVisitor
class	SampleBlockProcessor
class	SampleBuffer
class	SampleFilter
class	SampleVisitor
class	Scavenger
class	ScavengerVisitorBase
class	ScavengerWeakVisitor
class	ScavengeStats
class	Scheduler
class	ScopedHandle
class	ScopeTimer
class	Script
class	ScriptDeserializationCluster
class	ScriptSerializationCluster
class	ScriptUrlSetTraits
class	SemiSpace
class	SendAndExitMessagesHandler
class	SendPort
class	SendPortMessageDeserializationCluster
class	SendPortMessageSerializationCluster
class	Sentinel
class	SeqRegExpNode
class	SerializationCluster
class	SerializationRoots
class	SerializedObjectBuffer
class	Serializer
class	Service
class	ServiceEvent
class	ServiceIdZone
class	ServiceIsolate
class	ServiceIsolateVisitor
struct	ServiceMethodDescriptor
class	ServiceTestMessageHandler
class	Set
class	SetDeserializationCluster
class	SetFlagScope
class	SetFramePointerPattern
class	SetMessageDeserializationCluster
class	SetMessageSerializationCluster
class	SetSerializationCluster
struct	SharedSlowPathStubABI
class	ShiftInt64OpInstr
class	ShiftIntegerOpInstr
class	ShiftUint32OpInstr
class	SignalHandler
struct	SignatureTrait
struct	SignatureTrait< Cons< T0, Tx > >
struct	SignatureTrait< Nil >
struct	simd128_value_t
class	Simd128DeserializationCluster
class	Simd128MessageDeserializationCluster
class	Simd128MessageSerializationCluster
class	Simd128SerializationCluster
struct	simd_value_t
class	SimdLowering
struct	SimdOpInfo
class	SimdOpInstr
class	SimpleHashMap
class	SimpleTaskWithZoneAllocation
class	SimulateWork
class	SimulateWork2
class	Simulator
class	SingleTargetCache
class	SleepTask
class	Slot
class	SlotCache
class	SlowForwardMap
class	SlowFromTo
class	SlowObjectCopy
class	SlowObjectCopyBase
class	SlowPathCode
class	SmallSet
class	Smi
class	SmiMessageDeserializationCluster
class	SmiMessageSerializationCluster
class	SmiToDoubleInstr
class	SmiTraits
class	Snapshot
class	SnapshotHeaderReader
class	SourceReport
class	SpaceUsage
class	SpawnIsolateTask
class	SpawnTask
class	SpeculativeInliningPolicy
class	SpeculativeShiftInt64OpInstr
class	SpeculativeShiftUint32OpInstr
class	SplayTree
class	SSACompactor
class	SSALivenessAnalysis
class	StackFrame
class	StackFrameIterator
class	StackMapEntry
class	StackMapEntryKeyIntValueTrait
class	StackResource
class	StackTrace
class	StackTraceBuilder
class	StackTraceDeserializationCluster
class	StackTraceSerializationCluster
class	StackTraceUtils
class	StackZone
class	StartEvent
class	StartIsolateScope
class	StateMachineTask
class	StaticCallInstr
class	StaticTypeExactnessState
struct	STCInternalRegs
class	StickySpecialization
class	StopInstr
class	StoppedMutatorsScope
class	StoreBuffer
class	StoreFieldInstr
class	StoreIndexedInstr
class	StoreIndexedUnsafeInstr
class	StoreLocalInstr
class	StoreOptimizer
class	StoreStaticFieldInstr
class	StreamableSampleFilter
class	StreamInfo
class	StreamingWriteStream
class	StressTask
class	StrictCompareInstr
class	String
class	StringDeserializationCluster
class	StringHasher
class	StringParameter
class	StringSerializationCluster
class	StringSlice
class	StringSpecializationCid
class	StringToCharCodeInstr
struct	Struct1024BytesHomogeneousUint64
struct	Struct10BytesHomogeneousBool
struct	Struct10BytesInlineArrayBool
struct	Struct12BytesHomogeneousFloat
struct	Struct12BytesHomogeneousInt32
struct	Struct15BytesInlineArrayMixed
struct	Struct16BytesHomogeneousFloat
struct	Struct16BytesMixed
struct	Struct16BytesMixed2
struct	Struct16BytesNestedInt
struct	Struct17BytesInt
struct	Struct19BytesHomogeneousUint8
struct	Struct1ByteBool
struct	Struct1ByteInt
struct	Struct20BytesHomogeneousFloat
struct	Struct20BytesHomogeneousInt32
struct	Struct20BytesHomogeneousInt32Copy
struct	Struct2BytesInt
struct	Struct32BytesHomogeneousDouble
struct	Struct32BytesInlineArrayMultiDimensionalInt
struct	Struct32BytesNestedInt
struct	Struct3BytesHomogeneousUint8
struct	Struct3BytesInt2ByteAligned
struct	Struct3BytesPackedInt
struct	Struct3BytesPackedIntCopy
struct	Struct3BytesPackedIntMembersAligned
struct	Struct40BytesHomogeneousDouble
struct	Struct43693
struct	Struct46127
struct	Struct4BytesFloat
struct	Struct4BytesHomogeneousInt16
struct	Struct4BytesHomogeneousInt16Copy
struct	Struct4BytesInlineArrayMultiDimensionalInt
struct	Struct5BytesPackedMixed
struct	Struct64BytesInlineArrayMultiDimensionalInt
struct	Struct6BytesInlineArrayInt
struct	Struct7BytesHomogeneousUint8
struct	Struct7BytesInt4ByteAligned
struct	Struct8BytesFloat
struct	Struct8BytesHomogeneousFloat
struct	Struct8BytesInlineArrayInt
struct	Struct8BytesInlineArrayMultiDimensionalInt
struct	Struct8BytesInt
struct	Struct8BytesMixed
struct	Struct8BytesNestedFloat
struct	Struct8BytesNestedFloat2
struct	Struct8BytesNestedInt
struct	Struct8BytesNestedIntCopy
struct	Struct8BytesNestedMixed
struct	Struct8BytesPackedInt
struct	Struct9BytesHomogeneousUint8
struct	Struct9BytesInt4Or8ByteAligned
struct	Struct9BytesPackedMixed
struct	Struct9Uint8
struct	StructAlignmentInt16
struct	StructAlignmentInt32
struct	StructAlignmentInt64
struct	StructInlineArray100Bytes
struct	StructInlineArrayBig
struct	StructInlineArrayInt
struct	StructInlineArrayIrregular
struct	StructNestedAlignmentStruct5BytesPackedMixed
struct	StructNestedIntStructAlignmentInt16
struct	StructNestedIntStructAlignmentInt32
struct	StructNestedIntStructAlignmentInt64
struct	StructNestedIrregularBig
struct	StructNestedIrregularBigger
struct	StructNestedIrregularEvenBigger
struct	StructStruct16BytesHomogeneousFloat2
struct	StructStruct16BytesMixed3
struct	StructStruct32BytesHomogeneousDouble2
class	StubCode
class	SubtypeFinder
class	SubtypeTestCache
class	SubtypeTestCacheDeserializationCluster
class	SubtypeTestCacheSerializationCluster
class	SuspendInstr
class	SuspendState
struct	SuspendStubABI
class	SwitchableCallPattern
class	SwitchableCallPatternBase
class	Symbol
class	SymbolKeyValueTrait
class	Symbols
class	SymbolTraits
class	Syslog
class	SystemServiceIsolateVisitor
class	TableSelectorKeyValueTrait
class	TailCallInstr
class	TarArchive
class	TargetCPUFeatures
class	TargetEntryInstr
struct	TargetInfo
class	TaskWithZoneAllocation
class	Temp
class	TemplateAllocation
class	TemplateArrayAllocation
class	TemplateComparison
class	TemplateDartCall
class	TemplateDefinition
class	TemplateInstruction
class	TemplateLoadField
class	TemplateSlowPathCode
class	TemporaryRegisterAllocator
class	TestCase
class	TestCaseBase
struct	TestCaseMoves
class	TestCidsInstr
class	TesterState
class	TestIsolateScope
struct	TestLibEntry
class	TestMessageHandler
class	TestPipeline
class	TestRangeInstr
struct	TestResult
class	TestSmiInstr
class	TestStackedStackResource
class	TestStackResource
class	TestTask
class	TestTraits
class	TestValue
class	TestValueObject
class	TextBuffer
class	TextElement
class	TextNode
class	Thread
class	ThreadBarrier
class	ThreadInlineImpl
class	ThreadInterrupter
class	ThreadInterruptScope
struct	ThreadIteratorTestParams
class	ThreadLocalData
class	ThreadLocalEntry
class	ThreadPool
class	ThreadRegistry
class	ThreadSignalBlocker
class	ThreadStackResource
struct	ThreadStartInfo
class	ThreadState
struct	ThrowABI
class	ThrowErrorSlowPathCode
class	ThrowInstr
struct	Throws
class	TimelineRecorderOverride
class	TimelineStream
class	TimelineTestHelper
class	Timer
class	TimerImpl
class	TimerScope
class	ToggleBreakpointTask
class	Token
class	TokenPosition
class	Trace
class	TraceStubInvocationScope
class	TransferableTypedData
class	TransferableTypedDataMessageDeserializationCluster
class	TransferableTypedDataMessageSerializationCluster
class	TransferableTypedDataPeer
class	TransitionGeneratedToNative
class	TransitionGeneratedToVM
class	TransitionNativeToVM
class	TransitionSafepointState
class	TransitionToGenerated
class	TransitionToNative
class	TransitionToVM
class	TransitionVMToBlocked
class	TransitionVMToGenerated
class	TransitionVMToNative
class	TruncDivModInstr
class	TryCatchAnalyzer
struct	TsanUtils
struct	TTSInternalRegs
struct	TTSTestCase
class	TTSTestState
class	TwoByteString
class	TwoByteStringMessageDeserializationCluster
class	TwoByteStringMessageSerializationCluster
class	Type
class	TypeArguments
class	TypeArgumentsDeserializationCluster
class	TypeArgumentsKeyValueTrait
class	TypeArgumentsMessageDeserializationCluster
class	TypeArgumentsMessageSerializationCluster
class	TypeArgumentsSerializationCluster
class	TypedData
class	TypedDataBase
class	TypedDataDeduper
class	TypedDataDeserializationCluster
class	TypedDataKeyValueTrait
class	TypedDataMessageDeserializationCluster
class	TypedDataMessageSerializationCluster
class	TypedDataSerializationCluster
class	TypedDataSpecializer
class	TypedDataView
class	TypedDataViewDeserializationCluster
class	TypedDataViewMessageDeserializationCluster
class	TypedDataViewMessageSerializationCluster
class	TypedDataViewSerializationCluster
class	TypeDeserializationCluster
class	TypeMessageDeserializationCluster
class	TypeMessageSerializationCluster
class	TypeParameter
class	TypeParameterDeserializationCluster
class	TypeParameterKeyValueTrait
class	TypeParameters
class	TypeParametersChanged
class	TypeParametersDeserializationCluster
class	TypeParameterSerializationCluster
class	TypeParametersSerializationCluster
class	TypeSerializationCluster
struct	TypeTestABI
class	TypeTestingStubCallPattern
class	TypeTestingStubGenerator
class	TypeTestingStubNamer
class	TypeUsageInfo
class	UInt64Parameter
class	UIntParameter
class	UnaryDoubleOpInstr
class	UnaryInt64OpInstr
class	UnaryIntegerOpInstr
class	UnarySmiOpInstr
class	UnaryUint32OpInstr
class	UnboxedConstantInstr
class	UnboxedFieldBitmap
class	UnboxInstr
class	UnboxInt32Instr
class	UnboxInt64Instr
class	UnboxInteger32Instr
class	UnboxIntegerInstr
class	UnboxLaneInstr
class	UnboxUint32Instr
class	UnhandledException
class	UnhandledExceptionDeserializationCluster
class	UnhandledExceptionSerializationCluster
class	UnicodeRangeSplitter
union	Union16BytesNestedFloat
union	Union16BytesNestedInlineArrayFloat
union	Union2BytesInt
union	Union4BytesMixed
union	Union8BytesNestedFloat
union	Union9BytesNestedInt
class	UnitDeserializationRoots
class	UnitSerializationRoots
class	UnlinkedCall
class	UnlinkedCallDeserializationCluster
class	UnlinkedCallSerializationCluster
class	UnorderedHashMap
class	UnorderedHashSet
class	UnorderedHashTable
class	UnsafeExclusivePageIterator
class	UntaggedAbstractType
class	UntaggedApiError
class	UntaggedArray
class	UntaggedBool
class	UntaggedCallSiteData
class	UntaggedCapability
class	UntaggedClass
class	UntaggedClosure
class	UntaggedClosureData
class	UntaggedCode
class	UntaggedCodeSourceMap
class	UntaggedCompressedStackMaps
class	UntaggedConstMap
class	UntaggedConstSet
class	UntaggedContext
class	UntaggedContextScope
class	UntaggedDouble
class	UntaggedDynamicLibrary
class	UntaggedError
class	UntaggedExceptionHandlers
class	UntaggedExternalTypedData
class	UntaggedFfiTrampolineData
class	UntaggedField
class	UntaggedFinalizer
class	UntaggedFinalizerBase
class	UntaggedFinalizerEntry
class	UntaggedFloat32x4
class	UntaggedFloat64x2
class	UntaggedFunction
class	UntaggedFunctionType
class	UntaggedFutureOr
class	UntaggedGrowableObjectArray
class	UntaggedICData
class	UntaggedImmutableArray
class	UntaggedInstance
class	UntaggedInstructions
class	UntaggedInstructionsSection
class	UntaggedInstructionsTable
class	UntaggedInt32x4
class	UntaggedInteger
class	UntaggedKernelProgramInfo
class	UntaggedLanguageError
class	UntaggedLibrary
class	UntaggedLibraryPrefix
class	UntaggedLinkedHashBase
class	UntaggedLoadingUnit
class	UntaggedLocalVarDescriptors
class	UntaggedMap
class	UntaggedMegamorphicCache
class	UntaggedMint
class	UntaggedMirrorReference
class	UntaggedMonomorphicSmiableCall
class	UntaggedNamespace
class	UntaggedNativeFinalizer
class	UntaggedNumber
class	UntaggedObject
class	UntaggedObjectPool
class	UntaggedObjectPtrSetTraits
class	UntaggedOneByteString
class	UntaggedPatchClass
class	UntaggedPcDescriptors
class	UntaggedPointer
class	UntaggedPointerBase
class	UntaggedReceivePort
class	UntaggedRecord
class	UntaggedRecordType
class	UntaggedRegExp
class	UntaggedScript
class	UntaggedSendPort
class	UntaggedSentinel
class	UntaggedSet
class	UntaggedSingleTargetCache
class	UntaggedSmi
class	UntaggedStackTrace
class	UntaggedString
class	UntaggedSubtypeTestCache
class	UntaggedSuspendState
class	UntaggedTransferableTypedData
class	UntaggedTwoByteString
class	UntaggedType
class	UntaggedTypeArguments
class	UntaggedTypedData
class	UntaggedTypedDataBase
class	UntaggedTypedDataView
class	UntaggedTypeParameter
class	UntaggedTypeParameters
class	UntaggedUnhandledException
class	UntaggedUnlinkedCall
class	UntaggedUnwindError
class	UntaggedUserTag
class	UntaggedWeakArray
class	UntaggedWeakProperty
class	UntaggedWeakReference
class	UntaggedWeakSerializationReference
class	UnwindError
class	UnwindingRecords
class	UnwindingRecordsPlatform
struct	unwrap_enum
struct	unwrap_enum< T, false >
struct	unwrap_enum< T, true >
class	UriMappingTraits
class	UseInterval
class	UsePosition
class	UserTag
class	UserTagIsolatesVisitor
class	UserTags
class	Utf
class	Utf16
class	Utf8
class	Utf8ScanInstr
class	Utils
class	V8SnapshotProfileWriter
class	Value
class	ValueListIterable
class	ValueObject
struct	VarArgs
class	VariableIndex
class	VariableLivenessAnalysis
class	VariadicDefinition
class	VerifyAfterMarkingVisitor
class	VerifyObjectVisitor
class	VerifyPointersVisitor
class	VerifyWeakPointersVisitor
class	Version
struct	VeryLargeStruct
class	VirtualMemory
class	VisitMarker
class	VMDeserializationRoots
class	VMHandles
class	VMSerializationRoots
class	VMTag
class	VMTagCounters
class	VMTagScope
class	WaiterTask
struct	WeakAcqRelStorageTraits
class	WeakArray
class	WeakArrayDeserializationCluster
class	WeakArraySerializationCluster
struct	WeakArrayStorageTraits
class	WeakCodeReferences
class	WeakProperty
class	WeakPropertyDeserializationCluster
class	WeakPropertySerializationCluster
class	WeakReference
class	WeakSerializationReference
class	WeakTable
class	Worklist
class	WorklistElement
class	WritableCodeLiteralsScope
class	WritableCodePages
class	WritableVMIsolateScope
class	WriteBarrierElimination
class	WriteBarrierUpdateVisitor
class	WriteErrorSlowPath
class	WriteRwLocker
class	Zone
class	ZoneAllocated
class	ZoneCStringSet
class	ZoneDirectChainedHashMap
class	ZoneGrowableArray
class	ZoneGrowableHandlePtrArray
class	ZonePlace
class	ZoneSplayTree
class	ZoneTextBuffer
class	ZoneWriteStream

Typedefs
typedef Coord *(*	CoordUnOp) (Coord *coord)
typedef intptr_t(*	IntptrBinOp) (intptr_t a, intptr_t b)
typedef std::function< void()>	Work
typedef uint32_t(*	IntKeyHash) (uint32_t key)
typedef intptr_t	word
typedef uintptr_t	uword
typedef int32_t	classid_t
typedef CharArray< uint8_t >	Latin1Array
typedef CharArray< uint16_t >	UTF16Array
typedef CharArray< int32_t >	UTF32Array
typedef UnorderedHashSet< SymbolTraits, WeakAcqRelStorageTraits >	CanonicalStringSet
typedef UnorderedHashSet< CanonicalTypeTraits >	CanonicalTypeSet
typedef UnorderedHashSet< CanonicalFunctionTypeTraits >	CanonicalFunctionTypeSet
typedef UnorderedHashSet< CanonicalRecordTypeTraits >	CanonicalRecordTypeSet
typedef UnorderedHashSet< CanonicalTypeParameterTraits >	CanonicalTypeParameterSet
typedef UnorderedHashSet< CanonicalTypeArgumentsTraits >	CanonicalTypeArgumentsSet
typedef UnorderedHashMap< MetadataMapTraits >	MetadataMap
typedef UnorderedHashSet< DispatcherTraits, AcqRelStorageTraits >	DispatcherSet
typedef UnorderedHashSet< CanonicalInstanceTraits >	CanonicalInstancesSet
using	FfiCallbackFunctionSet = UnorderedHashSet< CanonicalFfiCallbackFunctionTraits >
typedef UnorderedHashSet< CanonicalRegExpTraits, WeakAcqRelStorageTraits >	CanonicalRegExpSet
typedef int32_t	ClassIdTagType
using	FunctionHashMap = UnorderedHashMap< FunctionHashMapTraits >
typedef DirectChainedHashMap< TableSelectorKeyValueTrait >	TableSelectorSet
typedef DirectChainedHashMap< SymbolKeyValueTrait >	SymbolSet
typedef UnorderedHashSet< FunctionKeyTraits >	FunctionSet
typedef DirectChainedHashMap< ClassKeyValueTrait >	ClassSet
typedef DirectChainedHashMap< AbstractTypeKeyValueTrait >	AbstractTypeSet
typedef DirectChainedHashMap< FunctionTypeKeyValueTrait >	FunctionTypeSet
typedef DirectChainedHashMap< TypeParameterKeyValueTrait >	TypeParameterSet
typedef DirectChainedHashMap< TypeArgumentsKeyValueTrait >	TypeArgumentsSet
typedef DirectChainedHashMap< ProgramElementKeyValueTrait >	ProgramElementSet
typedef DirectChainedHashMap< InstanceKeyValueTrait >	InstanceSet
typedef UnorderedHashMap< FunctionsTraits >	UniqueFunctionsMap
typedef MallocGrowableArray< CidRangeValue >	CidRangeVector
template<typename T >
using	serializable_type_t = typename unwrap_enum< std::remove_cv_t< T >, std::is_enum< T >::value >::type
typedef GrowableArray< Value * >	InputsArray
typedef ZoneGrowableArray< MoveArgumentInstr * >	MoveArgumentsArray
typedef ZoneGrowableArray< Location >	LocationArray
typedef bool(*	BoundaryOp) (RangeBoundary *)
using	YieldPoints = ZoneGrowableArray< TokenPosition >
typedef DirectChainedHashMap< DefinitionIndexPairTrait >	DefinitionIndexMap
typedef QRegister	FpuRegister
typedef simd128_value_t	fpu_register_t
typedef uint16_t	RegList
typedef uword(*	invokestub) (uword target_code, uword arguments_descriptor, uword arguments, Thread *thread)
typedef struct _Dart_Breakpoint *	Dart_Breakpoint
typedef struct _Dart_StackTrace *	Dart_StackTrace
typedef struct _Dart_ActivationFrame *	Dart_ActivationFrame
typedef Dart_Port	Dart_IsolateId
typedef void	Dart_ExceptionThrownHandler(Dart_IsolateId isolate_id, Dart_Handle exception_object, Dart_StackTrace stack_trace)
typedef void	Dart_IsolateEventHandler(Dart_IsolateId isolate_id, Dart_IsolateEvent kind)
typedef void	Dart_PausedEventHandler(Dart_IsolateId isolate_id, intptr_t bp_id, const Dart_CodeLocation &location)
typedef void	Dart_BreakpointResolvedHandler(Dart_IsolateId isolate_id, intptr_t bp_id, const Dart_CodeLocation &location)
typedef DeoptIntInstr< DeoptInstr::kUint32, CatchEntryMove::SourceKind::kUint32Slot, uint32_t >	DeoptUint32Instr
typedef DeoptIntInstr< DeoptInstr::kInt32, CatchEntryMove::SourceKind::kInt32Slot, int32_t >	DeoptInt32Instr
typedef DeoptIntInstr< DeoptInstr::kMint, CatchEntryMove::SourceKind::kInt64Slot, int64_t >	DeoptMintInstr
typedef DeoptFpuInstr< DeoptInstr::kFloat, CatchEntryMove::SourceKind::kFloatSlot, float, DoublePtr >	DeoptFloatInstr
typedef DeoptFpuInstr< DeoptInstr::kDouble, CatchEntryMove::SourceKind::kDoubleSlot, double, DoublePtr >	DeoptDoubleInstr
typedef DeoptFpuInstr< DeoptInstr::kFloat32x4, CatchEntryMove::SourceKind::kFloat32x4Slot, simd128_value_t, Float32x4Ptr >	DeoptFloat32x4Instr
typedef DeoptFpuInstr< DeoptInstr::kFloat64x2, CatchEntryMove::SourceKind::kFloat64x2Slot, simd128_value_t, Float64x2Ptr >	DeoptFloat64x2Instr
typedef DeoptFpuInstr< DeoptInstr::kInt32x4, CatchEntryMove::SourceKind::kInt32x4Slot, simd128_value_t, Int32x4Ptr >	DeoptInt32x4Instr
typedef RegisterSource< Register >	CpuRegisterSource
typedef RegisterSource< FpuRegister >	FpuRegisterSource
typedef UnorderedHashMap< NativeAssetsMapTraits >	NativeAssetsMap
typedef void(*	FlagHandler) (bool value)
typedef void(*	OptionHandler) (const char *value)
typedef uintptr_t	compressed_uword
typedef intptr_t	compressed_word
typedef uword	cpp_vtable
template<typename T >
using	PointerSet = DirectChainedHashMap< PointerSetKeyValueTrait< T > >
typedef UnorderedHashMap< SmiTraits >	IntHashMap
typedef MarkingVisitorBase< false >	UnsyncMarkingVisitor
typedef MarkingVisitorBase< true >	SyncMarkingVisitor
typedef StoreBuffer::Block	StoreBufferBlock
typedef MarkingStack::Block	MarkingStackBlock
typedef BlockWorkList< MarkingStack >	MarkerWorkList
typedef PromotionStack::Block	PromotionStackBlock
typedef BlockWorkList< PromotionStack >	PromotionWorkList
typedef ScavengerVisitorBase< false >	SerialScavengerVisitor
typedef ScavengerVisitorBase< true >	ParallelScavengerVisitor
typedef UnorderedHashSet< CodeTraits, WeakArrayStorageTraits >	WeakCodeSet
typedef DirectChainedHashMap< ObjectOffsetTrait >	ObjectOffsetMap
typedef FixedCache< intptr_t, ExceptionHandlerInfo, 16 >	HandlerInfoCache
typedef FixedCache< intptr_t, CatchEntryMovesRefPtr, 16 >	CatchEntryMovesCache
using	FieldMappingArray = ZoneGrowableArray< FieldMapping >
using	FieldOffsetArray = ZoneGrowableArray< intptr_t >
typedef void(*	LogPrinter) (const char *data)
typedef ObjectPtr(*	BootstrapNativeFunction) (Thread *thread, Zone *zone, NativeArguments *arguments)
typedef void(*	NativeFunction) (NativeArguments *arguments)
typedef void(*	NativeFunctionWrapper) (Dart_NativeArguments args, Dart_NativeFunction func)
typedef UnorderedHashSet< ClassFunctionsTraits >	ClassFunctionsSet
typedef UnorderedHashMap< LibraryLookupTraits >	LibraryLookupMap
typedef UnorderedHashMap< RecordFieldNamesMapTraits >	RecordFieldNamesMap
typedef ZoneGrowableHandlePtrArray< const String >	URIs
using	StaticCallsTable = ArrayOfTuplesView< Code::SCallTableEntry, std::tuple< Smi, Object, Function > >
using	StaticCallsTableEntry = StaticCallsTable::TupleView
using	SubtypeTestCacheTable = ArrayOfTuplesView< SubtypeTestCache::Entries, std::tuple< Object, TypeArguments, TypeArguments, TypeArguments, TypeArguments, TypeArguments, AbstractType, Bool > >
using	MegamorphicCacheEntries = ArrayOfTuplesView< MegamorphicCache::EntryType, std::tuple< Smi, Object > >
using	InstantiationsCacheTable = ArrayOfTuplesView< TypeArguments::Cache::Entry, std::tuple< Object, TypeArguments, TypeArguments >, TypeArguments::Cache::kHeaderSize >
typedef pthread_key_t	ThreadLocalKey
typedef pthread_t	ThreadId
typedef pthread_t	ThreadJoinId
typedef void(*	ThreadDestructor) (void *parameter)
typedef DirectChainedHashMap< FieldKeyValueTrait >	FieldSet
using	HostObjectAlignment = ObjectAlignment< kWordSize, kWordSizeLog2 >
typedef DirectChainedHashMap< StackMapEntryKeyIntValueTrait >	StackMapEntryIntMap
typedef bool	EmitCharacterFunction(Zone *zone, RegExpCompiler *compiler, uint16_t c, BlockLabel *on_failure, intptr_t cp_offset, bool check, bool preloaded)
typedef unibrow::Mapping< unibrow::Ecma262Canonicalize >	Canonicalize
using	RegExpCaptureName = ZoneGrowableArray< uint16_t >
typedef double(*	UnaryMathCFunction) (double x)
typedef double(*	BinaryMathCFunction) (double x, double y)
typedef void *(*	MemMoveCFunction) (void *dest, const void *src, size_t n)
typedef void(*	RuntimeFunction) (NativeArguments arguments)
using	BaseRuntimeEntry = compiler::RuntimeEntry
typedef void(*	ServiceMethodEntry) (Thread *thread, JSONStream *js)
typedef UnorderedHashMap< UriMappingTraits >	UriMapping
typedef void(*	SignalAction) (int signal, siginfo_t *info, void *context)
typedef ObjectPtr	CompressedObjectPtr
using	ReloadParticipationScope = AsThreadStackResource< RawReloadParticipationScope >

Enumerations
enum	{ kPathsUriOffset = 0 , kPathsSourceOffset = 1 , kPathsEntryLength = 2 }
enum	ClassId : intptr_t {   kIllegalCid = 0 , kNativePointer , kFreeListElement , kForwardingCorpse ,   kByteDataViewCid , kUnmodifiableByteDataViewCid , kByteBufferCid , kNullCid ,   kDynamicCid , kVoidCid , kNeverCid , kNumPredefinedCids }
enum class	CodeEntryKind { kNormal , kUnchecked , kMonomorphic , kMonomorphicUnchecked }
enum	TypeCheckMode { kTypeCheckFromLazySpecializeStub , kTypeCheckFromSlowStub , kTypeCheckFromInline }
enum	BlockAddressMode {   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 }
enum class	InnerPointerAccess { kNotUntagged , kMayBeInnerPointer , kCannotBeInnerPointer }
enum	StoreBarrierType { kNoStoreBarrier , kEmitStoreBarrier }
enum	AlignmentType { kUnalignedAccess , kAlignedAccess }
enum	TypeDataField { TypedDataBase_length , TypedDataView_offset_in_bytes , TypedDataView_typed_data }
enum	MatchOpCode {   kMatchAndMoveBranchTrue , kMatchAndMoveBranchFalse , kNop , kMoveAny ,   kMoveParallelMoves , kMoveGlob , kMoveDebugStepChecks , kInvalidMatchOpCode }
enum class	ParallelMovesHandling { kDefault , kSkip }
enum	Representation { kNumRepresentations }
enum	CSEMode { kOptimizeLoads , kOptimizeStores }
enum	NativeSlotsEnumeration { kNativeSlotsCount }
enum class	CompilerTracing { kOn , kOff }
enum	DeoptStubKind { kLazyDeoptFromReturn , kLazyDeoptFromThrow , kEagerDeopt }
enum	Register {   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , FP = R11 , NOTFP = R7 ,   IP = R12 , SP = R13 , LR = R14 , PC = R15 ,   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   R16 = 16 , R17 = 17 , R18 = 18 , R19 = 19 ,   R20 = 20 , R21 = 21 , R22 = 22 , R23 = 23 ,   R24 = 24 , R25 = 25 , R26 = 26 , R27 = 27 ,   R28 = 28 , R29 = 29 , R30 = 30 , R31 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , kNoRegister2 = -2 , CSP = 32 ,   ZR = 33 , IP0 = R16 , IP1 = R17 , SP = R13 ,   FP = R11 , LR = R14 , EAX = 0 , ECX = 1 ,   EDX = 2 , EBX = 3 , ESP = 4 , EBP = 5 ,   ESI = 6 , EDI = 7 , kNumberOfCpuRegisters = 16 , kNoRegister = -1 ,   ZR = 33 , RA = 1 , SP = R13 , GP = 3 ,   TP = 4 , T0 = 5 , T1 = 6 , T2 = 7 ,   FP = R11 , S1 = 1 , A0 = 10 , A1 = 11 ,   A2 = 12 , A3 = 13 , A4 = 14 , A5 = 15 ,   A6 = 16 , A7 = 17 , S2 = 2 , S3 = 3 ,   S4 = 4 , S5 = 5 , S6 = 6 , S7 = 7 ,   S8 = 8 , S9 = 9 , S10 = 10 , S11 = 11 ,   T3 = 28 , T4 = 29 , T5 = 30 , T6 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , RA2 = T0 , S0 = 0 ,   RAX = 0 , RCX = 1 , RDX = 2 , RBX = 3 ,   RSP = 4 , RBP = 5 , RSI = 6 , RDI = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 }
enum	SRegister {   kNoSRegister = -1 , S0 = 0 , S1 = 1 , S2 = 2 ,   S3 = 3 , S4 = 4 , S5 = 5 , S6 = 6 ,   S7 = 7 , S8 = 8 , S9 = 9 , S10 = 10 ,   S11 = 11 , S12 = 12 , S13 = 13 , S14 = 14 ,   S15 = 15 , S16 = 16 , S17 = 17 , S18 = 18 ,   S19 = 19 , S20 = 20 , S21 = 21 , S22 = 22 ,   S23 = 23 , S24 = 24 , S25 = 25 , S26 = 26 ,   S27 = 27 , S28 = 28 , S29 = 29 , S30 = 30 ,   S31 = 31 , kNumberOfSRegisters = 32 }
enum	DRegister {   kNoDRegister = -1 , D0 = 0 , D1 = 1 , D2 = 2 ,   D3 = 3 , D4 = 4 , D5 = 5 , D6 = 6 ,   D7 = 7 , D8 = 8 , D9 = 9 , D10 = 10 ,   D11 = 11 , D12 = 12 , D13 = 13 , D14 = 14 ,   D15 = 15 , D16 = 16 , D17 = 17 , D18 = 18 ,   D19 = 19 , D20 = 20 , D21 = 21 , D22 = 22 ,   D23 = 23 , D24 = 24 , D25 = 25 , D26 = 26 ,   D27 = 27 , D28 = 28 , D29 = 29 , D30 = 30 ,   D31 = 31 , kNumberOfDRegisters = 32 , kNumberOfOverlappingDRegisters = 16 }
enum	QRegister {   kNoQRegister = -1 , Q0 = 0 , Q1 = 1 , Q2 = 2 ,   Q3 = 3 , Q4 = 4 , Q5 = 5 , Q6 = 6 ,   Q7 = 7 , Q8 = 8 , Q9 = 9 , Q10 = 10 ,   Q11 = 11 , Q12 = 12 , Q13 = 13 , Q14 = 14 ,   Q15 = 15 , kNumberOfQRegisters = 16 , kNumberOfOverlappingQRegisters = 8 }
enum	Condition {   kNoCondition = -1 , EQ = 0 , NE = 1 , CS = 2 ,   CC = 3 , MI = 4 , PL = 5 , VS = 6 ,   VC = 7 , HI = 8 , LS = 9 , GE = 10 ,   LT = 11 , GT = 12 , LE = 13 , AL = 14 ,   kSpecialCondition = 15 , kNumberOfConditions = 16 , EQUAL = EQ , ZERO = EQUAL ,   NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL , LESS = LT , LESS_EQUAL = LE ,   GREATER_EQUAL = GE , GREATER = GT , UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS ,   UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS , OVERFLOW = VS , NO_OVERFLOW = VC ,   kInvalidCondition = 16 , kNoCondition = -1 , EQ = 0 , NE = 1 ,   CS = 2 , CC = 3 , MI = 4 , PL = 5 ,   VS = 6 , VC = 7 , HI = 8 , LS = 9 ,   GE = 10 , LT = 11 , GT = 12 , LE = 13 ,   AL = 14 , NV = 15 , kNumberOfConditions = 16 , EQUAL = EQ ,   ZERO = EQUAL , NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL , LESS = LT ,   LESS_EQUAL = LE , GREATER_EQUAL = GE , GREATER = GT , UNSIGNED_LESS = CC ,   UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS , OVERFLOW = VS ,   NO_OVERFLOW = VC , kInvalidCondition = 16 , kNoCondition = -1 , EQ = 0 ,   NE = 1 , CS = 2 , CC = 3 , MI = 4 ,   PL = 5 , VS = 6 , VC = 7 , HI = 8 ,   LS = 9 , GE = 10 , LT = 11 , GT = 12 ,   LE = 13 , AL = 14 , NV = 15 , kNumberOfConditions = 16 ,   EQUAL = EQ , ZERO = EQUAL , NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL ,   LESS = LT , LESS_EQUAL = LE , GREATER_EQUAL = GE , GREATER = GT ,   UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS ,   OVERFLOW = VS , NO_OVERFLOW = VC , kInvalidCondition = 16 , OVERFLOW = VS ,   NO_OVERFLOW = VC , BELOW = 2 , ABOVE_EQUAL = 3 , EQUAL = EQ ,   NOT_EQUAL = NE , BELOW_EQUAL = 6 , ABOVE = 7 , SIGN = 8 ,   NOT_SIGN = 9 , PARITY_EVEN = 10 , PARITY_ODD = 11 , LESS = LT ,   GREATER_EQUAL = GE , LESS_EQUAL = LE , GREATER = GT , ZERO = EQUAL ,   NOT_ZERO = NOT_EQUAL , NEGATIVE = SIGN , POSITIVE = NOT_SIGN , CARRY = BELOW ,   NOT_CARRY = ABOVE_EQUAL , UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI ,   UNSIGNED_GREATER_EQUAL = CS , kInvalidCondition = 16 }
enum	Opcode {   kNoOperand = -1 , AND = 0 , EOR = 1 , SUB = 2 ,   RSB = 3 , ADD = 4 , ADC = 5 , SBC = 6 ,   RSC = 7 , TST = 8 , TEQ = 9 , CMP = 10 ,   CMN = 11 , ORR = 12 , MOV = 13 , BIC = 14 ,   MVN = 15 , kMaxOperand = 16 , LUI = 0b0110111 , AUIPC = 0b0010111 ,   JAL = 0b1101111 , JALR = 0b1100111 , BRANCH = 0b1100011 , LOAD = 0b0000011 ,   STORE = 0b0100011 , OPIMM = 0b0010011 , OP = 0b0110011 , MISCMEM = 0b0001111 ,   SYSTEM = 0b1110011 , OP32 = 0b0111011 , OPIMM32 = 0b0011011 , AMO = 0b0101111 ,   LOADFP = 0b0000111 , STOREFP = 0b0100111 , FMADD = 0b1000011 , FMSUB = 0b1000111 ,   FNMSUB = 0b1001011 , FNMADD = 0b1001111 , OPFP = 0b1010011 }
enum	Shift {   kNoShift = -1 , LSL = 0 , LSR = 1 , ASR = 2 ,   ROR = 3 , kMaxShift = 4 , kNoShift = -1 , LSL = 0 ,   LSR = 1 , ASR = 2 , ROR = 3 , kMaxShift = 4 }
enum	InstructionFields {   kConditionShift = 28 , kConditionBits = 4 , kTypeShift = 25 , kTypeBits = 3 ,   kLinkShift = 24 , kLinkBits = 1 , kUShift = 23 , kUBits = 1 ,   kOpcodeShift = 21 , kOpcodeBits = 4 , kSShift = 20 , kSBits = 1 ,   kRnShift = 16 , kRnBits = 4 , kRdShift = 12 , kRdBits = 4 ,   kRsShift = 8 , kRsBits = 4 , kRmShift = 0 , kRmBits = 4 ,   kRotateShift = 8 , kRotateBits = 4 , kImmed8Shift = 0 , kImmed8Bits = 8 ,   kShiftImmShift = 7 , kShiftRegisterShift = 8 , kShiftImmBits = 5 , kShiftShift = 5 ,   kShiftBits = 2 , kOffset12Shift = 0 , kOffset12Bits = 12 , kOffset12Mask = 0x00000fff ,   kMulRdShift = 16 , kMulRdBits = 4 , kMulRnShift = 12 , kMulRnBits = 4 ,   kLdrExRnShift = 16 , kLdrExRtShift = 12 , kStrExRnShift = 16 , kStrExRdShift = 12 ,   kStrExRtShift = 0 , kMediaOp1Shift = 20 , kMediaOp1Bits = 5 , kMediaOp2Shift = 5 ,   kMediaOp2Bits = 3 , kDivRdShift = 16 , kDivRdBits = 4 , kDivRmShift = 8 ,   kDivRmBits = 4 , kDivRnShift = 0 , kDivRnBits = 4 , kBitFieldExtractWidthShift = 16 ,   kBitFieldExtractWidthBits = 5 , kBitFieldExtractLSBShift = 7 , kBitFieldExtractLSBBits = 5 , kBitFieldExtractRnShift = 0 ,   kBitFieldExtractRnBits = 4 , kCRmShift = 0 , kCRmBits = 4 , kOpc2Shift = 5 ,   kOpc2Bits = 3 , kCoprocShift = 8 , kCoprocBits = 4 , kCRnShift = 16 ,   kCRnBits = 4 , kOpc1Shift = 21 , kOpc1Bits = 3 , kBranchOffsetMask = 0x00ffffff ,   kSShift = 20 , kSBits = 1 , kSFShift = 31 , kSFBits = 1 ,   kSzShift = 30 , kSzBits = 2 , kRdShift = 12 , kRdBits = 4 ,   kRnShift = 16 , kRnBits = 4 , kRaShift = 10 , kRaBits = 5 ,   kRmShift = 0 , kRmBits = 4 , kRtShift = 0 , kRtBits = 5 ,   kRt2Shift = 10 , kRt2Bits = 5 , kRsShift = 8 , kRsBits = 4 ,   kVdShift = 0 , kVdBits = 5 , kVnShift = 5 , kVnBits = 5 ,   kVmShift = 16 , kVmBits = 5 , kVtShift = 0 , kVtBits = 5 ,   kVt2Shift = 10 , kVt2Bits = 5 , kImm3Shift = 10 , kImm3Bits = 3 ,   kImm4Shift = 11 , kImm4Bits = 4 , kImm5Shift = 16 , kImm5Bits = 5 ,   kImm6Shift = 10 , kImm6Bits = 6 , kImm7Shift = 15 , kImm7Bits = 7 ,   kImm7Mask = 0x7f << kImm7Shift , kImm8Shift = 13 , kImm8Bits = 8 , kImm9Shift = 12 ,   kImm9Bits = 9 , kImm12Shift = 10 , kImm12Bits = 12 , kImm12Mask = 0xfff << kImm12Shift ,   kImm12ShiftShift = 22 , kImm12ShiftBits = 2 , kImm14Shift = 5 , kImm14Bits = 14 ,   kImm14Mask = 0x3fff << kImm14Shift , kImm16Shift = 5 , kImm16Bits = 16 , kImm16Mask = 0xffff << kImm16Shift ,   kImm19Shift = 5 , kImm19Bits = 19 , kImm19Mask = 0x7ffff << kImm19Shift , kImm26Shift = 0 ,   kImm26Bits = 26 , kImm26Mask = 0x03ffffff << kImm26Shift , kCondShift = 0 , kCondBits = 4 ,   kCondMask = 0xf << kCondShift , kSelCondShift = 12 , kSelCondBits = 4 , kNShift = 22 ,   kNBits = 1 , kImmRShift = 16 , kImmRBits = 6 , kImmSShift = 10 ,   kImmSBits = 6 , kHWShift = 21 , kHWBits = 2 , kAddShiftExtendShift = 21 ,   kAddShiftExtendBits = 1 , kShiftTypeShift = 22 , kShiftTypeBits = 2 , kExtendTypeShift = 13 ,   kExtendTypeBits = 3 , kHintCRmShift = 8 , kHintCRmBits = 4 , kHintOp2Shift = 5 ,   kHintOp2Bits = 3 }
enum	ScaleFactor {   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 ,   TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 ,   TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 ,   TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE ,   TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 ,   TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 ,   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 }
enum	Register {   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , FP = R11 , NOTFP = R7 ,   IP = R12 , SP = R13 , LR = R14 , PC = R15 ,   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   R16 = 16 , R17 = 17 , R18 = 18 , R19 = 19 ,   R20 = 20 , R21 = 21 , R22 = 22 , R23 = 23 ,   R24 = 24 , R25 = 25 , R26 = 26 , R27 = 27 ,   R28 = 28 , R29 = 29 , R30 = 30 , R31 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , kNoRegister2 = -2 , CSP = 32 ,   ZR = 33 , IP0 = R16 , IP1 = R17 , SP = R13 ,   FP = R11 , LR = R14 , EAX = 0 , ECX = 1 ,   EDX = 2 , EBX = 3 , ESP = 4 , EBP = 5 ,   ESI = 6 , EDI = 7 , kNumberOfCpuRegisters = 16 , kNoRegister = -1 ,   ZR = 33 , RA = 1 , SP = R13 , GP = 3 ,   TP = 4 , T0 = 5 , T1 = 6 , T2 = 7 ,   FP = R11 , S1 = 1 , A0 = 10 , A1 = 11 ,   A2 = 12 , A3 = 13 , A4 = 14 , A5 = 15 ,   A6 = 16 , A7 = 17 , S2 = 2 , S3 = 3 ,   S4 = 4 , S5 = 5 , S6 = 6 , S7 = 7 ,   S8 = 8 , S9 = 9 , S10 = 10 , S11 = 11 ,   T3 = 28 , T4 = 29 , T5 = 30 , T6 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , RA2 = T0 , S0 = 0 ,   RAX = 0 , RCX = 1 , RDX = 2 , RBX = 3 ,   RSP = 4 , RBP = 5 , RSI = 6 , RDI = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 }
enum	VRegister {   V0 = 0 , V1 = 1 , V2 = 2 , V3 = 3 ,   V4 = 4 , V5 = 5 , V6 = 6 , V7 = 7 ,   V8 = 8 , V9 = 9 , V10 = 10 , V11 = 11 ,   V12 = 12 , V13 = 13 , V14 = 14 , V15 = 15 ,   V16 = 16 , V17 = 17 , V18 = 18 , V19 = 19 ,   V20 = 20 , V21 = 21 , V22 = 22 , V23 = 23 ,   V24 = 24 , V25 = 25 , V26 = 26 , V27 = 27 ,   V28 = 28 , V29 = 29 , V30 = 30 , V31 = 31 ,   kNumberOfVRegisters = 32 , kNoVRegister = -1 }
enum	Condition {   kNoCondition = -1 , EQ = 0 , NE = 1 , CS = 2 ,   CC = 3 , MI = 4 , PL = 5 , VS = 6 ,   VC = 7 , HI = 8 , LS = 9 , GE = 10 ,   LT = 11 , GT = 12 , LE = 13 , AL = 14 ,   kSpecialCondition = 15 , kNumberOfConditions = 16 , EQUAL = EQ , ZERO = EQUAL ,   NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL , LESS = LT , LESS_EQUAL = LE ,   GREATER_EQUAL = GE , GREATER = GT , UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS ,   UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS , OVERFLOW = VS , NO_OVERFLOW = VC ,   kInvalidCondition = 16 , kNoCondition = -1 , EQ = 0 , NE = 1 ,   CS = 2 , CC = 3 , MI = 4 , PL = 5 ,   VS = 6 , VC = 7 , HI = 8 , LS = 9 ,   GE = 10 , LT = 11 , GT = 12 , LE = 13 ,   AL = 14 , NV = 15 , kNumberOfConditions = 16 , EQUAL = EQ ,   ZERO = EQUAL , NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL , LESS = LT ,   LESS_EQUAL = LE , GREATER_EQUAL = GE , GREATER = GT , UNSIGNED_LESS = CC ,   UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS , OVERFLOW = VS ,   NO_OVERFLOW = VC , kInvalidCondition = 16 , kNoCondition = -1 , EQ = 0 ,   NE = 1 , CS = 2 , CC = 3 , MI = 4 ,   PL = 5 , VS = 6 , VC = 7 , HI = 8 ,   LS = 9 , GE = 10 , LT = 11 , GT = 12 ,   LE = 13 , AL = 14 , NV = 15 , kNumberOfConditions = 16 ,   EQUAL = EQ , ZERO = EQUAL , NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL ,   LESS = LT , LESS_EQUAL = LE , GREATER_EQUAL = GE , GREATER = GT ,   UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS ,   OVERFLOW = VS , NO_OVERFLOW = VC , kInvalidCondition = 16 , OVERFLOW = VS ,   NO_OVERFLOW = VC , BELOW = 2 , ABOVE_EQUAL = 3 , EQUAL = EQ ,   NOT_EQUAL = NE , BELOW_EQUAL = 6 , ABOVE = 7 , SIGN = 8 ,   NOT_SIGN = 9 , PARITY_EVEN = 10 , PARITY_ODD = 11 , LESS = LT ,   GREATER_EQUAL = GE , LESS_EQUAL = LE , GREATER = GT , ZERO = EQUAL ,   NOT_ZERO = NOT_EQUAL , NEGATIVE = SIGN , POSITIVE = NOT_SIGN , CARRY = BELOW ,   NOT_CARRY = ABOVE_EQUAL , UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI ,   UNSIGNED_GREATER_EQUAL = CS , kInvalidCondition = 16 }
enum	Bits {   B0 = (1 << 0) , B1 = (1 << 1) , B2 = (1 << 2) , B3 = (1 << 3) ,   B4 = (1 << 4) , B5 = (1 << 5) , B6 = (1 << 6) , B7 = (1 << 7) ,   B8 = (1 << 8) , B9 = (1 << 9) , B10 = (1 << 10) , B11 = (1 << 11) ,   B12 = (1 << 12) , B13 = (1 << 13) , B14 = (1 << 14) , B15 = (1 << 15) ,   B16 = (1 << 16) , B17 = (1 << 17) , 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) , B29 = (1 << 29) , B30 = (1 << 30) , B31 = (1 << 31) }
enum	MainOp {   DPImmediateMask = 0x1c000000 , DPImmediateFixed = B28 , CompareBranchMask = 0x1c000000 , CompareBranchFixed = B28 | B26 ,   LoadStoreMask = B27 | B25 , LoadStoreFixed = B27 , DPRegisterMask = 0x0e000000 , DPRegisterFixed = B27 | B25 ,   DPSimd1Mask = 0x1e000000 , DPSimd1Fixed = B27 | B26 | B25 , DPSimd2Mask = 0x1e000000 , DPSimd2Fixed = B28 | DPSimd1Fixed ,   FPMask = 0x5e000000 , FPFixed = B28 | B27 | B26 | B25 }
enum	CompareAndBranchOp { CompareAndBranchMask = 0x7e000000 , CompareAndBranchFixed = CompareBranchFixed | B29 , CBZ = CompareAndBranchFixed , CBNZ = CompareAndBranchFixed | B24 }
enum	ConditionalBranchOp { ConditionalBranchMask = 0xfe000000 , ConditionalBranchFixed = CompareBranchFixed | B30 , BCOND = ConditionalBranchFixed }
enum	ExceptionGenOp {   ExceptionGenMask = 0xff000000 , ExceptionGenFixed = CompareBranchFixed | B31 | B30 , SVC = ExceptionGenFixed | B0 , BRK = ExceptionGenFixed | B21 ,   HLT = ExceptionGenFixed | B22 }
enum	SystemOp { SystemMask = 0xffc00000 , SystemFixed = CompareBranchFixed | B31 | B30 | B24 , HINT = SystemFixed | B17 | B16 | B13 | B4 | B3 | B2 | B1 | B0 , CLREX }
enum	TestAndBranchOp { TestAndBranchMask = 0x7e000000 , TestAndBranchFixed = CompareBranchFixed | B29 | B25 , TBZ = TestAndBranchFixed , TBNZ = TestAndBranchFixed | B24 }
enum	UnconditionalBranchOp { UnconditionalBranchMask = 0x7c000000 , UnconditionalBranchFixed = CompareBranchFixed , B = UnconditionalBranchFixed , BL = UnconditionalBranchFixed | B31 }
enum	UnconditionalBranchRegOp {   UnconditionalBranchRegMask = 0xfe000000 , UnconditionalBranchRegFixed = CompareBranchFixed | B31 | B30 | B25 , BR = UnconditionalBranchRegFixed | B20 | B19 | B18 | B17 | B16 , BLR = BR | B21 ,   RET = BR | B22 }
enum	LoadRegLiteralOp { LoadRegLiteralMask = 0x3b000000 , LoadRegLiteralFixed = LoadStoreFixed | B28 , LDRpc = LoadRegLiteralFixed }
enum	LoadStoreExclusiveOp {   LoadStoreExclusiveMask = 0x3f000000 , LoadStoreExclusiveFixed = B27 , LDXR = LoadStoreExclusiveFixed | B22 , STXR = LoadStoreExclusiveFixed ,   LDAR = LoadStoreExclusiveFixed | B23 | B22 | B15 , STLR = LoadStoreExclusiveFixed | B23 | B15 }
enum	AtomicMemoryOp { AtomicMemoryMask = 0x3f200c00 , AtomicMemoryFixed = B29 | B28 | B27 | B21 , LDCLR = AtomicMemoryFixed | B12 , LDSET = AtomicMemoryFixed | B13 | B12 }
enum	LoadStoreRegOp {   LoadStoreRegMask = 0x3a000000 , LoadStoreRegFixed = LoadStoreFixed | B29 | B28 , STR = LoadStoreRegFixed , LDR = LoadStoreRegFixed | B22 ,   LDRS = LoadStoreRegFixed | B23 , FSTR = STR | B26 , FLDR = LDR | B26 , FSTRQ = STR | B26 | B23 ,   FLDRQ = LDR | B26 | B23 }
enum	LoadStoreRegPairOp {   LoadStoreRegPairMask = 0x3a000000 , LoadStoreRegPairFixed = LoadStoreFixed | B29 , STP = LoadStoreRegPairFixed , LDP = LoadStoreRegPairFixed | B22 ,   FSTP = STP | B26 , FLDP = LDP | B26 }
enum	AddSubImmOp { AddSubImmMask = 0x1f000000 , AddSubImmFixed = DPImmediateFixed | B24 , ADDI = AddSubImmFixed , SUBI = AddSubImmFixed | B30 }
enum	BitfieldOp {   BitfieldMask = 0x1f800000 , BitfieldFixed = 0x13000000 , SBFM = BitfieldFixed , BFM = BitfieldFixed | B29 ,   UBFM = BitfieldFixed | B30 , Bitfield64 = B31 | B22 }
enum	LogicalImmOp {   LogicalImmMask = 0x1f800000 , LogicalImmFixed = DPImmediateFixed | B25 , ANDI = LogicalImmFixed , ORRI = LogicalImmFixed | B29 ,   EORI = LogicalImmFixed | B30 , ANDIS = LogicalImmFixed | B30 | B29 }
enum	MoveWideOp {   MoveWideMask = 0x1f800000 , MoveWideFixed = DPImmediateFixed | B25 | B23 , MOVN = MoveWideFixed , MOVZ = MoveWideFixed | B30 ,   MOVK = MoveWideFixed | B30 | B29 }
enum	PCRelOp { PCRelMask = 0x1f000000 , PCRelFixed = DPImmediateFixed , ADR = PCRelFixed , ADRP = PCRelFixed | B31 }
enum	AddSubShiftExtOp { AddSubShiftExtMask = 0x1f000000 , AddSubShiftExtFixed = DPRegisterFixed | B24 , ADD = 4 , SUB = 2 }
enum	AddSubWithCarryOp { AddSubWithCarryMask = 0x1fe00000 , AddSubWithCarryFixed = DPRegisterFixed | B28 , ADC = 5 , SBC = 6 }
enum	ConditionalSelectOp {   ConditionalSelectMask = 0x1fe00000 , ConditionalSelectFixed = DPRegisterFixed | B28 | B23 , CSEL = ConditionalSelectFixed , CSINC = ConditionalSelectFixed | B10 ,   CSINV = ConditionalSelectFixed | B30 , CSNEG = ConditionalSelectFixed | B10 | B30 }
enum	MiscDP1SourceOp { MiscDP1SourceMask = 0x5fe00000 , MiscDP1SourceFixed = DPRegisterFixed | B30 | B28 | B23 | B22 , CLZ = MiscDP1SourceFixed | B12 , RBIT = MiscDP1SourceFixed }
enum	MiscDP2SourceOp {   MiscDP2SourceMask = 0x5fe00000 , MiscDP2SourceFixed = DPRegisterFixed | B28 | B23 | B22 , UDIV = MiscDP2SourceFixed | B11 , SDIV = MiscDP2SourceFixed | B11 | B10 ,   LSLV = MiscDP2SourceFixed | B13 , LSRV = MiscDP2SourceFixed | B13 | B10 , ASRV = MiscDP2SourceFixed | B13 | B11 }
enum	MiscDP3SourceOp {   MiscDP3SourceMask = 0x1f000000 , MiscDP3SourceFixed = DPRegisterFixed | B28 | B24 , MADDW = MiscDP3SourceFixed , MADD = MiscDP3SourceFixed | B31 ,   MSUBW = MiscDP3SourceFixed | B15 , MSUB = MiscDP3SourceFixed | B31 | B15 , SMULH = MiscDP3SourceFixed | B31 | B22 , UMULH = MiscDP3SourceFixed | B31 | B23 | B22 ,   SMADDL = MiscDP3SourceFixed | B31 | B21 , UMADDL = MiscDP3SourceFixed | B31 | B23 | B21 , SMSUBL = MiscDP3SourceFixed | B31 | B21 | B15 , UMSUBL = MiscDP3SourceFixed | B31 | B23 | B21 | B15 }
enum	LogicalShiftOp {   LogicalShiftMask = 0x1f000000 , LogicalShiftFixed = DPRegisterFixed , AND = 0 , BIC = 14 ,   ORR = 12 , ORN = LogicalShiftFixed | B29 | B21 , EOR = 1 , EON = LogicalShiftFixed | B30 | B21 ,   ANDS = LogicalShiftFixed | B30 | B29 , BICS = LogicalShiftFixed | B30 | B29 | B21 }
enum	SIMDCopyOp {   SIMDCopyMask = 0x9fe08400 , SIMDCopyFixed = DPSimd1Fixed | B10 , VDUPI = SIMDCopyFixed | B30 | B11 , VINSI = SIMDCopyFixed | B30 | B12 | B11 ,   VMOVW = SIMDCopyFixed | B13 | B12 | B11 , VMOVX = SIMDCopyFixed | B30 | B13 | B12 | B11 , VDUP = SIMDCopyFixed | B30 , VINS = SIMDCopyFixed | B30 | B29 }
enum	SIMDThreeSameOp {   SIMDThreeSameMask = 0x9f200400 , SIMDThreeSameFixed = DPSimd1Fixed | B21 | B10 , VAND = SIMDThreeSameFixed | B30 | B12 | B11 , VORR = SIMDThreeSameFixed | B30 | B23 | B12 | B11 ,   VEOR = SIMDThreeSameFixed | B30 | B29 | B12 | B11 , VADDW = SIMDThreeSameFixed | B30 | B23 | B15 , VADDX = SIMDThreeSameFixed | B30 | B23 | B22 | B15 , VSUBW = SIMDThreeSameFixed | B30 | B29 | B23 | B15 ,   VSUBX = SIMDThreeSameFixed | B30 | B29 | B23 | B22 | B15 , VADDS = SIMDThreeSameFixed | B30 | B15 | B14 | B12 , VADDD = SIMDThreeSameFixed | B30 | B22 | B15 | B14 | B12 , VSUBS = SIMDThreeSameFixed | B30 | B23 | B15 | B14 | B12 ,   VSUBD = SIMDThreeSameFixed | B30 | B23 | B22 | B15 | B14 | B12 , VMULS = SIMDThreeSameFixed | B30 | B29 | B15 | B14 | B12 | B11 , VMULD = SIMDThreeSameFixed | B30 | B29 | B22 | B15 | B14 | B12 | B11 , VDIVS = SIMDThreeSameFixed | B30 | B29 | B15 | B14 | B13 | B12 | B11 ,   VDIVD = SIMDThreeSameFixed | B30 | B29 | B22 | B15 | B14 | B13 | B12 | B11 , VCEQS = SIMDThreeSameFixed | B30 | B15 | B14 | B13 , VCEQD = SIMDThreeSameFixed | B30 | B22 | B15 | B14 | B13 , VCGES = SIMDThreeSameFixed | B30 | B29 | B15 | B14 | B13 ,   VCGED = SIMDThreeSameFixed | B30 | B29 | B22 | B15 | B14 | B13 , VCGTS = SIMDThreeSameFixed | B30 | B29 | B23 | B15 | B14 | B13 , VCGTD = SIMDThreeSameFixed | B30 | B29 | B23 | B22 | B15 | B14 | B13 , VMAXS = SIMDThreeSameFixed | B30 | B15 | B14 | B13 | B12 ,   VMAXD = SIMDThreeSameFixed | B30 | B22 | B15 | B14 | B13 | B12 , VMINS = SIMDThreeSameFixed | B30 | B23 | B15 | B14 | B13 | B12 , VMIND = SIMDThreeSameFixed | B30 | B23 | B22 | B15 | B14 | B13 | B12 , VRECPSS = SIMDThreeSameFixed | B30 | B15 | B14 | B13 | B12 | B11 ,   VRSQRTSS = SIMDThreeSameFixed | B30 | B23 | B15 | B14 | B13 | B12 | B11 }
enum	SIMDTwoRegOp {   SIMDTwoRegMask = 0x9f3e0c00 , SIMDTwoRegFixed = DPSimd1Fixed | B21 | B11 , VNOT = SIMDTwoRegFixed | B30 | B29 | B14 | B12 , VABSS = SIMDTwoRegFixed | B30 | B23 | B15 | B14 | B13 | B12 ,   VNEGS = SIMDTwoRegFixed | B30 | B29 | B23 | B15 | B14 | B13 | B12 , VABSD = SIMDTwoRegFixed | B30 | B23 | B22 | B15 | B14 | B13 | B12 , VNEGD = SIMDTwoRegFixed | B30 | B29 | B23 | B22 | B15 | B14 | B13 | B12 , VSQRTS = SIMDTwoRegFixed | B30 | B29 | B23 | B16 | B15 | B14 | B13 | B12 ,   VSQRTD , VRECPES = SIMDTwoRegFixed | B30 | B23 | B16 | B15 | B14 | B12 , VRSQRTES = SIMDTwoRegFixed | B30 | B29 | B23 | B16 | B15 | B14 | B12 }
enum	FPCompareOp { FPCompareMask = 0xffa0fc07 , FPCompareFixed = FPFixed | B21 | B13 , FCMPD = FPCompareFixed | B22 , FCMPZD = FPCompareFixed | B22 | B3 }
enum	FPOneSourceOp {   FPOneSourceMask = 0x5f207c00 , FPOneSourceFixed = FPFixed | B21 | B14 , FMOVDD = FPOneSourceFixed | B22 , FABSD = FPOneSourceFixed | B22 | B15 ,   FNEGD = FPOneSourceFixed | B22 | B16 , FSQRTD = FPOneSourceFixed | B22 | B16 | B15 , FCVTDS = FPOneSourceFixed | B15 | B17 , FCVTSD = FPOneSourceFixed | B22 | B17 }
enum	FPTwoSourceOp {   FPTwoSourceMask = 0xff200c00 , FPTwoSourceFixed = FPFixed | B21 | B11 , FMULD = FPTwoSourceFixed | B22 , FDIVD = FPTwoSourceFixed | B22 | B12 ,   FADDD = FPTwoSourceFixed | B22 | B13 , FSUBD = FPTwoSourceFixed | B22 | B13 | B12 }
enum	FPImmOp { FPImmMask = 0x5f201c00 , FPImmFixed = FPFixed | B21 | B12 , FMOVSI = FPImmFixed , FMOVDI = FPImmFixed | B22 }
enum	FPIntCvtOp {   FPIntCvtMask = 0x5f00fc00 , FPIntCvtFixed = FPFixed | B21 , FMOVRS = FPIntCvtFixed | B18 | B17 , FMOVSR = FPIntCvtFixed | B18 | B17 | B16 ,   FMOVRD = FPIntCvtFixed | B22 | B18 | B17 , FMOVDR = FPIntCvtFixed | B22 | B18 | B17 | B16 , FCVTZS_D = FPIntCvtFixed | B22 | B20 | B19 , FCVTMS_D = FPIntCvtFixed | B22 | B20 ,   FCVTPS_D = FPIntCvtFixed | B22 | B19 , SCVTFD = FPIntCvtFixed | B22 | B17 }
enum	Shift {   kNoShift = -1 , LSL = 0 , LSR = 1 , ASR = 2 ,   ROR = 3 , kMaxShift = 4 , kNoShift = -1 , LSL = 0 ,   LSR = 1 , ASR = 2 , ROR = 3 , kMaxShift = 4 }
enum	Extend {   kNoExtend = -1 , UXTB = 0 , UXTH = 1 , UXTW = 2 ,   UXTX = 3 , SXTB = 4 , SXTH = 5 , SXTW = 6 ,   SXTX = 7 , kMaxExtend = 8 }
enum	R31Type { R31IsSP , R31IsZR }
enum	InstructionFields {   kConditionShift = 28 , kConditionBits = 4 , kTypeShift = 25 , kTypeBits = 3 ,   kLinkShift = 24 , kLinkBits = 1 , kUShift = 23 , kUBits = 1 ,   kOpcodeShift = 21 , kOpcodeBits = 4 , kSShift = 20 , kSBits = 1 ,   kRnShift = 16 , kRnBits = 4 , kRdShift = 12 , kRdBits = 4 ,   kRsShift = 8 , kRsBits = 4 , kRmShift = 0 , kRmBits = 4 ,   kRotateShift = 8 , kRotateBits = 4 , kImmed8Shift = 0 , kImmed8Bits = 8 ,   kShiftImmShift = 7 , kShiftRegisterShift = 8 , kShiftImmBits = 5 , kShiftShift = 5 ,   kShiftBits = 2 , kOffset12Shift = 0 , kOffset12Bits = 12 , kOffset12Mask = 0x00000fff ,   kMulRdShift = 16 , kMulRdBits = 4 , kMulRnShift = 12 , kMulRnBits = 4 ,   kLdrExRnShift = 16 , kLdrExRtShift = 12 , kStrExRnShift = 16 , kStrExRdShift = 12 ,   kStrExRtShift = 0 , kMediaOp1Shift = 20 , kMediaOp1Bits = 5 , kMediaOp2Shift = 5 ,   kMediaOp2Bits = 3 , kDivRdShift = 16 , kDivRdBits = 4 , kDivRmShift = 8 ,   kDivRmBits = 4 , kDivRnShift = 0 , kDivRnBits = 4 , kBitFieldExtractWidthShift = 16 ,   kBitFieldExtractWidthBits = 5 , kBitFieldExtractLSBShift = 7 , kBitFieldExtractLSBBits = 5 , kBitFieldExtractRnShift = 0 ,   kBitFieldExtractRnBits = 4 , kCRmShift = 0 , kCRmBits = 4 , kOpc2Shift = 5 ,   kOpc2Bits = 3 , kCoprocShift = 8 , kCoprocBits = 4 , kCRnShift = 16 ,   kCRnBits = 4 , kOpc1Shift = 21 , kOpc1Bits = 3 , kBranchOffsetMask = 0x00ffffff ,   kSShift = 20 , kSBits = 1 , kSFShift = 31 , kSFBits = 1 ,   kSzShift = 30 , kSzBits = 2 , kRdShift = 12 , kRdBits = 4 ,   kRnShift = 16 , kRnBits = 4 , kRaShift = 10 , kRaBits = 5 ,   kRmShift = 0 , kRmBits = 4 , kRtShift = 0 , kRtBits = 5 ,   kRt2Shift = 10 , kRt2Bits = 5 , kRsShift = 8 , kRsBits = 4 ,   kVdShift = 0 , kVdBits = 5 , kVnShift = 5 , kVnBits = 5 ,   kVmShift = 16 , kVmBits = 5 , kVtShift = 0 , kVtBits = 5 ,   kVt2Shift = 10 , kVt2Bits = 5 , kImm3Shift = 10 , kImm3Bits = 3 ,   kImm4Shift = 11 , kImm4Bits = 4 , kImm5Shift = 16 , kImm5Bits = 5 ,   kImm6Shift = 10 , kImm6Bits = 6 , kImm7Shift = 15 , kImm7Bits = 7 ,   kImm7Mask = 0x7f << kImm7Shift , kImm8Shift = 13 , kImm8Bits = 8 , kImm9Shift = 12 ,   kImm9Bits = 9 , kImm12Shift = 10 , kImm12Bits = 12 , kImm12Mask = 0xfff << kImm12Shift ,   kImm12ShiftShift = 22 , kImm12ShiftBits = 2 , kImm14Shift = 5 , kImm14Bits = 14 ,   kImm14Mask = 0x3fff << kImm14Shift , kImm16Shift = 5 , kImm16Bits = 16 , kImm16Mask = 0xffff << kImm16Shift ,   kImm19Shift = 5 , kImm19Bits = 19 , kImm19Mask = 0x7ffff << kImm19Shift , kImm26Shift = 0 ,   kImm26Bits = 26 , kImm26Mask = 0x03ffffff << kImm26Shift , kCondShift = 0 , kCondBits = 4 ,   kCondMask = 0xf << kCondShift , kSelCondShift = 12 , kSelCondBits = 4 , kNShift = 22 ,   kNBits = 1 , kImmRShift = 16 , kImmRBits = 6 , kImmSShift = 10 ,   kImmSBits = 6 , kHWShift = 21 , kHWBits = 2 , kAddShiftExtendShift = 21 ,   kAddShiftExtendBits = 1 , kShiftTypeShift = 22 , kShiftTypeBits = 2 , kExtendTypeShift = 13 ,   kExtendTypeBits = 3 , kHintCRmShift = 8 , kHintCRmBits = 4 , kHintOp2Shift = 5 ,   kHintOp2Bits = 3 }
enum	ScaleFactor {   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 ,   TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 ,   TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 ,   TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE ,   TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 ,   TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 ,   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 }
enum	AlignmentStrategy { kAlignedToValueSize , kAlignedToValueSizeBut8AlignedTo4 , kAlignedToWordSize , kAlignedToWordSizeAndValueSize }
enum	ExtensionStrategy { kNotExtended , kExtendedTo4 , kExtendedTo8 }
enum	Register {   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , FP = R11 , NOTFP = R7 ,   IP = R12 , SP = R13 , LR = R14 , PC = R15 ,   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   R16 = 16 , R17 = 17 , R18 = 18 , R19 = 19 ,   R20 = 20 , R21 = 21 , R22 = 22 , R23 = 23 ,   R24 = 24 , R25 = 25 , R26 = 26 , R27 = 27 ,   R28 = 28 , R29 = 29 , R30 = 30 , R31 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , kNoRegister2 = -2 , CSP = 32 ,   ZR = 33 , IP0 = R16 , IP1 = R17 , SP = R13 ,   FP = R11 , LR = R14 , EAX = 0 , ECX = 1 ,   EDX = 2 , EBX = 3 , ESP = 4 , EBP = 5 ,   ESI = 6 , EDI = 7 , kNumberOfCpuRegisters = 16 , kNoRegister = -1 ,   ZR = 33 , RA = 1 , SP = R13 , GP = 3 ,   TP = 4 , T0 = 5 , T1 = 6 , T2 = 7 ,   FP = R11 , S1 = 1 , A0 = 10 , A1 = 11 ,   A2 = 12 , A3 = 13 , A4 = 14 , A5 = 15 ,   A6 = 16 , A7 = 17 , S2 = 2 , S3 = 3 ,   S4 = 4 , S5 = 5 , S6 = 6 , S7 = 7 ,   S8 = 8 , S9 = 9 , S10 = 10 , S11 = 11 ,   T3 = 28 , T4 = 29 , T5 = 30 , T6 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , RA2 = T0 , S0 = 0 ,   RAX = 0 , RCX = 1 , RDX = 2 , RBX = 3 ,   RSP = 4 , RBP = 5 , RSI = 6 , RDI = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 }
enum	ByteRegister {   AL = 14 , CL = 1 , DL = 2 , BL = UnconditionalBranchFixed | B31 ,   AH = 4 , CH = 5 , DH = 6 , BH = 7 ,   kNumberOfByteRegisters = 8 , kNoByteRegister = -1 , AL = 14 , CL = 1 ,   DL = 2 , BL = UnconditionalBranchFixed | B31 , AH = 4 , CH = 5 ,   DH = 6 , BH = 7 , SPL = 4 | 0x10 , BPL = 5 | 0x10 ,   SIL = 6 | 0x10 , DIL = 7 | 0x10 , R8B = 8 , R9B = 9 ,   R10B = 10 , R11B = 11 , R12B = 12 , R13B = 13 ,   R14B = 14 , R15B = 15 , kNumberOfByteRegisters = 8 , kNoByteRegister = -1 }
enum	XmmRegister {   XMM0 = 0 , XMM1 = 1 , XMM2 = 2 , XMM3 = 3 ,   XMM4 = 4 , XMM5 = 5 , XMM6 = 6 , XMM7 = 7 ,   kNumberOfXmmRegisters = 8 , kNoXmmRegister = -1 , XMM0 = 0 , XMM1 = 1 ,   XMM2 = 2 , XMM3 = 3 , XMM4 = 4 , XMM5 = 5 ,   XMM6 = 6 , XMM7 = 7 , XMM8 = 8 , XMM9 = 9 ,   XMM10 = 10 , XMM11 = 11 , XMM12 = 12 , XMM13 = 13 ,   XMM14 = 14 , XMM15 = 15 , kNumberOfXmmRegisters = 8 , kNoXmmRegister = -1 }
enum	ScaleFactor {   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 ,   TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 ,   TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 ,   TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE ,   TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 ,   TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 ,   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 }
enum	Register {   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , FP = R11 , NOTFP = R7 ,   IP = R12 , SP = R13 , LR = R14 , PC = R15 ,   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   R16 = 16 , R17 = 17 , R18 = 18 , R19 = 19 ,   R20 = 20 , R21 = 21 , R22 = 22 , R23 = 23 ,   R24 = 24 , R25 = 25 , R26 = 26 , R27 = 27 ,   R28 = 28 , R29 = 29 , R30 = 30 , R31 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , kNoRegister2 = -2 , CSP = 32 ,   ZR = 33 , IP0 = R16 , IP1 = R17 , SP = R13 ,   FP = R11 , LR = R14 , EAX = 0 , ECX = 1 ,   EDX = 2 , EBX = 3 , ESP = 4 , EBP = 5 ,   ESI = 6 , EDI = 7 , kNumberOfCpuRegisters = 16 , kNoRegister = -1 ,   ZR = 33 , RA = 1 , SP = R13 , GP = 3 ,   TP = 4 , T0 = 5 , T1 = 6 , T2 = 7 ,   FP = R11 , S1 = 1 , A0 = 10 , A1 = 11 ,   A2 = 12 , A3 = 13 , A4 = 14 , A5 = 15 ,   A6 = 16 , A7 = 17 , S2 = 2 , S3 = 3 ,   S4 = 4 , S5 = 5 , S6 = 6 , S7 = 7 ,   S8 = 8 , S9 = 9 , S10 = 10 , S11 = 11 ,   T3 = 28 , T4 = 29 , T5 = 30 , T6 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , RA2 = T0 , S0 = 0 ,   RAX = 0 , RCX = 1 , RDX = 2 , RBX = 3 ,   RSP = 4 , RBP = 5 , RSI = 6 , RDI = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 }
enum	FRegister {   FT0 = 0 , FT1 = 1 , FT2 = 2 , FT3 = 3 ,   FT4 = 4 , FT5 = 5 , FT6 = 6 , FT7 = 7 ,   FS0 = 8 , FS1 = 9 , FA0 = 10 , FA1 = 11 ,   FA2 = 12 , FA3 = 13 , FA4 = 14 , FA5 = 15 ,   FA6 = 16 , FA7 = 17 , FS2 = 18 , FS3 = 19 ,   FS4 = 20 , FS5 = 21 , FS6 = 22 , FS7 = 23 ,   FS8 = 24 , FS9 = 25 , FS10 = 26 , FS11 = 27 ,   FT8 = 28 , FT9 = 29 , FT10 = 30 , FT11 = 31 }
enum	Condition {   kNoCondition = -1 , EQ = 0 , NE = 1 , CS = 2 ,   CC = 3 , MI = 4 , PL = 5 , VS = 6 ,   VC = 7 , HI = 8 , LS = 9 , GE = 10 ,   LT = 11 , GT = 12 , LE = 13 , AL = 14 ,   kSpecialCondition = 15 , kNumberOfConditions = 16 , EQUAL = EQ , ZERO = EQUAL ,   NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL , LESS = LT , LESS_EQUAL = LE ,   GREATER_EQUAL = GE , GREATER = GT , UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS ,   UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS , OVERFLOW = VS , NO_OVERFLOW = VC ,   kInvalidCondition = 16 , kNoCondition = -1 , EQ = 0 , NE = 1 ,   CS = 2 , CC = 3 , MI = 4 , PL = 5 ,   VS = 6 , VC = 7 , HI = 8 , LS = 9 ,   GE = 10 , LT = 11 , GT = 12 , LE = 13 ,   AL = 14 , NV = 15 , kNumberOfConditions = 16 , EQUAL = EQ ,   ZERO = EQUAL , NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL , LESS = LT ,   LESS_EQUAL = LE , GREATER_EQUAL = GE , GREATER = GT , UNSIGNED_LESS = CC ,   UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS , OVERFLOW = VS ,   NO_OVERFLOW = VC , kInvalidCondition = 16 , kNoCondition = -1 , EQ = 0 ,   NE = 1 , CS = 2 , CC = 3 , MI = 4 ,   PL = 5 , VS = 6 , VC = 7 , HI = 8 ,   LS = 9 , GE = 10 , LT = 11 , GT = 12 ,   LE = 13 , AL = 14 , NV = 15 , kNumberOfConditions = 16 ,   EQUAL = EQ , ZERO = EQUAL , NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL ,   LESS = LT , LESS_EQUAL = LE , GREATER_EQUAL = GE , GREATER = GT ,   UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS ,   OVERFLOW = VS , NO_OVERFLOW = VC , kInvalidCondition = 16 , OVERFLOW = VS ,   NO_OVERFLOW = VC , BELOW = 2 , ABOVE_EQUAL = 3 , EQUAL = EQ ,   NOT_EQUAL = NE , BELOW_EQUAL = 6 , ABOVE = 7 , SIGN = 8 ,   NOT_SIGN = 9 , PARITY_EVEN = 10 , PARITY_ODD = 11 , LESS = LT ,   GREATER_EQUAL = GE , LESS_EQUAL = LE , GREATER = GT , ZERO = EQUAL ,   NOT_ZERO = NOT_EQUAL , NEGATIVE = SIGN , POSITIVE = NOT_SIGN , CARRY = BELOW ,   NOT_CARRY = ABOVE_EQUAL , UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI ,   UNSIGNED_GREATER_EQUAL = CS , kInvalidCondition = 16 }
enum	ScaleFactor {   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 ,   TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 ,   TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 ,   TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE ,   TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 ,   TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 ,   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 }
enum	Opcode {   kNoOperand = -1 , AND = 0 , EOR = 1 , SUB = 2 ,   RSB = 3 , ADD = 4 , ADC = 5 , SBC = 6 ,   RSC = 7 , TST = 8 , TEQ = 9 , CMP = 10 ,   CMN = 11 , ORR = 12 , MOV = 13 , BIC = 14 ,   MVN = 15 , kMaxOperand = 16 , LUI = 0b0110111 , AUIPC = 0b0010111 ,   JAL = 0b1101111 , JALR = 0b1100111 , BRANCH = 0b1100011 , LOAD = 0b0000011 ,   STORE = 0b0100011 , OPIMM = 0b0010011 , OP = 0b0110011 , MISCMEM = 0b0001111 ,   SYSTEM = 0b1110011 , OP32 = 0b0111011 , OPIMM32 = 0b0011011 , AMO = 0b0101111 ,   LOADFP = 0b0000111 , STOREFP = 0b0100111 , FMADD = 0b1000011 , FMSUB = 0b1000111 ,   FNMSUB = 0b1001011 , FNMADD = 0b1001111 , OPFP = 0b1010011 }
enum	Funct12 { ECALL = 0 , EBREAK = 1 }
enum	Funct3 {   F3_0 = 0 , F3_1 = 1 , BEQ = 0b000 , BNE = 0b001 ,   BLT = 0b100 , BGE = 0b101 , BLTU = 0b110 , BGEU = 0b111 ,   LB = 0b000 , LH = 0b001 , LW = 0b010 , LBU = 0b100 ,   LHU = 0b101 , LWU = 0b110 , LD = 0b011 , SB = 0b000 ,   SH = 0b001 , SW = 0b010 , SD = 0b011 , ADDI = AddSubImmFixed ,   SLLI = 0b001 , SLTI = 0b010 , SLTIU = 0b011 , XORI = 0b100 ,   SRI = 0b101 , ORI = 0b110 , ANDI = LogicalImmFixed , ADD = 4 ,   SLL = 0b001 , SLT = 0b010 , SLTU = 0b011 , XOR = 0b100 ,   SR = 0b101 , OR = 0b110 , AND = 0 , FENCE = 0b000 ,   FENCEI = 0b001 , CSRRW = 0b001 , CSRRS = 0b010 , CSRRC = 0b011 ,   CSRRWI = 0b101 , CSRRSI = 0b110 , CSRRCI = 0b111 , MUL = 0b000 ,   MULH = 0b001 , MULHSU = 0b010 , MULHU = 0b011 , DIV = 0b100 ,   DIVU = 0b101 , REM = 0b110 , REMU = 0b111 , MULW = 0b000 ,   DIVW = 0b100 , DIVUW = 0b101 , REMW = 0b110 , REMUW = 0b111 ,   WIDTH32 = 0b010 , WIDTH64 = 0b011 , S = 0b010 , D = 0b011 ,   J = 0b000 , JN = 0b001 , JX = 0b010 , FMIN = 0b000 ,   FMAX = 0b001 , FEQ = 0b010 , FLT = 0b001 , FLE = 0b000 ,   SH1ADD = 0b010 , SH2ADD = 0b100 , SH3ADD = 0b110 , F3_COUNT = 0b001 ,   MAX = 0b110 , MAXU = 0b111 , MIN = 0b100 , MINU = 0b101 ,   CLMUL = 0b001 , CLMULH = 0b011 , CLMULR = 0b010 , SEXT = 0b001 ,   ZEXT = 0b100 , ROL = 0b001 , ROR = 3 , BCLR = 0b001 ,   BEXT = 0b101 , F3_BINV = 0b001 , F3_BSET = 0b001 }
enum	Funct7 {   F7_0 = 0 , SRA = 0b0100000 , SUB = 2 , MULDIV = 0b0000001 ,   FADDS = 0b0000000 , FSUBS = 0b0000100 , FMULS = 0b0001000 , FDIVS = 0b0001100 ,   FSQRTS = 0b0101100 , FSGNJS = 0b0010000 , FMINMAXS = 0b0010100 , FCMPS = 0b1010000 ,   FCLASSS = 0b1110000 , FCVTintS = 0b1100000 , FCVTSint = 0b1101000 , FMVXW = 0b1110000 ,   FMVWX = 0b1111000 , FADDD = FPTwoSourceFixed | B22 | B13 , FSUBD = FPTwoSourceFixed | B22 | B13 | B12 , FMULD = FPTwoSourceFixed | B22 ,   FDIVD = FPTwoSourceFixed | B22 | B12 , FSQRTD = FPOneSourceFixed | B22 | B16 | B15 , FSGNJD = 0b0010001 , FMINMAXD = 0b0010101 ,   FCVTS = 0b0100000 , FCVTD = 0b0100001 , FCMPD = FPCompareFixed | B22 , FCLASSD = 0b1110001 ,   FCVTintD = 0b1100001 , FCVTDint = 0b1101001 , FMVXD = 0b1110001 , FMVDX = 0b1111001 ,   ADDUW = 0b0000100 , SHADD = 0b0010000 , SLLIUW = 0b0000100 , COUNT = 0b0110000 ,   MINMAXCLMUL = 0b0000101 , ROTATE = 0b0110000 , BCLRBEXT = 0b0100100 , BINV = 0b0110100 ,   BSET = 0b0010100 }
enum	Funct5 {   LR = R14 , SC = 0b00011 , AMOSWAP = 0b00001 , AMOADD = 0b00000 ,   AMOXOR = 0b00100 , AMOAND = 0b01100 , AMOOR = 0b01000 , AMOMIN = 0b10000 ,   AMOMAX = 0b10100 , AMOMINU = 0b11000 , AMOMAXU = 0b11100 }
enum	Funct2 { F2_S = 0b00 , F2_D = 0b01 }
enum	RoundingMode {   RNE = 0b000 , RTZ = 0b001 , RDN = 0b010 , RUP = 0b011 ,   RMM = 0b100 , DYN = 0b111 }
enum	FcvtRs2 { W = 0b00000 , WU = 0b00001 , L = 0b00010 , LU = 0b00011 }
enum	FClass {   kFClassNegInfinity = 1 << 0 , kFClassNegNormal = 1 << 1 , kFClassNegSubnormal = 1 << 2 , kFClassNegZero = 1 << 3 ,   kFClassPosZero = 1 << 4 , kFClassPosSubnormal = 1 << 5 , kFClassPosNormal = 1 << 6 , kFClassPosInfinity = 1 << 7 ,   kFClassSignallingNan = 1 << 8 , kFClassQuietNan = 1 << 9 }
enum	HartEffects {   kWrite = 1 << 0 , kRead = 1 << 1 , kOutput = 1 << 2 , kInput = 1 << 3 ,   kMemory = kWrite | kRead , kIO = kOutput | kInput , kAll = kMemory | kIO }
enum	COpcode {   C_OP_MASK = 0b1110000000000011 , C_ADDI4SPN = 0b0000000000000000 , C_FLD = 0b0010000000000000 , C_LW = 0b0100000000000000 ,   C_FLW = 0b0110000000000000 , C_LD = 0b0110000000000000 , C_FSD = 0b1010000000000000 , C_SW = 0b1100000000000000 ,   C_FSW = 0b1110000000000000 , C_SD = 0b1110000000000000 , C_ADDI = 0b0000000000000001 , C_JAL = 0b0010000000000001 ,   C_ADDIW = 0b0010000000000001 , C_LI = 0b0100000000000001 , C_ADDI16SP = 0b0110000000000001 , C_LUI = 0b0110000000000001 ,   C_MISCALU = 0b1000000000000001 , C_MISCALU_MASK = 0b1110110000000011 , C_SRLI = 0b1000000000000001 , C_SRAI = 0b1000010000000001 ,   C_ANDI = 0b1000100000000001 , C_RR = 0b1000110000000001 , C_RR_MASK = 0b1111110001100011 , C_SUB = 0b1000110000000001 ,   C_XOR = 0b1000110000100001 , C_OR = 0b1000110001000001 , C_AND = 0b1000110001100001 , C_SUBW = 0b1001110000000001 ,   C_ADDW = 0b1001110000100001 , C_J = 0b1010000000000001 , C_BEQZ = 0b1100000000000001 , C_BNEZ = 0b1110000000000001 ,   C_SLLI = 0b0000000000000010 , C_FLDSP = 0b0010000000000010 , C_LWSP = 0b0100000000000010 , C_FLWSP = 0b0110000000000010 ,   C_LDSP = 0b0110000000000010 , C_JR = 0b1000000000000010 , C_MV = 0b1000000000000010 , C_JALR = 0b1001000000000010 ,   C_ADD = 0b1001000000000010 , C_FSDSP = 0b1010000000000010 , C_SWSP = 0b1100000000000010 , C_FSWSP = 0b1110000000000010 ,   C_SDSP = 0b1110000000000010 , C_NOP = 0b0000000000000001 , C_EBREAK = 0b1001000000000010 }
enum	Register {   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , FP = R11 , NOTFP = R7 ,   IP = R12 , SP = R13 , LR = R14 , PC = R15 ,   R0 = 0 , R1 = 1 , R2 = 2 , R3 = 3 ,   R4 = 4 , R5 = 5 , R6 = 6 , R7 = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   R16 = 16 , R17 = 17 , R18 = 18 , R19 = 19 ,   R20 = 20 , R21 = 21 , R22 = 22 , R23 = 23 ,   R24 = 24 , R25 = 25 , R26 = 26 , R27 = 27 ,   R28 = 28 , R29 = 29 , R30 = 30 , R31 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , kNoRegister2 = -2 , CSP = 32 ,   ZR = 33 , IP0 = R16 , IP1 = R17 , SP = R13 ,   FP = R11 , LR = R14 , EAX = 0 , ECX = 1 ,   EDX = 2 , EBX = 3 , ESP = 4 , EBP = 5 ,   ESI = 6 , EDI = 7 , kNumberOfCpuRegisters = 16 , kNoRegister = -1 ,   ZR = 33 , RA = 1 , SP = R13 , GP = 3 ,   TP = 4 , T0 = 5 , T1 = 6 , T2 = 7 ,   FP = R11 , S1 = 1 , A0 = 10 , A1 = 11 ,   A2 = 12 , A3 = 13 , A4 = 14 , A5 = 15 ,   A6 = 16 , A7 = 17 , S2 = 2 , S3 = 3 ,   S4 = 4 , S5 = 5 , S6 = 6 , S7 = 7 ,   S8 = 8 , S9 = 9 , S10 = 10 , S11 = 11 ,   T3 = 28 , T4 = 29 , T5 = 30 , T6 = 31 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 , RA2 = T0 , S0 = 0 ,   RAX = 0 , RCX = 1 , RDX = 2 , RBX = 3 ,   RSP = 4 , RBP = 5 , RSI = 6 , RDI = 7 ,   R8 = 8 , R9 = 9 , R10 = 10 , R11 = 11 ,   R12 = 12 , R13 = 13 , R14 = 14 , R15 = 15 ,   kNumberOfCpuRegisters = 16 , kNoRegister = -1 }
enum	ByteRegister {   AL = 14 , CL = 1 , DL = 2 , BL = UnconditionalBranchFixed | B31 ,   AH = 4 , CH = 5 , DH = 6 , BH = 7 ,   kNumberOfByteRegisters = 8 , kNoByteRegister = -1 , AL = 14 , CL = 1 ,   DL = 2 , BL = UnconditionalBranchFixed | B31 , AH = 4 , CH = 5 ,   DH = 6 , BH = 7 , SPL = 4 | 0x10 , BPL = 5 | 0x10 ,   SIL = 6 | 0x10 , DIL = 7 | 0x10 , R8B = 8 , R9B = 9 ,   R10B = 10 , R11B = 11 , R12B = 12 , R13B = 13 ,   R14B = 14 , R15B = 15 , kNumberOfByteRegisters = 8 , kNoByteRegister = -1 }
enum	XmmRegister {   XMM0 = 0 , XMM1 = 1 , XMM2 = 2 , XMM3 = 3 ,   XMM4 = 4 , XMM5 = 5 , XMM6 = 6 , XMM7 = 7 ,   kNumberOfXmmRegisters = 8 , kNoXmmRegister = -1 , XMM0 = 0 , XMM1 = 1 ,   XMM2 = 2 , XMM3 = 3 , XMM4 = 4 , XMM5 = 5 ,   XMM6 = 6 , XMM7 = 7 , XMM8 = 8 , XMM9 = 9 ,   XMM10 = 10 , XMM11 = 11 , XMM12 = 12 , XMM13 = 13 ,   XMM14 = 14 , XMM15 = 15 , kNumberOfXmmRegisters = 8 , kNoXmmRegister = -1 }
enum	RexBits {   REX_NONE = 0 , REX_B = 1 << 0 , REX_X = 1 << 1 , REX_R = 1 << 2 ,   REX_W = 1 << 3 , REX_PREFIX = 1 << 6 }
enum	ScaleFactor {   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 ,   TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 ,   TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 ,   TIMES_4 = 2 , TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE ,   TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 , TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 ,   TIMES_8 = 3 , TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 ,   TIMES_1 = 0 , TIMES_2 = 1 , TIMES_4 = 2 , TIMES_8 = 3 ,   TIMES_16 = 4 , TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE , TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1 }
enum	Condition {   kNoCondition = -1 , EQ = 0 , NE = 1 , CS = 2 ,   CC = 3 , MI = 4 , PL = 5 , VS = 6 ,   VC = 7 , HI = 8 , LS = 9 , GE = 10 ,   LT = 11 , GT = 12 , LE = 13 , AL = 14 ,   kSpecialCondition = 15 , kNumberOfConditions = 16 , EQUAL = EQ , ZERO = EQUAL ,   NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL , LESS = LT , LESS_EQUAL = LE ,   GREATER_EQUAL = GE , GREATER = GT , UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS ,   UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS , OVERFLOW = VS , NO_OVERFLOW = VC ,   kInvalidCondition = 16 , kNoCondition = -1 , EQ = 0 , NE = 1 ,   CS = 2 , CC = 3 , MI = 4 , PL = 5 ,   VS = 6 , VC = 7 , HI = 8 , LS = 9 ,   GE = 10 , LT = 11 , GT = 12 , LE = 13 ,   AL = 14 , NV = 15 , kNumberOfConditions = 16 , EQUAL = EQ ,   ZERO = EQUAL , NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL , LESS = LT ,   LESS_EQUAL = LE , GREATER_EQUAL = GE , GREATER = GT , UNSIGNED_LESS = CC ,   UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS , OVERFLOW = VS ,   NO_OVERFLOW = VC , kInvalidCondition = 16 , kNoCondition = -1 , EQ = 0 ,   NE = 1 , CS = 2 , CC = 3 , MI = 4 ,   PL = 5 , VS = 6 , VC = 7 , HI = 8 ,   LS = 9 , GE = 10 , LT = 11 , GT = 12 ,   LE = 13 , AL = 14 , NV = 15 , kNumberOfConditions = 16 ,   EQUAL = EQ , ZERO = EQUAL , NOT_EQUAL = NE , NOT_ZERO = NOT_EQUAL ,   LESS = LT , LESS_EQUAL = LE , GREATER_EQUAL = GE , GREATER = GT ,   UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI , UNSIGNED_GREATER_EQUAL = CS ,   OVERFLOW = VS , NO_OVERFLOW = VC , kInvalidCondition = 16 , OVERFLOW = VS ,   NO_OVERFLOW = VC , BELOW = 2 , ABOVE_EQUAL = 3 , EQUAL = EQ ,   NOT_EQUAL = NE , BELOW_EQUAL = 6 , ABOVE = 7 , SIGN = 8 ,   NOT_SIGN = 9 , PARITY_EVEN = 10 , PARITY_ODD = 11 , LESS = LT ,   GREATER_EQUAL = GE , LESS_EQUAL = LE , GREATER = GT , ZERO = EQUAL ,   NOT_ZERO = NOT_EQUAL , NEGATIVE = SIGN , POSITIVE = NOT_SIGN , CARRY = BELOW ,   NOT_CARRY = ABOVE_EQUAL , UNSIGNED_LESS = CC , UNSIGNED_LESS_EQUAL = LS , UNSIGNED_GREATER = HI ,   UNSIGNED_GREATER_EQUAL = CS , kInvalidCondition = 16 }
enum	CpuInfoIndices {   kCpuInfoProcessor = 0 , kCpuInfoModel = 1 , kCpuInfoHardware = 2 , kCpuInfoFeatures = 3 ,   kCpuInfoArchitecture = 4 , kCpuInfoMax = 5 }
enum	CpuInfoMethod { kCpuInfoCpuId , kCpuInfoSystem , kCpuInfoNone , kCpuInfoDefault }
enum	Dart_ExceptionPauseInfo { kNoPauseOnExceptions = 1 , kPauseOnUnhandledExceptions , kPauseOnAllExceptions , kInvalidExceptionPauseInfo }
enum	Dart_IsolateEvent { kCreated = 0 , kInterrupted , kShutdown }
enum class	ExperimentalFeature {   inference_update_3 , inline_class , inference_update_2 , sealed_class ,   class_modifiers , records , patterns , unnamed_libraries ,   inference_update_1 , enhanced_enums , named_arguments_anywhere , super_parameters ,   constructor_tearoffs , generic_metadata , triple_shift , nonfunction_type_aliases ,   non_nullable , extension_methods , constant_update_2018 , control_flow_collections ,   set_literals , spread_collections }
enum	Generation { kNew , kOld , kImm }
enum	RootSlices {   kIsolate = 0 , kNumFixedRootSlices = 1 , kIsolate = 0 , kObjectIdRing ,   kStoreBuffer , kNumRootSlices }
enum	WeakSlices {   kWeakHandles = 0 , kWeakTables , kObjectIdRing , kRememberedSet ,   kNumWeakSlices , kWeakHandles = 0 , kWeakTables , kProgressBars ,   kRememberLiveTemporaries , kPruneWeak , kNumWeakSlices }
enum	{ kForwardingMask = 1 << UntaggedObject::kCardRememberedBit , kNotForwarded = 0 , kForwarded = kForwardingMask }
enum	RootSlices {   kIsolate = 0 , kNumFixedRootSlices = 1 , kIsolate = 0 , kObjectIdRing ,   kStoreBuffer , kNumRootSlices }
enum	WeakSlices {   kWeakHandles = 0 , kWeakTables , kObjectIdRing , kRememberedSet ,   kNumWeakSlices , kWeakHandles = 0 , kWeakTables , kProgressBars ,   kRememberLiveTemporaries , kPruneWeak , kNumWeakSlices }
enum class	GCType {   kScavenge , kEvacuate , kStartConcurrentMark , kMarkSweep ,   kMarkCompact }
enum class	GCReason {   kNewSpace , kStoreBuffer , kPromotion , kOldSpace ,   kFinalize , kFull , kExternal , kIdle ,   kDestroyed , kDebugging , kCatchUp }
enum	MarkExpectation { kForbidMarked , kAllowMarked , kRequireMarked }
enum	JSONRpcErrorCode {   kParseError = -32700 , kInvalidRequest = -32600 , kMethodNotFound = -32601 , kInvalidParams = -32602 ,   kInternalError = -32603 , kExtensionError = -32000 , kFeatureDisabled = 100 , kCannotAddBreakpoint = 102 ,   kStreamAlreadySubscribed = 103 , kStreamNotSubscribed = 104 , kIsolateMustBeRunnable = 105 , kIsolateMustBePaused = 106 ,   kCannotResume = 107 , kIsolateIsReloading = 108 , kIsolateReloadBarred = 109 , kIsolateMustHaveReloaded = 110 ,   kServiceAlreadyRegistered = 111 , kServiceDisappeared = 112 , kExpressionCompilationError = 113 , kInvalidTimelineRequest = 114 ,   kFileSystemAlreadyExists = 1001 , kFileSystemDoesNotExist = 1002 , kFileDoesNotExist = 1003 }
enum class	MessagePhase {   kBeforeTypes = 0 , kTypes = 1 , kCanonicalInstances = 2 , kNonCanonicalInstances = 3 ,   kNumPhases = 4 }
enum	TypedDataViewFormat { kTypedDataViewFromC , kTypedDataViewFromDart }
enum	QualifiedFunctionLibKind { kQualifiedFunctionLibKindLibUrl , kQualifiedFunctionLibKindLibName }
enum class	Nullability : uint8_t { kNullable = 0 , kNonNullable = 1 , kLegacy = 2 }
enum class	TypeEquality { kCanonical = 0 , kSyntactical = 1 , kInSubtypeTest = 2 }
enum class	NNBDCompiledMode { kStrong = 0 , kWeak = 1 , kAgnostic = 2 , kInvalid = 3 }
enum	Genericity { kAny , kCurrentClass , kFunctions }
enum	{ kNoneFree = 0 , kCurrentAndEnclosingFree = kMaxInt32 - 1 , kAllFree = kMaxInt32 }
enum class	FfiCallbackKind : uint8_t { kIsolateLocalStaticCallback , kIsolateLocalClosureCallback , kAsyncCallback }
enum class	EntryPointPragma {   kAlways , kNever , kGetterOnly , kSetterOnly ,   kCallOnly }
enum	TraversalRules { kInternalToIsolateGroup , kExternalBetweenIsolateGroups }
enum	{   kSmiTag = 0 , kHeapObjectTag = 1 , kSmiTagSize = 1 , kSmiTagMask = 1 ,   kSmiTagShift = 1 }
enum	TypedDataElementType
enum class	InstantiationMode : uint8_t { kNeedsInstantiation , kIsInstantiated , kSharesInstantiatorTypeArguments , kSharesFunctionTypeArguments }
enum	ContainedInLattice { kNotYet = 0 , kLatticeIn = 1 , kLatticeOut = 2 , kLatticeUnknown = 3 }
enum class	MissHandler { kInlineCacheMiss , kSwitchableCallMiss , kFixCallersTargetMonomorphic }
enum	SentinelType { kCollectedSentinel , kExpiredSentinel , kFreeSentinel }
enum	TimelineOrSamplesResponseFormat : bool { JSON = false , Perfetto = true }
enum class	ValidationPolicy { kValidateFrames = 0 , kDontValidateFrames = 1 }
enum class	RuntimeCallDeoptAbility { kCanLazyDeopt , kCannotLazyDeopt }
enum	SafepointLevel {   kGC , kGCAndDeopt , kGCAndDeoptAndReload , kNumLevels ,   kNoSafepoint }
enum class	CheckType {   kCannotBeChecked , kNotSubtype , kCidCheckOnly , kNeedsFinalization ,   kInstanceTypeArgumentsAreSubtypes }
enum	TTSTestResult {   kFail , kTTS , kExistingSTCEntry , kNewSTCEntry ,   kRuntimeCheck , kSpecialize , kRespecialize , kNumTestResults }
enum class	IdSpace : uint8_t {   kInvalid = 0 , kSnapshot = 1 , kVmText = 2 , kIsolateText = 3 ,   kVmData = 4 , kIsolateData = 5 , kArtificial = 6 }

Functions
	VM_UNIT_TEST_CASE (DirectoryCurrentNoScope)
	TEST_CASE (DirectoryCurrent)
	TEST_CASE (DirectoryExists)
	TEST_CASE (DirectorySystemTemp)
	TEST_CASE (DirectorySystemTempExists)
	TEST_CASE (DirectoryCreateTemp)
	TEST_CASE (DirectorySetCurrent)
	TEST_CASE (DirectoryCreateDelete)
	TEST_CASE (DirectoryRename)
DART_EXPORT void	InduceACrash ()
DART_EXPORT void	SetGlobalVar (int32_t v)
DART_EXPORT int32_t	GetGlobalVar ()
DART_EXPORT Coord	GetGlobalStruct ()
DART_EXPORT int32_t	SumPlus42 (int32_t a, int32_t b)
DART_EXPORT uint8_t	ReturnMaxUint8 ()
DART_EXPORT uint16_t	ReturnMaxUint16 ()
DART_EXPORT uint32_t	ReturnMaxUint32 ()
DART_EXPORT int8_t	ReturnMinInt8 ()
DART_EXPORT int16_t	ReturnMinInt16 ()
DART_EXPORT int32_t	ReturnMinInt32 ()
DART_EXPORT uint8_t	ReturnMaxUint8v2 ()
DART_EXPORT uint16_t	ReturnMaxUint16v2 ()
DART_EXPORT uint32_t	ReturnMaxUint32v2 ()
DART_EXPORT int8_t	ReturnMinInt8v2 ()
DART_EXPORT int16_t	ReturnMinInt16v2 ()
DART_EXPORT int32_t	ReturnMinInt32v2 ()
DART_EXPORT intptr_t	TakeMaxUint8 (uint8_t x)
DART_EXPORT intptr_t	TakeMaxUint16 (uint16_t x)
DART_EXPORT intptr_t	TakeMaxUint32 (uint32_t x)
DART_EXPORT intptr_t	TakeMinInt8 (int8_t x)
DART_EXPORT intptr_t	TakeMinInt16 (int16_t x)
DART_EXPORT intptr_t	TakeMinInt32 (int32_t x)
DART_EXPORT intptr_t	TakeMaxUint8x10 (uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t e, uint8_t f, uint8_t g, uint8_t h, uint8_t i, uint8_t j)
DART_EXPORT int64_t	IntComputation (int8_t a, int16_t b, int32_t c, int64_t d)
DART_EXPORT int64_t	Regress39044 (int64_t a, int8_t b)
DART_EXPORT intptr_t	Regress40537 (uint8_t x)
DART_EXPORT intptr_t	Regress40537Variant2 (uint8_t x)
DART_EXPORT uint8_t	Regress40537Variant3 (intptr_t x)
DART_EXPORT int64_t	UintComputation (uint8_t a, uint16_t b, uint32_t c, uint64_t d)
DART_EXPORT intptr_t	Times3 (intptr_t a)
DART_EXPORT double	Times1_337Double (double a)
DART_EXPORT float	Times1_337Float (float a)
DART_EXPORT intptr_t	SumManyInts (intptr_t a, intptr_t b, intptr_t c, intptr_t d, intptr_t e, intptr_t f, intptr_t g, intptr_t h, intptr_t i, intptr_t j)
DART_EXPORT int16_t	SumManySmallInts (int8_t a, int16_t b, int8_t c, int16_t d, int8_t e, int16_t f, int8_t g, int16_t h, int8_t i, int16_t j)
DART_EXPORT double	SumFloatsAndDoubles (float a, double b, float c)
DART_EXPORT int16_t	SumVeryManySmallInts (int8_t a01, int16_t a02, int8_t a03, int16_t a04, int8_t a05, int16_t a06, int8_t a07, int16_t a08, int8_t a09, int16_t a10, int8_t a11, int16_t a12, int8_t a13, int16_t a14, int8_t a15, int16_t a16, int8_t a17, int16_t a18, int8_t a19, int16_t a20, int8_t a21, int16_t a22, int8_t a23, int16_t a24, int8_t a25, int16_t a26, int8_t a27, int16_t a28, int8_t a29, int16_t a30, int8_t a31, int16_t a32, int8_t a33, int16_t a34, int8_t a35, int16_t a36, int8_t a37, int16_t a38, int8_t a39, int16_t a40)
DART_EXPORT double	SumVeryManyFloatsDoubles (float a01, double a02, float a03, double a04, float a05, double a06, float a07, double a08, float a09, double a10, float a11, double a12, float a13, double a14, float a15, double a16, float a17, double a18, float a19, double a20, float a21, double a22, float a23, double a24, float a25, double a26, float a27, double a28, float a29, double a30, float a31, double a32, float a33, double a34, float a35, double a36, float a37, double a38, float a39, double a40)
DART_EXPORT intptr_t	SumManyIntsOdd (intptr_t a, intptr_t b, intptr_t c, intptr_t d, intptr_t e, intptr_t f, intptr_t g, intptr_t h, intptr_t i, intptr_t j, intptr_t k)
DART_EXPORT double	SumManyDoubles (double a, double b, double c, double d, double e, double f, double g, double h, double i, double j)
DART_EXPORT double	SumManyNumbers (intptr_t a, float b, intptr_t c, double d, intptr_t e, float f, intptr_t g, double h, intptr_t i, float j, intptr_t k, double l, intptr_t m, float n, intptr_t o, double p, intptr_t q, float r, intptr_t s, double t)
DART_EXPORT int64_t *	Assign1337Index1 (int64_t *a)
DART_EXPORT Coord *	TransposeCoordinate (Coord *coord)
DART_EXPORT Coord *	CoordinateElemAt1 (Coord *coord)
DART_EXPORT Coord *	CoordinateUnOpTrice (CoordUnOp unop, Coord *coord)
DART_EXPORT IntptrBinOp	IntptrAdditionClosure ()
DART_EXPORT intptr_t	ApplyTo42And74 (IntptrBinOp binop)
DART_EXPORT int64_t *	NullableInt64ElemAt1 (int64_t *a)
DART_EXPORT int64_t	SumVeryLargeStruct (VeryLargeStruct *vls)
DART_EXPORT int64_t	SumStruct9Uint8 (Struct9Uint8 s9)
DART_EXPORT int64_t	SumReturnStruct9Uint8 (Struct9Uint8(*callback)(Struct9Uint8 *), Struct9Uint8 *in)
DART_EXPORT Struct9Uint8 *	AllocStruct9Uint8 ()
DART_EXPORT void	FreeStruct9Uint8 (Struct9Uint8 *address)
DART_EXPORT int64_t	SumSmallNumbers (int8_t a, int16_t b, int32_t c, uint8_t d, uint16_t e, uint32_t f)
DART_EXPORT uint8_t	IsRoughly1337 (float *a)
DART_EXPORT void	DevNullFloat (float a)
DART_EXPORT float	InventFloatValue ()
DART_EXPORT Struct20BytesHomogeneousInt32Copy	PassStructRecursive (int64_t recursionCounter, Struct20BytesHomogeneousInt32Copy a0, Struct20BytesHomogeneousInt32Copy(*f)(int64_t, Struct20BytesHomogeneousInt32Copy))
DART_EXPORT void	CallbackWithStruct (void(*f)(Struct8BytesNestedIntCopy))
DART_EXPORT intptr_t	TestSimpleAddition (intptr_t(*add)(int, int))
DART_EXPORT intptr_t	TestIntComputation (int64_t(*fn)(int8_t, int16_t, int32_t, int64_t))
DART_EXPORT intptr_t	TestUintComputation (uint64_t(*fn)(uint8_t, uint16_t, uint32_t, uint64_t))
DART_EXPORT intptr_t	TestSimpleMultiply (double(*fn)(double))
DART_EXPORT intptr_t	TestSimpleMultiplyFloat (float(*fn)(float))
DART_EXPORT intptr_t	TestManyInts (intptr_t(*fn)(intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t))
DART_EXPORT intptr_t	TestManyDoubles (double(*fn)(double, double, double, double, double, double, double, double, double, double))
DART_EXPORT intptr_t	TestManyArgs (double(*fn)(intptr_t a, float b, intptr_t c, double d, intptr_t e, float f, intptr_t g, double h, intptr_t i, float j, intptr_t k, double l, intptr_t m, float n, intptr_t o, double p, intptr_t q, float r, intptr_t s, double t))
DART_EXPORT intptr_t	TestSumFloatsAndDoubles (double(*fn)(float, double, float))
DART_EXPORT intptr_t	TestSumVeryManySmallInts (int16_t(*fn)(int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t))
DART_EXPORT intptr_t	TestSumVeryManyFloatsDoubles (double(*fn)(float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double))
DART_EXPORT intptr_t	TestStore (int64_t *(*fn)(int64_t *a))
DART_EXPORT intptr_t	TestReturnNull (int32_t(*fn)())
DART_EXPORT intptr_t	TestNullPointers (int64_t *(*fn)(int64_t *ptr))
DART_EXPORT intptr_t	TestReturnVoid (intptr_t(*return_void)())
DART_EXPORT intptr_t	TestThrowExceptionDouble (double(*fn)())
DART_EXPORT intptr_t	TestThrowExceptionPointer (void *(*fn)())
DART_EXPORT intptr_t	TestThrowException (intptr_t(*fn)())
DART_EXPORT intptr_t	TestTakeMaxUint8x10 (intptr_t(*fn)(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t))
DART_EXPORT intptr_t	TestReturnMaxUint8 (uint8_t(*fn)())
DART_EXPORT void	NativeTypePointerParam (void *p)
DART_EXPORT void *	NativeTypePointerReturn ()
DART_EXPORT void	CallbackNativeTypePointerParam (void(*f)(void *))
DART_EXPORT void	CallbackNativeTypePointerReturn (void *(*f)())
DART_EXPORT int32_t	PassStruct (void *)
DART_EXPORT uint64_t	Regress43693 (Struct43693 *my_struct)
DART_EXPORT Struct46127	Regress46127 ()
DART_EXPORT uint64_t	SizeOfStruct3BytesPackedInt ()
DART_EXPORT int64_t	WCharMinValue ()
DART_EXPORT int64_t	WCharMaxValue ()
DART_EXPORT int64_t	VariadicStructVarArgs (VarArgs a0,...)
DART_EXPORT void	CallFunctionOnSameThread (int64_t response_id, void(*fn)(int64_t, int32_t))
DART_EXPORT void	CallFunctionOnNewThreadBlocking (int64_t response_id, void(*fn)(int64_t, int32_t))
DART_EXPORT void	CallFunctionOnNewThreadNonBlocking (int64_t response_id, void(*fn)(int64_t, int32_t))
DART_EXPORT int32_t	CallTwoIntFunction (int32_t(*fn)(int32_t, int32_t), int32_t a, int32_t b)
DART_EXPORT void	CallTwoIntVoidFunction (void(*fn)(int32_t, int32_t), int32_t a, int32_t b)
DART_EXPORT void *	CallTwoIntPointerFunction (void *(*fn)(int32_t, int32_t), int32_t a, int32_t b)
DART_EXPORT int32_t	CallTwoPointerIntFunction (int32_t(*fn)(void *, void *), void *a, void *b)
DART_EXPORT char	TakeString (char *my_string)
DART_EXPORT int64_t	PassStruct1ByteIntx10 (Struct1ByteInt a0, Struct1ByteInt a1, Struct1ByteInt a2, Struct1ByteInt a3, Struct1ByteInt a4, Struct1ByteInt a5, Struct1ByteInt a6, Struct1ByteInt a7, Struct1ByteInt a8, Struct1ByteInt a9)
DART_EXPORT int64_t	PassStruct3BytesHomogeneousUint8x10 (Struct3BytesHomogeneousUint8 a0, Struct3BytesHomogeneousUint8 a1, Struct3BytesHomogeneousUint8 a2, Struct3BytesHomogeneousUint8 a3, Struct3BytesHomogeneousUint8 a4, Struct3BytesHomogeneousUint8 a5, Struct3BytesHomogeneousUint8 a6, Struct3BytesHomogeneousUint8 a7, Struct3BytesHomogeneousUint8 a8, Struct3BytesHomogeneousUint8 a9)
DART_EXPORT int64_t	PassStruct3BytesInt2ByteAlignedx10 (Struct3BytesInt2ByteAligned a0, Struct3BytesInt2ByteAligned a1, Struct3BytesInt2ByteAligned a2, Struct3BytesInt2ByteAligned a3, Struct3BytesInt2ByteAligned a4, Struct3BytesInt2ByteAligned a5, Struct3BytesInt2ByteAligned a6, Struct3BytesInt2ByteAligned a7, Struct3BytesInt2ByteAligned a8, Struct3BytesInt2ByteAligned a9)
DART_EXPORT int64_t	PassStruct4BytesHomogeneousInt16x10 (Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1, Struct4BytesHomogeneousInt16 a2, Struct4BytesHomogeneousInt16 a3, Struct4BytesHomogeneousInt16 a4, Struct4BytesHomogeneousInt16 a5, Struct4BytesHomogeneousInt16 a6, Struct4BytesHomogeneousInt16 a7, Struct4BytesHomogeneousInt16 a8, Struct4BytesHomogeneousInt16 a9)
DART_EXPORT int64_t	PassStruct7BytesHomogeneousUint8x10 (Struct7BytesHomogeneousUint8 a0, Struct7BytesHomogeneousUint8 a1, Struct7BytesHomogeneousUint8 a2, Struct7BytesHomogeneousUint8 a3, Struct7BytesHomogeneousUint8 a4, Struct7BytesHomogeneousUint8 a5, Struct7BytesHomogeneousUint8 a6, Struct7BytesHomogeneousUint8 a7, Struct7BytesHomogeneousUint8 a8, Struct7BytesHomogeneousUint8 a9)
DART_EXPORT int64_t	PassStruct7BytesInt4ByteAlignedx10 (Struct7BytesInt4ByteAligned a0, Struct7BytesInt4ByteAligned a1, Struct7BytesInt4ByteAligned a2, Struct7BytesInt4ByteAligned a3, Struct7BytesInt4ByteAligned a4, Struct7BytesInt4ByteAligned a5, Struct7BytesInt4ByteAligned a6, Struct7BytesInt4ByteAligned a7, Struct7BytesInt4ByteAligned a8, Struct7BytesInt4ByteAligned a9)
DART_EXPORT int64_t	PassStruct8BytesIntx10 (Struct8BytesInt a0, Struct8BytesInt a1, Struct8BytesInt a2, Struct8BytesInt a3, Struct8BytesInt a4, Struct8BytesInt a5, Struct8BytesInt a6, Struct8BytesInt a7, Struct8BytesInt a8, Struct8BytesInt a9)
DART_EXPORT float	PassStruct8BytesHomogeneousFloatx10 (Struct8BytesHomogeneousFloat a0, Struct8BytesHomogeneousFloat a1, Struct8BytesHomogeneousFloat a2, Struct8BytesHomogeneousFloat a3, Struct8BytesHomogeneousFloat a4, Struct8BytesHomogeneousFloat a5, Struct8BytesHomogeneousFloat a6, Struct8BytesHomogeneousFloat a7, Struct8BytesHomogeneousFloat a8, Struct8BytesHomogeneousFloat a9)
DART_EXPORT float	PassStruct8BytesMixedx10 (Struct8BytesMixed a0, Struct8BytesMixed a1, Struct8BytesMixed a2, Struct8BytesMixed a3, Struct8BytesMixed a4, Struct8BytesMixed a5, Struct8BytesMixed a6, Struct8BytesMixed a7, Struct8BytesMixed a8, Struct8BytesMixed a9)
DART_EXPORT int64_t	PassStruct9BytesHomogeneousUint8x10 (Struct9BytesHomogeneousUint8 a0, Struct9BytesHomogeneousUint8 a1, Struct9BytesHomogeneousUint8 a2, Struct9BytesHomogeneousUint8 a3, Struct9BytesHomogeneousUint8 a4, Struct9BytesHomogeneousUint8 a5, Struct9BytesHomogeneousUint8 a6, Struct9BytesHomogeneousUint8 a7, Struct9BytesHomogeneousUint8 a8, Struct9BytesHomogeneousUint8 a9)
DART_EXPORT int64_t	PassStruct9BytesInt4Or8ByteAlignedx10 (Struct9BytesInt4Or8ByteAligned a0, Struct9BytesInt4Or8ByteAligned a1, Struct9BytesInt4Or8ByteAligned a2, Struct9BytesInt4Or8ByteAligned a3, Struct9BytesInt4Or8ByteAligned a4, Struct9BytesInt4Or8ByteAligned a5, Struct9BytesInt4Or8ByteAligned a6, Struct9BytesInt4Or8ByteAligned a7, Struct9BytesInt4Or8ByteAligned a8, Struct9BytesInt4Or8ByteAligned a9)
DART_EXPORT float	PassStruct12BytesHomogeneousFloatx6 (Struct12BytesHomogeneousFloat a0, Struct12BytesHomogeneousFloat a1, Struct12BytesHomogeneousFloat a2, Struct12BytesHomogeneousFloat a3, Struct12BytesHomogeneousFloat a4, Struct12BytesHomogeneousFloat a5)
DART_EXPORT float	PassStruct16BytesHomogeneousFloatx5 (Struct16BytesHomogeneousFloat a0, Struct16BytesHomogeneousFloat a1, Struct16BytesHomogeneousFloat a2, Struct16BytesHomogeneousFloat a3, Struct16BytesHomogeneousFloat a4)
DART_EXPORT double	PassStruct16BytesMixedx10 (Struct16BytesMixed a0, Struct16BytesMixed a1, Struct16BytesMixed a2, Struct16BytesMixed a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9)
DART_EXPORT float	PassStruct16BytesMixed2x10 (Struct16BytesMixed2 a0, Struct16BytesMixed2 a1, Struct16BytesMixed2 a2, Struct16BytesMixed2 a3, Struct16BytesMixed2 a4, Struct16BytesMixed2 a5, Struct16BytesMixed2 a6, Struct16BytesMixed2 a7, Struct16BytesMixed2 a8, Struct16BytesMixed2 a9)
DART_EXPORT int64_t	PassStruct17BytesIntx10 (Struct17BytesInt a0, Struct17BytesInt a1, Struct17BytesInt a2, Struct17BytesInt a3, Struct17BytesInt a4, Struct17BytesInt a5, Struct17BytesInt a6, Struct17BytesInt a7, Struct17BytesInt a8, Struct17BytesInt a9)
DART_EXPORT int64_t	PassStruct19BytesHomogeneousUint8x10 (Struct19BytesHomogeneousUint8 a0, Struct19BytesHomogeneousUint8 a1, Struct19BytesHomogeneousUint8 a2, Struct19BytesHomogeneousUint8 a3, Struct19BytesHomogeneousUint8 a4, Struct19BytesHomogeneousUint8 a5, Struct19BytesHomogeneousUint8 a6, Struct19BytesHomogeneousUint8 a7, Struct19BytesHomogeneousUint8 a8, Struct19BytesHomogeneousUint8 a9)
DART_EXPORT int32_t	PassStruct20BytesHomogeneousInt32x10 (Struct20BytesHomogeneousInt32 a0, Struct20BytesHomogeneousInt32 a1, Struct20BytesHomogeneousInt32 a2, Struct20BytesHomogeneousInt32 a3, Struct20BytesHomogeneousInt32 a4, Struct20BytesHomogeneousInt32 a5, Struct20BytesHomogeneousInt32 a6, Struct20BytesHomogeneousInt32 a7, Struct20BytesHomogeneousInt32 a8, Struct20BytesHomogeneousInt32 a9)
DART_EXPORT float	PassStruct20BytesHomogeneousFloat (Struct20BytesHomogeneousFloat a0)
DART_EXPORT double	PassStruct32BytesHomogeneousDoublex5 (Struct32BytesHomogeneousDouble a0, Struct32BytesHomogeneousDouble a1, Struct32BytesHomogeneousDouble a2, Struct32BytesHomogeneousDouble a3, Struct32BytesHomogeneousDouble a4)
DART_EXPORT double	PassStruct40BytesHomogeneousDouble (Struct40BytesHomogeneousDouble a0)
DART_EXPORT uint64_t	PassStruct1024BytesHomogeneousUint64 (Struct1024BytesHomogeneousUint64 a0)
DART_EXPORT float	PassFloatStruct16BytesHomogeneousFloatFloatStruct1 (float a0, Struct16BytesHomogeneousFloat a1, float a2, Struct16BytesHomogeneousFloat a3, float a4, Struct16BytesHomogeneousFloat a5, float a6, Struct16BytesHomogeneousFloat a7, float a8)
DART_EXPORT double	PassFloatStruct32BytesHomogeneousDoubleFloatStruct (float a0, Struct32BytesHomogeneousDouble a1, float a2, Struct32BytesHomogeneousDouble a3, float a4, Struct32BytesHomogeneousDouble a5, float a6, Struct32BytesHomogeneousDouble a7, float a8)
DART_EXPORT double	PassInt8Struct16BytesMixedInt8Struct16BytesMixedIn (int8_t a0, Struct16BytesMixed a1, int8_t a2, Struct16BytesMixed a3, int8_t a4, Struct16BytesMixed a5, int8_t a6, Struct16BytesMixed a7, int8_t a8)
DART_EXPORT double	PassDoublex6Struct16BytesMixedx4Int32 (double a0, double a1, double a2, double a3, double a4, double a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9, int32_t a10)
DART_EXPORT double	PassInt32x4Struct16BytesMixedx4Double (int32_t a0, int32_t a1, int32_t a2, int32_t a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, double a8)
DART_EXPORT double	PassStruct40BytesHomogeneousDoubleStruct4BytesHomo (Struct40BytesHomogeneousDouble a0, Struct4BytesHomogeneousInt16 a1, Struct8BytesHomogeneousFloat a2)
DART_EXPORT double	PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int (int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, double a8, double a9, double a10, double a11, double a12, double a13, double a14, double a15, int64_t a16, int8_t a17, Struct1ByteInt a18, int64_t a19, int8_t a20, Struct4BytesHomogeneousInt16 a21, int64_t a22, int8_t a23, Struct8BytesInt a24, int64_t a25, int8_t a26, Struct8BytesHomogeneousFloat a27, int64_t a28, int8_t a29, Struct8BytesMixed a30, int64_t a31, int8_t a32, StructAlignmentInt16 a33, int64_t a34, int8_t a35, StructAlignmentInt32 a36, int64_t a37, int8_t a38, StructAlignmentInt64 a39)
DART_EXPORT int64_t	PassStructAlignmentInt16 (StructAlignmentInt16 a0)
DART_EXPORT int64_t	PassStructAlignmentInt32 (StructAlignmentInt32 a0)
DART_EXPORT int64_t	PassStructAlignmentInt64 (StructAlignmentInt64 a0)
DART_EXPORT int64_t	PassStruct8BytesNestedIntx10 (Struct8BytesNestedInt a0, Struct8BytesNestedInt a1, Struct8BytesNestedInt a2, Struct8BytesNestedInt a3, Struct8BytesNestedInt a4, Struct8BytesNestedInt a5, Struct8BytesNestedInt a6, Struct8BytesNestedInt a7, Struct8BytesNestedInt a8, Struct8BytesNestedInt a9)
DART_EXPORT float	PassStruct8BytesNestedFloatx10 (Struct8BytesNestedFloat a0, Struct8BytesNestedFloat a1, Struct8BytesNestedFloat a2, Struct8BytesNestedFloat a3, Struct8BytesNestedFloat a4, Struct8BytesNestedFloat a5, Struct8BytesNestedFloat a6, Struct8BytesNestedFloat a7, Struct8BytesNestedFloat a8, Struct8BytesNestedFloat a9)
DART_EXPORT float	PassStruct8BytesNestedFloat2x10 (Struct8BytesNestedFloat2 a0, Struct8BytesNestedFloat2 a1, Struct8BytesNestedFloat2 a2, Struct8BytesNestedFloat2 a3, Struct8BytesNestedFloat2 a4, Struct8BytesNestedFloat2 a5, Struct8BytesNestedFloat2 a6, Struct8BytesNestedFloat2 a7, Struct8BytesNestedFloat2 a8, Struct8BytesNestedFloat2 a9)
DART_EXPORT double	PassStruct8BytesNestedMixedx10 (Struct8BytesNestedMixed a0, Struct8BytesNestedMixed a1, Struct8BytesNestedMixed a2, Struct8BytesNestedMixed a3, Struct8BytesNestedMixed a4, Struct8BytesNestedMixed a5, Struct8BytesNestedMixed a6, Struct8BytesNestedMixed a7, Struct8BytesNestedMixed a8, Struct8BytesNestedMixed a9)
DART_EXPORT int64_t	PassStruct16BytesNestedIntx2 (Struct16BytesNestedInt a0, Struct16BytesNestedInt a1)
DART_EXPORT int64_t	PassStruct32BytesNestedIntx2 (Struct32BytesNestedInt a0, Struct32BytesNestedInt a1)
DART_EXPORT int64_t	PassStructNestedIntStructAlignmentInt16 (StructNestedIntStructAlignmentInt16 a0)
DART_EXPORT int64_t	PassStructNestedIntStructAlignmentInt32 (StructNestedIntStructAlignmentInt32 a0)
DART_EXPORT int64_t	PassStructNestedIntStructAlignmentInt64 (StructNestedIntStructAlignmentInt64 a0)
DART_EXPORT double	PassStructNestedIrregularEvenBiggerx4 (StructNestedIrregularEvenBigger a0, StructNestedIrregularEvenBigger a1, StructNestedIrregularEvenBigger a2, StructNestedIrregularEvenBigger a3)
DART_EXPORT int32_t	PassStruct8BytesInlineArrayIntx4 (Struct8BytesInlineArrayInt a0, Struct8BytesInlineArrayInt a1, Struct8BytesInlineArrayInt a2, Struct8BytesInlineArrayInt a3)
DART_EXPORT int32_t	PassStructInlineArrayIrregularx4 (StructInlineArrayIrregular a0, StructInlineArrayIrregular a1, StructInlineArrayIrregular a2, StructInlineArrayIrregular a3)
DART_EXPORT int32_t	PassStructInlineArray100Bytes (StructInlineArray100Bytes a0)
DART_EXPORT float	PassStructStruct16BytesHomogeneousFloat2x5 (StructStruct16BytesHomogeneousFloat2 a0, StructStruct16BytesHomogeneousFloat2 a1, StructStruct16BytesHomogeneousFloat2 a2, StructStruct16BytesHomogeneousFloat2 a3, StructStruct16BytesHomogeneousFloat2 a4)
DART_EXPORT double	PassStructStruct32BytesHomogeneousDouble2x5 (StructStruct32BytesHomogeneousDouble2 a0, StructStruct32BytesHomogeneousDouble2 a1, StructStruct32BytesHomogeneousDouble2 a2, StructStruct32BytesHomogeneousDouble2 a3, StructStruct32BytesHomogeneousDouble2 a4)
DART_EXPORT float	PassStructStruct16BytesMixed3x10 (StructStruct16BytesMixed3 a0, StructStruct16BytesMixed3 a1, StructStruct16BytesMixed3 a2, StructStruct16BytesMixed3 a3, StructStruct16BytesMixed3 a4, StructStruct16BytesMixed3 a5, StructStruct16BytesMixed3 a6, StructStruct16BytesMixed3 a7, StructStruct16BytesMixed3 a8, StructStruct16BytesMixed3 a9)
DART_EXPORT uint32_t	PassUint8Struct32BytesInlineArrayMultiDimensionalI (uint8_t a0, Struct32BytesInlineArrayMultiDimensionalInt a1, uint8_t a2, Struct8BytesInlineArrayMultiDimensionalInt a3, uint8_t a4, Struct8BytesInlineArrayMultiDimensionalInt a5, uint8_t a6)
DART_EXPORT uint32_t	PassUint8Struct4BytesInlineArrayMultiDimensionalIn (uint8_t a0, Struct4BytesInlineArrayMultiDimensionalInt a1, uint8_t a2)
DART_EXPORT int64_t	PassStruct3BytesPackedIntx10 (Struct3BytesPackedInt a0, Struct3BytesPackedInt a1, Struct3BytesPackedInt a2, Struct3BytesPackedInt a3, Struct3BytesPackedInt a4, Struct3BytesPackedInt a5, Struct3BytesPackedInt a6, Struct3BytesPackedInt a7, Struct3BytesPackedInt a8, Struct3BytesPackedInt a9)
DART_EXPORT int64_t	PassStruct8BytesPackedIntx10 (Struct8BytesPackedInt a0, Struct8BytesPackedInt a1, Struct8BytesPackedInt a2, Struct8BytesPackedInt a3, Struct8BytesPackedInt a4, Struct8BytesPackedInt a5, Struct8BytesPackedInt a6, Struct8BytesPackedInt a7, Struct8BytesPackedInt a8, Struct8BytesPackedInt a9)
DART_EXPORT double	PassStruct9BytesPackedMixedx10DoubleInt32x2 (Struct9BytesPackedMixed a0, Struct9BytesPackedMixed a1, Struct9BytesPackedMixed a2, Struct9BytesPackedMixed a3, Struct9BytesPackedMixed a4, Struct9BytesPackedMixed a5, Struct9BytesPackedMixed a6, Struct9BytesPackedMixed a7, Struct9BytesPackedMixed a8, Struct9BytesPackedMixed a9, double a10, int32_t a11, int32_t a12)
DART_EXPORT double	PassStruct5BytesPackedMixed (Struct5BytesPackedMixed a0)
DART_EXPORT double	PassStructNestedAlignmentStruct5BytesPackedMixed (StructNestedAlignmentStruct5BytesPackedMixed a0)
DART_EXPORT double	PassStruct6BytesInlineArrayInt (Struct6BytesInlineArrayInt a0)
DART_EXPORT double	PassStruct15BytesInlineArrayMixed (Struct15BytesInlineArrayMixed a0)
DART_EXPORT double	PassUnion4BytesMixedx10 (Union4BytesMixed a0, Union4BytesMixed a1, Union4BytesMixed a2, Union4BytesMixed a3, Union4BytesMixed a4, Union4BytesMixed a5, Union4BytesMixed a6, Union4BytesMixed a7, Union4BytesMixed a8, Union4BytesMixed a9)
DART_EXPORT double	PassUnion8BytesNestedFloatx10 (Union8BytesNestedFloat a0, Union8BytesNestedFloat a1, Union8BytesNestedFloat a2, Union8BytesNestedFloat a3, Union8BytesNestedFloat a4, Union8BytesNestedFloat a5, Union8BytesNestedFloat a6, Union8BytesNestedFloat a7, Union8BytesNestedFloat a8, Union8BytesNestedFloat a9)
DART_EXPORT double	PassUnion9BytesNestedIntx10 (Union9BytesNestedInt a0, Union9BytesNestedInt a1, Union9BytesNestedInt a2, Union9BytesNestedInt a3, Union9BytesNestedInt a4, Union9BytesNestedInt a5, Union9BytesNestedInt a6, Union9BytesNestedInt a7, Union9BytesNestedInt a8, Union9BytesNestedInt a9)
DART_EXPORT double	PassUnion16BytesNestedInlineArrayFloatx10 (Union16BytesNestedInlineArrayFloat a0, Union16BytesNestedInlineArrayFloat a1, Union16BytesNestedInlineArrayFloat a2, Union16BytesNestedInlineArrayFloat a3, Union16BytesNestedInlineArrayFloat a4, Union16BytesNestedInlineArrayFloat a5, Union16BytesNestedInlineArrayFloat a6, Union16BytesNestedInlineArrayFloat a7, Union16BytesNestedInlineArrayFloat a8, Union16BytesNestedInlineArrayFloat a9)
DART_EXPORT double	PassUnion16BytesNestedFloatx10 (Union16BytesNestedFloat a0, Union16BytesNestedFloat a1, Union16BytesNestedFloat a2, Union16BytesNestedFloat a3, Union16BytesNestedFloat a4, Union16BytesNestedFloat a5, Union16BytesNestedFloat a6, Union16BytesNestedFloat a7, Union16BytesNestedFloat a8, Union16BytesNestedFloat a9)
DART_EXPORT int32_t	PassUint8Boolx9Struct10BytesHomogeneousBoolBool (uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesHomogeneousBool a10, bool a11)
DART_EXPORT int32_t	PassUint8Boolx9Struct10BytesInlineArrayBoolBool (uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesInlineArrayBool a10, bool a11)
DART_EXPORT bool	PassUint8Struct1ByteBool (uint8_t a0, Struct1ByteBool a1)
DART_EXPORT wchar_t	PassWCharStructInlineArrayIntUintPtrx2LongUnsigned (wchar_t a0, StructInlineArrayInt a1, uintptr_t a2, uintptr_t a3, long a4, unsigned long a5)
DART_EXPORT int64_t	PassInt64x7Struct12BytesHomogeneousInt32 (int64_t a0, int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5, int64_t a6, Struct12BytesHomogeneousInt32 a7)
DART_EXPORT Struct1ByteInt	ReturnStruct1ByteInt (int8_t a0)
DART_EXPORT Struct3BytesHomogeneousUint8	ReturnStruct3BytesHomogeneousUint8 (uint8_t a0, uint8_t a1, uint8_t a2)
DART_EXPORT Struct3BytesInt2ByteAligned	ReturnStruct3BytesInt2ByteAligned (int16_t a0, int8_t a1)
DART_EXPORT Struct4BytesHomogeneousInt16	ReturnStruct4BytesHomogeneousInt16 (int16_t a0, int16_t a1)
DART_EXPORT Struct7BytesHomogeneousUint8	ReturnStruct7BytesHomogeneousUint8 (uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6)
DART_EXPORT Struct7BytesInt4ByteAligned	ReturnStruct7BytesInt4ByteAligned (int32_t a0, int16_t a1, int8_t a2)
DART_EXPORT Struct8BytesInt	ReturnStruct8BytesInt (int16_t a0, int16_t a1, int32_t a2)
DART_EXPORT Struct8BytesHomogeneousFloat	ReturnStruct8BytesHomogeneousFloat (float a0, float a1)
DART_EXPORT Struct8BytesMixed	ReturnStruct8BytesMixed (float a0, int16_t a1, int16_t a2)
DART_EXPORT Struct9BytesHomogeneousUint8	ReturnStruct9BytesHomogeneousUint8 (uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8)
DART_EXPORT Struct9BytesInt4Or8ByteAligned	ReturnStruct9BytesInt4Or8ByteAligned (int64_t a0, int8_t a1)
DART_EXPORT Struct12BytesHomogeneousFloat	ReturnStruct12BytesHomogeneousFloat (float a0, float a1, float a2)
DART_EXPORT Struct16BytesHomogeneousFloat	ReturnStruct16BytesHomogeneousFloat (float a0, float a1, float a2, float a3)
DART_EXPORT Struct16BytesMixed	ReturnStruct16BytesMixed (double a0, int64_t a1)
DART_EXPORT Struct16BytesMixed2	ReturnStruct16BytesMixed2 (float a0, float a1, float a2, int32_t a3)
DART_EXPORT Struct17BytesInt	ReturnStruct17BytesInt (int64_t a0, int64_t a1, int8_t a2)
DART_EXPORT Struct19BytesHomogeneousUint8	ReturnStruct19BytesHomogeneousUint8 (uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8, uint8_t a9, uint8_t a10, uint8_t a11, uint8_t a12, uint8_t a13, uint8_t a14, uint8_t a15, uint8_t a16, uint8_t a17, uint8_t a18)
DART_EXPORT Struct20BytesHomogeneousInt32	ReturnStruct20BytesHomogeneousInt32 (int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4)
DART_EXPORT Struct20BytesHomogeneousFloat	ReturnStruct20BytesHomogeneousFloat (float a0, float a1, float a2, float a3, float a4)
DART_EXPORT Struct32BytesHomogeneousDouble	ReturnStruct32BytesHomogeneousDouble (double a0, double a1, double a2, double a3)
DART_EXPORT Struct40BytesHomogeneousDouble	ReturnStruct40BytesHomogeneousDouble (double a0, double a1, double a2, double a3, double a4)
DART_EXPORT Struct1024BytesHomogeneousUint64	ReturnStruct1024BytesHomogeneousUint64 (uint64_t a0, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6, uint64_t a7, uint64_t a8, uint64_t a9, uint64_t a10, uint64_t a11, uint64_t a12, uint64_t a13, uint64_t a14, uint64_t a15, uint64_t a16, uint64_t a17, uint64_t a18, uint64_t a19, uint64_t a20, uint64_t a21, uint64_t a22, uint64_t a23, uint64_t a24, uint64_t a25, uint64_t a26, uint64_t a27, uint64_t a28, uint64_t a29, uint64_t a30, uint64_t a31, uint64_t a32, uint64_t a33, uint64_t a34, uint64_t a35, uint64_t a36, uint64_t a37, uint64_t a38, uint64_t a39, uint64_t a40, uint64_t a41, uint64_t a42, uint64_t a43, uint64_t a44, uint64_t a45, uint64_t a46, uint64_t a47, uint64_t a48, uint64_t a49, uint64_t a50, uint64_t a51, uint64_t a52, uint64_t a53, uint64_t a54, uint64_t a55, uint64_t a56, uint64_t a57, uint64_t a58, uint64_t a59, uint64_t a60, uint64_t a61, uint64_t a62, uint64_t a63, uint64_t a64, uint64_t a65, uint64_t a66, uint64_t a67, uint64_t a68, uint64_t a69, uint64_t a70, uint64_t a71, uint64_t a72, uint64_t a73, uint64_t a74, uint64_t a75, uint64_t a76, uint64_t a77, uint64_t a78, uint64_t a79, uint64_t a80, uint64_t a81, uint64_t a82, uint64_t a83, uint64_t a84, uint64_t a85, uint64_t a86, uint64_t a87, uint64_t a88, uint64_t a89, uint64_t a90, uint64_t a91, uint64_t a92, uint64_t a93, uint64_t a94, uint64_t a95, uint64_t a96, uint64_t a97, uint64_t a98, uint64_t a99, uint64_t a100, uint64_t a101, uint64_t a102, uint64_t a103, uint64_t a104, uint64_t a105, uint64_t a106, uint64_t a107, uint64_t a108, uint64_t a109, uint64_t a110, uint64_t a111, uint64_t a112, uint64_t a113, uint64_t a114, uint64_t a115, uint64_t a116, uint64_t a117, uint64_t a118, uint64_t a119, uint64_t a120, uint64_t a121, uint64_t a122, uint64_t a123, uint64_t a124, uint64_t a125, uint64_t a126, uint64_t a127)
DART_EXPORT Struct3BytesPackedInt	ReturnStruct3BytesPackedInt (int8_t a0, int16_t a1)
DART_EXPORT Struct8BytesPackedInt	ReturnStruct8BytesPackedInt (uint8_t a0, uint32_t a1, uint8_t a2, uint8_t a3, uint8_t a4)
DART_EXPORT Struct9BytesPackedMixed	ReturnStruct9BytesPackedMixed (uint8_t a0, double a1)
DART_EXPORT Union4BytesMixed	ReturnUnion4BytesMixed (uint32_t a0)
DART_EXPORT Union8BytesNestedFloat	ReturnUnion8BytesNestedFloat (double a0)
DART_EXPORT Union9BytesNestedInt	ReturnUnion9BytesNestedInt (Struct8BytesInt a0)
DART_EXPORT Union16BytesNestedFloat	ReturnUnion16BytesNestedFloat (Struct8BytesHomogeneousFloat a0)
DART_EXPORT Struct1ByteInt	ReturnStructArgumentStruct1ByteInt (Struct1ByteInt a0)
DART_EXPORT Struct1ByteInt	ReturnStructArgumentInt32x8Struct1ByteInt (int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct1ByteInt a8)
DART_EXPORT Struct8BytesHomogeneousFloat	ReturnStructArgumentStruct8BytesHomogeneousFloat (Struct8BytesHomogeneousFloat a0)
DART_EXPORT Struct20BytesHomogeneousInt32	ReturnStructArgumentStruct20BytesHomogeneousInt32 (Struct20BytesHomogeneousInt32 a0)
DART_EXPORT Struct20BytesHomogeneousInt32	ReturnStructArgumentInt32x8Struct20BytesHomogeneou (int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct20BytesHomogeneousInt32 a8)
DART_EXPORT Struct8BytesInlineArrayInt	ReturnStructArgumentStruct8BytesInlineArrayInt (Struct8BytesInlineArrayInt a0)
DART_EXPORT StructStruct16BytesHomogeneousFloat2	ReturnStructArgumentStructStruct16BytesHomogeneous (StructStruct16BytesHomogeneousFloat2 a0)
DART_EXPORT StructStruct32BytesHomogeneousDouble2	ReturnStructArgumentStructStruct32BytesHomogeneous (StructStruct32BytesHomogeneousDouble2 a0)
DART_EXPORT StructStruct16BytesMixed3	ReturnStructArgumentStructStruct16BytesMixed3 (StructStruct16BytesMixed3 a0)
DART_EXPORT StructAlignmentInt16	ReturnStructAlignmentInt16 (int8_t a0, int16_t a1, int8_t a2)
DART_EXPORT StructAlignmentInt32	ReturnStructAlignmentInt32 (int8_t a0, int32_t a1, int8_t a2)
DART_EXPORT StructAlignmentInt64	ReturnStructAlignmentInt64 (int8_t a0, int64_t a1, int8_t a2)
DART_EXPORT Struct8BytesNestedInt	ReturnStruct8BytesNestedInt (Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1)
DART_EXPORT Struct8BytesNestedFloat	ReturnStruct8BytesNestedFloat (Struct4BytesFloat a0, Struct4BytesFloat a1)
DART_EXPORT Struct8BytesNestedFloat2	ReturnStruct8BytesNestedFloat2 (Struct4BytesFloat a0, float a1)
DART_EXPORT Struct8BytesNestedMixed	ReturnStruct8BytesNestedMixed (Struct4BytesHomogeneousInt16 a0, Struct4BytesFloat a1)
DART_EXPORT Struct16BytesNestedInt	ReturnStruct16BytesNestedInt (Struct8BytesNestedInt a0, Struct8BytesNestedInt a1)
DART_EXPORT Struct32BytesNestedInt	ReturnStruct32BytesNestedInt (Struct16BytesNestedInt a0, Struct16BytesNestedInt a1)
DART_EXPORT StructNestedIntStructAlignmentInt16	ReturnStructNestedIntStructAlignmentInt16 (StructAlignmentInt16 a0, StructAlignmentInt16 a1)
DART_EXPORT StructNestedIntStructAlignmentInt32	ReturnStructNestedIntStructAlignmentInt32 (StructAlignmentInt32 a0, StructAlignmentInt32 a1)
DART_EXPORT StructNestedIntStructAlignmentInt64	ReturnStructNestedIntStructAlignmentInt64 (StructAlignmentInt64 a0, StructAlignmentInt64 a1)
DART_EXPORT StructNestedIrregularEvenBigger	ReturnStructNestedIrregularEvenBigger (uint64_t a0, StructNestedIrregularBigger a1, StructNestedIrregularBigger a2, double a3)
DART_EXPORT intptr_t	TestPassStruct1ByteIntx10 (int64_t(*f)(Struct1ByteInt a0, Struct1ByteInt a1, Struct1ByteInt a2, Struct1ByteInt a3, Struct1ByteInt a4, Struct1ByteInt a5, Struct1ByteInt a6, Struct1ByteInt a7, Struct1ByteInt a8, Struct1ByteInt a9))
DART_EXPORT intptr_t	TestPassStruct3BytesHomogeneousUint8x10 (int64_t(*f)(Struct3BytesHomogeneousUint8 a0, Struct3BytesHomogeneousUint8 a1, Struct3BytesHomogeneousUint8 a2, Struct3BytesHomogeneousUint8 a3, Struct3BytesHomogeneousUint8 a4, Struct3BytesHomogeneousUint8 a5, Struct3BytesHomogeneousUint8 a6, Struct3BytesHomogeneousUint8 a7, Struct3BytesHomogeneousUint8 a8, Struct3BytesHomogeneousUint8 a9))
DART_EXPORT intptr_t	TestPassStruct3BytesInt2ByteAlignedx10 (int64_t(*f)(Struct3BytesInt2ByteAligned a0, Struct3BytesInt2ByteAligned a1, Struct3BytesInt2ByteAligned a2, Struct3BytesInt2ByteAligned a3, Struct3BytesInt2ByteAligned a4, Struct3BytesInt2ByteAligned a5, Struct3BytesInt2ByteAligned a6, Struct3BytesInt2ByteAligned a7, Struct3BytesInt2ByteAligned a8, Struct3BytesInt2ByteAligned a9))
DART_EXPORT intptr_t	TestPassStruct4BytesHomogeneousInt16x10 (int64_t(*f)(Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1, Struct4BytesHomogeneousInt16 a2, Struct4BytesHomogeneousInt16 a3, Struct4BytesHomogeneousInt16 a4, Struct4BytesHomogeneousInt16 a5, Struct4BytesHomogeneousInt16 a6, Struct4BytesHomogeneousInt16 a7, Struct4BytesHomogeneousInt16 a8, Struct4BytesHomogeneousInt16 a9))
DART_EXPORT intptr_t	TestPassStruct7BytesHomogeneousUint8x10 (int64_t(*f)(Struct7BytesHomogeneousUint8 a0, Struct7BytesHomogeneousUint8 a1, Struct7BytesHomogeneousUint8 a2, Struct7BytesHomogeneousUint8 a3, Struct7BytesHomogeneousUint8 a4, Struct7BytesHomogeneousUint8 a5, Struct7BytesHomogeneousUint8 a6, Struct7BytesHomogeneousUint8 a7, Struct7BytesHomogeneousUint8 a8, Struct7BytesHomogeneousUint8 a9))
DART_EXPORT intptr_t	TestPassStruct7BytesInt4ByteAlignedx10 (int64_t(*f)(Struct7BytesInt4ByteAligned a0, Struct7BytesInt4ByteAligned a1, Struct7BytesInt4ByteAligned a2, Struct7BytesInt4ByteAligned a3, Struct7BytesInt4ByteAligned a4, Struct7BytesInt4ByteAligned a5, Struct7BytesInt4ByteAligned a6, Struct7BytesInt4ByteAligned a7, Struct7BytesInt4ByteAligned a8, Struct7BytesInt4ByteAligned a9))
DART_EXPORT intptr_t	TestPassStruct8BytesIntx10 (int64_t(*f)(Struct8BytesInt a0, Struct8BytesInt a1, Struct8BytesInt a2, Struct8BytesInt a3, Struct8BytesInt a4, Struct8BytesInt a5, Struct8BytesInt a6, Struct8BytesInt a7, Struct8BytesInt a8, Struct8BytesInt a9))
DART_EXPORT intptr_t	TestPassStruct8BytesHomogeneousFloatx10 (float(*f)(Struct8BytesHomogeneousFloat a0, Struct8BytesHomogeneousFloat a1, Struct8BytesHomogeneousFloat a2, Struct8BytesHomogeneousFloat a3, Struct8BytesHomogeneousFloat a4, Struct8BytesHomogeneousFloat a5, Struct8BytesHomogeneousFloat a6, Struct8BytesHomogeneousFloat a7, Struct8BytesHomogeneousFloat a8, Struct8BytesHomogeneousFloat a9))
DART_EXPORT intptr_t	TestPassStruct8BytesMixedx10 (float(*f)(Struct8BytesMixed a0, Struct8BytesMixed a1, Struct8BytesMixed a2, Struct8BytesMixed a3, Struct8BytesMixed a4, Struct8BytesMixed a5, Struct8BytesMixed a6, Struct8BytesMixed a7, Struct8BytesMixed a8, Struct8BytesMixed a9))
DART_EXPORT intptr_t	TestPassStruct9BytesHomogeneousUint8x10 (int64_t(*f)(Struct9BytesHomogeneousUint8 a0, Struct9BytesHomogeneousUint8 a1, Struct9BytesHomogeneousUint8 a2, Struct9BytesHomogeneousUint8 a3, Struct9BytesHomogeneousUint8 a4, Struct9BytesHomogeneousUint8 a5, Struct9BytesHomogeneousUint8 a6, Struct9BytesHomogeneousUint8 a7, Struct9BytesHomogeneousUint8 a8, Struct9BytesHomogeneousUint8 a9))
DART_EXPORT intptr_t	TestPassStruct9BytesInt4Or8ByteAlignedx10 (int64_t(*f)(Struct9BytesInt4Or8ByteAligned a0, Struct9BytesInt4Or8ByteAligned a1, Struct9BytesInt4Or8ByteAligned a2, Struct9BytesInt4Or8ByteAligned a3, Struct9BytesInt4Or8ByteAligned a4, Struct9BytesInt4Or8ByteAligned a5, Struct9BytesInt4Or8ByteAligned a6, Struct9BytesInt4Or8ByteAligned a7, Struct9BytesInt4Or8ByteAligned a8, Struct9BytesInt4Or8ByteAligned a9))
DART_EXPORT intptr_t	TestPassStruct12BytesHomogeneousFloatx6 (float(*f)(Struct12BytesHomogeneousFloat a0, Struct12BytesHomogeneousFloat a1, Struct12BytesHomogeneousFloat a2, Struct12BytesHomogeneousFloat a3, Struct12BytesHomogeneousFloat a4, Struct12BytesHomogeneousFloat a5))
DART_EXPORT intptr_t	TestPassStruct16BytesHomogeneousFloatx5 (float(*f)(Struct16BytesHomogeneousFloat a0, Struct16BytesHomogeneousFloat a1, Struct16BytesHomogeneousFloat a2, Struct16BytesHomogeneousFloat a3, Struct16BytesHomogeneousFloat a4))
DART_EXPORT intptr_t	TestPassStruct16BytesMixedx10 (double(*f)(Struct16BytesMixed a0, Struct16BytesMixed a1, Struct16BytesMixed a2, Struct16BytesMixed a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9))
DART_EXPORT intptr_t	TestPassStruct16BytesMixed2x10 (float(*f)(Struct16BytesMixed2 a0, Struct16BytesMixed2 a1, Struct16BytesMixed2 a2, Struct16BytesMixed2 a3, Struct16BytesMixed2 a4, Struct16BytesMixed2 a5, Struct16BytesMixed2 a6, Struct16BytesMixed2 a7, Struct16BytesMixed2 a8, Struct16BytesMixed2 a9))
DART_EXPORT intptr_t	TestPassStruct17BytesIntx10 (int64_t(*f)(Struct17BytesInt a0, Struct17BytesInt a1, Struct17BytesInt a2, Struct17BytesInt a3, Struct17BytesInt a4, Struct17BytesInt a5, Struct17BytesInt a6, Struct17BytesInt a7, Struct17BytesInt a8, Struct17BytesInt a9))
DART_EXPORT intptr_t	TestPassStruct19BytesHomogeneousUint8x10 (int64_t(*f)(Struct19BytesHomogeneousUint8 a0, Struct19BytesHomogeneousUint8 a1, Struct19BytesHomogeneousUint8 a2, Struct19BytesHomogeneousUint8 a3, Struct19BytesHomogeneousUint8 a4, Struct19BytesHomogeneousUint8 a5, Struct19BytesHomogeneousUint8 a6, Struct19BytesHomogeneousUint8 a7, Struct19BytesHomogeneousUint8 a8, Struct19BytesHomogeneousUint8 a9))
DART_EXPORT intptr_t	TestPassStruct20BytesHomogeneousInt32x10 (int32_t(*f)(Struct20BytesHomogeneousInt32 a0, Struct20BytesHomogeneousInt32 a1, Struct20BytesHomogeneousInt32 a2, Struct20BytesHomogeneousInt32 a3, Struct20BytesHomogeneousInt32 a4, Struct20BytesHomogeneousInt32 a5, Struct20BytesHomogeneousInt32 a6, Struct20BytesHomogeneousInt32 a7, Struct20BytesHomogeneousInt32 a8, Struct20BytesHomogeneousInt32 a9))
DART_EXPORT intptr_t	TestPassStruct20BytesHomogeneousFloat (float(*f)(Struct20BytesHomogeneousFloat a0))
DART_EXPORT intptr_t	TestPassStruct32BytesHomogeneousDoublex5 (double(*f)(Struct32BytesHomogeneousDouble a0, Struct32BytesHomogeneousDouble a1, Struct32BytesHomogeneousDouble a2, Struct32BytesHomogeneousDouble a3, Struct32BytesHomogeneousDouble a4))
DART_EXPORT intptr_t	TestPassStruct40BytesHomogeneousDouble (double(*f)(Struct40BytesHomogeneousDouble a0))
DART_EXPORT intptr_t	TestPassStruct1024BytesHomogeneousUint64 (uint64_t(*f)(Struct1024BytesHomogeneousUint64 a0))
DART_EXPORT intptr_t	TestPassFloatStruct16BytesHomogeneousFloatFloatStruct1 (float(*f)(float a0, Struct16BytesHomogeneousFloat a1, float a2, Struct16BytesHomogeneousFloat a3, float a4, Struct16BytesHomogeneousFloat a5, float a6, Struct16BytesHomogeneousFloat a7, float a8))
DART_EXPORT intptr_t	TestPassFloatStruct32BytesHomogeneousDoubleFloatStruct (double(*f)(float a0, Struct32BytesHomogeneousDouble a1, float a2, Struct32BytesHomogeneousDouble a3, float a4, Struct32BytesHomogeneousDouble a5, float a6, Struct32BytesHomogeneousDouble a7, float a8))
DART_EXPORT intptr_t	TestPassInt8Struct16BytesMixedInt8Struct16BytesMixedIn (double(*f)(int8_t a0, Struct16BytesMixed a1, int8_t a2, Struct16BytesMixed a3, int8_t a4, Struct16BytesMixed a5, int8_t a6, Struct16BytesMixed a7, int8_t a8))
DART_EXPORT intptr_t	TestPassDoublex6Struct16BytesMixedx4Int32 (double(*f)(double a0, double a1, double a2, double a3, double a4, double a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9, int32_t a10))
DART_EXPORT intptr_t	TestPassInt32x4Struct16BytesMixedx4Double (double(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, double a8))
DART_EXPORT intptr_t	TestPassStruct40BytesHomogeneousDoubleStruct4BytesHomo (double(*f)(Struct40BytesHomogeneousDouble a0, Struct4BytesHomogeneousInt16 a1, Struct8BytesHomogeneousFloat a2))
DART_EXPORT intptr_t	TestPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int (double(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, double a8, double a9, double a10, double a11, double a12, double a13, double a14, double a15, int64_t a16, int8_t a17, Struct1ByteInt a18, int64_t a19, int8_t a20, Struct4BytesHomogeneousInt16 a21, int64_t a22, int8_t a23, Struct8BytesInt a24, int64_t a25, int8_t a26, Struct8BytesHomogeneousFloat a27, int64_t a28, int8_t a29, Struct8BytesMixed a30, int64_t a31, int8_t a32, StructAlignmentInt16 a33, int64_t a34, int8_t a35, StructAlignmentInt32 a36, int64_t a37, int8_t a38, StructAlignmentInt64 a39))
DART_EXPORT intptr_t	TestPassStructAlignmentInt16 (int64_t(*f)(StructAlignmentInt16 a0))
DART_EXPORT intptr_t	TestPassStructAlignmentInt32 (int64_t(*f)(StructAlignmentInt32 a0))
DART_EXPORT intptr_t	TestPassStructAlignmentInt64 (int64_t(*f)(StructAlignmentInt64 a0))
DART_EXPORT intptr_t	TestPassStruct8BytesNestedIntx10 (int64_t(*f)(Struct8BytesNestedInt a0, Struct8BytesNestedInt a1, Struct8BytesNestedInt a2, Struct8BytesNestedInt a3, Struct8BytesNestedInt a4, Struct8BytesNestedInt a5, Struct8BytesNestedInt a6, Struct8BytesNestedInt a7, Struct8BytesNestedInt a8, Struct8BytesNestedInt a9))
DART_EXPORT intptr_t	TestPassStruct8BytesNestedFloatx10 (float(*f)(Struct8BytesNestedFloat a0, Struct8BytesNestedFloat a1, Struct8BytesNestedFloat a2, Struct8BytesNestedFloat a3, Struct8BytesNestedFloat a4, Struct8BytesNestedFloat a5, Struct8BytesNestedFloat a6, Struct8BytesNestedFloat a7, Struct8BytesNestedFloat a8, Struct8BytesNestedFloat a9))
DART_EXPORT intptr_t	TestPassStruct8BytesNestedFloat2x10 (float(*f)(Struct8BytesNestedFloat2 a0, Struct8BytesNestedFloat2 a1, Struct8BytesNestedFloat2 a2, Struct8BytesNestedFloat2 a3, Struct8BytesNestedFloat2 a4, Struct8BytesNestedFloat2 a5, Struct8BytesNestedFloat2 a6, Struct8BytesNestedFloat2 a7, Struct8BytesNestedFloat2 a8, Struct8BytesNestedFloat2 a9))
DART_EXPORT intptr_t	TestPassStruct8BytesNestedMixedx10 (double(*f)(Struct8BytesNestedMixed a0, Struct8BytesNestedMixed a1, Struct8BytesNestedMixed a2, Struct8BytesNestedMixed a3, Struct8BytesNestedMixed a4, Struct8BytesNestedMixed a5, Struct8BytesNestedMixed a6, Struct8BytesNestedMixed a7, Struct8BytesNestedMixed a8, Struct8BytesNestedMixed a9))
DART_EXPORT intptr_t	TestPassStruct16BytesNestedIntx2 (int64_t(*f)(Struct16BytesNestedInt a0, Struct16BytesNestedInt a1))
DART_EXPORT intptr_t	TestPassStruct32BytesNestedIntx2 (int64_t(*f)(Struct32BytesNestedInt a0, Struct32BytesNestedInt a1))
DART_EXPORT intptr_t	TestPassStructNestedIntStructAlignmentInt16 (int64_t(*f)(StructNestedIntStructAlignmentInt16 a0))
DART_EXPORT intptr_t	TestPassStructNestedIntStructAlignmentInt32 (int64_t(*f)(StructNestedIntStructAlignmentInt32 a0))
DART_EXPORT intptr_t	TestPassStructNestedIntStructAlignmentInt64 (int64_t(*f)(StructNestedIntStructAlignmentInt64 a0))
DART_EXPORT intptr_t	TestPassStructNestedIrregularEvenBiggerx4 (double(*f)(StructNestedIrregularEvenBigger a0, StructNestedIrregularEvenBigger a1, StructNestedIrregularEvenBigger a2, StructNestedIrregularEvenBigger a3))
DART_EXPORT intptr_t	TestPassStruct8BytesInlineArrayIntx4 (int32_t(*f)(Struct8BytesInlineArrayInt a0, Struct8BytesInlineArrayInt a1, Struct8BytesInlineArrayInt a2, Struct8BytesInlineArrayInt a3))
DART_EXPORT intptr_t	TestPassStructInlineArrayIrregularx4 (int32_t(*f)(StructInlineArrayIrregular a0, StructInlineArrayIrregular a1, StructInlineArrayIrregular a2, StructInlineArrayIrregular a3))
DART_EXPORT intptr_t	TestPassStructInlineArray100Bytes (int32_t(*f)(StructInlineArray100Bytes a0))
DART_EXPORT intptr_t	TestPassStructStruct16BytesHomogeneousFloat2x5 (float(*f)(StructStruct16BytesHomogeneousFloat2 a0, StructStruct16BytesHomogeneousFloat2 a1, StructStruct16BytesHomogeneousFloat2 a2, StructStruct16BytesHomogeneousFloat2 a3, StructStruct16BytesHomogeneousFloat2 a4))
DART_EXPORT intptr_t	TestPassStructStruct32BytesHomogeneousDouble2x5 (double(*f)(StructStruct32BytesHomogeneousDouble2 a0, StructStruct32BytesHomogeneousDouble2 a1, StructStruct32BytesHomogeneousDouble2 a2, StructStruct32BytesHomogeneousDouble2 a3, StructStruct32BytesHomogeneousDouble2 a4))
DART_EXPORT intptr_t	TestPassStructStruct16BytesMixed3x10 (float(*f)(StructStruct16BytesMixed3 a0, StructStruct16BytesMixed3 a1, StructStruct16BytesMixed3 a2, StructStruct16BytesMixed3 a3, StructStruct16BytesMixed3 a4, StructStruct16BytesMixed3 a5, StructStruct16BytesMixed3 a6, StructStruct16BytesMixed3 a7, StructStruct16BytesMixed3 a8, StructStruct16BytesMixed3 a9))
DART_EXPORT intptr_t	TestPassUint8Struct32BytesInlineArrayMultiDimensionalI (uint32_t(*f)(uint8_t a0, Struct32BytesInlineArrayMultiDimensionalInt a1, uint8_t a2, Struct8BytesInlineArrayMultiDimensionalInt a3, uint8_t a4, Struct8BytesInlineArrayMultiDimensionalInt a5, uint8_t a6))
DART_EXPORT intptr_t	TestPassUint8Struct4BytesInlineArrayMultiDimensionalIn (uint32_t(*f)(uint8_t a0, Struct4BytesInlineArrayMultiDimensionalInt a1, uint8_t a2))
DART_EXPORT intptr_t	TestPassStruct3BytesPackedIntx10 (int64_t(*f)(Struct3BytesPackedInt a0, Struct3BytesPackedInt a1, Struct3BytesPackedInt a2, Struct3BytesPackedInt a3, Struct3BytesPackedInt a4, Struct3BytesPackedInt a5, Struct3BytesPackedInt a6, Struct3BytesPackedInt a7, Struct3BytesPackedInt a8, Struct3BytesPackedInt a9))
DART_EXPORT intptr_t	TestPassStruct8BytesPackedIntx10 (int64_t(*f)(Struct8BytesPackedInt a0, Struct8BytesPackedInt a1, Struct8BytesPackedInt a2, Struct8BytesPackedInt a3, Struct8BytesPackedInt a4, Struct8BytesPackedInt a5, Struct8BytesPackedInt a6, Struct8BytesPackedInt a7, Struct8BytesPackedInt a8, Struct8BytesPackedInt a9))
DART_EXPORT intptr_t	TestPassStruct9BytesPackedMixedx10DoubleInt32x2 (double(*f)(Struct9BytesPackedMixed a0, Struct9BytesPackedMixed a1, Struct9BytesPackedMixed a2, Struct9BytesPackedMixed a3, Struct9BytesPackedMixed a4, Struct9BytesPackedMixed a5, Struct9BytesPackedMixed a6, Struct9BytesPackedMixed a7, Struct9BytesPackedMixed a8, Struct9BytesPackedMixed a9, double a10, int32_t a11, int32_t a12))
DART_EXPORT intptr_t	TestPassStruct5BytesPackedMixed (double(*f)(Struct5BytesPackedMixed a0))
DART_EXPORT intptr_t	TestPassStructNestedAlignmentStruct5BytesPackedMixed (double(*f)(StructNestedAlignmentStruct5BytesPackedMixed a0))
DART_EXPORT intptr_t	TestPassStruct6BytesInlineArrayInt (double(*f)(Struct6BytesInlineArrayInt a0))
DART_EXPORT intptr_t	TestPassStruct15BytesInlineArrayMixed (double(*f)(Struct15BytesInlineArrayMixed a0))
DART_EXPORT intptr_t	TestPassUnion4BytesMixedx10 (double(*f)(Union4BytesMixed a0, Union4BytesMixed a1, Union4BytesMixed a2, Union4BytesMixed a3, Union4BytesMixed a4, Union4BytesMixed a5, Union4BytesMixed a6, Union4BytesMixed a7, Union4BytesMixed a8, Union4BytesMixed a9))
DART_EXPORT intptr_t	TestPassUnion8BytesNestedFloatx10 (double(*f)(Union8BytesNestedFloat a0, Union8BytesNestedFloat a1, Union8BytesNestedFloat a2, Union8BytesNestedFloat a3, Union8BytesNestedFloat a4, Union8BytesNestedFloat a5, Union8BytesNestedFloat a6, Union8BytesNestedFloat a7, Union8BytesNestedFloat a8, Union8BytesNestedFloat a9))
DART_EXPORT intptr_t	TestPassUnion9BytesNestedIntx10 (double(*f)(Union9BytesNestedInt a0, Union9BytesNestedInt a1, Union9BytesNestedInt a2, Union9BytesNestedInt a3, Union9BytesNestedInt a4, Union9BytesNestedInt a5, Union9BytesNestedInt a6, Union9BytesNestedInt a7, Union9BytesNestedInt a8, Union9BytesNestedInt a9))
DART_EXPORT intptr_t	TestPassUnion16BytesNestedInlineArrayFloatx10 (double(*f)(Union16BytesNestedInlineArrayFloat a0, Union16BytesNestedInlineArrayFloat a1, Union16BytesNestedInlineArrayFloat a2, Union16BytesNestedInlineArrayFloat a3, Union16BytesNestedInlineArrayFloat a4, Union16BytesNestedInlineArrayFloat a5, Union16BytesNestedInlineArrayFloat a6, Union16BytesNestedInlineArrayFloat a7, Union16BytesNestedInlineArrayFloat a8, Union16BytesNestedInlineArrayFloat a9))
DART_EXPORT intptr_t	TestPassUnion16BytesNestedFloatx10 (double(*f)(Union16BytesNestedFloat a0, Union16BytesNestedFloat a1, Union16BytesNestedFloat a2, Union16BytesNestedFloat a3, Union16BytesNestedFloat a4, Union16BytesNestedFloat a5, Union16BytesNestedFloat a6, Union16BytesNestedFloat a7, Union16BytesNestedFloat a8, Union16BytesNestedFloat a9))
DART_EXPORT intptr_t	TestPassUint8Boolx9Struct10BytesHomogeneousBoolBool (int32_t(*f)(uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesHomogeneousBool a10, bool a11))
DART_EXPORT intptr_t	TestPassUint8Boolx9Struct10BytesInlineArrayBoolBool (int32_t(*f)(uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesInlineArrayBool a10, bool a11))
DART_EXPORT intptr_t	TestPassUint8Struct1ByteBool (bool(*f)(uint8_t a0, Struct1ByteBool a1))
DART_EXPORT intptr_t	TestPassWCharStructInlineArrayIntUintPtrx2LongUnsigned (wchar_t(*f)(wchar_t a0, StructInlineArrayInt a1, uintptr_t a2, uintptr_t a3, long a4, unsigned long a5))
DART_EXPORT intptr_t	TestPassInt64x7Struct12BytesHomogeneousInt32 (int64_t(*f)(int64_t a0, int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5, int64_t a6, Struct12BytesHomogeneousInt32 a7))
DART_EXPORT intptr_t	TestReturnStruct1ByteInt (Struct1ByteInt(*f)(int8_t a0))
DART_EXPORT intptr_t	TestReturnStruct3BytesHomogeneousUint8 (Struct3BytesHomogeneousUint8(*f)(uint8_t a0, uint8_t a1, uint8_t a2))
DART_EXPORT intptr_t	TestReturnStruct3BytesInt2ByteAligned (Struct3BytesInt2ByteAligned(*f)(int16_t a0, int8_t a1))
DART_EXPORT intptr_t	TestReturnStruct4BytesHomogeneousInt16 (Struct4BytesHomogeneousInt16(*f)(int16_t a0, int16_t a1))
DART_EXPORT intptr_t	TestReturnStruct7BytesHomogeneousUint8 (Struct7BytesHomogeneousUint8(*f)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6))
DART_EXPORT intptr_t	TestReturnStruct7BytesInt4ByteAligned (Struct7BytesInt4ByteAligned(*f)(int32_t a0, int16_t a1, int8_t a2))
DART_EXPORT intptr_t	TestReturnStruct8BytesInt (Struct8BytesInt(*f)(int16_t a0, int16_t a1, int32_t a2))
DART_EXPORT intptr_t	TestReturnStruct8BytesHomogeneousFloat (Struct8BytesHomogeneousFloat(*f)(float a0, float a1))
DART_EXPORT intptr_t	TestReturnStruct8BytesMixed (Struct8BytesMixed(*f)(float a0, int16_t a1, int16_t a2))
DART_EXPORT intptr_t	TestReturnStruct9BytesHomogeneousUint8 (Struct9BytesHomogeneousUint8(*f)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8))
DART_EXPORT intptr_t	TestReturnStruct9BytesInt4Or8ByteAligned (Struct9BytesInt4Or8ByteAligned(*f)(int64_t a0, int8_t a1))
DART_EXPORT intptr_t	TestReturnStruct12BytesHomogeneousFloat (Struct12BytesHomogeneousFloat(*f)(float a0, float a1, float a2))
DART_EXPORT intptr_t	TestReturnStruct16BytesHomogeneousFloat (Struct16BytesHomogeneousFloat(*f)(float a0, float a1, float a2, float a3))
DART_EXPORT intptr_t	TestReturnStruct16BytesMixed (Struct16BytesMixed(*f)(double a0, int64_t a1))
DART_EXPORT intptr_t	TestReturnStruct16BytesMixed2 (Struct16BytesMixed2(*f)(float a0, float a1, float a2, int32_t a3))
DART_EXPORT intptr_t	TestReturnStruct17BytesInt (Struct17BytesInt(*f)(int64_t a0, int64_t a1, int8_t a2))
DART_EXPORT intptr_t	TestReturnStruct19BytesHomogeneousUint8 (Struct19BytesHomogeneousUint8(*f)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8, uint8_t a9, uint8_t a10, uint8_t a11, uint8_t a12, uint8_t a13, uint8_t a14, uint8_t a15, uint8_t a16, uint8_t a17, uint8_t a18))
DART_EXPORT intptr_t	TestReturnStruct20BytesHomogeneousInt32 (Struct20BytesHomogeneousInt32(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4))
DART_EXPORT intptr_t	TestReturnStruct20BytesHomogeneousFloat (Struct20BytesHomogeneousFloat(*f)(float a0, float a1, float a2, float a3, float a4))
DART_EXPORT intptr_t	TestReturnStruct32BytesHomogeneousDouble (Struct32BytesHomogeneousDouble(*f)(double a0, double a1, double a2, double a3))
DART_EXPORT intptr_t	TestReturnStruct40BytesHomogeneousDouble (Struct40BytesHomogeneousDouble(*f)(double a0, double a1, double a2, double a3, double a4))
DART_EXPORT intptr_t	TestReturnStruct1024BytesHomogeneousUint64 (Struct1024BytesHomogeneousUint64(*f)(uint64_t a0, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6, uint64_t a7, uint64_t a8, uint64_t a9, uint64_t a10, uint64_t a11, uint64_t a12, uint64_t a13, uint64_t a14, uint64_t a15, uint64_t a16, uint64_t a17, uint64_t a18, uint64_t a19, uint64_t a20, uint64_t a21, uint64_t a22, uint64_t a23, uint64_t a24, uint64_t a25, uint64_t a26, uint64_t a27, uint64_t a28, uint64_t a29, uint64_t a30, uint64_t a31, uint64_t a32, uint64_t a33, uint64_t a34, uint64_t a35, uint64_t a36, uint64_t a37, uint64_t a38, uint64_t a39, uint64_t a40, uint64_t a41, uint64_t a42, uint64_t a43, uint64_t a44, uint64_t a45, uint64_t a46, uint64_t a47, uint64_t a48, uint64_t a49, uint64_t a50, uint64_t a51, uint64_t a52, uint64_t a53, uint64_t a54, uint64_t a55, uint64_t a56, uint64_t a57, uint64_t a58, uint64_t a59, uint64_t a60, uint64_t a61, uint64_t a62, uint64_t a63, uint64_t a64, uint64_t a65, uint64_t a66, uint64_t a67, uint64_t a68, uint64_t a69, uint64_t a70, uint64_t a71, uint64_t a72, uint64_t a73, uint64_t a74, uint64_t a75, uint64_t a76, uint64_t a77, uint64_t a78, uint64_t a79, uint64_t a80, uint64_t a81, uint64_t a82, uint64_t a83, uint64_t a84, uint64_t a85, uint64_t a86, uint64_t a87, uint64_t a88, uint64_t a89, uint64_t a90, uint64_t a91, uint64_t a92, uint64_t a93, uint64_t a94, uint64_t a95, uint64_t a96, uint64_t a97, uint64_t a98, uint64_t a99, uint64_t a100, uint64_t a101, uint64_t a102, uint64_t a103, uint64_t a104, uint64_t a105, uint64_t a106, uint64_t a107, uint64_t a108, uint64_t a109, uint64_t a110, uint64_t a111, uint64_t a112, uint64_t a113, uint64_t a114, uint64_t a115, uint64_t a116, uint64_t a117, uint64_t a118, uint64_t a119, uint64_t a120, uint64_t a121, uint64_t a122, uint64_t a123, uint64_t a124, uint64_t a125, uint64_t a126, uint64_t a127))
DART_EXPORT intptr_t	TestReturnStruct3BytesPackedInt (Struct3BytesPackedInt(*f)(int8_t a0, int16_t a1))
DART_EXPORT intptr_t	TestReturnStruct8BytesPackedInt (Struct8BytesPackedInt(*f)(uint8_t a0, uint32_t a1, uint8_t a2, uint8_t a3, uint8_t a4))
DART_EXPORT intptr_t	TestReturnStruct9BytesPackedMixed (Struct9BytesPackedMixed(*f)(uint8_t a0, double a1))
DART_EXPORT intptr_t	TestReturnUnion4BytesMixed (Union4BytesMixed(*f)(uint32_t a0))
DART_EXPORT intptr_t	TestReturnUnion8BytesNestedFloat (Union8BytesNestedFloat(*f)(double a0))
DART_EXPORT intptr_t	TestReturnUnion9BytesNestedInt (Union9BytesNestedInt(*f)(Struct8BytesInt a0))
DART_EXPORT intptr_t	TestReturnUnion16BytesNestedFloat (Union16BytesNestedFloat(*f)(Struct8BytesHomogeneousFloat a0))
DART_EXPORT intptr_t	TestReturnStructArgumentStruct1ByteInt (Struct1ByteInt(*f)(Struct1ByteInt a0))
DART_EXPORT intptr_t	TestReturnStructArgumentInt32x8Struct1ByteInt (Struct1ByteInt(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct1ByteInt a8))
DART_EXPORT intptr_t	TestReturnStructArgumentStruct8BytesHomogeneousFloat (Struct8BytesHomogeneousFloat(*f)(Struct8BytesHomogeneousFloat a0))
DART_EXPORT intptr_t	TestReturnStructArgumentStruct20BytesHomogeneousInt32 (Struct20BytesHomogeneousInt32(*f)(Struct20BytesHomogeneousInt32 a0))
DART_EXPORT intptr_t	TestReturnStructArgumentInt32x8Struct20BytesHomogeneou (Struct20BytesHomogeneousInt32(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct20BytesHomogeneousInt32 a8))
DART_EXPORT intptr_t	TestReturnStructArgumentStruct8BytesInlineArrayInt (Struct8BytesInlineArrayInt(*f)(Struct8BytesInlineArrayInt a0))
DART_EXPORT intptr_t	TestReturnStructArgumentStructStruct16BytesHomogeneous (StructStruct16BytesHomogeneousFloat2(*f)(StructStruct16BytesHomogeneousFloat2 a0))
DART_EXPORT intptr_t	TestReturnStructArgumentStructStruct32BytesHomogeneous (StructStruct32BytesHomogeneousDouble2(*f)(StructStruct32BytesHomogeneousDouble2 a0))
DART_EXPORT intptr_t	TestReturnStructArgumentStructStruct16BytesMixed3 (StructStruct16BytesMixed3(*f)(StructStruct16BytesMixed3 a0))
DART_EXPORT intptr_t	TestReturnStructAlignmentInt16 (StructAlignmentInt16(*f)(int8_t a0, int16_t a1, int8_t a2))
DART_EXPORT intptr_t	TestReturnStructAlignmentInt32 (StructAlignmentInt32(*f)(int8_t a0, int32_t a1, int8_t a2))
DART_EXPORT intptr_t	TestReturnStructAlignmentInt64 (StructAlignmentInt64(*f)(int8_t a0, int64_t a1, int8_t a2))
DART_EXPORT intptr_t	TestReturnStruct8BytesNestedInt (Struct8BytesNestedInt(*f)(Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1))
DART_EXPORT intptr_t	TestReturnStruct8BytesNestedFloat (Struct8BytesNestedFloat(*f)(Struct4BytesFloat a0, Struct4BytesFloat a1))
DART_EXPORT intptr_t	TestReturnStruct8BytesNestedFloat2 (Struct8BytesNestedFloat2(*f)(Struct4BytesFloat a0, float a1))
DART_EXPORT intptr_t	TestReturnStruct8BytesNestedMixed (Struct8BytesNestedMixed(*f)(Struct4BytesHomogeneousInt16 a0, Struct4BytesFloat a1))
DART_EXPORT intptr_t	TestReturnStruct16BytesNestedInt (Struct16BytesNestedInt(*f)(Struct8BytesNestedInt a0, Struct8BytesNestedInt a1))
DART_EXPORT intptr_t	TestReturnStruct32BytesNestedInt (Struct32BytesNestedInt(*f)(Struct16BytesNestedInt a0, Struct16BytesNestedInt a1))
DART_EXPORT intptr_t	TestReturnStructNestedIntStructAlignmentInt16 (StructNestedIntStructAlignmentInt16(*f)(StructAlignmentInt16 a0, StructAlignmentInt16 a1))
DART_EXPORT intptr_t	TestReturnStructNestedIntStructAlignmentInt32 (StructNestedIntStructAlignmentInt32(*f)(StructAlignmentInt32 a0, StructAlignmentInt32 a1))
DART_EXPORT intptr_t	TestReturnStructNestedIntStructAlignmentInt64 (StructNestedIntStructAlignmentInt64(*f)(StructAlignmentInt64 a0, StructAlignmentInt64 a1))
DART_EXPORT intptr_t	TestReturnStructNestedIrregularEvenBigger (StructNestedIrregularEvenBigger(*f)(uint64_t a0, StructNestedIrregularBigger a1, StructNestedIrregularBigger a2, double a3))
DART_EXPORT void	TestAsyncPassStruct1ByteIntx10 (void(*f)(Struct1ByteInt a0, Struct1ByteInt a1, Struct1ByteInt a2, Struct1ByteInt a3, Struct1ByteInt a4, Struct1ByteInt a5, Struct1ByteInt a6, Struct1ByteInt a7, Struct1ByteInt a8, Struct1ByteInt a9))
DART_EXPORT void	TestAsyncPassStruct3BytesHomogeneousUint8x10 (void(*f)(Struct3BytesHomogeneousUint8 a0, Struct3BytesHomogeneousUint8 a1, Struct3BytesHomogeneousUint8 a2, Struct3BytesHomogeneousUint8 a3, Struct3BytesHomogeneousUint8 a4, Struct3BytesHomogeneousUint8 a5, Struct3BytesHomogeneousUint8 a6, Struct3BytesHomogeneousUint8 a7, Struct3BytesHomogeneousUint8 a8, Struct3BytesHomogeneousUint8 a9))
DART_EXPORT void	TestAsyncPassStruct3BytesInt2ByteAlignedx10 (void(*f)(Struct3BytesInt2ByteAligned a0, Struct3BytesInt2ByteAligned a1, Struct3BytesInt2ByteAligned a2, Struct3BytesInt2ByteAligned a3, Struct3BytesInt2ByteAligned a4, Struct3BytesInt2ByteAligned a5, Struct3BytesInt2ByteAligned a6, Struct3BytesInt2ByteAligned a7, Struct3BytesInt2ByteAligned a8, Struct3BytesInt2ByteAligned a9))
DART_EXPORT void	TestAsyncPassStruct4BytesHomogeneousInt16x10 (void(*f)(Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1, Struct4BytesHomogeneousInt16 a2, Struct4BytesHomogeneousInt16 a3, Struct4BytesHomogeneousInt16 a4, Struct4BytesHomogeneousInt16 a5, Struct4BytesHomogeneousInt16 a6, Struct4BytesHomogeneousInt16 a7, Struct4BytesHomogeneousInt16 a8, Struct4BytesHomogeneousInt16 a9))
DART_EXPORT void	TestAsyncPassStruct7BytesHomogeneousUint8x10 (void(*f)(Struct7BytesHomogeneousUint8 a0, Struct7BytesHomogeneousUint8 a1, Struct7BytesHomogeneousUint8 a2, Struct7BytesHomogeneousUint8 a3, Struct7BytesHomogeneousUint8 a4, Struct7BytesHomogeneousUint8 a5, Struct7BytesHomogeneousUint8 a6, Struct7BytesHomogeneousUint8 a7, Struct7BytesHomogeneousUint8 a8, Struct7BytesHomogeneousUint8 a9))
DART_EXPORT void	TestAsyncPassStruct7BytesInt4ByteAlignedx10 (void(*f)(Struct7BytesInt4ByteAligned a0, Struct7BytesInt4ByteAligned a1, Struct7BytesInt4ByteAligned a2, Struct7BytesInt4ByteAligned a3, Struct7BytesInt4ByteAligned a4, Struct7BytesInt4ByteAligned a5, Struct7BytesInt4ByteAligned a6, Struct7BytesInt4ByteAligned a7, Struct7BytesInt4ByteAligned a8, Struct7BytesInt4ByteAligned a9))
DART_EXPORT void	TestAsyncPassStruct8BytesIntx10 (void(*f)(Struct8BytesInt a0, Struct8BytesInt a1, Struct8BytesInt a2, Struct8BytesInt a3, Struct8BytesInt a4, Struct8BytesInt a5, Struct8BytesInt a6, Struct8BytesInt a7, Struct8BytesInt a8, Struct8BytesInt a9))
DART_EXPORT void	TestAsyncPassStruct8BytesHomogeneousFloatx10 (void(*f)(Struct8BytesHomogeneousFloat a0, Struct8BytesHomogeneousFloat a1, Struct8BytesHomogeneousFloat a2, Struct8BytesHomogeneousFloat a3, Struct8BytesHomogeneousFloat a4, Struct8BytesHomogeneousFloat a5, Struct8BytesHomogeneousFloat a6, Struct8BytesHomogeneousFloat a7, Struct8BytesHomogeneousFloat a8, Struct8BytesHomogeneousFloat a9))
DART_EXPORT void	TestAsyncPassStruct8BytesMixedx10 (void(*f)(Struct8BytesMixed a0, Struct8BytesMixed a1, Struct8BytesMixed a2, Struct8BytesMixed a3, Struct8BytesMixed a4, Struct8BytesMixed a5, Struct8BytesMixed a6, Struct8BytesMixed a7, Struct8BytesMixed a8, Struct8BytesMixed a9))
DART_EXPORT void	TestAsyncPassStruct9BytesHomogeneousUint8x10 (void(*f)(Struct9BytesHomogeneousUint8 a0, Struct9BytesHomogeneousUint8 a1, Struct9BytesHomogeneousUint8 a2, Struct9BytesHomogeneousUint8 a3, Struct9BytesHomogeneousUint8 a4, Struct9BytesHomogeneousUint8 a5, Struct9BytesHomogeneousUint8 a6, Struct9BytesHomogeneousUint8 a7, Struct9BytesHomogeneousUint8 a8, Struct9BytesHomogeneousUint8 a9))
DART_EXPORT void	TestAsyncPassStruct9BytesInt4Or8ByteAlignedx10 (void(*f)(Struct9BytesInt4Or8ByteAligned a0, Struct9BytesInt4Or8ByteAligned a1, Struct9BytesInt4Or8ByteAligned a2, Struct9BytesInt4Or8ByteAligned a3, Struct9BytesInt4Or8ByteAligned a4, Struct9BytesInt4Or8ByteAligned a5, Struct9BytesInt4Or8ByteAligned a6, Struct9BytesInt4Or8ByteAligned a7, Struct9BytesInt4Or8ByteAligned a8, Struct9BytesInt4Or8ByteAligned a9))
DART_EXPORT void	TestAsyncPassStruct12BytesHomogeneousFloatx6 (void(*f)(Struct12BytesHomogeneousFloat a0, Struct12BytesHomogeneousFloat a1, Struct12BytesHomogeneousFloat a2, Struct12BytesHomogeneousFloat a3, Struct12BytesHomogeneousFloat a4, Struct12BytesHomogeneousFloat a5))
DART_EXPORT void	TestAsyncPassStruct16BytesHomogeneousFloatx5 (void(*f)(Struct16BytesHomogeneousFloat a0, Struct16BytesHomogeneousFloat a1, Struct16BytesHomogeneousFloat a2, Struct16BytesHomogeneousFloat a3, Struct16BytesHomogeneousFloat a4))
DART_EXPORT void	TestAsyncPassStruct16BytesMixedx10 (void(*f)(Struct16BytesMixed a0, Struct16BytesMixed a1, Struct16BytesMixed a2, Struct16BytesMixed a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9))
DART_EXPORT void	TestAsyncPassStruct16BytesMixed2x10 (void(*f)(Struct16BytesMixed2 a0, Struct16BytesMixed2 a1, Struct16BytesMixed2 a2, Struct16BytesMixed2 a3, Struct16BytesMixed2 a4, Struct16BytesMixed2 a5, Struct16BytesMixed2 a6, Struct16BytesMixed2 a7, Struct16BytesMixed2 a8, Struct16BytesMixed2 a9))
DART_EXPORT void	TestAsyncPassStruct17BytesIntx10 (void(*f)(Struct17BytesInt a0, Struct17BytesInt a1, Struct17BytesInt a2, Struct17BytesInt a3, Struct17BytesInt a4, Struct17BytesInt a5, Struct17BytesInt a6, Struct17BytesInt a7, Struct17BytesInt a8, Struct17BytesInt a9))
DART_EXPORT void	TestAsyncPassStruct19BytesHomogeneousUint8x10 (void(*f)(Struct19BytesHomogeneousUint8 a0, Struct19BytesHomogeneousUint8 a1, Struct19BytesHomogeneousUint8 a2, Struct19BytesHomogeneousUint8 a3, Struct19BytesHomogeneousUint8 a4, Struct19BytesHomogeneousUint8 a5, Struct19BytesHomogeneousUint8 a6, Struct19BytesHomogeneousUint8 a7, Struct19BytesHomogeneousUint8 a8, Struct19BytesHomogeneousUint8 a9))
DART_EXPORT void	TestAsyncPassStruct20BytesHomogeneousInt32x10 (void(*f)(Struct20BytesHomogeneousInt32 a0, Struct20BytesHomogeneousInt32 a1, Struct20BytesHomogeneousInt32 a2, Struct20BytesHomogeneousInt32 a3, Struct20BytesHomogeneousInt32 a4, Struct20BytesHomogeneousInt32 a5, Struct20BytesHomogeneousInt32 a6, Struct20BytesHomogeneousInt32 a7, Struct20BytesHomogeneousInt32 a8, Struct20BytesHomogeneousInt32 a9))
DART_EXPORT void	TestAsyncPassStruct20BytesHomogeneousFloat (void(*f)(Struct20BytesHomogeneousFloat a0))
DART_EXPORT void	TestAsyncPassStruct32BytesHomogeneousDoublex5 (void(*f)(Struct32BytesHomogeneousDouble a0, Struct32BytesHomogeneousDouble a1, Struct32BytesHomogeneousDouble a2, Struct32BytesHomogeneousDouble a3, Struct32BytesHomogeneousDouble a4))
DART_EXPORT void	TestAsyncPassStruct40BytesHomogeneousDouble (void(*f)(Struct40BytesHomogeneousDouble a0))
DART_EXPORT void	TestAsyncPassStruct1024BytesHomogeneousUint64 (void(*f)(Struct1024BytesHomogeneousUint64 a0))
DART_EXPORT void	TestAsyncPassFloatStruct16BytesHomogeneousFloatFloatStruct1 (void(*f)(float a0, Struct16BytesHomogeneousFloat a1, float a2, Struct16BytesHomogeneousFloat a3, float a4, Struct16BytesHomogeneousFloat a5, float a6, Struct16BytesHomogeneousFloat a7, float a8))
DART_EXPORT void	TestAsyncPassFloatStruct32BytesHomogeneousDoubleFloatStruct (void(*f)(float a0, Struct32BytesHomogeneousDouble a1, float a2, Struct32BytesHomogeneousDouble a3, float a4, Struct32BytesHomogeneousDouble a5, float a6, Struct32BytesHomogeneousDouble a7, float a8))
DART_EXPORT void	TestAsyncPassInt8Struct16BytesMixedInt8Struct16BytesMixedIn (void(*f)(int8_t a0, Struct16BytesMixed a1, int8_t a2, Struct16BytesMixed a3, int8_t a4, Struct16BytesMixed a5, int8_t a6, Struct16BytesMixed a7, int8_t a8))
DART_EXPORT void	TestAsyncPassDoublex6Struct16BytesMixedx4Int32 (void(*f)(double a0, double a1, double a2, double a3, double a4, double a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9, int32_t a10))
DART_EXPORT void	TestAsyncPassInt32x4Struct16BytesMixedx4Double (void(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, double a8))
DART_EXPORT void	TestAsyncPassStruct40BytesHomogeneousDoubleStruct4BytesHomo (void(*f)(Struct40BytesHomogeneousDouble a0, Struct4BytesHomogeneousInt16 a1, Struct8BytesHomogeneousFloat a2))
DART_EXPORT void	TestAsyncPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int (void(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, double a8, double a9, double a10, double a11, double a12, double a13, double a14, double a15, int64_t a16, int8_t a17, Struct1ByteInt a18, int64_t a19, int8_t a20, Struct4BytesHomogeneousInt16 a21, int64_t a22, int8_t a23, Struct8BytesInt a24, int64_t a25, int8_t a26, Struct8BytesHomogeneousFloat a27, int64_t a28, int8_t a29, Struct8BytesMixed a30, int64_t a31, int8_t a32, StructAlignmentInt16 a33, int64_t a34, int8_t a35, StructAlignmentInt32 a36, int64_t a37, int8_t a38, StructAlignmentInt64 a39))
DART_EXPORT void	TestAsyncPassStructAlignmentInt16 (void(*f)(StructAlignmentInt16 a0))
DART_EXPORT void	TestAsyncPassStructAlignmentInt32 (void(*f)(StructAlignmentInt32 a0))
DART_EXPORT void	TestAsyncPassStructAlignmentInt64 (void(*f)(StructAlignmentInt64 a0))
DART_EXPORT void	TestAsyncPassStruct8BytesNestedIntx10 (void(*f)(Struct8BytesNestedInt a0, Struct8BytesNestedInt a1, Struct8BytesNestedInt a2, Struct8BytesNestedInt a3, Struct8BytesNestedInt a4, Struct8BytesNestedInt a5, Struct8BytesNestedInt a6, Struct8BytesNestedInt a7, Struct8BytesNestedInt a8, Struct8BytesNestedInt a9))
DART_EXPORT void	TestAsyncPassStruct8BytesNestedFloatx10 (void(*f)(Struct8BytesNestedFloat a0, Struct8BytesNestedFloat a1, Struct8BytesNestedFloat a2, Struct8BytesNestedFloat a3, Struct8BytesNestedFloat a4, Struct8BytesNestedFloat a5, Struct8BytesNestedFloat a6, Struct8BytesNestedFloat a7, Struct8BytesNestedFloat a8, Struct8BytesNestedFloat a9))
DART_EXPORT void	TestAsyncPassStruct8BytesNestedFloat2x10 (void(*f)(Struct8BytesNestedFloat2 a0, Struct8BytesNestedFloat2 a1, Struct8BytesNestedFloat2 a2, Struct8BytesNestedFloat2 a3, Struct8BytesNestedFloat2 a4, Struct8BytesNestedFloat2 a5, Struct8BytesNestedFloat2 a6, Struct8BytesNestedFloat2 a7, Struct8BytesNestedFloat2 a8, Struct8BytesNestedFloat2 a9))
DART_EXPORT void	TestAsyncPassStruct8BytesNestedMixedx10 (void(*f)(Struct8BytesNestedMixed a0, Struct8BytesNestedMixed a1, Struct8BytesNestedMixed a2, Struct8BytesNestedMixed a3, Struct8BytesNestedMixed a4, Struct8BytesNestedMixed a5, Struct8BytesNestedMixed a6, Struct8BytesNestedMixed a7, Struct8BytesNestedMixed a8, Struct8BytesNestedMixed a9))
DART_EXPORT void	TestAsyncPassStruct16BytesNestedIntx2 (void(*f)(Struct16BytesNestedInt a0, Struct16BytesNestedInt a1))
DART_EXPORT void	TestAsyncPassStruct32BytesNestedIntx2 (void(*f)(Struct32BytesNestedInt a0, Struct32BytesNestedInt a1))
DART_EXPORT void	TestAsyncPassStructNestedIntStructAlignmentInt16 (void(*f)(StructNestedIntStructAlignmentInt16 a0))
DART_EXPORT void	TestAsyncPassStructNestedIntStructAlignmentInt32 (void(*f)(StructNestedIntStructAlignmentInt32 a0))
DART_EXPORT void	TestAsyncPassStructNestedIntStructAlignmentInt64 (void(*f)(StructNestedIntStructAlignmentInt64 a0))
DART_EXPORT void	TestAsyncPassStructNestedIrregularEvenBiggerx4 (void(*f)(StructNestedIrregularEvenBigger a0, StructNestedIrregularEvenBigger a1, StructNestedIrregularEvenBigger a2, StructNestedIrregularEvenBigger a3))
DART_EXPORT void	TestAsyncPassStruct8BytesInlineArrayIntx4 (void(*f)(Struct8BytesInlineArrayInt a0, Struct8BytesInlineArrayInt a1, Struct8BytesInlineArrayInt a2, Struct8BytesInlineArrayInt a3))
DART_EXPORT void	TestAsyncPassStructInlineArrayIrregularx4 (void(*f)(StructInlineArrayIrregular a0, StructInlineArrayIrregular a1, StructInlineArrayIrregular a2, StructInlineArrayIrregular a3))
DART_EXPORT void	TestAsyncPassStructInlineArray100Bytes (void(*f)(StructInlineArray100Bytes a0))
DART_EXPORT void	TestAsyncPassStructStruct16BytesHomogeneousFloat2x5 (void(*f)(StructStruct16BytesHomogeneousFloat2 a0, StructStruct16BytesHomogeneousFloat2 a1, StructStruct16BytesHomogeneousFloat2 a2, StructStruct16BytesHomogeneousFloat2 a3, StructStruct16BytesHomogeneousFloat2 a4))
DART_EXPORT void	TestAsyncPassStructStruct32BytesHomogeneousDouble2x5 (void(*f)(StructStruct32BytesHomogeneousDouble2 a0, StructStruct32BytesHomogeneousDouble2 a1, StructStruct32BytesHomogeneousDouble2 a2, StructStruct32BytesHomogeneousDouble2 a3, StructStruct32BytesHomogeneousDouble2 a4))
DART_EXPORT void	TestAsyncPassStructStruct16BytesMixed3x10 (void(*f)(StructStruct16BytesMixed3 a0, StructStruct16BytesMixed3 a1, StructStruct16BytesMixed3 a2, StructStruct16BytesMixed3 a3, StructStruct16BytesMixed3 a4, StructStruct16BytesMixed3 a5, StructStruct16BytesMixed3 a6, StructStruct16BytesMixed3 a7, StructStruct16BytesMixed3 a8, StructStruct16BytesMixed3 a9))
DART_EXPORT void	TestAsyncPassUint8Struct32BytesInlineArrayMultiDimensionalI (void(*f)(uint8_t a0, Struct32BytesInlineArrayMultiDimensionalInt a1, uint8_t a2, Struct8BytesInlineArrayMultiDimensionalInt a3, uint8_t a4, Struct8BytesInlineArrayMultiDimensionalInt a5, uint8_t a6))
DART_EXPORT void	TestAsyncPassUint8Struct4BytesInlineArrayMultiDimensionalIn (void(*f)(uint8_t a0, Struct4BytesInlineArrayMultiDimensionalInt a1, uint8_t a2))
DART_EXPORT void	TestAsyncPassStruct3BytesPackedIntx10 (void(*f)(Struct3BytesPackedInt a0, Struct3BytesPackedInt a1, Struct3BytesPackedInt a2, Struct3BytesPackedInt a3, Struct3BytesPackedInt a4, Struct3BytesPackedInt a5, Struct3BytesPackedInt a6, Struct3BytesPackedInt a7, Struct3BytesPackedInt a8, Struct3BytesPackedInt a9))
DART_EXPORT void	TestAsyncPassStruct8BytesPackedIntx10 (void(*f)(Struct8BytesPackedInt a0, Struct8BytesPackedInt a1, Struct8BytesPackedInt a2, Struct8BytesPackedInt a3, Struct8BytesPackedInt a4, Struct8BytesPackedInt a5, Struct8BytesPackedInt a6, Struct8BytesPackedInt a7, Struct8BytesPackedInt a8, Struct8BytesPackedInt a9))
DART_EXPORT void	TestAsyncPassStruct9BytesPackedMixedx10DoubleInt32x2 (void(*f)(Struct9BytesPackedMixed a0, Struct9BytesPackedMixed a1, Struct9BytesPackedMixed a2, Struct9BytesPackedMixed a3, Struct9BytesPackedMixed a4, Struct9BytesPackedMixed a5, Struct9BytesPackedMixed a6, Struct9BytesPackedMixed a7, Struct9BytesPackedMixed a8, Struct9BytesPackedMixed a9, double a10, int32_t a11, int32_t a12))
DART_EXPORT void	TestAsyncPassStruct5BytesPackedMixed (void(*f)(Struct5BytesPackedMixed a0))
DART_EXPORT void	TestAsyncPassStructNestedAlignmentStruct5BytesPackedMixed (void(*f)(StructNestedAlignmentStruct5BytesPackedMixed a0))
DART_EXPORT void	TestAsyncPassStruct6BytesInlineArrayInt (void(*f)(Struct6BytesInlineArrayInt a0))
DART_EXPORT void	TestAsyncPassStruct15BytesInlineArrayMixed (void(*f)(Struct15BytesInlineArrayMixed a0))
DART_EXPORT void	TestAsyncPassUnion4BytesMixedx10 (void(*f)(Union4BytesMixed a0, Union4BytesMixed a1, Union4BytesMixed a2, Union4BytesMixed a3, Union4BytesMixed a4, Union4BytesMixed a5, Union4BytesMixed a6, Union4BytesMixed a7, Union4BytesMixed a8, Union4BytesMixed a9))
DART_EXPORT void	TestAsyncPassUnion8BytesNestedFloatx10 (void(*f)(Union8BytesNestedFloat a0, Union8BytesNestedFloat a1, Union8BytesNestedFloat a2, Union8BytesNestedFloat a3, Union8BytesNestedFloat a4, Union8BytesNestedFloat a5, Union8BytesNestedFloat a6, Union8BytesNestedFloat a7, Union8BytesNestedFloat a8, Union8BytesNestedFloat a9))
DART_EXPORT void	TestAsyncPassUnion9BytesNestedIntx10 (void(*f)(Union9BytesNestedInt a0, Union9BytesNestedInt a1, Union9BytesNestedInt a2, Union9BytesNestedInt a3, Union9BytesNestedInt a4, Union9BytesNestedInt a5, Union9BytesNestedInt a6, Union9BytesNestedInt a7, Union9BytesNestedInt a8, Union9BytesNestedInt a9))
DART_EXPORT void	TestAsyncPassUnion16BytesNestedInlineArrayFloatx10 (void(*f)(Union16BytesNestedInlineArrayFloat a0, Union16BytesNestedInlineArrayFloat a1, Union16BytesNestedInlineArrayFloat a2, Union16BytesNestedInlineArrayFloat a3, Union16BytesNestedInlineArrayFloat a4, Union16BytesNestedInlineArrayFloat a5, Union16BytesNestedInlineArrayFloat a6, Union16BytesNestedInlineArrayFloat a7, Union16BytesNestedInlineArrayFloat a8, Union16BytesNestedInlineArrayFloat a9))
DART_EXPORT void	TestAsyncPassUnion16BytesNestedFloatx10 (void(*f)(Union16BytesNestedFloat a0, Union16BytesNestedFloat a1, Union16BytesNestedFloat a2, Union16BytesNestedFloat a3, Union16BytesNestedFloat a4, Union16BytesNestedFloat a5, Union16BytesNestedFloat a6, Union16BytesNestedFloat a7, Union16BytesNestedFloat a8, Union16BytesNestedFloat a9))
DART_EXPORT void	TestAsyncPassUint8Boolx9Struct10BytesHomogeneousBoolBool (void(*f)(uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesHomogeneousBool a10, bool a11))
DART_EXPORT void	TestAsyncPassUint8Boolx9Struct10BytesInlineArrayBoolBool (void(*f)(uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesInlineArrayBool a10, bool a11))
DART_EXPORT void	TestAsyncPassUint8Struct1ByteBool (void(*f)(uint8_t a0, Struct1ByteBool a1))
DART_EXPORT void	TestAsyncPassWCharStructInlineArrayIntUintPtrx2LongUnsigned (void(*f)(wchar_t a0, StructInlineArrayInt a1, uintptr_t a2, uintptr_t a3, long a4, unsigned long a5))
DART_EXPORT void	TestAsyncPassInt64x7Struct12BytesHomogeneousInt32 (void(*f)(int64_t a0, int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5, int64_t a6, Struct12BytesHomogeneousInt32 a7))
DART_EXPORT void	TestAsyncReturnStruct1ByteInt (void(*f)(int8_t a0))
DART_EXPORT void	TestAsyncReturnStruct3BytesHomogeneousUint8 (void(*f)(uint8_t a0, uint8_t a1, uint8_t a2))
DART_EXPORT void	TestAsyncReturnStruct3BytesInt2ByteAligned (void(*f)(int16_t a0, int8_t a1))
DART_EXPORT void	TestAsyncReturnStruct4BytesHomogeneousInt16 (void(*f)(int16_t a0, int16_t a1))
DART_EXPORT void	TestAsyncReturnStruct7BytesHomogeneousUint8 (void(*f)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6))
DART_EXPORT void	TestAsyncReturnStruct7BytesInt4ByteAligned (void(*f)(int32_t a0, int16_t a1, int8_t a2))
DART_EXPORT void	TestAsyncReturnStruct8BytesInt (void(*f)(int16_t a0, int16_t a1, int32_t a2))
DART_EXPORT void	TestAsyncReturnStruct8BytesHomogeneousFloat (void(*f)(float a0, float a1))
DART_EXPORT void	TestAsyncReturnStruct8BytesMixed (void(*f)(float a0, int16_t a1, int16_t a2))
DART_EXPORT void	TestAsyncReturnStruct9BytesHomogeneousUint8 (void(*f)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8))
DART_EXPORT void	TestAsyncReturnStruct9BytesInt4Or8ByteAligned (void(*f)(int64_t a0, int8_t a1))
DART_EXPORT void	TestAsyncReturnStruct12BytesHomogeneousFloat (void(*f)(float a0, float a1, float a2))
DART_EXPORT void	TestAsyncReturnStruct16BytesHomogeneousFloat (void(*f)(float a0, float a1, float a2, float a3))
DART_EXPORT void	TestAsyncReturnStruct16BytesMixed (void(*f)(double a0, int64_t a1))
DART_EXPORT void	TestAsyncReturnStruct16BytesMixed2 (void(*f)(float a0, float a1, float a2, int32_t a3))
DART_EXPORT void	TestAsyncReturnStruct17BytesInt (void(*f)(int64_t a0, int64_t a1, int8_t a2))
DART_EXPORT void	TestAsyncReturnStruct19BytesHomogeneousUint8 (void(*f)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8, uint8_t a9, uint8_t a10, uint8_t a11, uint8_t a12, uint8_t a13, uint8_t a14, uint8_t a15, uint8_t a16, uint8_t a17, uint8_t a18))
DART_EXPORT void	TestAsyncReturnStruct20BytesHomogeneousInt32 (void(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4))
DART_EXPORT void	TestAsyncReturnStruct20BytesHomogeneousFloat (void(*f)(float a0, float a1, float a2, float a3, float a4))
DART_EXPORT void	TestAsyncReturnStruct32BytesHomogeneousDouble (void(*f)(double a0, double a1, double a2, double a3))
DART_EXPORT void	TestAsyncReturnStruct40BytesHomogeneousDouble (void(*f)(double a0, double a1, double a2, double a3, double a4))
DART_EXPORT void	TestAsyncReturnStruct1024BytesHomogeneousUint64 (void(*f)(uint64_t a0, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6, uint64_t a7, uint64_t a8, uint64_t a9, uint64_t a10, uint64_t a11, uint64_t a12, uint64_t a13, uint64_t a14, uint64_t a15, uint64_t a16, uint64_t a17, uint64_t a18, uint64_t a19, uint64_t a20, uint64_t a21, uint64_t a22, uint64_t a23, uint64_t a24, uint64_t a25, uint64_t a26, uint64_t a27, uint64_t a28, uint64_t a29, uint64_t a30, uint64_t a31, uint64_t a32, uint64_t a33, uint64_t a34, uint64_t a35, uint64_t a36, uint64_t a37, uint64_t a38, uint64_t a39, uint64_t a40, uint64_t a41, uint64_t a42, uint64_t a43, uint64_t a44, uint64_t a45, uint64_t a46, uint64_t a47, uint64_t a48, uint64_t a49, uint64_t a50, uint64_t a51, uint64_t a52, uint64_t a53, uint64_t a54, uint64_t a55, uint64_t a56, uint64_t a57, uint64_t a58, uint64_t a59, uint64_t a60, uint64_t a61, uint64_t a62, uint64_t a63, uint64_t a64, uint64_t a65, uint64_t a66, uint64_t a67, uint64_t a68, uint64_t a69, uint64_t a70, uint64_t a71, uint64_t a72, uint64_t a73, uint64_t a74, uint64_t a75, uint64_t a76, uint64_t a77, uint64_t a78, uint64_t a79, uint64_t a80, uint64_t a81, uint64_t a82, uint64_t a83, uint64_t a84, uint64_t a85, uint64_t a86, uint64_t a87, uint64_t a88, uint64_t a89, uint64_t a90, uint64_t a91, uint64_t a92, uint64_t a93, uint64_t a94, uint64_t a95, uint64_t a96, uint64_t a97, uint64_t a98, uint64_t a99, uint64_t a100, uint64_t a101, uint64_t a102, uint64_t a103, uint64_t a104, uint64_t a105, uint64_t a106, uint64_t a107, uint64_t a108, uint64_t a109, uint64_t a110, uint64_t a111, uint64_t a112, uint64_t a113, uint64_t a114, uint64_t a115, uint64_t a116, uint64_t a117, uint64_t a118, uint64_t a119, uint64_t a120, uint64_t a121, uint64_t a122, uint64_t a123, uint64_t a124, uint64_t a125, uint64_t a126, uint64_t a127))
DART_EXPORT void	TestAsyncReturnStruct3BytesPackedInt (void(*f)(int8_t a0, int16_t a1))
DART_EXPORT void	TestAsyncReturnStruct8BytesPackedInt (void(*f)(uint8_t a0, uint32_t a1, uint8_t a2, uint8_t a3, uint8_t a4))
DART_EXPORT void	TestAsyncReturnStruct9BytesPackedMixed (void(*f)(uint8_t a0, double a1))
DART_EXPORT void	TestAsyncReturnUnion4BytesMixed (void(*f)(uint32_t a0))
DART_EXPORT void	TestAsyncReturnUnion8BytesNestedFloat (void(*f)(double a0))
DART_EXPORT void	TestAsyncReturnUnion9BytesNestedInt (void(*f)(Struct8BytesInt a0))
DART_EXPORT void	TestAsyncReturnUnion16BytesNestedFloat (void(*f)(Struct8BytesHomogeneousFloat a0))
DART_EXPORT void	TestAsyncReturnStructArgumentStruct1ByteInt (void(*f)(Struct1ByteInt a0))
DART_EXPORT void	TestAsyncReturnStructArgumentInt32x8Struct1ByteInt (void(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct1ByteInt a8))
DART_EXPORT void	TestAsyncReturnStructArgumentStruct8BytesHomogeneousFloat (void(*f)(Struct8BytesHomogeneousFloat a0))
DART_EXPORT void	TestAsyncReturnStructArgumentStruct20BytesHomogeneousInt32 (void(*f)(Struct20BytesHomogeneousInt32 a0))
DART_EXPORT void	TestAsyncReturnStructArgumentInt32x8Struct20BytesHomogeneou (void(*f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct20BytesHomogeneousInt32 a8))
DART_EXPORT void	TestAsyncReturnStructArgumentStruct8BytesInlineArrayInt (void(*f)(Struct8BytesInlineArrayInt a0))
DART_EXPORT void	TestAsyncReturnStructArgumentStructStruct16BytesHomogeneous (void(*f)(StructStruct16BytesHomogeneousFloat2 a0))
DART_EXPORT void	TestAsyncReturnStructArgumentStructStruct32BytesHomogeneous (void(*f)(StructStruct32BytesHomogeneousDouble2 a0))
DART_EXPORT void	TestAsyncReturnStructArgumentStructStruct16BytesMixed3 (void(*f)(StructStruct16BytesMixed3 a0))
DART_EXPORT void	TestAsyncReturnStructAlignmentInt16 (void(*f)(int8_t a0, int16_t a1, int8_t a2))
DART_EXPORT void	TestAsyncReturnStructAlignmentInt32 (void(*f)(int8_t a0, int32_t a1, int8_t a2))
DART_EXPORT void	TestAsyncReturnStructAlignmentInt64 (void(*f)(int8_t a0, int64_t a1, int8_t a2))
DART_EXPORT void	TestAsyncReturnStruct8BytesNestedInt (void(*f)(Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1))
DART_EXPORT void	TestAsyncReturnStruct8BytesNestedFloat (void(*f)(Struct4BytesFloat a0, Struct4BytesFloat a1))
DART_EXPORT void	TestAsyncReturnStruct8BytesNestedFloat2 (void(*f)(Struct4BytesFloat a0, float a1))
DART_EXPORT void	TestAsyncReturnStruct8BytesNestedMixed (void(*f)(Struct4BytesHomogeneousInt16 a0, Struct4BytesFloat a1))
DART_EXPORT void	TestAsyncReturnStruct16BytesNestedInt (void(*f)(Struct8BytesNestedInt a0, Struct8BytesNestedInt a1))
DART_EXPORT void	TestAsyncReturnStruct32BytesNestedInt (void(*f)(Struct16BytesNestedInt a0, Struct16BytesNestedInt a1))
DART_EXPORT void	TestAsyncReturnStructNestedIntStructAlignmentInt16 (void(*f)(StructAlignmentInt16 a0, StructAlignmentInt16 a1))
DART_EXPORT void	TestAsyncReturnStructNestedIntStructAlignmentInt32 (void(*f)(StructAlignmentInt32 a0, StructAlignmentInt32 a1))
DART_EXPORT void	TestAsyncReturnStructNestedIntStructAlignmentInt64 (void(*f)(StructAlignmentInt64 a0, StructAlignmentInt64 a1))
DART_EXPORT void	TestAsyncReturnStructNestedIrregularEvenBigger (void(*f)(uint64_t a0, StructNestedIrregularBigger a1, StructNestedIrregularBigger a2, double a3))
DART_EXPORT int64_t	VariadicAt1Int64x2 (int64_t a0,...)
DART_EXPORT double	VariadicAt1Doublex2 (double a0,...)
DART_EXPORT int64_t	VariadicAt1Int64x5 (int64_t a0,...)
DART_EXPORT double	VariadicAt1Doublex5 (double a0,...)
DART_EXPORT int64_t	VariadicAt1Int64x20 (int64_t a0,...)
DART_EXPORT double	VariadicAt1Doublex20 (double a0,...)
DART_EXPORT int64_t	VariadicAt1Int64x2Struct8BytesIntInt64 (int64_t a0,...)
DART_EXPORT double	VariadicAt1Doublex2Struct32BytesHomogeneousDoubleD (double a0,...)
DART_EXPORT double	VariadicAt1DoubleStruct12BytesHomogeneousFloatDoub (double a0,...)
DART_EXPORT int32_t	VariadicAt1Int32Struct20BytesHomogeneousInt32Int32 (int32_t a0,...)
DART_EXPORT double	VariadicAt1DoubleStruct20BytesHomogeneousFloatDoub (double a0,...)
DART_EXPORT int32_t	VariadicAt2Int32Int64IntPtr (int32_t a0, int64_t a1,...)
DART_EXPORT double	VariadicAt1DoubleInt64Int32DoubleInt64Int32 (double a0,...)
DART_EXPORT double	VariadicAt1Int64Int32Struct12BytesHomogeneousFloat (int64_t a0,...)
DART_EXPORT double	VariadicAt11Doublex8FloatStruct12BytesHomogeneousF (double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, float a8, Struct12BytesHomogeneousFloat a9, int64_t a10,...)
DART_EXPORT double	VariadicAt1DoubleInt64Int32Struct20BytesHomogeneou (double a0,...)
DART_EXPORT double	VariadicAt5Doublex5 (double a0, double a1, double a2, double a3, double a4,...)
DART_EXPORT int64_t	VariadicAt1Int64x7Struct12BytesHomogeneousInt32 (int64_t a0,...)
DART_EXPORT int32_t	VariadicAt1Struct12BytesHomogeneousInt32Int32x4 (Struct12BytesHomogeneousInt32 a0,...)
DART_EXPORT intptr_t	TestVariadicAt1Int64x2 (int64_t(*f)(int64_t a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Doublex2 (double(*f)(double a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Int64x5 (int64_t(*f)(int64_t a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Doublex5 (double(*f)(double a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Int64x20 (int64_t(*f)(int64_t a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Doublex20 (double(*f)(double a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Int64x2Struct8BytesIntInt64 (int64_t(*f)(int64_t a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Doublex2Struct32BytesHomogeneousDoubleD (double(*f)(double a0,...))
DART_EXPORT intptr_t	TestVariadicAt1DoubleStruct12BytesHomogeneousFloatDoub (double(*f)(double a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Int32Struct20BytesHomogeneousInt32Int32 (int32_t(*f)(int32_t a0,...))
DART_EXPORT intptr_t	TestVariadicAt1DoubleStruct20BytesHomogeneousFloatDoub (double(*f)(double a0,...))
DART_EXPORT intptr_t	TestVariadicAt2Int32Int64IntPtr (int32_t(*f)(int32_t a0, int64_t a1,...))
DART_EXPORT intptr_t	TestVariadicAt1DoubleInt64Int32DoubleInt64Int32 (double(*f)(double a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Int64Int32Struct12BytesHomogeneousFloat (double(*f)(int64_t a0,...))
DART_EXPORT intptr_t	TestVariadicAt11Doublex8FloatStruct12BytesHomogeneousF (double(*f)(double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, float a8, Struct12BytesHomogeneousFloat a9, int64_t a10,...))
DART_EXPORT intptr_t	TestVariadicAt1DoubleInt64Int32Struct20BytesHomogeneou (double(*f)(double a0,...))
DART_EXPORT intptr_t	TestVariadicAt5Doublex5 (double(*f)(double a0, double a1, double a2, double a3, double a4,...))
DART_EXPORT intptr_t	TestVariadicAt1Int64x7Struct12BytesHomogeneousInt32 (int64_t(*f)(int64_t a0,...))
DART_EXPORT intptr_t	TestVariadicAt1Struct12BytesHomogeneousInt32Int32x4 (int32_t(*f)(Struct12BytesHomogeneousInt32 a0,...))
DART_EXPORT int8_t	TakeInt8Pointer (int8_t *data, size_t length)
DART_EXPORT int8_t	TakeInt8PointerMany (int8_t *data0, int8_t *data1, int8_t *data2, int8_t *data3, int8_t *data4, int8_t *data5, int8_t *data6, int8_t *data7, int8_t *data8, int8_t *data9, int8_t *data10, int8_t *data11, int8_t *data12, int8_t *data13, int8_t *data14, int8_t *data15, int8_t *data16, int8_t *data17, int8_t *data18, int8_t *data19)
DART_EXPORT int16_t	TakeInt16Pointer (int16_t *data, size_t length)
DART_EXPORT int16_t	TakeInt16PointerMany (int16_t *data0, int16_t *data1, int16_t *data2, int16_t *data3, int16_t *data4, int16_t *data5, int16_t *data6, int16_t *data7, int16_t *data8, int16_t *data9, int16_t *data10, int16_t *data11, int16_t *data12, int16_t *data13, int16_t *data14, int16_t *data15, int16_t *data16, int16_t *data17, int16_t *data18, int16_t *data19)
DART_EXPORT int32_t	TakeInt32Pointer (int32_t *data, size_t length)
DART_EXPORT int32_t	TakeInt32PointerMany (int32_t *data0, int32_t *data1, int32_t *data2, int32_t *data3, int32_t *data4, int32_t *data5, int32_t *data6, int32_t *data7, int32_t *data8, int32_t *data9, int32_t *data10, int32_t *data11, int32_t *data12, int32_t *data13, int32_t *data14, int32_t *data15, int32_t *data16, int32_t *data17, int32_t *data18, int32_t *data19)
DART_EXPORT int64_t	TakeInt64Pointer (int64_t *data, size_t length)
DART_EXPORT int64_t	TakeInt64PointerMany (int64_t *data0, int64_t *data1, int64_t *data2, int64_t *data3, int64_t *data4, int64_t *data5, int64_t *data6, int64_t *data7, int64_t *data8, int64_t *data9, int64_t *data10, int64_t *data11, int64_t *data12, int64_t *data13, int64_t *data14, int64_t *data15, int64_t *data16, int64_t *data17, int64_t *data18, int64_t *data19)
DART_EXPORT uint8_t	TakeUint8Pointer (uint8_t *data, size_t length)
DART_EXPORT uint8_t	TakeUint8PointerMany (uint8_t *data0, uint8_t *data1, uint8_t *data2, uint8_t *data3, uint8_t *data4, uint8_t *data5, uint8_t *data6, uint8_t *data7, uint8_t *data8, uint8_t *data9, uint8_t *data10, uint8_t *data11, uint8_t *data12, uint8_t *data13, uint8_t *data14, uint8_t *data15, uint8_t *data16, uint8_t *data17, uint8_t *data18, uint8_t *data19)
DART_EXPORT uint16_t	TakeUint16Pointer (uint16_t *data, size_t length)
DART_EXPORT uint16_t	TakeUint16PointerMany (uint16_t *data0, uint16_t *data1, uint16_t *data2, uint16_t *data3, uint16_t *data4, uint16_t *data5, uint16_t *data6, uint16_t *data7, uint16_t *data8, uint16_t *data9, uint16_t *data10, uint16_t *data11, uint16_t *data12, uint16_t *data13, uint16_t *data14, uint16_t *data15, uint16_t *data16, uint16_t *data17, uint16_t *data18, uint16_t *data19)
DART_EXPORT uint32_t	TakeUint32Pointer (uint32_t *data, size_t length)
DART_EXPORT uint32_t	TakeUint32PointerMany (uint32_t *data0, uint32_t *data1, uint32_t *data2, uint32_t *data3, uint32_t *data4, uint32_t *data5, uint32_t *data6, uint32_t *data7, uint32_t *data8, uint32_t *data9, uint32_t *data10, uint32_t *data11, uint32_t *data12, uint32_t *data13, uint32_t *data14, uint32_t *data15, uint32_t *data16, uint32_t *data17, uint32_t *data18, uint32_t *data19)
DART_EXPORT uint64_t	TakeUint64Pointer (uint64_t *data, size_t length)
DART_EXPORT uint64_t	TakeUint64PointerMany (uint64_t *data0, uint64_t *data1, uint64_t *data2, uint64_t *data3, uint64_t *data4, uint64_t *data5, uint64_t *data6, uint64_t *data7, uint64_t *data8, uint64_t *data9, uint64_t *data10, uint64_t *data11, uint64_t *data12, uint64_t *data13, uint64_t *data14, uint64_t *data15, uint64_t *data16, uint64_t *data17, uint64_t *data18, uint64_t *data19)
DART_EXPORT float	TakeFloatPointer (float *data, size_t length)
DART_EXPORT float	TakeFloatPointerMany (float *data0, float *data1, float *data2, float *data3, float *data4, float *data5, float *data6, float *data7, float *data8, float *data9, float *data10, float *data11, float *data12, float *data13, float *data14, float *data15, float *data16, float *data17, float *data18, float *data19)
DART_EXPORT double	TakeDoublePointer (double *data, size_t length)
DART_EXPORT double	TakeDoublePointerMany (double *data0, double *data1, double *data2, double *data3, double *data4, double *data5, double *data6, double *data7, double *data8, double *data9, double *data10, double *data11, double *data12, double *data13, double *data14, double *data15, double *data16, double *data17, double *data18, double *data19)
DART_EXPORT bool	TakeBoolPointer (bool *data, size_t length)
DART_EXPORT bool	TakeBoolPointerMany (bool *data0, bool *data1, bool *data2, bool *data3, bool *data4, bool *data5, bool *data6, bool *data7, bool *data8, bool *data9, bool *data10, bool *data11, bool *data12, bool *data13, bool *data14, bool *data15, bool *data16, bool *data17, bool *data18, bool *data19)
DART_EXPORT int16_t	TakeStruct2BytesIntPointerMany (Struct2BytesInt *data0, Struct2BytesInt *data1, Struct2BytesInt *data2, Struct2BytesInt *data3, Struct2BytesInt *data4, Struct2BytesInt *data5, Struct2BytesInt *data6, Struct2BytesInt *data7, Struct2BytesInt *data8, Struct2BytesInt *data9, Struct2BytesInt *data10, Struct2BytesInt *data11, Struct2BytesInt *data12, Struct2BytesInt *data13, Struct2BytesInt *data14, Struct2BytesInt *data15, Struct2BytesInt *data16, Struct2BytesInt *data17, Struct2BytesInt *data18, Struct2BytesInt *data19)
DART_EXPORT int16_t	TakeUnion2BytesIntPointerMany (Union2BytesInt *data0, Union2BytesInt *data1, Union2BytesInt *data2, Union2BytesInt *data3, Union2BytesInt *data4, Union2BytesInt *data5, Union2BytesInt *data6, Union2BytesInt *data7, Union2BytesInt *data8, Union2BytesInt *data9, Union2BytesInt *data10, Union2BytesInt *data11, Union2BytesInt *data12, Union2BytesInt *data13, Union2BytesInt *data14, Union2BytesInt *data15, Union2BytesInt *data16, Union2BytesInt *data17, Union2BytesInt *data18, Union2BytesInt *data19)
DART_EXPORT int64_t	MinInt64 ()
DART_EXPORT int64_t	MinInt32 ()
DART_EXPORT double	SmallDouble ()
DART_EXPORT void *	LargePointer ()
DART_EXPORT void	TriggerGC (uint64_t count)
DART_EXPORT void	CollectOnNthAllocation (intptr_t num_allocations)
DART_EXPORT void	Regress37069 (uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, uint64_t g, uint64_t h, uint64_t i, uint64_t j, uint64_t k)
DART_EXPORT uint8_t	IsThreadInGenerated ()
DART_EXPORT void *	UnprotectCodeOtherThread (void *isolate, std::condition_variable *var, std::mutex *mut)
DART_EXPORT void *	TestUnprotectCode (void(*fn)(void *))
DART_EXPORT void	WaitForHelper (HelperThreadState *helper)
void	ClobberAndCall (void(*fn)())
DART_EXPORT intptr_t	TestGC (void(*do_gc)())
DART_EXPORT void	RestoreSIGPIPEHandler ()
DART_EXPORT void	IGH_MsanUnpoison (void *start, intptr_t length)
DART_EXPORT Dart_Isolate	IGH_CreateIsolate (const char *name, void *peer)
DART_EXPORT void	IGH_StartIsolate (Dart_Isolate child_isolate, int64_t main_isolate_port, const char *library_uri, const char *function_name, bool errors_are_fatal, Dart_Port on_error_port, Dart_Port on_exit_port)
DART_EXPORT intptr_t	InitDartApiDL (void *data)
void	Fatal (char const *file, int line, char const *error)
DART_EXPORT void	SleepOnAnyOS (intptr_t seconds)
void	NotifyDart (Dart_Port send_port, const Work *work)
intptr_t	MyCallbackBlocking (intptr_t a)
void	MyCallbackNonBlocking (intptr_t a)
void	Work1 ()
void	Work2 ()
DART_EXPORT void	RegisterMyCallbackBlocking (Dart_Port send_port, intptr_t(*callback1)(intptr_t))
DART_EXPORT void	RegisterMyCallbackNonBlocking (Dart_Port send_port, void(*callback)(intptr_t))
DART_EXPORT void	StartWorkSimulator ()
DART_EXPORT void	StopWorkSimulator ()
DART_EXPORT void	ExecuteCallback (Work *work_ptr)
DART_EXPORT void *	Calloc (size_t count, size_t size)
DART_EXPORT void	FreeFinalizer (void *, void *value)
uint8_t	MyCallback1 (uint8_t a)
void	MyCallback2 (uint8_t a)
void	Work1_2 ()
void	Work2_2 ()
DART_EXPORT void	RegisterSendPort (Dart_Port send_port)
DART_EXPORT void	StartWorkSimulator2 ()
DART_EXPORT void	StopWorkSimulator2 ()
DART_EXPORT void	ThreadPoolTest_BarrierSync (Dart_Isolate(*dart_current_isolate)(), void(*dart_enter_isolate)(Dart_Isolate), void(*dart_exit_isolate)(), intptr_t num_threads)
DART_EXPORT void	IsolateExitTest_LookupAndCallIsolateExit (int i)
static void	RunFinalizer (void *isolate_callback_data, void *peer)
DART_EXPORT Dart_Handle	PassObjectToC (Dart_Handle h)
DART_EXPORT void	ClosureCallbackThroughHandle (void(*callback)(Dart_Handle), Dart_Handle closureHandle)
DART_EXPORT Dart_Handle	ReturnHandleInCallback (Dart_Handle(*callback)())
DART_EXPORT Dart_Handle	HandleRecursion (Dart_Handle object, Dart_Handle(*callback)(int64_t), int64_t i)
DART_EXPORT int64_t	HandleReadFieldValue (Dart_Handle handle)
DART_EXPORT int64_t	PropagateErrorWithoutHandle (Dart_Handle(*callback)())
DART_EXPORT Dart_Handle	ThrowOnReturnOfError (Dart_Handle(*callback)())
DART_EXPORT Dart_Handle	TrueHandle ()
DART_EXPORT Dart_Handle	PassObjectToCUseDynamicLinking (Dart_Handle h)
DART_EXPORT void	RegisterClosureCallbackFP (void(*callback)(Dart_Handle))
DART_EXPORT void	RegisterClosureCallback (Dart_Handle h)
DART_EXPORT void	InvokeClosureCallback ()
DART_EXPORT void	ReleaseClosureCallback ()
DART_EXPORT void	SetArgumentTo42 (void *token)
DART_EXPORT Dart_Handle	GetRootLibraryUrl ()
intptr_t	ReturnIntPtr (intptr_t x)
intptr_t	PassAsHandle (Dart_Handle handle)
intptr_t	PassAsPointer (void *ptr)
intptr_t	PassAsPointerAndValue (void *ptr, intptr_t value)
intptr_t	PassAsValueAndPointer (intptr_t value, void *ptr)
intptr_t *	AllocateResource (intptr_t value)
void	DeleteResource (intptr_t *resource)
intptr_t	GetResourceValue (intptr_t *resource)
void	DummyResourceFinalizer (void *isolate_peer, void *peer)
void	SetResourceFinalizer (Dart_Handle handle, intptr_t *resource)
intptr_t	AddPtrAndInt (void *self, intptr_t x)
intptr_t	AddHandleFieldAndInt (Dart_Handle self, intptr_t x)
intptr_t	AddPtrAndPtr (void *self, void *other)
intptr_t	AddHandleFieldAndPtr (Dart_Handle self, void *other)
intptr_t	AddHandleFieldAndHandleField (Dart_Handle self, Dart_Handle other)
intptr_t	AddPtrAndHandleField (void *self, Dart_Handle other)
intptr_t	ReturnIntPtrMethod (Dart_Handle self, intptr_t value)
static void *	FfiNativeResolver (const char *name, uintptr_t args_n)
DART_EXPORT void	SetFfiNativeResolverForTest (Dart_Handle url)
DART_EXPORT void	WaitUntilNThreadsEnterBarrier (intptr_t num_threads)
DART_EXPORT bool	IsNull (Dart_Handle object)
DART_EXPORT RefCountedResource *	AllocateRefcountedResource ()
DART_EXPORT void	IncreaseRefcount (RefCountedResource *peer)
DART_EXPORT void	DecreaseRefcount (void *peer)
DART_EXPORT void	TestDeprecatedSymbols ()
DART_EXPORT void	SemanticsUpdateBuilderUpdateNode (void *this_, int id, int flags, int actions, int maxValueLength, int currentValueLength, int textSelectionBase, int textSelectionExtent, int platformViewId, int scrollChildren, int scrollIndex, double scrollPosition, double scrollExtentMax, double scrollExtentMin, double left, double top, double right, double bottom, double elevation, double thickness, Dart_Handle label, Dart_Handle labelAttributes, Dart_Handle value, Dart_Handle valueAttributes, Dart_Handle increasedValue, Dart_Handle increasedValueAttributes, Dart_Handle decreasedValue, Dart_Handle decreasedValueAttributes, Dart_Handle hint, Dart_Handle hintAttributes, Dart_Handle tooltip, int textDirection, Dart_Handle transform, Dart_Handle childrenInTraversalOrder, Dart_Handle childrenInHitTestOrder, Dart_Handle localContextActions)
DART_EXPORT void	ManyHandles (Dart_Handle o0, Dart_Handle o1, Dart_Handle o2, Dart_Handle o3, Dart_Handle o4, Dart_Handle o5, Dart_Handle o6, Dart_Handle o7, Dart_Handle o8, Dart_Handle o9, Dart_Handle o10, Dart_Handle o11, Dart_Handle o12, Dart_Handle o13, Dart_Handle o14, Dart_Handle o15, Dart_Handle o16, Dart_Handle o17, Dart_Handle o18, Dart_Handle o19)
	TEST_CASE (Read)
	TEST_CASE (OpenUri_RelativeFilename)
	TEST_CASE (OpenUri_AbsoluteFilename)
static const char *	Concat (const char *a, const char *b)
	TEST_CASE (OpenUri_ValidUri)
	TEST_CASE (OpenUri_UriWithSpaces)
	TEST_CASE (OpenUri_InvalidUriPercentEncoding)
	TEST_CASE (OpenUri_TruncatedUriPercentEncoding)
	TEST_CASE (FileLength)
	TEST_CASE (FilePosition)
static uint32_t	WordHash (uint32_t key)
static uint32_t	Hash (uint32_t key)
static uint32_t	CollisionHash1 (uint32_t key)
static uint32_t	CollisionHash2 (uint32_t key)
static uint32_t	CollisionHash3 (uint32_t key)
static uint32_t	CollisionHash4 (uint32_t key)
void	TestSet (IntKeyHash hash, int size)
	VM_UNIT_TEST_CASE (SimpleHashMap_Basic)
	UNIT_TEST_CASE (PRIORITY_HEAP_WITH_INDEX__INCREASING)
	UNIT_TEST_CASE (PRIORITY_HEAP_WITH_INDEX__DECREASING)
	UNIT_TEST_CASE (PRIORITY_HEAP_WITH_INDEX__DELETE_BY_VALUES)
	UNIT_TEST_CASE (PRIORITY_HEAP_WITH_INDEX__GROW_SHRINK)
	UNIT_TEST_CASE (PRIORITY_HEAP_WITH_INDEX__CHANGE_PRIORITY)
static void	PrintUsage ()
static Dart_Isolate	CreateAndSetupServiceIsolate (const char *script_uri, const char *packages_config, Dart_IsolateFlags *flags, char **error)
static Dart_Isolate	CreateIsolateAndSetup (const char *script_uri, const char *main, const char *package_root, const char *packages_config, Dart_IsolateFlags *flags, void *data, char **error)
static void	CleanupIsolateGroup (void *callback_data)
static void	EmbedderInformationCallback (Dart_EmbedderInformation *info)
void	ShiftArgs (int *argc, const char **argv)
static int	Main (int argc, const char **argv)
	DEFINE_NATIVE_ENTRY (List_allocate, 0, 2)
	DEFINE_NATIVE_ENTRY (List_setIndexed, 0, 3)
	DEFINE_NATIVE_ENTRY (List_getLength, 0, 1)
	DEFINE_NATIVE_ENTRY (List_slice, 0, 4)
	DEFINE_NATIVE_ENTRY (ImmutableList_from, 0, 4)
	DEFINE_NATIVE_ENTRY (AsyncStarMoveNext_debuggerStepCheck, 0, 1)
	DEFINE_NATIVE_ENTRY (SuspendState_instantiateClosureWithFutureTypeArgument, 0, 2)
	DEFINE_NATIVE_ENTRY (Bool_fromEnvironment, 0, 3)
	DEFINE_NATIVE_ENTRY (Bool_hasEnvironment, 0, 2)
	DEFINE_NATIVE_ENTRY (DateTime_timeZoneName, 0, 1)
	DEFINE_NATIVE_ENTRY (DateTime_timeZoneOffsetInSeconds, 0, 1)
	DEFINE_NATIVE_ENTRY (DateTime_currentTimeMicros, 0, 0)
	DEFINE_NATIVE_ENTRY (Developer_debugger, 0, 2)
	DEFINE_NATIVE_ENTRY (Developer_inspect, 0, 1)
	DEFINE_NATIVE_ENTRY (Developer_log, 0, 8)
	DEFINE_NATIVE_ENTRY (Developer_postEvent, 0, 2)
	DEFINE_NATIVE_ENTRY (Developer_lookupExtension, 0, 1)
	DEFINE_NATIVE_ENTRY (Developer_registerExtension, 0, 2)
	DEFINE_NATIVE_ENTRY (Developer_getServiceMajorVersion, 0, 0)
	DEFINE_NATIVE_ENTRY (Developer_getServiceMinorVersion, 0, 0)
static void	SendNull (const SendPort &port)
	DEFINE_NATIVE_ENTRY (Developer_getServerInfo, 0, 1)
	DEFINE_NATIVE_ENTRY (Developer_webServerControl, 0, 3)
	DEFINE_NATIVE_ENTRY (Developer_getIsolateIdFromSendPort, 0, 1)
	DEFINE_NATIVE_ENTRY (Developer_getObjectId, 0, 1)
	DEFINE_NATIVE_ENTRY (Developer_reachability_barrier, 0, 0)
	DEFINE_NATIVE_ENTRY (Developer_NativeRuntime_buildId, 0, 0)
	DEFINE_NATIVE_ENTRY (Developer_NativeRuntime_writeHeapSnapshotToFile, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_doubleFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_add, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_sub, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_mul, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_div, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_modulo, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_remainder, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_greaterThan, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_greaterThanFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_equal, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_equalToInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_round, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_floor, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_ceil, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_truncate, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_toInt, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_parse, 0, 3)
	DEFINE_NATIVE_ENTRY (Double_toString, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_toStringAsFixed, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_toStringAsExponential, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_toStringAsPrecision, 0, 2)
	DEFINE_NATIVE_ENTRY (Double_getIsInfinite, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_getIsNaN, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_getIsNegative, 0, 1)
	DEFINE_NATIVE_ENTRY (Double_flipSignBit, 0, 1)
static ScriptPtr	FindScript (DartFrameIterator *iterator)
	DEFINE_NATIVE_ENTRY (AssertionError_throwNew, 0, 3)
	DEFINE_NATIVE_ENTRY (AssertionError_throwNewSource, 0, 5)
	DEFINE_NATIVE_ENTRY (TypeError_throwNew, 0, 4)
	DEFINE_NATIVE_ENTRY (Error_throwWithStackTrace, 0, 2)
	DEFINE_NATIVE_ENTRY (Ffi_createNativeCallableListener, 1, 2)
	DEFINE_NATIVE_ENTRY (Ffi_createNativeCallableIsolateLocal, 1, 3)
	DEFINE_NATIVE_ENTRY (Ffi_deleteNativeCallable, 1, 1)
	DEFINE_NATIVE_ENTRY (Ffi_updateNativeCallableKeepIsolateAliveCounter, 1, 1)
	DEFINE_NATIVE_ENTRY (DartNativeApiFunctionPointer, 0, 1)
	DEFINE_NATIVE_ENTRY (DartApiDLMajorVersion, 0, 0)
	DEFINE_NATIVE_ENTRY (DartApiDLMinorVersion, 0, 0)
	DEFINE_NATIVE_ENTRY (DartApiDLInitializeData, 0, 0)
	DEFINE_FFI_NATIVE_ENTRY (FinalizerEntry_SetExternalSize, void,(Dart_Handle entry_handle, intptr_t external_size))
	DEFINE_FFI_NATIVE_ENTRY (Pointer_asTypedListFinalizerAllocateData, void *,())
void	AsTypedListFinalizerCallback (void *peer)
	DEFINE_FFI_NATIVE_ENTRY (Pointer_asTypedListFinalizerCallbackPointer, void *,())
static void *	LoadDynamicLibrary (const char *library_file, char **error=nullptr)
static void *	ResolveSymbol (void *handle, const char *symbol, char **error)
static bool	SymbolExists (void *handle, const char *symbol)
	DEFINE_NATIVE_ENTRY (Ffi_dl_open, 0, 1)
	DEFINE_NATIVE_ENTRY (Ffi_dl_processLibrary, 0, 0)
	DEFINE_NATIVE_ENTRY (Ffi_dl_executableLibrary, 0, 0)
	DEFINE_NATIVE_ENTRY (Ffi_dl_close, 0, 1)
	DEFINE_NATIVE_ENTRY (Ffi_dl_lookup, 1, 2)
	DEFINE_NATIVE_ENTRY (Ffi_dl_getHandle, 0, 1)
	DEFINE_NATIVE_ENTRY (Ffi_dl_providesSymbol, 0, 2)
static Dart_FfiNativeResolver	GetFfiNativeResolver (Thread *const thread, const String &lib_url_str)
static void *	FfiResolveWithFfiNativeResolver (Thread *const thread, Dart_FfiNativeResolver resolver, const String &symbol, intptr_t args_n, char **error)
static StringPtr	GetPlatformScriptPath (Thread *thread)
static ArrayPtr	GetAssetLocation (Thread *const thread, const String &asset)
static char *	AvailableAssetsToCString (Thread *const thread)
static void *	FfiResolveAsset (Thread *const thread, const Array &asset_location, const String &symbol, char **error)
static void	ThrowFfiResolveError (const String &symbol, const String &asset, char *error)
intptr_t	FfiResolveInternal (const String &asset, const String &symbol, uintptr_t args_n, char **error)
static intptr_t	FfiResolve (Dart_Handle asset_handle, Dart_Handle symbol_handle, uintptr_t args_n)
	DEFINE_NATIVE_ENTRY (Ffi_GetFfiNativeResolver, 1, 0)
	DEFINE_NATIVE_ENTRY (Function_apply, 0, 2)
static bool	ClosureEqualsHelper (Zone *zone, const Closure &receiver, const Object &other)
	DEFINE_NATIVE_ENTRY (Closure_equals, 0, 2)
	DEFINE_NATIVE_ENTRY (Closure_computeHash, 0, 1)
	DEFINE_NATIVE_ENTRY (GrowableList_allocate, 0, 2)
	DEFINE_NATIVE_ENTRY (GrowableList_setIndexed, 0, 3)
	DEFINE_NATIVE_ENTRY (GrowableList_getLength, 0, 1)
	DEFINE_NATIVE_ENTRY (GrowableList_getCapacity, 0, 1)
	DEFINE_NATIVE_ENTRY (GrowableList_setLength, 0, 2)
	DEFINE_NATIVE_ENTRY (GrowableList_setData, 0, 2)
	DEFINE_NATIVE_ENTRY (Internal_makeListFixedLength, 0, 1)
	DEFINE_NATIVE_ENTRY (Internal_makeFixedListUnmodifiable, 0, 1)
	DEFINE_NATIVE_ENTRY (Identical_comparison, 0, 2)
static bool	CheckInteger (const Integer &i)
	DEFINE_NATIVE_ENTRY (Integer_bitAndFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_bitOrFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_bitXorFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_addFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_subFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_mulFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_truncDivFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_moduloFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_greaterThanFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_equalToInteger, 0, 2)
static IntegerPtr	ParseInteger (const String &value)
	DEFINE_NATIVE_ENTRY (Integer_parse, 0, 1)
	DEFINE_NATIVE_ENTRY (Integer_fromEnvironment, 0, 3)
static IntegerPtr	ShiftOperationHelper (Token::Kind kind, const Integer &value, const Integer &amount)
	DEFINE_NATIVE_ENTRY (Integer_shrFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_ushrFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Integer_shlFromInteger, 0, 2)
	DEFINE_NATIVE_ENTRY (Smi_bitNegate, 0, 1)
	DEFINE_NATIVE_ENTRY (Smi_bitLength, 0, 1)
uint32_t	Multiply64Hash (int64_t ivalue)
	DEFINE_NATIVE_ENTRY (Mint_bitNegate, 0, 1)
	DEFINE_NATIVE_ENTRY (Mint_bitLength, 0, 1)
	DEFINE_NATIVE_ENTRY (Capability_factory, 0, 1)
	DEFINE_NATIVE_ENTRY (Capability_equals, 0, 2)
	DEFINE_NATIVE_ENTRY (Capability_get_hashcode, 0, 1)
	DEFINE_NATIVE_ENTRY (RawReceivePort_factory, 0, 2)
	DEFINE_NATIVE_ENTRY (RawReceivePort_get_id, 0, 1)
	DEFINE_NATIVE_ENTRY (RawReceivePort_closeInternal, 0, 1)
	DEFINE_NATIVE_ENTRY (RawReceivePort_setActive, 0, 2)
	DEFINE_NATIVE_ENTRY (RawReceivePort_getActive, 0, 1)
	DEFINE_NATIVE_ENTRY (SendPort_get_id, 0, 1)
	DEFINE_NATIVE_ENTRY (SendPort_get_hashcode, 0, 1)
static bool	InSameGroup (Isolate *sender, const SendPort &receiver)
	DEFINE_NATIVE_ENTRY (SendPort_sendInternal_, 0, 2)
static ObjectPtr	ValidateMessageObject (Zone *zone, Isolate *isolate, const Object &obj)
	DEFINE_NATIVE_ENTRY (Isolate_exit_, 0, 2)
static const char *	NewConstChar (const char *chars)
static ObjectPtr	DeserializeMessage (Thread *thread, Message *message)
static void	ThrowIsolateSpawnException (const String &message)
static const char *	String2UTF8 (const String &str)
	DEFINE_NATIVE_ENTRY (Isolate_spawnFunction, 0, 10)
static const char *	CanonicalizeUri (Thread *thread, const Library &library, const String &uri, char **error)
	DEFINE_NATIVE_ENTRY (Isolate_spawnUri, 0, 12)
	DEFINE_NATIVE_ENTRY (Isolate_getDebugName, 0, 1)
	DEFINE_NATIVE_ENTRY (Isolate_getPortAndCapabilitiesOfCurrentIsolate, 0, 0)
	DEFINE_NATIVE_ENTRY (Isolate_getCurrentRootUriStr, 0, 0)
	DEFINE_NATIVE_ENTRY (Isolate_registerKernelBlob, 0, 1)
	DEFINE_NATIVE_ENTRY (Isolate_unregisterKernelBlob, 0, 1)
	DEFINE_NATIVE_ENTRY (Isolate_sendOOB, 0, 2)
static void	ExternalTypedDataFinalizer (void *isolate_callback_data, void *peer)
static intptr_t	GetTypedDataSizeOrThrow (const Instance &instance)
	DEFINE_NATIVE_ENTRY (TransferableTypedData_factory, 0, 2)
	DEFINE_NATIVE_ENTRY (TransferableTypedData_materialize, 0, 1)
	DEFINE_NATIVE_ENTRY (Math_doublePow, 0, 2)
	DEFINE_NATIVE_ENTRY (Random_initialSeed, 0, 0)
	DEFINE_NATIVE_ENTRY (SecureRandom_getBytes, 0, 1)
static InstancePtr	CreateMirror (const String &mirror_class_name, const Array &constructor_arguments)
static void	ThrowNoSuchMethod (const Instance &receiver, const String &function_name, const Array &arguments, const Array &argument_names, const InvocationMirror::Level level, const InvocationMirror::Kind kind)
static void	EnsureConstructorsAreCompiled (const Function &func)
static InstancePtr	CreateParameterMirrorList (const Function &func, const FunctionType &signature, const Instance &owner_mirror)
static InstancePtr	CreateTypeVariableMirror (const TypeParameter &param, const Instance &owner_mirror)
static InstancePtr	CreateTypeVariableList (const Class &cls)
static InstancePtr	CreateFunctionTypeMirror (const AbstractType &type)
static InstancePtr	CreateMethodMirror (const Function &func, const Instance &owner_mirror, const AbstractType &instantiator)
static InstancePtr	CreateVariableMirror (const Field &field, const Instance &owner_mirror)
static InstancePtr	CreateClassMirror (const Class &cls, const AbstractType &type, const Bool &is_declaration, const Instance &owner_mirror)
static bool	IsCensoredLibrary (const String &url)
static InstancePtr	CreateLibraryMirror (Thread *thread, const Library &lib)
static InstancePtr	CreateCombinatorMirror (const Object &identifiers, bool is_show)
static InstancePtr	CreateLibraryDependencyMirror (Thread *thread, const Instance &importer, const Library &importee, const Array &show_names, const Array &hide_names, const Object &metadata, const LibraryPrefix &prefix, const String &prefix_name, const bool is_import, const bool is_deferred)
static InstancePtr	CreateLibraryDependencyMirror (Thread *thread, const Instance &importer, const Namespace &ns, const LibraryPrefix &prefix, const bool is_import, const bool is_deferred)
	DEFINE_NATIVE_ENTRY (LibraryMirror_fromPrefix, 0, 1)
	DEFINE_NATIVE_ENTRY (LibraryMirror_libraryDependencies, 0, 2)
static InstancePtr	CreateTypeMirror (const AbstractType &type)
static InstancePtr	CreateIsolateMirror ()
static void	VerifyMethodKindShifts ()
static AbstractTypePtr	InstantiateType (const AbstractType &type, const AbstractType &instantiator)
	DEFINE_NATIVE_ENTRY (MirrorSystem_libraries, 0, 0)
	DEFINE_NATIVE_ENTRY (MirrorSystem_isolate, 0, 0)
static void	ThrowLanguageError (const char *message)
	DEFINE_NATIVE_ENTRY (IsolateMirror_loadUri, 0, 1)
	DEFINE_NATIVE_ENTRY (Mirrors_makeLocalClassMirror, 0, 1)
	DEFINE_NATIVE_ENTRY (Mirrors_makeLocalTypeMirror, 0, 1)
	DEFINE_NATIVE_ENTRY (Mirrors_instantiateGenericType, 0, 2)
	DEFINE_NATIVE_ENTRY (Mirrors_mangleName, 0, 2)
	DEFINE_NATIVE_ENTRY (MirrorReference_equals, 0, 2)
	DEFINE_NATIVE_ENTRY (DeclarationMirror_metadata, 0, 1)
	DEFINE_NATIVE_ENTRY (FunctionTypeMirror_call_method, 0, 2)
	DEFINE_NATIVE_ENTRY (FunctionTypeMirror_parameters, 0, 2)
	DEFINE_NATIVE_ENTRY (FunctionTypeMirror_return_type, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_libraryUri, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_supertype, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_supertype_instantiated, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_interfaces, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_interfaces_instantiated, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_mixin, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_mixin_instantiated, 0, 2)
	DEFINE_NATIVE_ENTRY (ClassMirror_members, 0, 3)
	DEFINE_NATIVE_ENTRY (ClassMirror_constructors, 0, 3)
	DEFINE_NATIVE_ENTRY (LibraryMirror_members, 0, 2)
	DEFINE_NATIVE_ENTRY (ClassMirror_type_variables, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_type_arguments, 0, 1)
	DEFINE_NATIVE_ENTRY (TypeVariableMirror_owner, 0, 1)
	DEFINE_NATIVE_ENTRY (TypeVariableMirror_upper_bound, 0, 1)
	DEFINE_NATIVE_ENTRY (InstanceMirror_invoke, 0, 5)
	DEFINE_NATIVE_ENTRY (InstanceMirror_invokeGetter, 0, 3)
	DEFINE_NATIVE_ENTRY (InstanceMirror_invokeSetter, 0, 4)
	DEFINE_NATIVE_ENTRY (InstanceMirror_computeType, 0, 1)
	DEFINE_NATIVE_ENTRY (ClosureMirror_function, 0, 1)
	DEFINE_NATIVE_ENTRY (ClassMirror_invoke, 0, 5)
	DEFINE_NATIVE_ENTRY (ClassMirror_invokeGetter, 0, 3)
	DEFINE_NATIVE_ENTRY (ClassMirror_invokeSetter, 0, 4)
	DEFINE_NATIVE_ENTRY (ClassMirror_invokeConstructor, 0, 5)
	DEFINE_NATIVE_ENTRY (LibraryMirror_invoke, 0, 5)
	DEFINE_NATIVE_ENTRY (LibraryMirror_invokeGetter, 0, 3)
	DEFINE_NATIVE_ENTRY (LibraryMirror_invokeSetter, 0, 4)
	DEFINE_NATIVE_ENTRY (MethodMirror_owner, 0, 2)
	DEFINE_NATIVE_ENTRY (MethodMirror_parameters, 0, 2)
	DEFINE_NATIVE_ENTRY (MethodMirror_return_type, 0, 2)
	DEFINE_NATIVE_ENTRY (MethodMirror_source, 0, 1)
static InstancePtr	CreateSourceLocation (const String &uri, intptr_t line, intptr_t column)
	DEFINE_NATIVE_ENTRY (DeclarationMirror_location, 0, 1)
	DEFINE_NATIVE_ENTRY (ParameterMirror_type, 0, 3)
	DEFINE_NATIVE_ENTRY (VariableMirror_type, 0, 2)
	DEFINE_NATIVE_ENTRY (TypeMirror_subtypeTest, 0, 2)
	DEFINE_NATIVE_ENTRY (DartAsync_fatal, 0, 1)
	DEFINE_NATIVE_ENTRY (Object_equals, 0, 1)
static intptr_t	GetHash (Isolate *isolate, const ObjectPtr obj)
	DEFINE_NATIVE_ENTRY (Object_getHash, 0, 1)
	DEFINE_NATIVE_ENTRY (Object_toString, 0, 1)
	DEFINE_NATIVE_ENTRY (Object_runtimeType, 0, 1)
static bool	HaveSameRuntimeTypeHelper (Zone *zone, const Instance &left, const Instance &right)
	DEFINE_NATIVE_ENTRY (Object_haveSameRuntimeType, 0, 2)
	DEFINE_NATIVE_ENTRY (Object_instanceOf, 0, 4)
	DEFINE_NATIVE_ENTRY (Object_simpleInstanceOf, 0, 2)
	DEFINE_NATIVE_ENTRY (AbstractType_toString, 0, 1)
	DEFINE_NATIVE_ENTRY (AbstractType_getHashCode, 0, 1)
	DEFINE_NATIVE_ENTRY (AbstractType_equality, 0, 2)
	DEFINE_NATIVE_ENTRY (Type_equality, 0, 2)
	DEFINE_NATIVE_ENTRY (LibraryPrefix_isLoaded, 0, 1)
	DEFINE_NATIVE_ENTRY (LibraryPrefix_setLoaded, 0, 1)
	DEFINE_NATIVE_ENTRY (LibraryPrefix_loadingUnit, 0, 1)
	DEFINE_NATIVE_ENTRY (LibraryPrefix_issueLoad, 0, 1)
	DEFINE_NATIVE_ENTRY (Internal_unsafeCast, 0, 1)
	DEFINE_NATIVE_ENTRY (Internal_nativeEffect, 0, 1)
	DEFINE_NATIVE_ENTRY (Internal_collectAllGarbage, 0, 0)
	DEFINE_NATIVE_ENTRY (Internal_deoptimizeFunctionsOnStack, 0, 0)
	DEFINE_NATIVE_ENTRY (Internal_allocateObjectInstructionsStart, 0, 0)
	DEFINE_NATIVE_ENTRY (Internal_allocateObjectInstructionsEnd, 0, 0)
static bool	ExtractInterfaceTypeArgs (Zone *zone, const Class &instance_cls, const TypeArguments &instance_type_args, const Class &interface_cls, TypeArguments *interface_type_args)
	DEFINE_NATIVE_ENTRY (Internal_extractTypeArguments, 0, 2)
	DEFINE_NATIVE_ENTRY (Internal_prependTypeArguments, 0, 4)
	DEFINE_NATIVE_ENTRY (Internal_boundsCheckForPartialInstantiation, 0, 2)
	DEFINE_NATIVE_ENTRY (InvocationMirror_unpackTypeArguments, 0, 2)
	DEFINE_NATIVE_ENTRY (NoSuchMethodError_existingMethodSignature, 0, 3)
	DEFINE_NATIVE_ENTRY (UserTag_new, 0, 2)
	DEFINE_NATIVE_ENTRY (UserTag_label, 0, 1)
	DEFINE_NATIVE_ENTRY (UserTag_makeCurrent, 0, 1)
	DEFINE_NATIVE_ENTRY (UserTag_defaultTag, 0, 0)
	DEFINE_NATIVE_ENTRY (Profiler_getCurrentTag, 0, 0)
	DEFINE_NATIVE_ENTRY (RegExp_factory, 0, 6)
	DEFINE_NATIVE_ENTRY (RegExp_getPattern, 0, 1)
	DEFINE_NATIVE_ENTRY (RegExp_getIsMultiLine, 0, 1)
	DEFINE_NATIVE_ENTRY (RegExp_getIsUnicode, 0, 1)
	DEFINE_NATIVE_ENTRY (RegExp_getIsDotAll, 0, 1)
	DEFINE_NATIVE_ENTRY (RegExp_getIsCaseSensitive, 0, 1)
	DEFINE_NATIVE_ENTRY (RegExp_getGroupCount, 0, 1)
	DEFINE_NATIVE_ENTRY (RegExp_getGroupNameMap, 0, 1)
static ObjectPtr	ExecuteMatch (Zone *zone, NativeArguments *arguments, bool sticky)
	DEFINE_NATIVE_ENTRY (RegExp_ExecuteMatch, 0, 3)
	DEFINE_NATIVE_ENTRY (RegExp_ExecuteMatchSticky, 0, 3)
static void	ThrowMaskRangeException (int64_t m)
	DEFINE_NATIVE_ENTRY (Float32x4_fromDoubles, 0, 4)
	DEFINE_NATIVE_ENTRY (Float32x4_splat, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_zero, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_fromInt32x4Bits, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_fromFloat64x2, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_add, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_negate, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_sub, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_mul, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_div, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_cmplt, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_cmplte, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_cmpgt, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_cmpgte, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_cmpequal, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_cmpnequal, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_scale, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_abs, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_clamp, 0, 3)
	DEFINE_NATIVE_ENTRY (Float32x4_getX, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_getY, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_getZ, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_getW, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_getSignMask, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_getSignMask, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_shuffle, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_shuffleMix, 0, 3)
	DEFINE_NATIVE_ENTRY (Float32x4_setX, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_setY, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_setZ, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_setW, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_min, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_max, 0, 2)
	DEFINE_NATIVE_ENTRY (Float32x4_sqrt, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_reciprocal, 0, 1)
	DEFINE_NATIVE_ENTRY (Float32x4_reciprocalSqrt, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_fromInts, 0, 4)
	DEFINE_NATIVE_ENTRY (Int32x4_fromBools, 0, 4)
	DEFINE_NATIVE_ENTRY (Int32x4_fromFloat32x4Bits, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_or, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_and, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_xor, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_add, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_sub, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_getX, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_getY, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_getZ, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_getW, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_shuffle, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_shuffleMix, 0, 3)
	DEFINE_NATIVE_ENTRY (Int32x4_setX, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_setY, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_setZ, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_setW, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_getFlagX, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_getFlagY, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_getFlagZ, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_getFlagW, 0, 1)
	DEFINE_NATIVE_ENTRY (Int32x4_setFlagX, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_setFlagY, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_setFlagZ, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_setFlagW, 0, 2)
	DEFINE_NATIVE_ENTRY (Int32x4_select, 0, 3)
	DEFINE_NATIVE_ENTRY (Float64x2_fromDoubles, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_splat, 0, 1)
	DEFINE_NATIVE_ENTRY (Float64x2_zero, 0, 1)
	DEFINE_NATIVE_ENTRY (Float64x2_fromFloat32x4, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_add, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_negate, 0, 1)
	DEFINE_NATIVE_ENTRY (Float64x2_sub, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_mul, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_div, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_scale, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_abs, 0, 1)
	DEFINE_NATIVE_ENTRY (Float64x2_clamp, 0, 3)
	DEFINE_NATIVE_ENTRY (Float64x2_getX, 0, 1)
	DEFINE_NATIVE_ENTRY (Float64x2_getY, 0, 1)
	DEFINE_NATIVE_ENTRY (Float64x2_getSignMask, 0, 1)
	DEFINE_NATIVE_ENTRY (Float64x2_setX, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_setY, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_min, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_max, 0, 2)
	DEFINE_NATIVE_ENTRY (Float64x2_sqrt, 0, 1)
	DECLARE_FLAG (bool, show_invisible_frames)
static StackTracePtr	CreateStackTraceObject (Zone *zone, const GrowableObjectArray &code_list, const GrowableArray< uword > &pc_offset_list)
static StackTracePtr	CurrentStackTrace (Thread *thread, intptr_t skip_frames=1)
StackTracePtr	GetStackTraceForException ()
	DEFINE_NATIVE_ENTRY (StackTrace_current, 0, 0)
static void	AppendFrames (const GrowableObjectArray &code_list, GrowableArray< uword > *pc_offset_list, int skip_frames)
const StackTrace &	GetCurrentStackTrace (int skip_frames)
bool	HasStack ()
	DEFINE_NATIVE_ENTRY (Stopwatch_now, 0, 0)
	DEFINE_NATIVE_ENTRY (Stopwatch_frequency, 0, 0)
	DEFINE_NATIVE_ENTRY (String_fromEnvironment, 0, 3)
	DEFINE_NATIVE_ENTRY (StringBase_createFromCodePoints, 0, 3)
	DEFINE_NATIVE_ENTRY (StringBase_substringUnchecked, 0, 3)
static uint16_t	CharacterLimit (const String &string, intptr_t start, intptr_t end)
static bool	CheckSlicesOneByte (const String &base, const Array &matches, const int len)
	DEFINE_NATIVE_ENTRY (StringBase_joinReplaceAllResult, 0, 4)
	DEFINE_NATIVE_ENTRY (StringBase_intern, 0, 1)
	DEFINE_NATIVE_ENTRY (OneByteString_substringUnchecked, 0, 3)
	DEFINE_NATIVE_ENTRY (Internal_allocateOneByteString, 0, 1)
	DEFINE_NATIVE_ENTRY (Internal_allocateTwoByteString, 0, 1)
	DEFINE_NATIVE_ENTRY (OneByteString_allocateFromOneByteList, 0, 3)
	DEFINE_NATIVE_ENTRY (Internal_writeIntoOneByteString, 0, 3)
	DEFINE_NATIVE_ENTRY (Internal_writeIntoTwoByteString, 0, 3)
	DEFINE_NATIVE_ENTRY (TwoByteString_allocateFromTwoByteList, 0, 3)
	DEFINE_NATIVE_ENTRY (String_getHashCode, 0, 1)
	DEFINE_NATIVE_ENTRY (String_getLength, 0, 1)
static uint16_t	StringValueAt (const String &str, const Integer &index)
	DEFINE_NATIVE_ENTRY (String_charAt, 0, 2)
	DEFINE_NATIVE_ENTRY (String_concat, 0, 2)
	DEFINE_NATIVE_ENTRY (String_toLowerCase, 0, 1)
	DEFINE_NATIVE_ENTRY (String_toUpperCase, 0, 1)
	DEFINE_NATIVE_ENTRY (String_concatRange, 0, 3)
	DEFINE_NATIVE_ENTRY (StringBuffer_createStringFromUint16Array, 0, 3)
	DEFINE_NATIVE_ENTRY (Timeline_isDartStreamEnabled, 0, 0)
	DEFINE_NATIVE_ENTRY (Timeline_getNextTaskId, 0, 0)
	DEFINE_NATIVE_ENTRY (Timeline_getTraceClock, 0, 0)
	DEFINE_NATIVE_ENTRY (Timeline_reportTaskEvent, 0, 5)
	DEFINE_NATIVE_ENTRY (TypedDataBase_length, 0, 1)
	DEFINE_NATIVE_ENTRY (TypedDataView_offsetInBytes, 0, 1)
	DEFINE_NATIVE_ENTRY (TypedDataView_typedData, 0, 1)
static bool	IsTypedDataUint8ArrayClassId (intptr_t cid)
	DEFINE_NATIVE_ENTRY (TypedDataBase_setClampedRange, 0, 5)
	DEFINE_NATIVE_ENTRY (Uri_isWindowsPlatform, 0, 0)
	DECLARE_FLAG (bool, trace_service)
	DEFINE_NATIVE_ENTRY (VMService_SendIsolateServiceMessage, 0, 2)
	DEFINE_NATIVE_ENTRY (VMService_SendRootServiceMessage, 0, 1)
	DEFINE_NATIVE_ENTRY (VMService_SendObjectRootServiceMessage, 0, 1)
	DEFINE_NATIVE_ENTRY (VMService_OnStart, 0, 0)
	DEFINE_NATIVE_ENTRY (VMService_OnExit, 0, 0)
	DEFINE_NATIVE_ENTRY (VMService_OnServerAddressChange, 0, 1)
	DEFINE_NATIVE_ENTRY (VMService_ListenStream, 0, 2)
	DEFINE_NATIVE_ENTRY (VMService_CancelStream, 0, 1)
	DEFINE_NATIVE_ENTRY (VMService_RequestAssets, 0, 0)
static void	ContentsFinalizer (void *isolate_callback_data, void *peer)
	DEFINE_NATIVE_ENTRY (VMService_DecodeAssets, 0, 1)
	DEFINE_NATIVE_ENTRY (VMService_AddUserTagsToStreamableSampleList, 0, 1)
	DEFINE_NATIVE_ENTRY (VMService_RemoveUserTagsFromStreamableSampleList, 0, 1)
void *	calloc (size_t n, size_t size)
void *	malloc (size_t size)
void *	realloc (void *ptr, size_t size)
template<typename T >
static T	LoadRelaxed (const T *ptr)
constexpr intptr_t	RoundWordsToKB (intptr_t size_in_words)
constexpr intptr_t	RoundWordsToMB (intptr_t size_in_words)
constexpr intptr_t	RoundWordsToGB (intptr_t size_in_words)
constexpr double	WordsToMB (intptr_t size_in_words)
constexpr double	MicrosecondsToSeconds (int64_t micros)
constexpr double	MicrosecondsToMilliseconds (int64_t micros)
template<typename T >
static void	USE (T &&)
template<class D , class S >
DART_FORCE_INLINE D	bit_cast (const S &source)
template<class D , class S >
DART_FORCE_INLINE D	bit_copy (const S &source)
static uint8_t	Hex (uint8_t value)
template<typename T >
static T	LoadUnaligned (const T *ptr)
template<typename T >
static void	StoreUnaligned (T *ptr, T value)
static void	GetLastErrorAsString (char **error)
sys::ComponentContext *	ComponentContext ()
void	SetDartVmNode (std::unique_ptr< inspect::Node > node)
std::unique_ptr< inspect::Node >	TakeDartVmNode ()
char *	CheckIsAtLeastMinRequiredMacOSVersion ()
static void *	Allocate (uword size, Zone *zone)
static void	StackAllocatedDestructionHelper (int *ptr)
	ISOLATE_UNIT_TEST_CASE (StackAllocatedDestruction)
static void	StackAllocatedLongJumpHelper (int *ptr, LongJumpScope *jump)
	ISOLATE_UNIT_TEST_CASE (StackAllocatedLongJump)
static void	StackedStackResourceDestructionHelper (int *ptr)
static void	StackResourceDestructionHelper (int *ptr)
	ISOLATE_UNIT_TEST_CASE (StackResourceDestruction)
static void	StackedStackResourceLongJumpHelper (int *ptr, LongJumpScope *jump)
static void	StackResourceLongJumpHelper (int *ptr, LongJumpScope *jump)
	ISOLATE_UNIT_TEST_CASE (StackResourceLongJump)
	TEST_CASE (AMA_Test)
	DEFINE_FLAG (bool, print_cluster_information, false, "Print information about clusters written to snapshot")
	COMPILE_ASSERT (kUnreachableReference==WeakTable::kNoValue)
static constexpr bool	IsAllocatedReference (intptr_t ref)
static constexpr bool	IsArtificialReference (intptr_t ref)
static constexpr bool	IsReachableReference (intptr_t ref)
static UnboxedFieldBitmap	CalculateTargetUnboxedFieldsBitmap (Serializer *s, intptr_t class_id)
template<bool need_entry_point_for_non_discarded>
static DART_FORCE_INLINE CodePtr	GetCodeAndEntryPointByIndex (const Deserializer *d, intptr_t code_index, uword *entry_point)
static int	CompareClusters (SerializationCluster *const *a, SerializationCluster *const *b)
	VM_UNIT_TEST_CASE (FetchAndIncrement)
	VM_UNIT_TEST_CASE (FetchAndDecrement)
	VM_UNIT_TEST_CASE (FetchAndIncrementSigned)
	VM_UNIT_TEST_CASE (FetchAndDecrementSigned)
	VM_UNIT_TEST_CASE (IncrementBy)
	VM_UNIT_TEST_CASE (DecrementBy)
	VM_UNIT_TEST_CASE (FetchOrRelaxed)
	VM_UNIT_TEST_CASE (FetchAndRelaxed)
	VM_UNIT_TEST_CASE (LoadRelaxed)
	TEST_CASE (CompareAndSwapWord)
	TEST_CASE (CompareAndSwapUint32)
uint8_t *	DecodeBase64 (const char *str, intptr_t *out_decoded_len)
	TEST_CASE (Base64Decode)
	TEST_CASE (Base64DecodeMalformed)
	TEST_CASE (Base64DecodeEmpty)
	BENCHMARK (CorelibCompileAll)
static char *	ComputeKernelServicePath (const char *arg)
	BENCHMARK (CorelibIsolateStartup)
static void	InitNativeFields (Dart_NativeArguments args)
static void	UseDartApi (Dart_NativeArguments args)
static Dart_NativeFunction	bm_uda_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	BENCHMARK (UseDartApi)
static void	vmservice_resolver (Dart_NativeArguments args)
static Dart_NativeFunction	NativeResolver (Dart_Handle name, int arg_count, bool *auto_setup_scope)
	BENCHMARK (KernelServiceCompileAll)
static void	StackFrame_accessFrame (Dart_NativeArguments args)
static Dart_NativeFunction	StackFrameNativeResolver (Dart_Handle name, int arg_count, bool *auto_setup_scope)
	BENCHMARK (FrameLookup)
	BENCHMARK_SIZE (CoreSnapshotSize)
	BENCHMARK_SIZE (StandaloneSnapshotSize)
	BENCHMARK (CreateMirrorSystem)
	BENCHMARK (EnterExitIsolate)
	BENCHMARK (SerializeNull)
	BENCHMARK (SerializeSmi)
	BENCHMARK (SimpleMessage)
	BENCHMARK (LargeMap)
	BENCHMARK_MEMORY (InitialRSS)
	DECLARE_FLAG (int, code_heap_size)
	DECLARE_FLAG (int, old_gen_growth_space_ratio)
Dart_Handle	NewString (const char *str)
template<intptr_t Size>
void	TestBitSet ()
	TEST_CASE (BitSetBasic)
	TEST_CASE (BitVector)
	VM_UNIT_TEST_CASE (BitFields)
template<typename T >
static void	TestSignExtendedBitField ()
template<typename T >
static void	TestNotSignExtendedBitField ()
	VM_UNIT_TEST_CASE (BitFields_SignedField)
	VM_UNIT_TEST_CASE_WITH_EXPECTATION (BitFields_Assert, DEBUG_CRASH)
static CompressedStackMapsPtr	MapsFromBuilder (Zone *zone, BitmapBuilder *bmap)
	ISOLATE_UNIT_TEST_CASE (BitmapBuilder)
	ISOLATE_UNIT_TEST_CASE (BitmapBuilder_Regress44946)
	VM_UNIT_TEST_CASE (BoolField)
static void	Finish (Thread *thread)
static ErrorPtr	BootstrapFromKernelSingleProgram (Thread *thread, std::unique_ptr< kernel::Program > program)
static ErrorPtr	BootstrapFromKernel (Thread *thread, const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
static CatchEntryMove	NewMove (intptr_t src, intptr_t dst)
void	RunTestCaseWithPermutations (const TestCaseMoves *mapping, intptr_t *insert_permutation, intptr_t count)
void	RunTestCase (const TestCaseMoves *mapping, intptr_t count)
	ISOLATE_UNIT_TEST_CASE (CatchEntryMoves)
	DEFINE_FLAG (bool, print_classes, false, "Prints details about loaded classes.")
	DEFINE_FLAG (bool, trace_class_finalization, false, "Trace class finalization.")
	DEFINE_FLAG (bool, trace_type_finalization, false, "Trace type finalization.")
static void	RemoveCHAOptimizedCode (const Class &subclass, const GrowableArray< intptr_t > &added_subclass_to_cids)
static void	AddSuperType (const AbstractType &type, GrowableArray< intptr_t > *finalized_super_classes)
static void	CollectFinalizedSuperClasses (const Class &cls_, GrowableArray< intptr_t > *finalized_super_classes)
static void	CollectImmediateSuperInterfaces (const Class &cls, GrowableArray< intptr_t > *cids)
static bool	IsPotentialExactGeneric (const AbstractType &type)
static void	MarkImplemented (Zone *zone, const Class &iface)
static ClassPtr	CreateTestClass (const char *name)
	ISOLATE_UNIT_TEST_CASE (ClassFinalizer)
bool	IsInternalOnlyClassId (intptr_t index)
bool	IsErrorClassId (intptr_t index)
bool	IsNumberClassId (intptr_t index)
bool	IsIntegerClassId (intptr_t index)
bool	IsStringClassId (intptr_t index)
bool	IsOneByteStringClassId (intptr_t index)
bool	IsBuiltinListClassId (intptr_t index)
bool	IsTypeClassId (intptr_t index)
bool	IsTypedDataBaseClassId (intptr_t index)
bool	IsTypedDataClassId (intptr_t index)
bool	IsTypedDataViewClassId (intptr_t index)
bool	IsExternalTypedDataClassId (intptr_t index)
bool	IsFfiPointerClassId (intptr_t index)
bool	IsFfiTypeClassId (intptr_t index)
bool	IsFfiDynamicLibraryClassId (intptr_t index)
bool	IsInternalVMdefinedClassId (intptr_t index)
bool	IsImplicitFieldClassId (intptr_t index)
	COMPILE_ASSERT (kFirstInternalOnlyCid==kObjectCid+1)
	COMPILE_ASSERT (kInstanceCid==kLastInternalOnlyCid+1)
	COMPILE_ASSERT (kFirstErrorCid==kErrorCid &&kApiErrorCid==kFirstErrorCid+1 &&kLanguageErrorCid==kFirstErrorCid+2 &&kUnhandledExceptionCid==kFirstErrorCid+3 &&kUnwindErrorCid==kFirstErrorCid+4 &&kLastErrorCid==kUnwindErrorCid &&kLastInternalOnlyCid==kLastErrorCid)
bool	IsConcreteTypeClassId (intptr_t index)
	COMPILE_ASSERT (kOneByteStringCid==kStringCid+1 &&kTwoByteStringCid==kStringCid+2)
bool	IsArrayClassId (intptr_t index)
	COMPILE_ASSERT (kTypedDataCidRemainderInternal==0)
	COMPILE_ASSERT (kTypedDataInt8ArrayCid+kTypedDataCidRemainderView==kTypedDataInt8ArrayViewCid)
	COMPILE_ASSERT (kFirstTypedDataCid==kTypedDataInt8ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+1 *kNumTypedDataCidRemainders==kTypedDataUint8ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+2 *kNumTypedDataCidRemainders==kTypedDataUint8ClampedArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+3 *kNumTypedDataCidRemainders==kTypedDataInt16ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+4 *kNumTypedDataCidRemainders==kTypedDataUint16ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+5 *kNumTypedDataCidRemainders==kTypedDataInt32ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+6 *kNumTypedDataCidRemainders==kTypedDataUint32ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+7 *kNumTypedDataCidRemainders==kTypedDataInt64ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+8 *kNumTypedDataCidRemainders==kTypedDataUint64ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+9 *kNumTypedDataCidRemainders==kTypedDataFloat32ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+10 *kNumTypedDataCidRemainders==kTypedDataFloat64ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+11 *kNumTypedDataCidRemainders==kTypedDataFloat32x4ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+12 *kNumTypedDataCidRemainders==kTypedDataInt32x4ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+13 *kNumTypedDataCidRemainders==kTypedDataFloat64x2ArrayCid)
	COMPILE_ASSERT (kFirstTypedDataCid+13 *kNumTypedDataCidRemainders+kTypedDataCidRemainderUnmodifiable==kLastTypedDataCid)
	COMPILE_ASSERT (kFfiStructCid+1==kFirstTypedDataCid)
	COMPILE_ASSERT (kLastTypedDataCid+1==kByteDataViewCid)
bool	IsUnmodifiableTypedDataViewClassId (intptr_t index)
bool	IsClampedTypedDataBaseClassId (intptr_t index)
bool	IsExternalPayloadClassId (classid_t cid)
bool	IsDeeplyImmutableCid (intptr_t predefined_cid)
bool	IsShallowlyImmutableCid (intptr_t predefined_cid)
bool	ShouldHaveImmutabilityBitSetCid (intptr_t predefined_cid)
bool	IsFfiPredefinedClassId (classid_t class_id)
	COMPILE_ASSERT (kByteBufferCid+1==kNullCid)
	DEFINE_FLAG (bool, print_class_table, false, "Print initial class table.")
static void	NativeFunc (Dart_NativeArguments args)
static Dart_NativeFunction	native_resolver (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (StackMapGC)
	ISOLATE_UNIT_TEST_CASE (DescriptorList_TokenPositions)
	DEFINE_FLAG (bool, write_protect_code, kShouldWriteProtectCodeByDefault, "Write protect jitted code")
bool	MatchesPattern (uword end, const int16_t *pattern, intptr_t size)
	DEFINE_FLAG (int, max_exhaustive_polymorphic_checks, 5, "If a call receiver is known to be of at most this many classes, " "generate exhaustive class tests instead of a megamorphic call")
	DEFINE_FLAG (bool, print_precompiler_timings, false, "Print per-phase breakdown of time spent precompiling")
	DEFINE_FLAG (bool, print_unique_targets, false, "Print unique dynamic targets")
	DEFINE_FLAG (charp, print_object_layout_to, nullptr, "Print layout of Dart objects to the given file")
	DEFINE_FLAG (bool, trace_precompiler, false, "Trace precompiler.")
	DEFINE_FLAG (int, max_speculative_inlining_attempts, 1, "Max number of attempts with speculative inlining (precompilation only)")
	DEFINE_FLAG (charp, write_retained_reasons_to, nullptr, "Print reasons for retaining objects to the given file")
	DECLARE_FLAG (bool, print_flow_graph)
	DECLARE_FLAG (bool, print_flow_graph_optimized)
	DECLARE_FLAG (bool, trace_compiler)
	DECLARE_FLAG (bool, trace_optimizing_compiler)
	DECLARE_FLAG (bool, trace_bailout)
	DECLARE_FLAG (bool, trace_failed_optimization_attempts)
	DECLARE_FLAG (bool, trace_inlining_intervals)
	DECLARE_FLAG (int, inlining_hotness)
	DECLARE_FLAG (int, inlining_size_threshold)
	DECLARE_FLAG (int, inlining_callee_size_threshold)
	DECLARE_FLAG (int, inline_getters_setters_smaller_than)
	DECLARE_FLAG (int, inlining_depth_threshold)
	DECLARE_FLAG (int, inlining_caller_size_threshold)
	DECLARE_FLAG (int, inlining_constant_arguments_max_size_threshold)
	DECLARE_FLAG (int, inlining_constant_arguments_min_size_threshold)
	DECLARE_FLAG (bool, print_instruction_stats)
	DEFINE_FLAG (bool, check_code_pointer, false, "Verify instructions offset in code object." "NOTE: This breaks the profiler.")
	ASSEMBLER_TEST_RUN (StoreIntoObject, test)
	ASSEMBLER_TEST_RUN (InstantiateTypeArgumentsHashKeys, test)
	DEFINE_FLAG (bool, trace_source_positions, false, "Source position diagnostics")
	DEFINE_FLAG (bool, include_inlining_info_in_disassembly, true, "Include inlining information when printing disassembly") void DisassembleToStdout
	ISOLATE_UNIT_TEST_CASE (Disassembler)
	ISOLATE_UNIT_TEST_CASE (Disassembler_InvalidInput)
static intptr_t	CountBoundChecks (FlowGraph *flow_graph)
static std::pair< intptr_t, intptr_t >	ApplyBCE (const char *script_chars, CompilerPass::PipelineMode mode)
static void	TestScriptJIT (const char *script_chars, intptr_t expected_before, intptr_t expected_after)
	ISOLATE_UNIT_TEST_CASE (BCECannotRemove)
	ISOLATE_UNIT_TEST_CASE (BCERemoveOne)
	ISOLATE_UNIT_TEST_CASE (BCESimpleLoops)
	ISOLATE_UNIT_TEST_CASE (BCESimpleLoopsDown)
	ISOLATE_UNIT_TEST_CASE (BCEModulo)
	ISOLATE_UNIT_TEST_CASE (BCELowerTriangular)
	ISOLATE_UNIT_TEST_CASE (BCEUpperTriangular)
	ISOLATE_UNIT_TEST_CASE (BCETriangularDown)
	ISOLATE_UNIT_TEST_CASE (BCENamedLength)
	ISOLATE_UNIT_TEST_CASE (BCEBubbleSort)
	ISOLATE_UNIT_TEST_CASE (BCEArithmeticWrapAround)
	ISOLATE_UNIT_TEST_CASE (BCEListNamedAndPlainLength)
static intptr_t	GetEdgeCount (const Array &edge_counters, intptr_t edge_id)
static void	SetEdgeWeight (BlockEntryInstr *block, BlockEntryInstr *successor, const Array &edge_counters, intptr_t entry_count)
static void	Union (GrowableArray< Chain * > *chains, Chain *source_chain, Chain *target_chain)
static bool	PhiHasSingleUse (PhiInstr *phi, Value *use)
static bool	IsTrivialBlock (BlockEntryInstr *block, Definition *defn)
static void	EliminateTrivialBlock (BlockEntryInstr *block, Definition *instr, IfThenElseInstr *before)
	DEFINE_FLAG (bool, remove_redundant_phis, true, "Remove redundant phis.")
	DEFINE_FLAG (bool, trace_constant_propagation, false, "Print constant propagation and useless code elimination.")
static bool	IsIdenticalConstants (const Object &left, const Object &right)
static bool	CompareIntegers (Token::Kind kind, const Integer &left, const Integer &right)
static bool	IsIntegerOrDouble (const Object &value)
static double	ToDouble (const Object &value)
static RedefinitionInstr *	InsertRedefinition (FlowGraph *graph, BlockEntryInstr *dom, Definition *original, const Object &constant_value)
static bool	HasPhis (BlockEntryInstr *block)
static bool	IsEmptyBlock (BlockEntryInstr *block)
static BlockEntryInstr *	FindFirstNonEmptySuccessor (TargetEntryInstr *block, BitVector *empty_blocks)
	ISOLATE_UNIT_TEST_CASE (ConstantPropagation_PhiUnwrappingAndConvergence)
void	StrictCompareSentinel (Thread *thread, bool negate, bool non_sentinel_on_left)
	ISOLATE_UNIT_TEST_CASE (ConstantPropagator_StrictCompareEqualsSentinelLeft)
	ISOLATE_UNIT_TEST_CASE (ConstantPropagator_StrictCompareEqualsSentinelRightt)
	ISOLATE_UNIT_TEST_CASE (ConstantPropagator_StrictCompareNotEqualsSentinelLeft)
	ISOLATE_UNIT_TEST_CASE (ConstantPropagator_StrictCompareNotEqualsSentinelRight)
static IntegerPtr	BinaryIntegerEvaluateRaw (const Integer &left, const Integer &right, Token::Kind token_kind)
static IntegerPtr	UnaryIntegerEvaluateRaw (const Integer &value, Token::Kind token_kind, Zone *zone)
static IntegerPtr	BitLengthEvaluateRaw (const Integer &value, Zone *zone)
	DEFINE_FLAG (bool, prune_dead_locals, true, "optimize dead locals away")
static bool	ShouldReorderBlocks (const Function &function, FlowGraph::CompilationMode mode)
static bool	IsMarkedWithNoBoundsChecks (const Function &function)
static void	PrintBitVector (const char *tag, BitVector *v)
static Location	EnvIndexToStackLocation (intptr_t num_direct_parameters, intptr_t env_index)
static bool	IsUnboxedInteger (Representation rep)
static bool	ShouldInlineSimd ()
static bool	CanUnboxDouble ()
static bool	CanConvertInt64ToDouble ()
static bool	NeedsRecordBoxing (Definition *def)
static bool	IsDominatedUse (Instruction *dom, Value *use)
static bool	IsPositiveOrZeroSmiConst (Definition *d)
static BinarySmiOpInstr *	AsSmiShiftLeftInstruction (Definition *d)
static TargetEntryInstr *	NewTarget (FlowGraph *graph, Instruction *inherit)
static JoinEntryInstr *	NewJoin (FlowGraph *graph, Instruction *inherit)
static GotoInstr *	NewGoto (FlowGraph *graph, JoinEntryInstr *target, Instruction *inherit)
static BranchInstr *	NewBranch (FlowGraph *graph, ComparisonInstr *cmp, Instruction *inherit)
	DEFINE_FLAG (bool, trace_inlining_intervals, false, "Inlining interval diagnostics")
	DEFINE_FLAG (bool, enable_peephole, true, "Enable peephole optimization")
	DEFINE_FLAG (bool, enable_simd_inline, true, "Enable inlining of SIMD related method calls.")
	DEFINE_FLAG (int, min_optimization_counter_threshold, 5000, "The minimum invocation count for a function.")
	DEFINE_FLAG (int, optimization_counter_scale, 2000, "The scale of invocation count, by size of the function.")
	DEFINE_FLAG (bool, source_lines, false, "Emit source line as assembly comment.")
	DEFINE_FLAG (bool, force_indirect_calls, false, "Do not emit PC relative calls.")
	DECLARE_FLAG (charp, deoptimize_filter)
	DECLARE_FLAG (bool, intrinsify)
	DECLARE_FLAG (int, regexp_optimization_counter_threshold)
	DECLARE_FLAG (int, reoptimization_counter_threshold)
	DECLARE_FLAG (int, stacktrace_every)
	DECLARE_FLAG (charp, stacktrace_filter)
	DECLARE_FLAG (int, gc_every)
	DEFINE_FLAG (bool, align_all_loops, false, "Align all loop headers to 32 byte boundary")
static bool	IsPusher (Instruction *instr)
static bool	IsPopper (Instruction *instr)
static const Code &	StubEntryFor (const ICData &ic_data, bool optimized)
static Register	AllocateFreeRegister (bool *blocked_registers)
static FpuRegister	AllocateFreeFpuRegister (bool *blocked_registers)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_LateVariablePhiUnboxing)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_UnboxedFloatPhi)
void	TestLargeFrame (const char *type, const char *zero, const char *one, const char *main)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_LargeFrame_Int)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_LargeFrame_Double)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_LargeFrame_Int32x4)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_LargeFrame_Float32x4)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_LargeFrame_Float64x2)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_PhiUnboxingHeuristic_Double)
static void	TestPhiUnboxingHeuristicSimd (const char *script)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_PhiUnboxingHeuristic_Float32x4)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_PhiUnboxingHeuristic_Float64x2)
	ISOLATE_UNIT_TEST_CASE (FlowGraph_PhiUnboxingHeuristic_Int32x4)
	DEFINE_FLAG (bool, propagate_ic_data, true, "Propagate IC data from unoptimized to optimized IC calls.")
	DEFINE_FLAG (bool, two_args_smi_icd, true, "Generate special IC stubs for two args Smi operations")
	DECLARE_FLAG (bool, inline_alloc)
	DECLARE_FLAG (bool, use_slow_path)
static int	OrderById (CidRange *const *a, CidRange *const *b)
static int	OrderByFrequencyThenId (CidRange *const *a, CidRange *const *b)
static intptr_t	Usage (Thread *thread, const Function &function)
static bool	IsMarked (BlockEntryInstr *block, GrowableArray< BlockEntryInstr * > *preorder)
static intptr_t	RepresentationBits (Representation r)
static int64_t	RepresentationMask (Representation r)
static Definition *	CanonicalizeCommutativeDoubleArithmetic (Token::Kind op, Value *left, Value *right)
static bool	IsCommutative (Token::Kind op)
static bool	IsFpCompare (ComparisonInstr *comp)
static bool	MayBeBoxableNumber (intptr_t cid)
static bool	MayBeNumber (CompileType *type)
static Definition *	CanonicalizeStrictCompare (StrictCompareInstr *compare, bool *negated, bool is_branch)
static bool	BindsToGivenConstant (Value *v, intptr_t expected)
static bool	RecognizeTestPattern (Value *left, Value *right, bool *negate)
static bool	IsSingleUseUnboxOrConstant (Value *use)
static CodePtr	TwoArgsSmiOpInlineCacheEntry (Token::Kind kind)
static FunctionPtr	FindBinarySmiOp (Zone *zone, const String &name)
static const String &	EvaluateToString (Zone *zone, Definition *defn)
static Definition *	CanonicalizeStringInterpolate (StaticCallInstr *call, FlowGraph *flow_graph)
static Definition *	CanonicalizeStringInterpolateSingle (StaticCallInstr *call, FlowGraph *flow_graph)
static bool	AllInputsAreRedefinitions (PhiInstr *phi)
static AlignmentType	StrengthenAlignment (intptr_t cid, AlignmentType alignment)
	DEFINE_BACKEND (LoadThread,(Register out))
static constexpr Representation	SimdRepresentation (Representation rep)
	ISOLATE_UNIT_TEST_CASE (InstructionTests)
	ISOLATE_UNIT_TEST_CASE (OptimizationTests)
	ISOLATE_UNIT_TEST_CASE (IRTest_EliminateWriteBarrier)
static void	ExpectStores (FlowGraph *flow_graph, const std::vector< const char * > &expected_stores)
static void	RunInitializingStoresTest (const Library &root_library, const char *function_name, CompilerPass::PipelineMode mode, const std::vector< const char * > &expected_stores)
	ISOLATE_UNIT_TEST_CASE (IRTest_InitializingStores)
bool	TestIntConverterCanonicalizationRule (Thread *thread, int64_t min_value, int64_t max_value, Representation initial, Representation intermediate, Representation final)
	ISOLATE_UNIT_TEST_CASE (IL_IntConverterCanonicalization)
	ISOLATE_UNIT_TEST_CASE (IL_PhiCanonicalization)
	ISOLATE_UNIT_TEST_CASE (IL_UnboxIntegerCanonicalization)
static void	WriteCidTo (intptr_t cid, BaseTextBuffer *buffer)
static void	TestNullAwareEqualityCompareCanonicalization (Thread *thread, bool allow_representation_change)
	ISOLATE_UNIT_TEST_CASE (IL_Canonicalize_EqualityCompare)
static void	WriteCidRangeVectorTo (const CidRangeVector &ranges, BaseTextBuffer *buffer)
static bool	ExpectRangesContainCid (const Expect &expect, const CidRangeVector &ranges, intptr_t expected)
static void	RangesContainExpectedCids (const Expect &expect, const CidRangeVector &ranges, const GrowableArray< intptr_t > &expected)
	ISOLATE_UNIT_TEST_CASE (HierarchyInfo_Object_Subtype)
	ISOLATE_UNIT_TEST_CASE (HierarchyInfo_Function_Subtype)
	ISOLATE_UNIT_TEST_CASE (HierarchyInfo_Num_Subtype)
	ISOLATE_UNIT_TEST_CASE (HierarchyInfo_Int_Subtype)
	ISOLATE_UNIT_TEST_CASE (HierarchyInfo_String_Subtype)
	ISOLATE_UNIT_TEST_CASE (IRTest_DoubleEqualsSmi)
	ISOLATE_UNIT_TEST_CASE (IRTest_LoadThread)
	ISOLATE_UNIT_TEST_CASE (IRTest_CachableIdempotentCall)
FlowGraph *	SetupFfiFlowgraph (TestPipeline *pipeline, const compiler::ffi::CallMarshaller &marshaller, uword native_entry, bool is_leaf)
	ISOLATE_UNIT_TEST_CASE (IRTest_FfiCallInstrLeafDoesntSpill)
static void	TestConstantFoldToSmi (const Library &root_library, const char *function_name, CompilerPass::PipelineMode mode, intptr_t expected_value)
	ISOLATE_UNIT_TEST_CASE (ConstantFold_bitLength)
static void	TestRepresentationChangeDuringCanonicalization (Thread *thread, bool allow_representation_change)
	ISOLATE_UNIT_TEST_CASE (IL_Canonicalize_RepresentationChange)
static void	TestCanonicalizationOfTypedDataViewFieldLoads (Thread *thread, TypeDataField field_kind)
	ISOLATE_UNIT_TEST_CASE (IL_Canonicalize_TypedDataViewFactory)
	ISOLATE_UNIT_TEST_CASE (IL_Canonicalize_InstanceCallWithNoICDataInAOT)
static void	TestTestRangeCanonicalize (const AbstractType &type, uword lower, uword upper, bool result)
	ISOLATE_UNIT_TEST_CASE (IL_Canonicalize_TestRange)
void	TestStaticFieldForwarding (Thread *thread, const Class &test_cls, const Field &field, intptr_t num_stores, bool expected_to_forward)
	ISOLATE_UNIT_TEST_CASE (IL_Canonicalize_FinalFieldForwarding)
LibraryPtr	LoadTestScript (const char *script, Dart_NativeEntryResolver resolver, const char *lib_uri)
LibraryPtr	ReloadTestScript (const char *script)
FunctionPtr	GetFunction (const Library &lib, const char *name)
ClassPtr	GetClass (const Library &lib, const char *name)
TypeParameterPtr	GetClassTypeParameter (const Class &klass, intptr_t index)
TypeParameterPtr	GetFunctionTypeParameter (const Function &fun, intptr_t index)
ObjectPtr	Invoke (const Library &lib, const char *name)
InstructionsPtr	BuildInstructions (std::function< void(compiler::Assembler *assembler)> fun)
	NOT_IN_PRODUCT (LibraryPtr ReloadTestScript(const char *script))
	DEFINE_FLAG (int, deoptimization_counter_inlining_threshold, 12, "How many times we allow deoptimization before we stop inlining.")
	DEFINE_FLAG (bool, trace_inlining, false, "Trace inlining")
	DEFINE_FLAG (charp, inlining_filter, nullptr, "Inline only in named function")
	DEFINE_FLAG (int, inline_getters_setters_smaller_than, 10, "Always inline getters and setters that have fewer instructions")
	DEFINE_FLAG (int, inlining_depth_threshold, 6, "Inline function calls up to threshold nesting depth")
	DEFINE_FLAG (int, inlining_size_threshold, 25, "Always inline functions that have threshold or fewer instructions")
	DEFINE_FLAG (int, inlining_callee_call_sites_threshold, 1, "Always inline functions containing threshold or fewer calls.")
	DEFINE_FLAG (int, inlining_callee_size_threshold, 160, "Do not inline callees larger than threshold")
	DEFINE_FLAG (int, inlining_small_leaf_size_threshold, 50, "Do not inline leaf callees larger than threshold")
	DEFINE_FLAG (int, inlining_caller_size_threshold, 50000, "Stop inlining once caller reaches the threshold.")
	DEFINE_FLAG (int, inlining_hotness, 10, "Inline only hotter calls, in percents (0 .. 100); " "default 10%: calls above-equal 10% of max-count are inlined.")
	DEFINE_FLAG (int, inlining_recursion_depth_threshold, 1, "Inline recursive function calls up to threshold recursion depth.")
	DEFINE_FLAG (int, max_inlined_per_depth, 500, "Max. number of inlined calls per depth")
	DEFINE_FLAG (bool, print_inlining_tree, false, "Print inlining tree")
	DECLARE_FLAG (int, max_deoptimization_counter_threshold)
static bool	IsCallRecursive (const Function &function, Definition *call)
static intptr_t	AotCallCountApproximation (intptr_t nesting_depth)
static bool	IsSmallLeafOrReduction (int inlining_depth, intptr_t call_site_instructions, FlowGraph *graph)
static bool	IsAThisCallThroughAnUncheckedEntryPoint (Definition *call)
static bool	CalleeParameterTypeMightBeMoreSpecific (BitVector *is_generic_covariant_impl, const FunctionType &interface_target_signature, const FunctionType &callee_signature, intptr_t first_arg_index, intptr_t arg_index)
static void	ReplaceParameterStubs (Zone *zone, FlowGraph *caller_graph, InlinedCallData *call_data, const TargetInfo *target_info)
static Instruction *	AppendInstruction (Instruction *first, Instruction *second)
static void	TracePolyInlining (const CallTargets &targets, intptr_t idx, intptr_t total, const char *message)
static bool	IsInlineableOperator (const Function &function)
	ISOLATE_UNIT_TEST_CASE (Inliner_PolyInliningRedefinition)
	ISOLATE_UNIT_TEST_CASE (Inliner_TypedData_Regress7551)
	ISOLATE_UNIT_TEST_CASE (Inliner_InlineForceOptimized)
static void	TestPrint (Dart_NativeArguments args)
void	InspectStack (Dart_NativeArguments args)
static Dart_NativeFunction	PrintAndInspectResolver (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (Inliner_InlineAndRunForceOptimized)
static intptr_t	MinPosition (intptr_t a, intptr_t b)
static bool	IsInstructionStartPosition (intptr_t pos)
static bool	IsInstructionEndPosition (intptr_t pos)
static intptr_t	ToInstructionStart (intptr_t pos)
static intptr_t	ToInstructionEnd (intptr_t pos)
static ExtraLoopInfo *	ComputeExtraLoopInfo (Zone *zone, LoopInfo *loop_info)
static const GrowableArray< BlockEntryInstr * > &	BlockOrderForAllocation (const FlowGraph &flow_graph)
static void	DeepLiveness (MaterializeObjectInstr *mat, BitVector *live_in)
static bool	HasOnlyUnconstrainedUsesInLoop (LiveRange *range, intptr_t boundary)
static bool	HasOnlyUnconstrainedUses (LiveRange *range)
static Location::Kind	RegisterKindFromPolicy (Location loc)
static ParallelMoveInstr *	CreateParallelMoveBefore (Instruction *instr, intptr_t pos)
static ParallelMoveInstr *	CreateParallelMoveAfter (Instruction *instr, intptr_t pos)
static UsePosition *	FirstUseAfter (UsePosition *use, intptr_t after)
static intptr_t	FirstIntersection (UseInterval *a, UseInterval *u)
template<typename PositionType >
PositionType *	SplitListOfPositions (PositionType **head, intptr_t split_pos, bool split_at_start)
static bool	ShouldBeAllocatedBefore (LiveRange *a, LiveRange *b)
static void	AddToSortedListOfRanges (GrowableArray< LiveRange * > *list, LiveRange *range)
static LiveRange *	FindCover (LiveRange *parent, intptr_t pos)
static bool	AreLocationsAllTheSame (const GrowableArray< Location > &locs)
static void	EmitMoveOnEdge (BlockEntryInstr *succ, BlockEntryInstr *pred, const MoveOperands &move)
static Representation	RepresentationForRange (Representation definition_rep)
static bool	ValidOutputForAlwaysCalls (const Location &loc)
Location	LocationRegisterOrConstant (Value *value)
Location	LocationRegisterOrSmiConstant (Value *value, intptr_t min_value, intptr_t max_value)
Location	LocationWritableRegisterOrConstant (Value *value)
Location	LocationWritableRegisterOrSmiConstant (Value *value, intptr_t min_value, intptr_t max_value)
Location	LocationFixedRegisterOrConstant (Value *value, Register reg)
Location	LocationFixedRegisterOrSmiConstant (Value *value, Register reg)
Location	LocationAnyOrConstant (Value *value)
compiler::Address	LocationToStackSlotAddress (Location loc)
Location	LocationArgumentsDescriptorLocation ()
Location	LocationExceptionLocation ()
Location	LocationStackTraceLocation ()
Location	LocationRemapForSlowPath (Location loc, Definition *def, intptr_t *cpu_reg_slots, intptr_t *fpu_reg_slots)
intptr_t	LocationCount (Representation rep)
template<typename Instr , typename Out >
LocationSummary *	MakeLocationSummaryFromEmitter (Zone *zone, const Instr *instr, void(*Emit)(FlowGraphCompiler *, Instr *, Out))
template<typename Instr , typename Out , typename T0 >
	DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION (1,(T0))
template<typename Instr , typename Out , typename T0 , typename T1 >
	DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION (2,(T0, T1))
template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 >
	DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION (3,(T0, T1, T2))
template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 , typename T3 >
	DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION (4,(T0, T1, T2, T3))
template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
	DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION (5,(T0, T1, T2, T3, T4))
template<typename Instr , typename Out >
void	InvokeEmitter (FlowGraphCompiler *compiler, Instr *instr, void(*Emit)(FlowGraphCompiler *, Instr *, Out))
template<typename Instr , typename Out , typename T0 >
void	InvokeEmitter (FlowGraphCompiler *compiler, Instr *instr, void(*Emit)(FlowGraphCompiler *, Instr *, Out, T0))
template<typename Instr , typename Out , typename T0 , typename T1 >
void	InvokeEmitter (FlowGraphCompiler *compiler, Instr *instr, void(*Emit)(FlowGraphCompiler *, Instr *, Out, T0, T1))
template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 >
void	InvokeEmitter (FlowGraphCompiler *compiler, Instr *instr, void(*Emit)(FlowGraphCompiler *, Instr *, Out, T0, T1, T2))
template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 , typename T3 >
void	InvokeEmitter (FlowGraphCompiler *compiler, Instr *instr, void(*Emit)(FlowGraphCompiler *, Instr *, Out, T0, T1, T2, T3))
template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
void	InvokeEmitter (FlowGraphCompiler *compiler, Instr *instr, void(*Emit)(FlowGraphCompiler *, Instr *, Out, T0, T1, T2, T3, T4))
static LocationArray *	MakeLocationArray ()
static LocationArray *	MakeLocationArray (Location loc0)
static LocationArray *	MakeLocationArray (Location loc0, Location loc1)
static void	ValidateSummary (LocationSummary *locs, Location expected_output, const LocationArray *expected_inputs, const LocationArray *expected_temps)
static void	FillSummary (LocationSummary *locs, Location expected_output, const LocationArray *expected_inputs, const LocationArray *expected_temps)
	INSTRUCTION_TEST (Unary, 1,(Register out, Register in), ReqReg,(ReqReg),(), RegLoc(0),(RegLoc(1)),())
	INSTRUCTION_TEST (Binary1, 2,(Register out, Register in0, FpuRegister in1), ReqReg,(ReqReg, Location::RequiresFpuRegister()),(), RegLoc(0),(RegLoc(1), FpuLoc(2)),())
	INSTRUCTION_TEST (Binary2, 2,(Register out, FpuRegister in0, Register in1), ReqReg,(ReqFpu, ReqReg),(), RegLoc(0),(FpuLoc(1), RegLoc(2)),())
	INSTRUCTION_TEST (FixedOutput, 0,(Fixed< Register, Reg(3)> out), RegLoc(3),(),(), RegLoc(3),(),())
	INSTRUCTION_TEST (FixedInput, 1,(FpuRegister out, Fixed< FpuRegister, Fpu(3)> in), ReqFpu,(FpuLoc(3)),(), FpuLoc(0),(FpuLoc(3)),())
	INSTRUCTION_TEST (SameAsFirstInput, 2,(SameAsFirstInput, Register in0, Register in1), Location::SameAsFirstInput(),(ReqReg, ReqReg),(), RegLoc(0),(RegLoc(0), RegLoc(1)),())
	INSTRUCTION_TEST (Temps, 2,(Register out, Register in0, FpuRegister in1, Temp< FpuRegister > temp0, Temp< Register > temp1), ReqReg,(ReqReg, ReqFpu),(ReqFpu, ReqReg), RegLoc(0),(RegLoc(1), FpuLoc(2)),(FpuLoc(3), RegLoc(4)))
	INSTRUCTION_TEST (FixedTemp, 0,(FpuRegister out, Temp< Fixed< FpuRegister, Fpu(3)> > temp), ReqFpu,(),(FpuLoc(3)), FpuLoc(4),(),(FpuLoc(3)))
static intptr_t	InitIndex (LoopInfo *loop)
static bool	IsConstant (Definition *def, int64_t *val)
static bool	CanBeMadeExclusive (LoopInfo *loop, InductionVar *x, Instruction *branch, bool is_lower)
static bool	SafelyAdjust (Zone *zone, InductionVar *lower_bound, int64_t lower_bound_offset, InductionVar *upper_bound, int64_t upper_bound_offset, InductionVar **min, InductionVar **max)
void	TestString (BaseTextBuffer *f, LoopInfo *loop, const GrowableArray< BlockEntryInstr * > &preorder)
static const char *	ComputeInduction (Thread *thread, const char *script_chars)
	ISOLATE_UNIT_TEST_CASE (BasicInductionUp)
	ISOLATE_UNIT_TEST_CASE (BasicInductionDown)
	ISOLATE_UNIT_TEST_CASE (BasicInductionStepUp)
	ISOLATE_UNIT_TEST_CASE (BasicInductionStepDown)
	ISOLATE_UNIT_TEST_CASE (BasicInductionLoopNest)
	ISOLATE_UNIT_TEST_CASE (ChainInduction)
	ISOLATE_UNIT_TEST_CASE (TwoWayInduction)
	ISOLATE_UNIT_TEST_CASE (DerivedInduction)
	ISOLATE_UNIT_TEST_CASE (WrapAroundAndDerived)
	ISOLATE_UNIT_TEST_CASE (PeriodicAndDerived)
	ISOLATE_UNIT_TEST_CASE (NonStrictConditionUp)
	ISOLATE_UNIT_TEST_CASE (NonStrictConditionUpWrap)
	ISOLATE_UNIT_TEST_CASE (NonStrictConditionDown)
	ISOLATE_UNIT_TEST_CASE (NonStrictConditionDownWrap)
	ISOLATE_UNIT_TEST_CASE (NotEqualConditionUp)
	ISOLATE_UNIT_TEST_CASE (NotEqualConditionDown)
	ISOLATE_UNIT_TEST_CASE (SecondExitUp)
	ISOLATE_UNIT_TEST_CASE (SecondExitDown)
static classid_t	TypedDataCidForElementSize (intptr_t elem_size)
static intptr_t	ExpectedValue (intptr_t i)
static void	InitializeMemory (uint8_t *input, uint8_t *output)
static bool	CheckMemory (Expect expect, const uint8_t *input, const uint8_t *output, intptr_t dest_start, intptr_t src_start, intptr_t length, intptr_t elem_size)
static void	RunMemoryCopyInstrTest (intptr_t src_start, intptr_t dest_start, intptr_t length, intptr_t elem_size, bool unboxed_inputs, bool use_same_buffer)
static uword	RegMaskBit (Register reg)
	DEFINE_FLAG (bool, array_bounds_check_elimination, true, "Eliminate redundant bounds checks.")
	DEFINE_FLAG (bool, trace_range_analysis, false, "Trace range analysis progress")
	DEFINE_FLAG (bool, trace_integer_ir_selection, false, "Print integer IR selection optimization pass.")
	DECLARE_FLAG (bool, trace_constant_propagation)
static Definition *	UnwrapConstraint (Definition *defn)
static bool	AreEqualDefinitions (Definition *a, Definition *b)
static bool	DependOnSameSymbol (const RangeBoundary &a, const RangeBoundary &b)
static RangeBoundary	WidenMin (const Range *range, const Range *new_range, RangeBoundary::RangeSize size)
static RangeBoundary	WidenMax (const Range *range, const Range *new_range, RangeBoundary::RangeSize size)
static RangeBoundary	NarrowMin (const Range *range, const Range *new_range, RangeBoundary::RangeSize size)
static RangeBoundary	NarrowMax (const Range *range, const Range *new_range, RangeBoundary::RangeSize size)
static RangeBoundary::RangeSize	RangeSizeForPhi (Definition *phi)
static void	NarrowBinaryInt64Op (BinaryInt64OpInstr *int64_op)
static void	NarrowShiftInt64Op (ShiftIntegerOpInstr *int64_op)
static RangeBoundary	CanonicalizeBoundary (const RangeBoundary &a, const RangeBoundary &overflow)
static bool	CanonicalizeMaxBoundary (RangeBoundary *a)
static bool	CanonicalizeMinBoundary (RangeBoundary *a)
static bool	CanonicalizeForComparison (RangeBoundary *a, RangeBoundary *b, BoundaryOp op, const RangeBoundary &overflow)
static RangeBoundary::RangeSize	RepresentationToRangeSize (Representation r)
static void	ConvertRangeToUnsigned (int64_t a, int64_t b, uint64_t *ua, uint64_t *ub)
static void	ConvertRangeToSigned (uint64_t a, uint64_t b, int64_t *sa, int64_t *sb)
static int	BitSize (const Range *range)
static bool	DependsOnSymbol (const RangeBoundary &a, Definition *symbol)
static void	Join (Range *range, Definition *defn, const Range *defn_range, RangeBoundary::RangeSize size)
static bool	DominatesPhi (BlockEntryInstr *a, BlockEntryInstr *phi_block)
static RangeBoundary	EnsureAcyclicSymbol (BlockEntryInstr *phi_block, const RangeBoundary &a, const RangeBoundary &limit)
static const Range *	GetInputRange (RangeAnalysis *analysis, RangeBoundary::RangeSize size, Value *input)
static void	CacheRange (Range **slot, const Range *range, RangeBoundary::RangeSize size)
static bool	IsRedundantBasedOnRangeInformation (Value *index, Value *length)
	TEST_CASE (RangeTests)
	TEST_CASE (RangeTestsInt64Range)
	TEST_CASE (RangeUtils)
	TEST_CASE (RangeBinaryOp)
	TEST_CASE (RangeAdd)
	TEST_CASE (RangeSub)
	TEST_CASE (RangeAnd)
	TEST_CASE (RangeIntersectionMinMax)
	TEST_CASE (RangeJoinMinMax)
	ISOLATE_UNIT_TEST_CASE (RangeAnalysis_LoadClassId)
	ISOLATE_UNIT_TEST_CASE (ReachabilityFence_Simple)
	ISOLATE_UNIT_TEST_CASE (ReachabilityFence_Loop)
	ISOLATE_UNIT_TEST_CASE (ReachabilityFence_NoCanonicalize)
	DEFINE_FLAG (bool, dead_store_elimination, true, "Eliminate dead stores")
	DEFINE_FLAG (bool, load_cse, true, "Use redundant load elimination.")
	DEFINE_FLAG (bool, optimize_lazy_initializer_calls, true, "Eliminate redundant lazy initializer calls.")
	DEFINE_FLAG (bool, trace_load_optimization, false, "Print live sets for load optimization pass.")
static Definition *	GetStoredValue (Instruction *instr)
static bool	IsPhiDependentPlace (Place *place)
static PhiPlaceMoves *	ComputePhiMoves (PointerSet< Place > *map, ZoneGrowableArray< Place * > *places, bool print_traces)
static DART_FORCE_INLINE void	SetPlaceId (Instruction *instr, intptr_t id)
static DART_FORCE_INLINE bool	HasPlaceId (const Instruction *instr)
static DART_FORCE_INLINE intptr_t	GetPlaceId (const Instruction *instr)
static AliasedSet *	NumberPlaces (FlowGraph *graph, PointerSet< Place > *map, CSEMode mode)
static bool	IsLoadEliminationCandidate (Instruction *instr)
static bool	IsLoopInvariantLoad (ZoneGrowableArray< BitVector * > *sets, intptr_t loop_header_index, Instruction *instr)
static bool	IsValidLengthForAllocationSinking (ArrayAllocationInstr *array_alloc)
static bool	IsSupportedAllocation (Instruction *instr)
static Definition *	StoreDestination (Value *use)
static Definition *	LoadSource (Definition *instr)
static void	AddSlot (ZoneGrowableArray< const Slot * > *slots, const Slot &slot)
static Instruction *	ExitForMaterialization (MaterializeObjectInstr *mat)
static Instruction *	FirstMaterializationAt (Instruction *exit)
static InnerPointerAccess	AccessForSlotInAllocatedObject (Definition *alloc, const Slot &slot)
template<typename T >
void	AddInstruction (GrowableArray< T * > *list, T *value)
static bool	IsDataFieldOfTypedDataView (Definition *alloc, const Slot &slot)
void	OptimizeCatchEntryStates (FlowGraph *flow_graph, bool is_aot)
static bool	HasRealUse (Definition *def)
static bool	IsMarkedWithNoInterrupts (const Function &function)
static void	NoopNative (Dart_NativeArguments args)
static Dart_NativeFunction	NoopNativeLookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
static void	FlattenScopeIntoEnvironment (FlowGraph *graph, LocalScope *scope, GrowableArray< LocalVariable * > *env)
static void	TryCatchOptimizerTest (Thread *thread, const char *script_chars, std::initializer_list< const char * > synchronized)
	ISOLATE_UNIT_TEST_CASE (TryCatchOptimizer_DeadParameterElimination_Simple1)
	ISOLATE_UNIT_TEST_CASE (TryCatchOptimizer_DeadParameterElimination_Simple2)
	ISOLATE_UNIT_TEST_CASE (TryCatchOptimizer_DeadParameterElimination_Cyclic1)
	ISOLATE_UNIT_TEST_CASE (TryCatchOptimizer_DeadParameterElimination_Cyclic2)
static void	TestAliasingViaRedefinition (Thread *thread, bool make_it_escape, std::function< Definition *(CompilerState *S, FlowGraph *, Definition *)> make_redefinition)
static Definition *	MakeCheckNull (CompilerState *S, FlowGraph *flow_graph, Definition *defn)
static Definition *	MakeRedefinition (CompilerState *S, FlowGraph *flow_graph, Definition *defn)
static Definition *	MakeAssertAssignable (CompilerState *S, FlowGraph *flow_graph, Definition *defn)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedefinitionAliasing_CheckNull_NoEscape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedefinitionAliasing_CheckNull_Escape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedefinitionAliasing_Redefinition_NoEscape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedefinitionAliasing_Redefinition_Escape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedefinitionAliasing_AssertAssignable_NoEscape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedefinitionAliasing_AssertAssignable_Escape)
static void	TestAliasingViaStore (Thread *thread, bool make_it_escape, bool make_host_escape, std::function< Definition *(CompilerState *S, FlowGraph *, Definition *)> make_redefinition)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_CheckNull_NoEscape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_CheckNull_Escape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_CheckNull_EscapeViaHost)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_Redefinition_NoEscape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_Redefinition_Escape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_Redefinition_EscapeViaHost)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_AssertAssignable_NoEscape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_AssertAssignable_Escape)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaStore_AssertAssignable_EscapeViaHost)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_AliasingViaTypedDataAndUntaggedTypedData)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_LoadDataFieldOfNewTypedData)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_TypedArrayViewAliasing)
static void	CountLoadsStores (FlowGraph *flow_graph, intptr_t *loads, intptr_t *stores)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedundantStoresAndLoads)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedundantStaticFieldInitialization)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedundantInitializerCallAfterIf)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedundantInitializerCallInLoop)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedundantInitializingStoreAOT)
	ISOLATE_UNIT_TEST_CASE (LoadOptimizer_RedundantStoreAOT)
	ISOLATE_UNIT_TEST_CASE (AllocationSinking_Arrays)
	ISOLATE_UNIT_TEST_CASE (AllocationSinking_Records)
	ISOLATE_UNIT_TEST_CASE (DelayAllocations_DelayAcrossCalls)
	ISOLATE_UNIT_TEST_CASE (DelayAllocations_DontDelayIntoLoop)
	ISOLATE_UNIT_TEST_CASE (CheckStackOverflowElimination_NoInterruptsPragma)
	ISOLATE_UNIT_TEST_CASE (BoundsCheckElimination_Pragma)
	ISOLATE_UNIT_TEST_CASE (CSE_Redefinitions)
	ISOLATE_UNIT_TEST_CASE (AllocationSinking_NoViewDataMaterialization)
	ISOLATE_UNIT_TEST_CASE (LICM_Deopt_Regress51220)
	ISOLATE_UNIT_TEST_CASE (LICM_Deopt_Regress50245)
	TEST_CASE (SlotFromGuardedField)
	DEFINE_FLAG (bool, trace_type_propagation, false, "Trace flow graph type propagation")
static void	TraceStrongModeType (const Instruction *instr, const AbstractType &type)
static void	TraceStrongModeType (const Instruction *instr, CompileType *compileType)
static bool	CanPotentiallyBeSmi (const AbstractType &type, bool recurse)
static CompileType	ComputeListFactoryType (CompileType *inferred_type, Value *type_args_value)
static AbstractTypePtr	ExtractElementTypeFromArrayType (const AbstractType &array_type)
static AbstractTypePtr	GetElementTypeFromArray (Value *array)
static CompileType	ComputeArrayElementType (Value *array)
	ISOLATE_UNIT_TEST_CASE (TypePropagator_RedefinitionAfterStrictCompareWithNull)
	ISOLATE_UNIT_TEST_CASE (TypePropagator_RedefinitionAfterStrictCompareWithLoadClassId)
	ISOLATE_UNIT_TEST_CASE (TypePropagator_Refinement)
	ISOLATE_UNIT_TEST_CASE (TypePropagator_Regress36156)
	ISOLATE_UNIT_TEST_CASE (CompileType_CanBeSmi)
	ISOLATE_UNIT_TEST_CASE (TypePropagator_RegressFlutter76919)
	ISOLATE_UNIT_TEST_CASE (TypePropagator_RecordFieldAccess)
int	LowestFirst (const TokenPosition *a, const TokenPosition *b)
static YieldPoints *	GetYieldPointsFromGraph (FlowGraph *flow_graph)
static YieldPoints *	GetYieldPointsFromCode (const Code &code)
void	RunTestInMode (CompilerPass::PipelineMode mode)
	ISOLATE_UNIT_TEST_CASE (IRTest_YieldIndexAvailableJIT)
	ISOLATE_UNIT_TEST_CASE (IRTest_YieldIndexAvailableAOT)
	DECLARE_FLAG (bool, enable_simd_inline)
static void	RefineUseTypes (Definition *instr)
static bool	ShouldInlineSimd ()
static bool	CanUnboxDouble ()
static bool	CanConvertInt64ToDouble ()
static bool	IsNumberCid (intptr_t cid)
static bool	ShouldSpecializeForDouble (const BinaryFeedback &binary_feedback)
static bool	IsLengthOneString (Definition *d)
static bool	SmiFitsInDouble ()
static bool	CidTestResultsContains (const ZoneGrowableArray< intptr_t > &results, intptr_t test_cid)
static void	TryAddTest (ZoneGrowableArray< intptr_t > *results, intptr_t test_cid, bool result)
static void	PurgeNegativeTestCidsEntries (ZoneGrowableArray< intptr_t > *results)
static bool	IsSmiValue (Value *val, intptr_t *int_val)
static CompileType *	ResultType (Definition *call)
static bool	InlineTypedDataIndexCheck (FlowGraph *flow_graph, Instruction *call, Definition *receiver, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result, const String &symbol)
static intptr_t	PrepareInlineIndexedOp (FlowGraph *flow_graph, Instruction *call, intptr_t array_cid, Definition **array, Definition **index, Instruction **cursor)
static bool	InlineGetIndexed (FlowGraph *flow_graph, bool can_speculate, bool is_dynamic_call, MethodRecognizer::Kind kind, Definition *call, Definition *receiver, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static bool	InlineSetIndexed (FlowGraph *flow_graph, MethodRecognizer::Kind kind, const Function &target, Instruction *call, Definition *receiver, const InstructionSource &source, CallSpecializer::ExactnessInfo *exactness, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static bool	InlineDoubleOp (FlowGraph *flow_graph, Token::Kind op_kind, Instruction *call, Definition *receiver, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static bool	InlineDoubleTestOp (FlowGraph *flow_graph, Instruction *call, Definition *receiver, MethodRecognizer::Kind kind, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static bool	InlineGrowableArraySetter (FlowGraph *flow_graph, const Slot &field, StoreBarrierType store_barrier_type, Instruction *call, Definition *receiver, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static bool	InlineLoadClassId (FlowGraph *flow_graph, Instruction *call, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static Definition *	PrepareInlineStringIndexOp (FlowGraph *flow_graph, Instruction *call, intptr_t cid, Definition *str, Definition *index, Instruction *cursor)
static bool	InlineStringBaseCharAt (FlowGraph *flow_graph, Instruction *call, Definition *receiver, intptr_t cid, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static bool	InlineStringBaseCodeUnitAt (FlowGraph *flow_graph, Instruction *call, Definition *receiver, intptr_t cid, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static bool	CheckMask (Definition *definition, intptr_t *mask_ptr)
static bool	InlineSimdOp (FlowGraph *flow_graph, bool is_dynamic_call, Instruction *call, Definition *receiver, MethodRecognizer::Kind kind, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static Instruction *	InlineMul (FlowGraph *flow_graph, Instruction *cursor, Definition *x, Definition *y)
static bool	InlineMathIntPow (FlowGraph *flow_graph, Instruction *call, GraphEntryInstr *graph_entry, FunctionEntryInstr **entry, Instruction **last, Definition **result)
static intptr_t	CountFinalizedSubclasses (Thread *thread, const Class &cls)
	TEST_CASE (ClassHierarchyAnalysis)
	DEFINE_OPTION_HANDLER (CompilerPass::ParseFiltersFromFlag, compiler_passes, "List of comma separated compilation passes flags. " "Use -Name to disable a pass, Name to print IL after it. " "Do --compiler-passes=help for more information.")
	DEFINE_FLAG (bool, test_il_serialization, false, "Test IL serialization.")
	COMPILER_PASS (ComputeSSA, { flow_graph->ComputeSSA(nullptr);})
	COMPILER_PASS (ApplyICData, { state->call_specializer->ApplyICData();})
	COMPILER_PASS (TryOptimizePatterns, { flow_graph->TryOptimizePatterns();})
	COMPILER_PASS (SetOuterInliningId, { FlowGraphInliner::SetInliningId(flow_graph, 0);})
	COMPILER_PASS (Inlining, { FlowGraphInliner inliner(flow_graph, &state->inline_id_to_function, &state->inline_id_to_token_pos, &state->caller_inline_id, state->speculative_policy, state->precompiler);state->inlining_depth=inliner.Inline();})
	COMPILER_PASS (TypePropagation, { FlowGraphTypePropagator::Propagate(flow_graph);})
	COMPILER_PASS (ApplyClassIds, { state->call_specializer->ApplyClassIds();})
	COMPILER_PASS (EliminateStackOverflowChecks, { if(!flow_graph->IsCompiledForOsr()) { CheckStackOverflowElimination::EliminateStackOverflow(flow_graph);} })
	COMPILER_PASS (Canonicalize, { if(flow_graph->Canonicalize()) { flow_graph->Canonicalize();} })
	COMPILER_PASS (BranchSimplify, { BranchSimplifier::Simplify(flow_graph);})
	COMPILER_PASS (IfConvert, { IfConverter::Simplify(flow_graph);})
	COMPILER_PASS_REPEAT (ConstantPropagation, { ConstantPropagator::Optimize(flow_graph);return true;})
	COMPILER_PASS (OptimisticallySpecializeSmiPhis, { LICM licm(flow_graph);licm.OptimisticallySpecializeSmiPhis();})
	COMPILER_PASS (WidenSmiToInt32, { flow_graph->WidenSmiToInt32();})
	COMPILER_PASS (SelectRepresentations, { flow_graph->SelectRepresentations();})
	COMPILER_PASS (SelectRepresentations_Final, { flow_graph->SelectRepresentations();flow_graph->disallow_unmatched_representations();})
	COMPILER_PASS (UseTableDispatch, { state->call_specializer->ReplaceInstanceCallsWithDispatchTableCalls();})
	COMPILER_PASS_REPEAT (CSE, { return DominatorBasedCSE::Optimize(flow_graph);})
	COMPILER_PASS (LICM, { flow_graph->RenameUsesDominatedByRedefinitions();DEBUG_ASSERT(flow_graph->VerifyRedefinitions());LICM licm(flow_graph);licm.Optimize();flow_graph->RemoveRedefinitions(true);})
	COMPILER_PASS (DSE, { DeadStoreElimination::Optimize(flow_graph);})
	COMPILER_PASS (RangeAnalysis, { RangeAnalysis range_analysis(flow_graph);range_analysis.Analyze();})
	COMPILER_PASS (OptimizeBranches, { ConstantPropagator::OptimizeBranches(flow_graph);})
	COMPILER_PASS (OptimizeTypedDataAccesses, { TypedDataSpecializer::Optimize(flow_graph);})
	COMPILER_PASS (TryCatchOptimization, { OptimizeCatchEntryStates(flow_graph, CompilerState::Current().is_aot());})
	COMPILER_PASS (EliminateEnvironments, { flow_graph->EliminateEnvironments();})
	COMPILER_PASS (EliminateDeadPhis, { DeadCodeElimination::EliminateDeadPhis(flow_graph);})
	COMPILER_PASS (DCE, { DeadCodeElimination::EliminateDeadCode(flow_graph);})
	COMPILER_PASS (DelayAllocations, { DelayAllocations::Optimize(flow_graph);})
	COMPILER_PASS (AllocationSinking_Sink, { if(flow_graph->graph_entry() ->catch_entries().is_empty()) { state->sinking=new AllocationSinking(flow_graph);state->sinking->Optimize();} })
	COMPILER_PASS (AllocationSinking_DetachMaterializations, { if(state->sinking !=nullptr) { state->sinking->DetachMaterializations();} })
	COMPILER_PASS (AllocateRegisters, { flow_graph->InsertMoveArguments();flow_graph->GetLoopHierarchy();FlowGraphAllocator allocator(*flow_graph);allocator.AllocateRegisters();})
	COMPILER_PASS (AllocateRegistersForGraphIntrinsic, { flow_graph->set_max_argument_slot_count(0);flow_graph->GetLoopHierarchy();FlowGraphAllocator allocator(*flow_graph, true);allocator.AllocateRegisters();})
	COMPILER_PASS (ReorderBlocks, { BlockScheduler::ReorderBlocks(flow_graph);})
	COMPILER_PASS (EliminateWriteBarriers, { EliminateWriteBarriers(flow_graph);})
	COMPILER_PASS (FinalizeGraph, { intptr_t instruction_count=0;intptr_t call_site_count=0;FlowGraphInliner::CollectGraphInfo(flow_graph, 0, true, &instruction_count, &call_site_count);flow_graph->function().set_inlining_depth(state->inlining_depth);flow_graph->RemoveRedefinitions();})
	COMPILER_PASS (TestILSerialization, { if(FLAG_test_il_serialization &&CompilerState::Current().is_aot()) { Zone *zone=flow_graph->zone();auto *detached_defs=new(zone) ZoneGrowableArray< Definition * >(zone, 0);flow_graph->CompactSSA(detached_defs);ZoneWriteStream write_stream(flow_graph->zone(), 1024);FlowGraphSerializer serializer(&write_stream);serializer.WriteFlowGraph(*flow_graph, *detached_defs);ReadStream read_stream(write_stream.buffer(), write_stream.bytes_written());FlowGraphDeserializer deserializer(flow_graph->parsed_function(), &read_stream);state->set_flow_graph(deserializer.ReadFlowGraph());} })
	COMPILER_PASS (LoweringAfterCodeMotionDisabled, { flow_graph->ExtractNonInternalTypedDataPayloads();})
	COMPILER_PASS (GenerateCode, { state->graph_compiler->CompileGraph();})
template<typename T >
T *	PutIfAbsent (Thread *thread, ZoneGrowableArray< T * > **array_slot, intptr_t index, std::function< T *()> create)
DART_EXPORT void	Dart_PrepareToAbort ()
DART_EXPORT void	Dart_DumpNativeStackTrace (void *context)
uword	FindDoubleConstant (double value)
bool	SimpleInstanceOfType (const AbstractType &type)
	ISOLATE_UNIT_TEST_CASE (StreamingFlowGraphBuilder_ConstFoldStringConcats)
	ISOLATE_UNIT_TEST_CASE (StreamingFlowGraphBuilder_FlattenNestedStringInterp)
	ISOLATE_UNIT_TEST_CASE (StreamingFlowGraphBuilder_DropEmptyStringInterp)
	ISOLATE_UNIT_TEST_CASE (StreamingFlowGraphBuilder_ConcatStringLits)
	ISOLATE_UNIT_TEST_CASE (StreamingFlowGraphBuilder_InvariantFlagInListLiterals)
	ISOLATE_UNIT_TEST_CASE (StreamingFlowGraphBuilder_TypedClosureCall)
	ISOLATE_UNIT_TEST_CASE (StreamingFlowGraphBuilder_StaticGetFinalFieldWithTrivialInitializer)
	DEFINE_FLAG (bool, print_huge_methods, false, "Print huge methods (less optimized)")
	DEFINE_FLAG (int, force_switch_dispatch_type, -1, "Force switch statements to use a particular dispatch type: " "-1=auto, 0=linear scan, 1=binary search, 2=jump table")
	DEFINE_FLAG (bool, intrinsify, true, "Instrinsify when possible")
	DEFINE_FLAG (bool, trace_intrinsifier, false, "Trace intrinsifier")
	DEFINE_FLAG (int, max_deoptimization_counter_threshold, 16, "How many times we allow deoptimization before we disallow optimization.")
	DEFINE_FLAG (charp, optimization_filter, nullptr, "Optimize only named function")
	DEFINE_FLAG (bool, print_flow_graph, false, "Print the IR flow graph.")
	DEFINE_FLAG (bool, print_flow_graph_optimized, false, "Print the IR flow graph when optimizing.")
	DEFINE_FLAG (bool, print_ic_data_map, false, "Print the deopt-id to ICData map in optimizing compiler.")
	DEFINE_FLAG (bool, print_code_source_map, false, "Print code source map.")
	DEFINE_FLAG (bool, stress_test_background_compilation, false, "Keep background compiler running all the time")
	DEFINE_FLAG (bool, stop_on_excessive_deoptimization, false, "Debugging: stops program if deoptimizing same function too often")
	DEFINE_FLAG (bool, trace_compiler, false, "Trace compiler operations.")
	DEFINE_FLAG (bool, trace_failed_optimization_attempts, false, "Traces all failed optimization attempts")
	DEFINE_FLAG (bool, trace_optimizing_compiler, false, "Trace only optimizing compiler operations.")
	DEFINE_FLAG (bool, trace_bailout, false, "Print bailout from ssa compiler.")
static void	PrecompilationModeHandler (bool value)
	DEFINE_FLAG_HANDLER (PrecompilationModeHandler, precompilation, "Precompilation mode")
	DEFINE_RUNTIME_ENTRY (CompileFunction, 1)
static ObjectPtr	CompileFunctionHelper (CompilationPipeline *pipeline, const Function &function, volatile bool optimized, intptr_t osr_id)
static Token::Kind	RecognizeTokenKindHelper (const String &name)
static bool	IsCreateLargeArray (Definition *defn)
void	EliminateWriteBarriers (FlowGraph *flow_graph)
	ISOLATE_UNIT_TEST_CASE (IRTest_WriteBarrierElimination_JoinSuccessors)
	ISOLATE_UNIT_TEST_CASE (IRTest_WriteBarrierElimination_AtLeastOnce)
static void	TestWBEForArrays (int length)
	ISOLATE_UNIT_TEST_CASE (IRTest_WriteBarrierElimination_Arrays)
	ISOLATE_UNIT_TEST_CASE (IRTest_WriteBarrierElimination_Regress43786)
	ISOLATE_UNIT_TEST_CASE (IRTest_WriteBarrierElimination_LoadLateField)
	ISOLATE_UNIT_TEST_CASE (IRTest_WriteBarrierElimination_LoadLateStaticField)
	ISOLATE_UNIT_TEST_CASE (CompileFunction)
	ISOLATE_UNIT_TEST_CASE (OptimizeCompileFunctionOnHelperThread)
	ISOLATE_UNIT_TEST_CASE (CompileFunctionOnHelperThread)
	ISOLATE_UNIT_TEST_CASE (RegenerateAllocStubs)
	TEST_CASE (EvalExpression)
	ISOLATE_UNIT_TEST_CASE (EvalExpressionWithLazyCompile)
	ISOLATE_UNIT_TEST_CASE (EvalExpressionExhaustCIDs)
	TEST_CASE (ManyClasses)
static constexpr bool	IsArgumentRegister (Register reg)
static constexpr bool	IsFpuArgumentRegister (FpuRegister reg)
static constexpr bool	IsCalleeSavedRegister (Register reg)
constexpr bool	IsAbiPreservedRegister (Register reg)
static ScaleFactor	ToScaleFactor (intptr_t index_scale, bool index_unboxed)
static Utils::BitsRange< Register >	RegisterRange (uint32_t regs)
static DRegister	EvenDRegisterOf (QRegister q)
static DRegister	OddDRegisterOf (QRegister q)
static SRegister	EvenSRegisterOf (DRegister d)
static SRegister	OddSRegisterOf (DRegister d)
static QRegister	QRegisterOf (DRegister d)
static QRegister	QRegisterOf (SRegister s)
static DRegister	DRegisterOf (SRegister s)
static Condition	InvertCondition (Condition c)
float	ReciprocalEstimate (float op)
float	ReciprocalStep (float op1, float op2)
float	ReciprocalSqrtEstimate (float op)
float	ReciprocalSqrtStep (float op1, float op2)
constexpr bool	operator== (Register r, LinkRegister)
constexpr bool	operator!= (Register r, LinkRegister lr)
Register	ConcreteRegister (LinkRegister)
static Register	ConcreteRegister (Register r)
static Condition	InvertCondition (Condition c)
static uint64_t	RotateRight (uint64_t value, uint8_t rotate, uint8_t width)
static uint64_t	RepeatBitsAcrossReg (uint8_t reg_size, uint64_t value, uint8_t width)
ByteRegister	ByteRegisterOf (Register reg)
	DECLARE_FLAG (bool, use_compressed_instructions)
static Condition	InvertCondition (Condition c)
int32_t	SignExtend (int N, int32_t value)
intx_t	sign_extend (int32_t x)
intx_t	sign_extend (int64_t x)
intx_t	sign_extend (uint32_t x)
intx_t	sign_extend (uint64_t x)
intx_t	ImmLo (intx_t imm)
intx_t	ImmHi (intx_t imm)
bool	IsBTypeImm (intptr_t imm)
uint32_t	EncodeBTypeImm (intptr_t imm)
intptr_t	DecodeBTypeImm (uint32_t encoded)
bool	IsJTypeImm (intptr_t imm)
uint32_t	EncodeJTypeImm (intptr_t imm)
intptr_t	DecodeJTypeImm (uint32_t encoded)
bool	IsITypeImm (intptr_t imm)
uint32_t	EncodeITypeImm (intptr_t imm)
intptr_t	DecodeITypeImm (uint32_t encoded)
bool	IsUTypeImm (intptr_t imm)
uint32_t	EncodeUTypeImm (intptr_t imm)
intptr_t	DecodeUTypeImm (uint32_t encoded)
bool	IsSTypeImm (intptr_t imm)
uint32_t	EncodeSTypeImm (intptr_t imm)
intptr_t	DecodeSTypeImm (uint32_t encoded)
bool	IsCInstruction (uint16_t parcel)
bool	IsCSPLoad4Imm (intptr_t imm)
uint32_t	EncodeCSPLoad4Imm (intptr_t imm)
intx_t	DecodeCSPLoad4Imm (uint32_t encoding)
bool	IsCSPLoad8Imm (intptr_t imm)
uint32_t	EncodeCSPLoad8Imm (intptr_t imm)
intx_t	DecodeCSPLoad8Imm (uint32_t encoding)
bool	IsCSPStore4Imm (intptr_t imm)
uint32_t	EncodeCSPStore4Imm (intptr_t imm)
intx_t	DecodeCSPStore4Imm (uint32_t encoding)
bool	IsCSPStore8Imm (intptr_t imm)
uint32_t	EncodeCSPStore8Imm (intptr_t imm)
intx_t	DecodeCSPStore8Imm (uint32_t encoding)
bool	IsCMem4Imm (intptr_t imm)
uint32_t	EncodeCMem4Imm (intptr_t imm)
intx_t	DecodeCMem4Imm (uint32_t encoding)
bool	IsCMem8Imm (intptr_t imm)
uint32_t	EncodeCMem8Imm (intptr_t imm)
intx_t	DecodeCMem8Imm (uint32_t encoding)
bool	IsCJImm (intptr_t imm)
uint32_t	EncodeCJImm (intptr_t imm)
intx_t	DecodeCJImm (uint32_t encoding)
bool	IsCBImm (intptr_t imm)
uint32_t	EncodeCBImm (intptr_t imm)
intx_t	DecodeCBImm (uint32_t encoding)
bool	IsCIImm (intptr_t imm)
uint32_t	EncodeCIImm (intptr_t imm)
intx_t	DecodeCIImm (uint32_t encoding)
bool	IsCUImm (intptr_t imm)
uint32_t	EncodeCUImm (intptr_t imm)
intx_t	DecodeCUImm (uint32_t encoding)
bool	IsCI16Imm (intptr_t imm)
uint32_t	EncodeCI16Imm (intptr_t imm)
intx_t	DecodeCI16Imm (uint32_t encoding)
bool	IsCI4SPNImm (intptr_t imm)
uint32_t	EncodeCI4SPNImm (intptr_t imm)
intx_t	DecodeCI4SPNImm (uint32_t encoding)
static constexpr Extension	RV_I (0)
static constexpr Extension	RV_M (1)
static constexpr Extension	RV_A (2)
static constexpr Extension	RV_F (3)
static constexpr Extension	RV_D (4)
static constexpr Extension	RV_C (5)
static constexpr Extension	RV_Zba (6)
static constexpr Extension	RV_Zbb (7)
static constexpr Extension	RV_Zbc (8)
static constexpr Extension	RV_Zbs (9)
static Condition	InvertCondition (Condition c)
	DECLARE_FLAG (bool, use_sse41)
	VM_UNIT_TEST_CASE (Id)
	VM_UNIT_TEST_CASE (GetCpuModelTest)
	DECLARE_FLAG (bool, trace_shutdown)
static void	native_echo (Dart_NativeArguments args)
static void	CustomIsolateImpl_start (Dart_NativeArguments args)
static Dart_NativeFunction	NativeLookup (Dart_Handle name, int argc, bool *auto_setup_scope)
static void	NotifyMessage (Dart_Isolate dest_isolate)
	VM_UNIT_TEST_CASE (CustomIsolates)
	DECLARE_FLAG (bool, print_class_table)
	DEFINE_FLAG (bool, trace_shutdown, false, "Trace VM shutdown on stderr")
static void	DumpAliveIsolates (intptr_t num_attempts, bool only_application_isolates)
static bool	OnlyVmIsolateLeft ()
static void	FinalizeBuiltinClasses (Thread *thread)
	DEFINE_FLAG (bool, verify_acquired_data, false, "Verify correct API acquire/release of typed data.")
	DEFINE_FLAG (bool, dump_tables, false, "Dump common hash tables before snapshotting.")
	DEFINE_FLAG (bool, enable_deprecated_wait_for, false, "Enable deprecated dart:cli waitFor. " "This feature will be fully removed in Dart 3.4 release. " "See https://dartbug.com/52121.")
const char *	CanonicalFunction (const char *func)
static InstancePtr	GetListInstance (Zone *zone, const Object &obj)
static InstancePtr	GetMapInstance (Zone *zone, const Object &obj)
static bool	IsCompiletimeErrorObject (Zone *zone, const Object &obj)
static bool	GetNativeStringArgument (NativeArguments *arguments, int arg_index, Dart_Handle *str, void **peer)
static bool	GetNativeIntegerArgument (NativeArguments *arguments, int arg_index, int64_t *value)
static bool	GetNativeUnsignedIntegerArgument (NativeArguments *arguments, int arg_index, uint64_t *value)
static bool	GetNativeDoubleArgument (NativeArguments *arguments, int arg_index, double *value)
static Dart_Handle	GetNativeFieldsOfArgument (NativeArguments *arguments, int arg_index, int num_fields, intptr_t *field_values, const char *current_func)
static FunctionPtr	FindCoreLibPrivateFunction (Zone *zone, const String &name)
static ObjectPtr	CallStatic1Arg (Zone *zone, const String &name, const Instance &arg0)
static ObjectPtr	CallStatic2Args (Zone *zone, const String &name, const Instance &arg0, const Instance &arg1)
static ObjectPtr	CallStatic3Args (Zone *zone, const String &name, const Instance &arg0, const Instance &arg1, const Instance &arg2)
static const char *	GetErrorString (Thread *thread, const Object &obj)
static Dart_Handle	InitNewReadOnlyApiHandle (ObjectPtr raw)
DART_EXPORT bool	Dart_IsError (Dart_Handle handle)
DART_EXPORT void	Dart_KillIsolate (Dart_Isolate handle)
DART_EXPORT bool	Dart_IsApiError (Dart_Handle object)
DART_EXPORT bool	Dart_IsUnhandledExceptionError (Dart_Handle object)
DART_EXPORT bool	Dart_IsCompilationError (Dart_Handle object)
DART_EXPORT bool	Dart_IsFatalError (Dart_Handle object)
DART_EXPORT const char *	Dart_GetError (Dart_Handle handle)
DART_EXPORT bool	Dart_ErrorHasException (Dart_Handle handle)
DART_EXPORT Dart_Handle	Dart_ErrorGetException (Dart_Handle handle)
DART_EXPORT Dart_Handle	Dart_ErrorGetStackTrace (Dart_Handle handle)
DART_EXPORT Dart_Handle	Dart_NewApiError (const char *error)
DART_EXPORT Dart_Handle	Dart_NewCompilationError (const char *error)
DART_EXPORT Dart_Handle	Dart_NewUnhandledExceptionError (Dart_Handle exception)
DART_EXPORT void	Dart_PropagateError (Dart_Handle handle)
DART_EXPORT Dart_Handle	Dart_ToString (Dart_Handle object)
DART_EXPORT bool	Dart_IdentityEquals (Dart_Handle obj1, Dart_Handle obj2)
DART_EXPORT Dart_Handle	Dart_HandleFromPersistent (Dart_PersistentHandle object)
DART_EXPORT Dart_Handle	Dart_HandleFromWeakPersistent (Dart_WeakPersistentHandle object)
static Dart_Handle	HandleFromFinalizable (Dart_FinalizableHandle object)
DART_EXPORT Dart_PersistentHandle	Dart_NewPersistentHandle (Dart_Handle object)
DART_EXPORT void	Dart_SetPersistentHandle (Dart_PersistentHandle obj1, Dart_Handle obj2)
static bool	IsFfiCompound (Thread *T, const Object &obj)
static Dart_WeakPersistentHandle	AllocateWeakPersistentHandle (Thread *thread, const Object &ref, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
static Dart_WeakPersistentHandle	AllocateWeakPersistentHandle (Thread *T, Dart_Handle object, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
static Dart_FinalizableHandle	AllocateFinalizableHandle (Thread *thread, const Object &ref, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
static Dart_FinalizableHandle	AllocateFinalizableHandle (Thread *T, Dart_Handle object, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT Dart_WeakPersistentHandle	Dart_NewWeakPersistentHandle (Dart_Handle object, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT Dart_FinalizableHandle	Dart_NewFinalizableHandle (Dart_Handle object, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT void	Dart_DeletePersistentHandle (Dart_PersistentHandle object)
DART_EXPORT void	Dart_DeleteWeakPersistentHandle (Dart_WeakPersistentHandle object)
DART_EXPORT void	Dart_DeleteFinalizableHandle (Dart_FinalizableHandle object, Dart_Handle strong_ref_to_object)
DART_EXPORT const char *	Dart_VersionString ()
DART_EXPORT char *	Dart_Initialize (Dart_InitializeParams *params)
DART_EXPORT char *	Dart_Cleanup ()
DART_EXPORT char *	Dart_SetVMFlags (int argc, const char **argv)
DART_EXPORT bool	Dart_IsVMFlagSet (const char *flag_name)
static Dart_Isolate	CreateIsolate (IsolateGroup *group, bool is_new_group, const char *name, void *isolate_data, char **error)
Isolate *	CreateWithinExistingIsolateGroup (IsolateGroup *group, const char *name, char **error)
DART_EXPORT void	Dart_IsolateFlagsInitialize (Dart_IsolateFlags *flags)
DART_EXPORT Dart_Isolate	Dart_CreateIsolateGroup (const char *script_uri, const char *name, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, Dart_IsolateFlags *flags, void *isolate_group_data, void *isolate_data, char **error)
DART_EXPORT Dart_Isolate	Dart_CreateIsolateGroupFromKernel (const char *script_uri, const char *name, const uint8_t *kernel_buffer, intptr_t kernel_buffer_size, Dart_IsolateFlags *flags, void *isolate_group_data, void *isolate_data, char **error)
DART_EXPORT Dart_Isolate	Dart_CreateIsolateInGroup (Dart_Isolate group_member, const char *name, Dart_IsolateShutdownCallback shutdown_callback, Dart_IsolateCleanupCallback cleanup_callback, void *child_isolate_data, char **error)
DART_EXPORT void	Dart_ShutdownIsolate ()
DART_EXPORT Dart_Isolate	Dart_CurrentIsolate ()
DART_EXPORT void *	Dart_CurrentIsolateData ()
DART_EXPORT void *	Dart_IsolateData (Dart_Isolate isolate)
DART_EXPORT Dart_IsolateGroup	Dart_CurrentIsolateGroup ()
DART_EXPORT void *	Dart_CurrentIsolateGroupData ()
DART_EXPORT Dart_IsolateGroupId	Dart_CurrentIsolateGroupId ()
DART_EXPORT void *	Dart_IsolateGroupData (Dart_Isolate isolate)
DART_EXPORT Dart_Handle	Dart_DebugName ()
DART_EXPORT const char *	Dart_DebugNameToCString ()
DART_EXPORT const char *	Dart_IsolateServiceId (Dart_Isolate isolate)
DART_EXPORT void	Dart_EnterIsolate (Dart_Isolate isolate)
DART_EXPORT void	Dart_StartProfiling ()
DART_EXPORT void	Dart_StopProfiling ()
DART_EXPORT void	Dart_ThreadDisableProfiling ()
DART_EXPORT void	Dart_ThreadEnableProfiling ()
DART_EXPORT void	Dart_AddSymbols (const char *dso_name, void *buffer, intptr_t buffer_size)
DART_EXPORT bool	Dart_WriteProfileToTimeline (Dart_Port main_port, char **error)
DART_EXPORT bool	Dart_ShouldPauseOnStart ()
DART_EXPORT void	Dart_SetShouldPauseOnStart (bool should_pause)
DART_EXPORT bool	Dart_IsPausedOnStart ()
DART_EXPORT void	Dart_SetPausedOnStart (bool paused)
DART_EXPORT bool	Dart_ShouldPauseOnExit ()
DART_EXPORT void	Dart_SetShouldPauseOnExit (bool should_pause)
DART_EXPORT bool	Dart_IsPausedOnExit ()
DART_EXPORT void	Dart_SetPausedOnExit (bool paused)
DART_EXPORT void	Dart_SetStickyError (Dart_Handle error)
DART_EXPORT bool	Dart_HasStickyError ()
DART_EXPORT Dart_Handle	Dart_GetStickyError ()
DART_EXPORT void	Dart_NotifyIdle (int64_t deadline)
DART_EXPORT void	Dart_NotifyDestroyed ()
DART_EXPORT void	Dart_EnableHeapSampling ()
DART_EXPORT void	Dart_DisableHeapSampling ()
DART_EXPORT void	Dart_RegisterHeapSamplingCallback (Dart_HeapSamplingCreateCallback create_callback, Dart_HeapSamplingDeleteCallback delete_callback)
DART_EXPORT void	Dart_ReportSurvivingAllocations (Dart_HeapSamplingReportCallback callback, void *context, bool force_gc)
DART_EXPORT void	Dart_SetHeapSamplingPeriod (intptr_t bytes)
DART_EXPORT void	Dart_NotifyLowMemory ()
DART_EXPORT Dart_PerformanceMode	Dart_SetPerformanceMode (Dart_PerformanceMode mode)
DART_EXPORT void	Dart_ExitIsolate ()
DART_EXPORT Dart_Handle	Dart_CreateSnapshot (uint8_t **vm_snapshot_data_buffer, intptr_t *vm_snapshot_data_size, uint8_t **isolate_snapshot_data_buffer, intptr_t *isolate_snapshot_data_size, bool is_core)
DART_EXPORT bool	Dart_IsKernel (const uint8_t *buffer, intptr_t buffer_size)
DART_EXPORT char *	Dart_IsolateMakeRunnable (Dart_Isolate isolate)
DART_EXPORT void	Dart_SetMessageNotifyCallback (Dart_MessageNotifyCallback message_notify_callback)
DART_EXPORT Dart_MessageNotifyCallback	Dart_GetMessageNotifyCallback ()
static void	RunLoopDone (uword param)
DART_EXPORT Dart_Handle	Dart_RunLoop ()
DART_EXPORT bool	Dart_RunLoopAsync (bool errors_are_fatal, Dart_Port on_error_port, Dart_Port on_exit_port, char **error)
DART_EXPORT Dart_Handle	Dart_HandleMessage ()
DART_EXPORT bool	Dart_HandleServiceMessages ()
DART_EXPORT bool	Dart_HasServiceMessages ()
DART_EXPORT bool	Dart_HasLivePorts ()
DART_EXPORT bool	Dart_Post (Dart_Port port_id, Dart_Handle handle)
DART_EXPORT Dart_Handle	Dart_NewSendPort (Dart_Port port_id)
DART_EXPORT Dart_Handle	Dart_SendPortGetId (Dart_Handle port, Dart_Port *port_id)
DART_EXPORT Dart_Port	Dart_GetMainPortId ()
DART_EXPORT void	Dart_EnterScope ()
DART_EXPORT void	Dart_ExitScope ()
DART_EXPORT uint8_t *	Dart_ScopeAllocate (intptr_t size)
DART_EXPORT Dart_Handle	Dart_Null ()
DART_EXPORT bool	Dart_IsNull (Dart_Handle object)
DART_EXPORT Dart_Handle	Dart_EmptyString ()
DART_EXPORT Dart_Handle	Dart_TypeDynamic ()
DART_EXPORT Dart_Handle	Dart_TypeVoid ()
DART_EXPORT Dart_Handle	Dart_TypeNever ()
DART_EXPORT Dart_Handle	Dart_ObjectEquals (Dart_Handle obj1, Dart_Handle obj2, bool *value)
static bool	InstanceIsType (const Thread *thread, const Instance &instance, const Type &type)
DART_EXPORT Dart_Handle	Dart_ObjectIsType (Dart_Handle object, Dart_Handle type, bool *value)
DART_EXPORT bool	Dart_IsInstance (Dart_Handle object)
DART_EXPORT bool	Dart_IsNumber (Dart_Handle object)
DART_EXPORT bool	Dart_IsInteger (Dart_Handle object)
DART_EXPORT bool	Dart_IsDouble (Dart_Handle object)
DART_EXPORT bool	Dart_IsBoolean (Dart_Handle object)
DART_EXPORT bool	Dart_IsString (Dart_Handle object)
DART_EXPORT bool	Dart_IsStringLatin1 (Dart_Handle object)
DART_EXPORT bool	Dart_IsList (Dart_Handle object)
DART_EXPORT bool	Dart_IsMap (Dart_Handle object)
DART_EXPORT bool	Dart_IsLibrary (Dart_Handle object)
DART_EXPORT bool	Dart_IsType (Dart_Handle handle)
DART_EXPORT bool	Dart_IsFunction (Dart_Handle handle)
DART_EXPORT bool	Dart_IsVariable (Dart_Handle handle)
DART_EXPORT bool	Dart_IsTypeVariable (Dart_Handle handle)
DART_EXPORT bool	Dart_IsClosure (Dart_Handle object)
DART_EXPORT bool	Dart_IsTearOff (Dart_Handle object)
DART_EXPORT bool	Dart_IsTypedData (Dart_Handle handle)
DART_EXPORT bool	Dart_IsByteBuffer (Dart_Handle handle)
DART_EXPORT bool	Dart_IsFuture (Dart_Handle handle)
DART_EXPORT Dart_Handle	Dart_InstanceGetType (Dart_Handle instance)
DART_EXPORT Dart_Handle	Dart_FunctionName (Dart_Handle function)
DART_EXPORT Dart_Handle	Dart_ClassName (Dart_Handle cls_type)
DART_EXPORT Dart_Handle	Dart_FunctionOwner (Dart_Handle function)
DART_EXPORT Dart_Handle	Dart_FunctionIsStatic (Dart_Handle function, bool *is_static)
DART_EXPORT Dart_Handle	Dart_ClosureFunction (Dart_Handle closure)
DART_EXPORT Dart_Handle	Dart_ClassLibrary (Dart_Handle cls_type)
DART_EXPORT Dart_Handle	Dart_IntegerFitsIntoInt64 (Dart_Handle integer, bool *fits)
DART_EXPORT Dart_Handle	Dart_IntegerFitsIntoUint64 (Dart_Handle integer, bool *fits)
DART_EXPORT Dart_Handle	Dart_NewInteger (int64_t value)
DART_EXPORT Dart_Handle	Dart_NewIntegerFromUint64 (uint64_t value)
DART_EXPORT Dart_Handle	Dart_NewIntegerFromHexCString (const char *str)
DART_EXPORT Dart_Handle	Dart_IntegerToInt64 (Dart_Handle integer, int64_t *value)
DART_EXPORT Dart_Handle	Dart_IntegerToUint64 (Dart_Handle integer, uint64_t *value)
DART_EXPORT Dart_Handle	Dart_IntegerToHexCString (Dart_Handle integer, const char **value)
DART_EXPORT Dart_Handle	Dart_NewDouble (double value)
DART_EXPORT Dart_Handle	Dart_DoubleValue (Dart_Handle double_obj, double *value)
DART_EXPORT Dart_Handle	Dart_GetStaticMethodClosure (Dart_Handle library, Dart_Handle cls_type, Dart_Handle function_name)
DART_EXPORT Dart_Handle	Dart_True ()
DART_EXPORT Dart_Handle	Dart_False ()
DART_EXPORT Dart_Handle	Dart_NewBoolean (bool value)
DART_EXPORT Dart_Handle	Dart_BooleanValue (Dart_Handle boolean_obj, bool *value)
DART_EXPORT Dart_Handle	Dart_StringLength (Dart_Handle str, intptr_t *len)
DART_EXPORT Dart_Handle	Dart_StringUTF8Length (Dart_Handle str, intptr_t *len)
DART_EXPORT Dart_Handle	Dart_NewStringFromCString (const char *str)
DART_EXPORT Dart_Handle	Dart_NewStringFromUTF8 (const uint8_t *utf8_array, intptr_t length)
DART_EXPORT Dart_Handle	Dart_NewStringFromUTF16 (const uint16_t *utf16_array, intptr_t length)
DART_EXPORT Dart_Handle	Dart_NewStringFromUTF32 (const int32_t *utf32_array, intptr_t length)
DART_EXPORT Dart_Handle	Dart_StringToCString (Dart_Handle object, const char **cstr)
DART_EXPORT Dart_Handle	Dart_StringToUTF8 (Dart_Handle str, uint8_t **utf8_array, intptr_t *length)
DART_EXPORT Dart_Handle	Dart_CopyUTF8EncodingOfString (Dart_Handle str, uint8_t *utf8_array, intptr_t length)
DART_EXPORT Dart_Handle	Dart_StringToLatin1 (Dart_Handle str, uint8_t *latin1_array, intptr_t *length)
DART_EXPORT Dart_Handle	Dart_StringToUTF16 (Dart_Handle str, uint16_t *utf16_array, intptr_t *length)
DART_EXPORT Dart_Handle	Dart_StringStorageSize (Dart_Handle str, intptr_t *size)
DART_EXPORT Dart_Handle	Dart_StringGetProperties (Dart_Handle object, intptr_t *char_size, intptr_t *str_len, void **peer)
DART_EXPORT Dart_Handle	Dart_NewList (intptr_t length)
static TypeArgumentsPtr	TypeArgumentsForElementType (ObjectStore *store, Dart_CoreType_Id element_type_id)
DART_EXPORT Dart_Handle	Dart_NewListOf (Dart_CoreType_Id element_type_id, intptr_t length)
static bool	CanTypeContainNull (const Type &type)
DART_EXPORT Dart_Handle	Dart_NewListOfType (Dart_Handle element_type, intptr_t length)
DART_EXPORT Dart_Handle	Dart_NewListOfTypeFilled (Dart_Handle element_type, Dart_Handle fill_object, intptr_t length)
DART_EXPORT Dart_Handle	Dart_ListLength (Dart_Handle list, intptr_t *len)
DART_EXPORT Dart_Handle	Dart_ListGetAt (Dart_Handle list, intptr_t index)
DART_EXPORT Dart_Handle	Dart_ListGetRange (Dart_Handle list, intptr_t offset, intptr_t length, Dart_Handle *result)
DART_EXPORT Dart_Handle	Dart_ListSetAt (Dart_Handle list, intptr_t index, Dart_Handle value)
static ObjectPtr	ResolveConstructor (const char *current_func, const Class &cls, const String &class_name, const String &dotted_name, int num_args)
static ObjectPtr	ThrowArgumentError (const char *exception_message)
DART_EXPORT Dart_Handle	Dart_ListGetAsBytes (Dart_Handle list, intptr_t offset, uint8_t *native_array, intptr_t length)
DART_EXPORT Dart_Handle	Dart_ListSetAsBytes (Dart_Handle list, intptr_t offset, const uint8_t *native_array, intptr_t length)
DART_EXPORT Dart_Handle	Dart_MapGetAt (Dart_Handle map, Dart_Handle key)
DART_EXPORT Dart_Handle	Dart_MapContainsKey (Dart_Handle map, Dart_Handle key)
DART_EXPORT Dart_Handle	Dart_MapKeys (Dart_Handle map)
static Dart_TypedData_Type	GetType (intptr_t class_id)
DART_EXPORT Dart_TypedData_Type	Dart_GetTypeOfTypedData (Dart_Handle object)
DART_EXPORT Dart_TypedData_Type	Dart_GetTypeOfExternalTypedData (Dart_Handle object)
static Dart_Handle	NewByteData (Thread *thread, intptr_t length)
static Dart_Handle	NewTypedData (Thread *thread, intptr_t cid, intptr_t length)
static Dart_Handle	NewExternalTypedData (Thread *thread, intptr_t cid, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback, bool unmodifiable)
static Dart_Handle	NewExternalByteData (Thread *thread, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback, bool unmodifiable)
DART_EXPORT Dart_Handle	Dart_NewTypedData (Dart_TypedData_Type type, intptr_t length)
static Dart_Handle	NewExternalTypedDataWithFinalizer (Dart_TypedData_Type type, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback, bool unmodifiable)
DART_EXPORT Dart_Handle	Dart_NewExternalTypedData (Dart_TypedData_Type type, void *data, intptr_t length)
DART_EXPORT Dart_Handle	Dart_NewExternalTypedDataWithFinalizer (Dart_TypedData_Type type, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT Dart_Handle	Dart_NewUnmodifiableExternalTypedDataWithFinalizer (Dart_TypedData_Type type, const void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
static ObjectPtr	GetByteBufferConstructor (Thread *thread, const String &class_name, const String &constructor_name, intptr_t num_args)
DART_EXPORT Dart_Handle	Dart_NewByteBuffer (Dart_Handle typed_data)
DART_EXPORT Dart_Handle	Dart_TypedDataAcquireData (Dart_Handle object, Dart_TypedData_Type *type, void **data, intptr_t *len)
DART_EXPORT Dart_Handle	Dart_TypedDataReleaseData (Dart_Handle object)
DART_EXPORT Dart_Handle	Dart_GetDataFromByteBuffer (Dart_Handle object)
DART_EXPORT Dart_Handle	Dart_New (Dart_Handle type, Dart_Handle constructor_name, int number_of_arguments, Dart_Handle *arguments)
static InstancePtr	AllocateObject (Thread *thread, const Class &cls)
DART_EXPORT Dart_Handle	Dart_Allocate (Dart_Handle type)
DART_EXPORT Dart_Handle	Dart_AllocateWithNativeFields (Dart_Handle type, intptr_t num_native_fields, const intptr_t *native_fields)
static Dart_Handle	SetupArguments (Thread *thread, int num_args, Dart_Handle *arguments, int extra_args, Array *args)
DART_EXPORT Dart_Handle	Dart_InvokeConstructor (Dart_Handle object, Dart_Handle name, int number_of_arguments, Dart_Handle *arguments)
DART_EXPORT Dart_Handle	Dart_Invoke (Dart_Handle target, Dart_Handle name, int number_of_arguments, Dart_Handle *arguments)
DART_EXPORT Dart_Handle	Dart_InvokeClosure (Dart_Handle closure, int number_of_arguments, Dart_Handle *arguments)
DART_EXPORT Dart_Handle	Dart_GetField (Dart_Handle container, Dart_Handle name)
DART_EXPORT Dart_Handle	Dart_SetField (Dart_Handle container, Dart_Handle name, Dart_Handle value)
DART_EXPORT Dart_Handle	Dart_ThrowException (Dart_Handle exception)
DART_EXPORT Dart_Handle	Dart_ReThrowException (Dart_Handle exception, Dart_Handle stacktrace)
DART_EXPORT Dart_Handle	Dart_GetNativeInstanceFieldCount (Dart_Handle obj, int *count)
DART_EXPORT Dart_Handle	Dart_GetNativeInstanceField (Dart_Handle obj, int index, intptr_t *value)
DART_EXPORT Dart_Handle	Dart_SetNativeInstanceField (Dart_Handle obj, int index, intptr_t value)
DART_EXPORT void *	Dart_GetNativeIsolateGroupData (Dart_NativeArguments args)
DART_EXPORT Dart_Handle	Dart_GetNativeArguments (Dart_NativeArguments args, int num_arguments, const Dart_NativeArgument_Descriptor *argument_descriptors, Dart_NativeArgument_Value *arg_values)
DART_EXPORT Dart_Handle	Dart_GetNativeArgument (Dart_NativeArguments args, int index)
DART_EXPORT int	Dart_GetNativeArgumentCount (Dart_NativeArguments args)
DART_EXPORT Dart_Handle	Dart_GetNativeFieldsOfArgument (Dart_NativeArguments args, int arg_index, int num_fields, intptr_t *field_values)
DART_EXPORT Dart_Handle	Dart_GetNativeReceiver (Dart_NativeArguments args, intptr_t *value)
DART_EXPORT Dart_Handle	Dart_GetNativeStringArgument (Dart_NativeArguments args, int arg_index, void **peer)
DART_EXPORT Dart_Handle	Dart_GetNativeIntegerArgument (Dart_NativeArguments args, int index, int64_t *value)
DART_EXPORT Dart_Handle	Dart_GetNativeBooleanArgument (Dart_NativeArguments args, int index, bool *value)
DART_EXPORT Dart_Handle	Dart_GetNativeDoubleArgument (Dart_NativeArguments args, int index, double *value)
DART_EXPORT void	Dart_SetReturnValue (Dart_NativeArguments args, Dart_Handle retval)
DART_EXPORT void	Dart_SetWeakHandleReturnValue (Dart_NativeArguments args, Dart_WeakPersistentHandle rval)
DART_EXPORT Dart_Handle	Dart_SetEnvironmentCallback (Dart_EnvironmentCallback callback)
DART_EXPORT void	Dart_SetBooleanReturnValue (Dart_NativeArguments args, bool retval)
DART_EXPORT void	Dart_SetIntegerReturnValue (Dart_NativeArguments args, int64_t retval)
DART_EXPORT void	Dart_SetDoubleReturnValue (Dart_NativeArguments args, double retval)
DART_EXPORT Dart_Handle	Dart_SetLibraryTagHandler (Dart_LibraryTagHandler handler)
DART_EXPORT Dart_Handle	Dart_DefaultCanonicalizeUrl (Dart_Handle base_url, Dart_Handle url)
DART_EXPORT Dart_Handle	Dart_SetDeferredLoadHandler (Dart_DeferredLoadHandler handler)
DART_EXPORT Dart_Handle	Dart_LoadScriptFromKernel (const uint8_t *buffer, intptr_t buffer_size)
DART_EXPORT Dart_Handle	Dart_RootLibrary ()
DART_EXPORT Dart_Handle	Dart_SetRootLibrary (Dart_Handle library)
DART_EXPORT Dart_Handle	Dart_GetClass (Dart_Handle library, Dart_Handle class_name)
static Dart_Handle	GetTypeCommon (Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments, Nullability nullability)
DART_EXPORT Dart_Handle	Dart_GetType (Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
DART_EXPORT Dart_Handle	Dart_GetNullableType (Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
DART_EXPORT Dart_Handle	Dart_GetNonNullableType (Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
static Dart_Handle	TypeToHelper (Dart_Handle type, Nullability nullability)
DART_EXPORT Dart_Handle	Dart_TypeToNullableType (Dart_Handle type)
DART_EXPORT Dart_Handle	Dart_TypeToNonNullableType (Dart_Handle type)
static Dart_Handle	IsOfTypeNullabilityHelper (Dart_Handle type, Nullability nullability, bool *result)
DART_EXPORT Dart_Handle	Dart_IsNullableType (Dart_Handle type, bool *result)
DART_EXPORT Dart_Handle	Dart_IsNonNullableType (Dart_Handle type, bool *result)
DART_EXPORT Dart_Handle	Dart_IsLegacyType (Dart_Handle type, bool *result)
DART_EXPORT Dart_Handle	Dart_LibraryUrl (Dart_Handle library)
DART_EXPORT Dart_Handle	Dart_LibraryResolvedUrl (Dart_Handle library)
DART_EXPORT Dart_Handle	Dart_GetLoadedLibraries ()
DART_EXPORT Dart_Handle	Dart_LookupLibrary (Dart_Handle url)
DART_EXPORT Dart_Handle	Dart_LibraryHandleError (Dart_Handle library_in, Dart_Handle error_in)
static Dart_Handle	LoadLibrary (Thread *T, const ExternalTypedData &td)
DART_EXPORT Dart_Handle	Dart_LoadLibraryFromKernel (const uint8_t *buffer, intptr_t buffer_size)
DART_EXPORT Dart_Handle	Dart_LoadLibrary (Dart_Handle kernel_buffer)
DART_EXPORT Dart_Handle	Dart_FinalizeLoading (bool complete_futures)
static Dart_Handle	DeferredLoadComplete (intptr_t loading_unit_id, bool error, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, const char *error_message, bool transient_error)
DART_EXPORT Dart_Handle	Dart_DeferredLoadComplete (intptr_t loading_unit_id, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions)
DART_EXPORT Dart_Handle	Dart_DeferredLoadCompleteError (intptr_t loading_unit_id, const char *error_message, bool transient)
DART_EXPORT Dart_Handle	Dart_SetNativeResolver (Dart_Handle library, Dart_NativeEntryResolver resolver, Dart_NativeEntrySymbol symbol)
DART_EXPORT Dart_Handle	Dart_GetNativeResolver (Dart_Handle library, Dart_NativeEntryResolver *resolver)
DART_EXPORT Dart_Handle	Dart_GetNativeSymbol (Dart_Handle library, Dart_NativeEntrySymbol *resolver)
DART_EXPORT Dart_Handle	Dart_SetFfiNativeResolver (Dart_Handle library, Dart_FfiNativeResolver resolver)
DART_EXPORT Dart_Handle	Dart_GetPeer (Dart_Handle object, void **peer)
DART_EXPORT Dart_Handle	Dart_SetPeer (Dart_Handle object, void *peer)
DART_EXPORT bool	Dart_IsKernelIsolate (Dart_Isolate isolate)
DART_EXPORT bool	Dart_KernelIsolateIsRunning ()
DART_EXPORT Dart_Port	Dart_KernelPort ()
DART_EXPORT Dart_KernelCompilationResult	Dart_CompileToKernel (const char *script_uri, const uint8_t *platform_kernel, intptr_t platform_kernel_size, bool incremental_compile, bool for_snapshot, bool embed_sources, const char *package_config, Dart_KernelCompilationVerbosityLevel verbosity)
DART_EXPORT Dart_KernelCompilationResult	Dart_KernelListDependencies ()
DART_EXPORT void	Dart_SetDartLibrarySourcesKernel (const uint8_t *platform_kernel, const intptr_t platform_kernel_size)
DART_EXPORT bool	Dart_DetectNullSafety (const char *script_uri, const char *package_config, const char *original_working_directory, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
DART_EXPORT bool	Dart_IsServiceIsolate (Dart_Isolate isolate)
DART_EXPORT void	Dart_RegisterIsolateServiceRequestCallback (const char *name, Dart_ServiceRequestCallback callback, void *user_data)
DART_EXPORT void	Dart_RegisterRootServiceRequestCallback (const char *name, Dart_ServiceRequestCallback callback, void *user_data)
DART_EXPORT void	Dart_SetEmbedderInformationCallback (Dart_EmbedderInformationCallback callback)
DART_EXPORT char *	Dart_SetServiceStreamCallbacks (Dart_ServiceStreamListenCallback listen_callback, Dart_ServiceStreamCancelCallback cancel_callback)
DART_EXPORT char *	Dart_ServiceSendDataEvent (const char *stream_id, const char *event_kind, const uint8_t *bytes, intptr_t bytes_length)
DART_EXPORT void	Dart_SetDwarfStackTraceFootnoteCallback (Dart_DwarfStackTraceFootnoteCallback callback)
DART_EXPORT char *	Dart_SetFileModifiedCallback (Dart_FileModifiedCallback file_modified_callback)
DART_EXPORT bool	Dart_IsReloading ()
DART_EXPORT bool	Dart_SetEnabledTimelineCategory (const char *categories)
DART_EXPORT int64_t	Dart_TimelineGetMicros ()
DART_EXPORT int64_t	Dart_TimelineGetTicks ()
DART_EXPORT int64_t	Dart_TimelineGetTicksFrequency ()
DART_EXPORT void	Dart_RecordTimelineEvent (const char *label, int64_t timestamp0, int64_t timestamp1_or_id, intptr_t flow_id_count, const int64_t *flow_ids, Dart_Timeline_Event_Type type, intptr_t argument_count, const char **argument_names, const char **argument_values)
DART_EXPORT void	Dart_SetTimelineRecorderCallback (Dart_TimelineRecorderCallback callback)
DART_EXPORT void	Dart_SetThreadName (const char *name)
DART_EXPORT Dart_Handle	Dart_SortClasses ()
DART_EXPORT Dart_Handle	Dart_Precompile ()
DART_EXPORT Dart_Handle	Dart_CreateAppAOTSnapshotAsAssembly (Dart_StreamingWriteCallback callback, void *callback_data, bool strip, void *debug_callback_data)
DART_EXPORT Dart_Handle	Dart_CreateAppAOTSnapshotAsAssemblies (Dart_CreateLoadingUnitCallback next_callback, void *next_callback_data, bool strip, Dart_StreamingWriteCallback write_callback, Dart_StreamingCloseCallback close_callback)
DART_EXPORT Dart_Handle	Dart_CreateVMAOTSnapshotAsAssembly (Dart_StreamingWriteCallback callback, void *callback_data)
DART_EXPORT Dart_Handle	Dart_CreateAppAOTSnapshotAsElf (Dart_StreamingWriteCallback callback, void *callback_data, bool strip, void *debug_callback_data)
DART_EXPORT Dart_Handle	Dart_CreateAppAOTSnapshotAsElfs (Dart_CreateLoadingUnitCallback next_callback, void *next_callback_data, bool strip, Dart_StreamingWriteCallback write_callback, Dart_StreamingCloseCallback close_callback)
DART_EXPORT Dart_Handle	Dart_LoadingUnitLibraryUris (intptr_t loading_unit_id)
static void	DropRegExpMatchCode (Zone *zone)
static void	KillNonMainIsolatesSlow (Thread *thread, Isolate *main_isolate)
DART_EXPORT Dart_Handle	Dart_CreateAppJITSnapshotAsBlobs (uint8_t **isolate_snapshot_data_buffer, intptr_t *isolate_snapshot_data_size, uint8_t **isolate_snapshot_instructions_buffer, intptr_t *isolate_snapshot_instructions_size)
DART_EXPORT Dart_Handle	Dart_GetObfuscationMap (uint8_t **buffer, intptr_t *buffer_length)
DART_EXPORT bool	Dart_IsPrecompiledRuntime ()
DART_EXPORT Dart_Handle	Dart_GetCurrentUserTag ()
DART_EXPORT Dart_Handle	Dart_GetDefaultUserTag ()
DART_EXPORT Dart_Handle	Dart_NewUserTag (const char *label)
DART_EXPORT Dart_Handle	Dart_SetCurrentUserTag (Dart_Handle user_tag)
DART_EXPORT char *	Dart_GetUserTagLabel (Dart_Handle user_tag)
DART_EXPORT char *	Dart_WriteHeapSnapshot (Dart_HeapSnapshotWriteChunkCallback write, void *context)
	DECLARE_FLAG (bool, verify_acquired_data)
	DECLARE_FLAG (bool, complete_timeline)
	UNIT_TEST_CASE (DartAPI_DartInitializeAfterCleanup)
	UNIT_TEST_CASE (DartAPI_DartInitializeCallsCodeObserver)
	UNIT_TEST_CASE (DartAPI_DartInitializeHeapSizes)
	TEST_CASE (Dart_KillIsolate)
	TEST_CASE (Dart_KillIsolatePriority)
	TEST_CASE (DartAPI_ErrorHandleBasics)
	TEST_CASE (DartAPI_StackTraceInfo)
	TEST_CASE (DartAPI_DeepStackTraceInfo)
void	VerifyStackOverflowStackTraceInfo (const char *script, const char *top_frame_func_name, const char *entry_func_name, int expected_line_number, int expected_column_number)
	TEST_CASE (DartAPI_StackOverflowStackTraceInfoBraceFunction1)
	TEST_CASE (DartAPI_StackOverflowStackTraceInfoBraceFunction2)
	TEST_CASE (DartAPI_StackOverflowStackTraceInfoArrowFunction)
	TEST_CASE (DartAPI_OutOfMemoryStackTraceInfo)
void	CurrentStackTraceNative (Dart_NativeArguments args)
static Dart_NativeFunction	CurrentStackTraceNativeLookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_CurrentStackTraceInfo)
	TEST_CASE (DartAPI_ErrorHandleTypes)
	TEST_CASE (DartAPI_UnhandleExceptionError)
void	JustPropagateErrorNative (Dart_NativeArguments args)
static Dart_NativeFunction	JustPropagateError_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_EnsureUnwindErrorHandled_WhenKilled)
	TEST_CASE (DartAPI_EnsureUnwindErrorHandled_WhenSendAndExit)
void	PropagateErrorNative (Dart_NativeArguments args)
static Dart_NativeFunction	PropagateError_native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_PropagateCompileTimeError)
	TEST_CASE (DartAPI_PropagateError)
	TEST_CASE (DartAPI_Error)
	TEST_CASE (DartAPI_Null)
	TEST_CASE (DartAPI_EmptyString)
	TEST_CASE (DartAPI_TypeDynamic)
	TEST_CASE (DartAPI_TypeVoid)
	TEST_CASE (DartAPI_TypeNever)
	TEST_CASE (DartAPI_IdentityEquals)
	TEST_CASE (DartAPI_ObjectEquals)
	TEST_CASE (DartAPI_InstanceValues)
	TEST_CASE (DartAPI_InstanceGetType)
	TEST_CASE (DartAPI_FunctionName)
	TEST_CASE (DartAPI_FunctionOwner)
	TEST_CASE (DartAPI_IsTearOff)
	TEST_CASE (DartAPI_FunctionIsStatic)
	TEST_CASE (DartAPI_ClosureFunction)
	TEST_CASE (DartAPI_GetStaticMethodClosure)
	TEST_CASE (DartAPI_ClassLibrary)
	TEST_CASE (DartAPI_BooleanValues)
	TEST_CASE (DartAPI_BooleanConstants)
	TEST_CASE (DartAPI_DoubleValues)
	TEST_CASE (DartAPI_NumberValues)
	TEST_CASE (DartAPI_IntegerValues)
	TEST_CASE (DartAPI_IntegerToHexCString)
	TEST_CASE (DartAPI_IntegerFitsIntoInt64)
	TEST_CASE (DartAPI_IntegerFitsIntoUint64)
	TEST_CASE (DartAPI_ArrayValues)
	TEST_CASE (DartAPI_IsString)
	TEST_CASE (DartAPI_NewString)
	TEST_CASE (DartAPI_MalformedStringToUTF8)
	TEST_CASE (DartAPI_CopyUTF8EncodingOfString)
	TEST_CASE (DartAPI_ExternalTypedDataPretenure)
	TEST_CASE (DartAPI_ListAccess)
	TEST_CASE (DartAPI_MapAccess)
	TEST_CASE (DartAPI_IsFuture)
	TEST_CASE (DartAPI_TypedDataViewListGetAsBytes)
	TEST_CASE (DartAPI_TypedDataViewListIsTypedData)
	TEST_CASE (DartAPI_UnmodifiableTypedDataViewListIsTypedData)
	TEST_CASE (DartAPI_TypedDataAccess)
	TEST_CASE (DartAPI_ByteBufferAccess)
static void	ByteDataNativeFunction (Dart_NativeArguments args)
static Dart_NativeFunction	ByteDataNativeResolver (Dart_Handle name, int arg_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_ByteDataAccess)
static void	ExternalByteDataNativeFunction (Dart_NativeArguments args)
static Dart_NativeFunction	ExternalByteDataNativeResolver (Dart_Handle name, int arg_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_ExternalByteDataAccess)
void	ByteDataFinalizer (void *isolate_data, void *peer)
	TEST_CASE (DartAPI_ExternalByteDataFinalizer)
static void	OptExternalByteDataNativeFunction (Dart_NativeArguments args)
static Dart_NativeFunction	OptExternalByteDataNativeResolver (Dart_Handle name, int arg_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_OptimizedExternalByteDataAccess)
static void	TestTypedDataDirectAccess ()
	TEST_CASE (DartAPI_TypedDataDirectAccessUnverified)
	TEST_CASE (DartAPI_TypedDataDirectAccessVerified)
static void	TestDirectAccess (Dart_Handle lib, Dart_Handle array, Dart_TypedData_Type expected_type, bool is_external)
static void	TestTypedDataDirectAccess1 ()
	TEST_CASE (DartAPI_TypedDataDirectAccess1Unverified)
	TEST_CASE (DartAPI_TypedDataDirectAccess1Verified)
static void	TestTypedDataViewDirectAccess ()
	TEST_CASE (DartAPI_TypedDataViewDirectAccessUnverified)
	TEST_CASE (DartAPI_TypedDataViewDirectAccessVerified)
static void	TestUnmodifiableTypedDataViewDirectAccess ()
	TEST_CASE (DartAPI_UnmodifiableTypedDataViewDirectAccessUnverified)
	TEST_CASE (DartAPI_UnmodifiableTypedDataViewDirectAccessVerified)
static void	TestByteDataDirectAccess ()
	TEST_CASE (DartAPI_ByteDataDirectAccessUnverified)
	TEST_CASE (DartAPI_ByteDataDirectAccessVerified)
	TEST_CASE (DartAPI_NewUnmodifiableExternalTypedDataWithFinalizer)
	TEST_CASE (DartAPI_UnmodifiableTypedData_PassByReference)
static void	NopCallback (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_ExternalAllocationDuringNoCallbackScope)
static void	ExternalTypedDataAccessTests (Dart_Handle obj, Dart_TypedData_Type expected_type, uint8_t data[], intptr_t data_length)
	TEST_CASE (DartAPI_ExternalTypedDataAccess)
	TEST_CASE (DartAPI_ExternalClampedTypedDataAccess)
	TEST_CASE (DartAPI_ExternalUint8ClampedArrayAccess)
static void	UnreachedCallback (void *isolate_callback_data, void *peer)
static void	ExternalTypedDataFinalizer (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_ExternalTypedDataCallback)
static void	SlowFinalizer (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_SlowFinalizer)
static void	SlowWeakPersistentHandle (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_SlowWeakPersistentHandle)
static void	CheckFloat32x4Data (Dart_Handle obj)
	TEST_CASE (DartAPI_Float32x4List)
	VM_UNIT_TEST_CASE (DartAPI_EnterExitScope)
	VM_UNIT_TEST_CASE (DartAPI_PersistentHandles)
	VM_UNIT_TEST_CASE (DartAPI_NewPersistentHandle_FromPersistentHandle)
	VM_UNIT_TEST_CASE (DartAPI_AssignToPersistentHandle)
static Dart_Handle	AllocateNewString (const char *c_str)
static Dart_Handle	AllocateOldString (const char *c_str)
static Dart_Handle	AsHandle (Dart_PersistentHandle weak)
static Dart_Handle	AsHandle (Dart_WeakPersistentHandle weak)
	TEST_CASE (DartAPI_WeakPersistentHandle)
static void	FinalizableHandleCallback (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_FinalizableHandle)
	TEST_CASE (DartAPI_WeakPersistentHandleErrors)
	TEST_CASE (DartAPI_FinalizableHandleErrors)
static void	WeakPersistentHandlePeerCleanupEnsuresIGFinalizer (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_WeakPersistentHandleCleanupFinalizerAtShutdown)
static void	WeakPersistentHandlePeerCleanupFinalizer (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_WeakPersistentHandleCleanupFinalizer)
static void	FinalizableHandlePeerCleanupFinalizer (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_FinalizableHandleCleanupFinalizer)
static void	WeakPersistentHandlePeerFinalizer (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_WeakPersistentHandleCallback)
static void	FinalizableHandlePeerFinalizer (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_FinalizableHandleCallback)
	TEST_CASE (DartAPI_WeakPersistentHandleNoCallback)
	TEST_CASE (DartAPI_FinalizableHandleNoCallback)
static void	DeleteWeakHandleOnFinalization (void *isolate_callback_data, void *peer)
static void	DontDeleteWeakHandleOnFinalization (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_WeakPersistentHandleCallbackSelfDelete)
	VM_UNIT_TEST_CASE (DartAPI_WeakPersistentHandlesCallbackShutdown)
	VM_UNIT_TEST_CASE (DartAPI_FinalizableHandlesCallbackShutdown)
	TEST_CASE (DartAPI_WeakPersistentHandleExternalAllocationSize)
	TEST_CASE (DartAPI_FinalizableHandleExternalAllocationSize)
	TEST_CASE (DartAPI_WeakPersistentHandleExternalAllocationSizeNewspaceGC)
	TEST_CASE (DartAPI_FinalizableHandleExternalAllocationSizeNewspaceGC)
	TEST_CASE (DartAPI_WeakPersistentHandleExternalAllocationSizeOldspaceGC)
	TEST_CASE (DartAPI_FinalizableHandleExternalAllocationSizeOldspaceGC)
	TEST_CASE (DartAPI_WeakPersistentHandleExternalAllocationSizeOddReferents)
	TEST_CASE (DartAPI_FinalizableHandleExternalAllocationSizeOddReferents)
void FUNCTION_NAME()	SecretKeeper_KeepSecret (Dart_NativeArguments native_args)
static Dart_NativeFunction	SecretKeeperNativeResolver (Dart_Handle name, int argument_count, bool *auto_setup_scope)
static intptr_t	ReturnPtrAsInt (void *ptr)
static void *	SecretKeeperFfiNativeResolver (const char *name, uintptr_t argn)
	TEST_CASE (DartAPI_NativeFieldAccess)
	TEST_CASE (DartAPI_NativeFieldAccess_Throws)
static void	ImplicitReferencesCallback (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_ImplicitReferencesOldSpace)
	TEST_CASE (DartAPI_ImplicitReferencesNewSpace)
	VM_UNIT_TEST_CASE (DartAPI_LocalHandles)
	VM_UNIT_TEST_CASE (DartAPI_LocalZoneMemory)
	VM_UNIT_TEST_CASE (DartAPI_Isolates)
	VM_UNIT_TEST_CASE (DartAPI_IsolateGroups)
	VM_UNIT_TEST_CASE (DartAPI_CurrentIsolateData)
static Dart_Handle	LoadScript (const char *url_str, const char *source)
	TEST_CASE (DartAPI_DebugName)
	TEST_CASE (DartAPI_IsolateServiceID)
static void	MyMessageNotifyCallback (Dart_Isolate dest_isolate)
	VM_UNIT_TEST_CASE (DartAPI_SetMessageCallbacks)
	TEST_CASE (DartAPI_SetStickyError)
	TEST_CASE (DartAPI_TypeGetNonParametricTypes)
	TEST_CASE (DartAPI_TypeGetParameterizedTypes)
static void	TestFieldOk (Dart_Handle container, Dart_Handle name, bool final, const char *initial_value)
static void	TestFieldNotFound (Dart_Handle container, Dart_Handle name)
	TEST_CASE (DartAPI_FieldAccess)
	TEST_CASE (DartAPI_SetField_FunnyValue)
	TEST_CASE (DartAPI_SetField_BadType)
void	NativeFieldLookup (Dart_NativeArguments args)
static Dart_NativeFunction	native_field_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_InjectNativeFields2)
	TEST_CASE (DartAPI_InjectNativeFields3)
	TEST_CASE (DartAPI_InjectNativeFields4)
void	TestNativeFieldsAccess_init (Dart_NativeArguments args)
void	TestNativeFieldsAccess_access (Dart_NativeArguments args)
void	TestNativeFieldsAccess_invalidAccess (Dart_NativeArguments args)
static Dart_NativeFunction	TestNativeFieldsAccess_lookup (Dart_Handle name, int argument_count, bool *auto_scope)
	TEST_CASE (DartAPI_TestNativeFieldsAccess)
	TEST_CASE (DartAPI_InjectNativeFieldsSuperClass)
static void	TestNativeFields (Dart_Handle retobj)
	TEST_CASE (DartAPI_ImplicitNativeFieldAccess)
	TEST_CASE (DartAPI_NegativeNativeFieldAccess)
	TEST_CASE (DartAPI_GetStaticField_RunsInitializer)
	TEST_CASE (DartAPI_GetField_CheckIsolate)
	TEST_CASE (DartAPI_SetField_CheckIsolate)
	TEST_CASE (DartAPI_New)
	TEST_CASE (DartAPI_New_Issue42939)
	TEST_CASE (DartAPI_New_Issue44205)
	TEST_CASE (DartAPI_InvokeConstructor_Issue44205)
	TEST_CASE (DartAPI_InvokeClosure_Issue44205)
	TEST_CASE (DartAPI_NewListOf)
	TEST_CASE (DartAPI_NewListOfType)
	TEST_CASE (DartAPI_NewListOfTypeFilled)
static Dart_Handle	PrivateLibName (Dart_Handle lib, const char *str)
	TEST_CASE (DartAPI_Invoke)
	TEST_CASE (DartAPI_Invoke_PrivateStatic)
	TEST_CASE (DartAPI_Invoke_FunnyArgs)
	TEST_CASE (DartAPI_Invoke_BadArgs)
	TEST_CASE (DartAPI_Invoke_Null)
	TEST_CASE (DartAPI_InvokeNoSuchMethod)
	TEST_CASE (DartAPI_InvokeClosure)
void	ExceptionNative (Dart_NativeArguments args)
static Dart_NativeFunction	native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_ThrowException)
static void	NativeArgumentCreate (Dart_NativeArguments args)
static void	NativeArgumentAccess (Dart_NativeArguments args)
static Dart_NativeFunction	native_args_lookup (Dart_Handle name, int argument_count, bool *auto_scope_setup)
	TEST_CASE (DartAPI_GetNativeArguments)
static void	NativeArgumentCounter (Dart_NativeArguments args)
static Dart_NativeFunction	gnac_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_GetNativeArgumentCount)
	TEST_CASE (DartAPI_TypeToNullability)
	TEST_CASE (DartAPI_GetNullableType)
	TEST_CASE (DartAPI_GetNonNullableType)
	TEST_CASE (DartAPI_InstanceOf)
	TEST_CASE (DartAPI_RootLibrary)
	TEST_CASE (DartAPI_LookupLibrary)
	TEST_CASE (DartAPI_LibraryUrl)
static void	MyNativeFunction1 (Dart_NativeArguments args)
static void	MyNativeFunction2 (Dart_NativeArguments args)
static Dart_NativeFunction	MyNativeResolver1 (Dart_Handle name, int arg_count, bool *auto_setup_scope)
static Dart_NativeFunction	MyNativeResolver2 (Dart_Handle name, int arg_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_SetNativeResolver)
	TEST_CASE (DartAPI_ImportLibrary2)
	TEST_CASE (DartAPI_ImportLibrary3)
	TEST_CASE (DartAPI_ImportLibrary4)
	TEST_CASE (DartAPI_ImportLibrary5)
	TEST_CASE (DartAPI_Multiroot_Valid)
	TEST_CASE (DartAPI_Multiroot_FailWhenUriIsWrong)
static void	NewNativePort_send123 (Dart_Port dest_port_id, Dart_CObject *message)
static void	NewNativePort_send321 (Dart_Port dest_port_id, Dart_CObject *message)
	TEST_CASE (DartAPI_IllegalNewSendPort)
	TEST_CASE (DartAPI_IllegalPost)
static void	UnreachableFinalizer (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_PostCObject_DoesNotRunFinalizerOnFailure)
	VM_UNIT_TEST_CASE (DartAPI_NewNativePort)
static void	NewNativePort_sendInteger123 (Dart_Port dest_port_id, Dart_CObject *message)
static void	NewNativePort_sendInteger321 (Dart_Port dest_port_id, Dart_CObject *message)
	TEST_CASE (DartAPI_NativePortPostInteger)
static void	NewNativePort_Transferrable1 (Dart_Port dest_port_id, Dart_CObject *message)
static void	NewNativePort_Transferrable2 (Dart_Port dest_port_id, Dart_CObject *message)
	TEST_CASE (DartAPI_NativePortPostTransferrableTypedData)
static void	NewNativePort_ExternalTypedData (Dart_Port dest_port_id, Dart_CObject *message)
static void	FinalizeTypedData (void *isolate_callback_data, void *peer)
	TEST_CASE (DartAPI_NativePortPostExternalTypedData)
static void	UnreachableMessageHandler (Dart_Port dest_port_id, Dart_CObject *message)
	TEST_CASE (DartAPI_NativePortPostUserClass)
static void	NewNativePort_nativeReceiveNull (Dart_Port dest_port_id, Dart_CObject *message)
	TEST_CASE (DartAPI_NativePortReceiveNull)
static void	NewNativePort_nativeReceiveInteger (Dart_Port dest_port_id, Dart_CObject *message)
	TEST_CASE (DartAPI_NativePortReceiveInteger)
static Dart_Isolate	RunLoopTestCallback (const char *script_name, const char *main, const char *package_root, const char *package_config, Dart_IsolateFlags *flags, void *data, char **error)
static void	RunLoopTest (bool throw_exception)
	VM_UNIT_TEST_CASE (DartAPI_RunLoop_Success)
	VM_UNIT_TEST_CASE (DartAPI_RunLoop_Exception)
static void	IsolateShutdownTestCallback (void *group_data, void *isolate_data)
static void	IsolateCleanupTestCallback (void *group_data, void *isolate_data)
static void	IsolateGroupCleanupTestCallback (void *callback_data)
	VM_UNIT_TEST_CASE (DartAPI_IsolateShutdownAndCleanup)
static void	IsolateShutdownRunDartCodeTestCallback (void *isolate_group_data, void *isolate_data)
	VM_UNIT_TEST_CASE (DartAPI_IsolateShutdownRunDartCode)
static int64_t	GetValue (Dart_Handle arg)
static void	NativeFoo1 (Dart_NativeArguments args)
static void	NativeFoo2 (Dart_NativeArguments args)
static void	NativeFoo3 (Dart_NativeArguments args)
static void	NativeFoo4 (Dart_NativeArguments args)
static Dart_NativeFunction	MyNativeClosureResolver (Dart_Handle name, int arg_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_NativeFunctionClosure)
static void	StaticNativeFoo1 (Dart_NativeArguments args)
static void	StaticNativeFoo2 (Dart_NativeArguments args)
static void	StaticNativeFoo3 (Dart_NativeArguments args)
static void	StaticNativeFoo4 (Dart_NativeArguments args)
static Dart_NativeFunction	MyStaticNativeClosureResolver (Dart_Handle name, int arg_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_NativeStaticFunctionClosure)
	TEST_CASE (DartAPI_RangeLimits)
	TEST_CASE (DartAPI_NewString_Null)
	TEST_CASE (DartAPI_InvalidGetSetPeer)
	TEST_CASE (DartAPI_OneNewSpacePeer)
	TEST_CASE (DartAPI_CollectOneNewSpacePeer)
	TEST_CASE (DartAPI_TwoNewSpacePeers)
	TEST_CASE (DartAPI_CollectTwoNewSpacePeers)
	TEST_CASE (DartAPI_CopyNewSpacePeers)
	TEST_CASE (DartAPI_OnePromotedPeer)
	TEST_CASE (DartAPI_OneOldSpacePeer)
	TEST_CASE (DartAPI_CollectOneOldSpacePeer)
	TEST_CASE (DartAPI_TwoOldSpacePeers)
	TEST_CASE (DartAPI_CollectTwoOldSpacePeers)
	TEST_CASE (DartAPI_StringFromExternalTypedData)
	TEST_CASE (DartAPI_TimelineDuration)
	TEST_CASE (DartAPI_TimelineBegin)
	TEST_CASE (DartAPI_TimelineEnd)
	TEST_CASE (DartAPI_TimelineInstant)
	TEST_CASE (DartAPI_TimelineAsyncDisabled)
	TEST_CASE (DartAPI_TimelineAsync)
	TEST_CASE (DartAPI_TimelineClock)
	TEST_CASE (DartAPI_TimelineCategories)
static void	NotifyIdleShortNative (Dart_NativeArguments args)
static Dart_NativeFunction	NotifyIdleShort_native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_NotifyIdleShort)
static void	NotifyIdleLongNative (Dart_NativeArguments args)
static Dart_NativeFunction	NotifyIdleLong_native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_NotifyIdleLong)
static void	NotifyDestroyedNative (Dart_NativeArguments args)
static Dart_NativeFunction	NotifyDestroyed_native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_NotifyDestroyed)
static void	SetPerformanceModeDefault (Dart_NativeArguments args)
static void	SetPerformanceModeLatency (Dart_NativeArguments args)
static Dart_NativeFunction	SetMode_native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_SetPerformanceMode)
static void	NotifyLowMemoryNative (Dart_NativeArguments args)
static Dart_NativeFunction	NotifyLowMemory_native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DartAPI_NotifyLowMemory)
	TEST_CASE (DartAPI_InvokeImportedFunction)
	TEST_CASE (DartAPI_InvokeVMServiceMethod)
static void	InvokeServiceMessages (uword param)
	TEST_CASE (DartAPI_InvokeVMServiceMethod_Loop)
static void	HandleResponse (Dart_Port dest_port_id, Dart_CObject *message)
static void	CreateNativePorts (uword param)
	TEST_CASE (DartAPI_NativePort_Loop)
static void	ReportTimelineEvents ()
	TEST_CASE (DartAPI_TimelineEvents_Serialization)
static void	CreateTimelineEvents (uword param)
	UNIT_TEST_CASE (DartAPI_TimelineEvents_Loop)
	UNIT_TEST_CASE (DartAPI_TimelineEvents_NullFlowIdsHandledGracefully)
static intptr_t	EchoInt (double x)
static void *	FfiNativeResolver (const char *name, uintptr_t args_n)
	TEST_CASE (Dart_SetFfiNativeResolver)
	TEST_CASE (Dart_SetFfiNativeResolver_MissingResolver)
static void *	NopResolver (const char *name, uintptr_t args_n)
	TEST_CASE (Dart_SetFfiNativeResolver_DoesNotResolve)
	TEST_CASE (DartAPI_UserTags)
static void *	HeapSamplingCreate (Dart_Isolate isolate, Dart_IsolateGroup isolate_group, const char *cls_name, intptr_t heap_size)
static void	HeapSamplingDelete (void *data)
void	HeapSamplingReport (void *context, void *data)
void	ResetHeapSamplingState (const char *expected_cls=nullptr)
void	HandleInterrupts (Thread *thread)
void	InitHeapSampling (Thread *thread, const char *expected_cls)
	TEST_CASE (DartAPI_HeapSampling_UserDefinedClass)
	TEST_CASE (DartAPI_HeapSampling_APIAllocations)
	TEST_CASE (DartAPI_HeapSampling_NonTrivialSamplingPeriod)
	VM_UNIT_TEST_CASE (DartAPI_HeapSampling_CorrectSamplingIntervalForOldSpaceAllocations)
void	ProtectedHandleCallback (void *peer)
	DECLARE_FLAG (bool, precompiled_mode)
static void	DebuggerSetResumeIfStepping (Isolate *isolate)
static ObjectPtr	RehashObjects (Zone *zone, const Library &library, const Object &array_or_growable_array)
	TEST_CASE (BaseWriteStream_Write)
	TEST_CASE (BaseWriteStream_WriteUnsigned)
template<typename T >
void	TestRaw ()
	TEST_CASE (ReadStream_Read16)
	TEST_CASE (ReadStream_Read32)
	TEST_CASE (ReadStream_Read64)
	TEST_CASE (BaseWriteStream_WriteLEB128)
	TEST_CASE (BaseWriteStream_WriteSLEB128)
	DEFINE_FLAG (bool, trace_debugger_stacktrace, false, "Trace debugger stacktrace collection")
	DEFINE_FLAG (bool, trace_rewind, false, "Trace frame rewind")
	DEFINE_FLAG (bool, verbose_debug, false, "Verbose debugger messages")
	DECLARE_FLAG (bool, trace_deoptimization)
	DECLARE_FLAG (bool, warn_on_pause_with_no_debugger)
static void	InvokeEventHandler (ServiceEvent *event)
static const char *	QualifiedFunctionName (const Function &func)
static bool	FunctionOverlaps (const Function &func, const String &script_url, TokenPosition token_pos, TokenPosition end_token_pos)
static bool	IsImplicitFunction (const Function &func)
static DART_FORCE_INLINE ObjectPtr	GetVariableValue (uword addr)
static bool	IsSyntheticVariableName (const String &var_name)
static bool	IsPrivateVariableName (const String &var_name)
static bool	IsFunctionVisible (const Function &function)
static ActivationFrame *	TopDartFrame ()
static bool	IsAtAsyncJump (ActivationFrame *top_frame)
static bool	CanRewindFrame (intptr_t frame_index, const char **error)
static ActivationFrame *	CollectDartFrame (uword pc, StackFrame *frame, const Code &code, const Array &deopt_frame, intptr_t deopt_frame_offset)
static ArrayPtr	DeoptimizeToArray (Thread *thread, StackFrame *frame, const Code &code)
static void	RefineBreakpointPos (const Script &script, TokenPosition pos, TokenPosition next_closest_token_position, TokenPosition requested_token_pos, TokenPosition last_token_pos, intptr_t requested_column, TokenPosition exact_token_pos, TokenPosition *best_fit_pos, intptr_t *best_column, intptr_t *best_line)
static TokenPosition	ResolveBreakpointPos (const Function &func, TokenPosition requested_token_pos, TokenPosition last_token_pos, intptr_t requested_column, TokenPosition exact_token_pos)
static void	UpdateBestFit (Function *best_fit, const Function &func)
static TokenPosition	FindExactTokenPosition (const Script &script, TokenPosition start_of_line, intptr_t column_number)
static FunctionPtr	FindInnermostClosure (Zone *zone, const Function &function, TokenPosition token_pos)
static intptr_t	FindNextRewindFrameIndex (DebuggerStackTrace *stack, intptr_t frame_index)
static uword	LookupRewindPc (const Code &code, uword return_address)
Dart_Handle	Dart_StackTraceLength (Dart_StackTrace trace, intptr_t *length)
Dart_Handle	Dart_GetActivationFrame (Dart_StackTrace trace, int frame_index, Dart_ActivationFrame *frame)
Dart_Handle	Dart_GetStackTrace (Dart_StackTrace *trace)
Dart_Handle	Dart_GetStackTraceFromError (Dart_Handle handle, Dart_StackTrace *trace)
Dart_Handle	Dart_ActivationFrameInfo (Dart_ActivationFrame activation_frame, Dart_Handle *function_name, Dart_Handle *script_url, intptr_t *line_number, intptr_t *column_number)
Dart_Handle	Dart_SetBreakpoint (Dart_Handle script_url_in, intptr_t line_number)
Dart_Handle	Dart_RemoveBreakpoint (Dart_Handle breakpoint_id_in)
Dart_Handle	Dart_EvaluateStaticExpr (Dart_Handle lib_handle, Dart_Handle expr_in)
Dart_Handle	Dart_LibraryId (Dart_Handle library, intptr_t *library_id)
Dart_Handle	Dart_GetLibraryDebuggable (intptr_t library_id, bool *is_debuggable)
Dart_Handle	Dart_SetLibraryDebuggable (intptr_t library_id, bool is_debuggable)
	DECLARE_FLAG (bool, trace_deoptimization_verbose)
static intptr_t	ToContextIndex (intptr_t offset_in_bytes)
	DEFINE_FLAG (bool, compress_deopt_info, true, "Compress the size of the deoptimization info for optimized code.")
static bool	IsObjectInstruction (DeoptInstr::Kind kind)
static void	FillDeferredSlots (DeoptContext *deopt_context, DeferredSlot **slot_list)
void	DoubleToCString (double d, char *buffer, int buffer_size)
StringPtr	DoubleToStringAsFixed (double d, int fraction_digits)
StringPtr	DoubleToStringAsExponential (double d, int fraction_digits)
StringPtr	DoubleToStringAsPrecision (double d, int precision)
bool	CStringToDouble (const char *str, intptr_t length, double *result)
IntegerPtr	DoubleToInteger (Zone *zone, double val)
static uint64_t	double_to_uint64 (double d)
	DEFINE_FLAG (bool, print_stacktrace_at_throw, false, "Prints a stack trace everytime a throw occurs.")
static void	BuildStackTrace (StackTraceBuilder *builder)
static intptr_t	SlotIndexToFrameIndex (intptr_t slot)
static intptr_t	SlotIndexToFpRelativeOffset (intptr_t slot)
static void	FindErrorHandler (uword *handler_pc, uword *handler_sp, uword *handler_fp)
static void	ClearLazyDeopts (Thread *thread, uword frame_pointer)
static void	JumpToExceptionHandler (Thread *thread, uword program_counter, uword stack_pointer, uword frame_pointer, const Object &exception_object, const Object &stacktrace_object)
static FieldPtr	LookupStackTraceField (const Instance &instance)
static DART_NORETURN void	ThrowExceptionHelper (Thread *thread, const Instance &incoming_exception, const Instance &existing_stacktrace, const bool is_rethrow, const bool bypass_debugger)
void FUNCTION_NAME()	Unhandled_equals (Dart_NativeArguments args)
void FUNCTION_NAME()	Unhandled_invoke (Dart_NativeArguments args)
void FUNCTION_NAME()	Unhandled_invoke2 (Dart_NativeArguments args)
static Dart_NativeFunction	native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (UnhandledExceptions)
bool	GetExperimentalFeatureDefault (ExperimentalFeature feature)
const char *	GetExperimentalFeatureName (ExperimentalFeature feature)
ArrayPtr	GetNativeAssetsMap (Thread *thread)
FunctionPtr	CreateTestFunction (FfiCallbackKind kind)
	VM_UNIT_TEST_CASE (FfiCallbackMetadata_CreateSyncFfiCallback)
	VM_UNIT_TEST_CASE (FfiCallbackMetadata_CreateAsyncFfiCallback)
	VM_UNIT_TEST_CASE (FfiCallbackMetadata_CreateIsolateLocalFfiCallback)
	ISOLATE_UNIT_TEST_CASE (FfiCallbackMetadata_TrampolineRecycling)
	VM_UNIT_TEST_CASE (FfiCallbackMetadata_DeleteTrampolines)
static void	RunBigRandomMultithreadedTest (uint64_t seed)
	ISOLATE_UNIT_TEST_CASE (FfiCallbackMetadata_BigRandomMultithreadedTest)
	UNIT_TEST_CASE (FixedCacheEmpty)
	UNIT_TEST_CASE (FixedCacheHalfFull)
	UNIT_TEST_CASE (FixedCacheFullResource)
	DEFINE_FLAG (bool, print_flags, false, "Print flags as they are being parsed.")
	DEFINE_FLAG (bool, ignore_unrecognized_flags, false, "Ignore unrecognized flags.")
static void	Normalize (char *s)
static bool	IsValidFlag (const char *name, const char *prefix, intptr_t prefix_length)
	DEFINE_FLAG (bool, basic_flag, true, "Testing of a basic boolean flag.")
	DECLARE_FLAG (bool, print_flags)
	VM_UNIT_TEST_CASE (BasicFlags)
	DEFINE_FLAG (bool, parse_flag_bool_test, true, "Flags::Parse (bool) testing")
	DEFINE_FLAG (charp, string_opt_test, nullptr, "Testing: string option.")
	DEFINE_FLAG (charp, entrypoint_test, "main", "Testing: entrypoint")
	DEFINE_FLAG (int, counter, 100, "Testing: int flag")
	VM_UNIT_TEST_CASE (ParseFlags)
GDB_HELPER void *	_currentThread ()
GDB_HELPER void	_printObjectPtr (uword object)
GDB_HELPER Object *	_handle (uword object)
GDB_HELPER void	_disassemble (uword pc)
GDB_HELPER void	_printDartStackTrace ()
GDB_HELPER void	_printStackTrace ()
GDB_HELPER void	_printGeneratedStackTrace (uword fp, uword sp, uword pc)
GDB_HELPER void	_printStackTraceWithLocals ()
template<class GrowableArrayInt , class GrowableArrayInt64 >
void	TestGrowableArray ()
	TEST_CASE (GrowableArray)
	TEST_CASE (MallocGrowableArray)
static int	greatestFirst (const int *a, const int *b)
	TEST_CASE (GrowableArraySort)
	ISOLATE_UNIT_TEST_CASE (GrowableHandlePtr)
	TEST_CASE (GrowableArrayMoveCtor)
	TEST_CASE (GrowableArrayMoveAssign)
FieldPtr	LookupField (Dart_Handle library, const char *class_name, const char *field_name)
	TEST_CASE (GuardFieldSimpleTest)
	TEST_CASE (GuardFieldFinalListTest)
	TEST_CASE (GuardFieldFinalVariableLengthListTest)
	TEST_CASE (GuardFieldConstructorTest)
	TEST_CASE (GuardFieldConstructor2Test)
	ISOLATE_UNIT_TEST_CASE (AllocateZoneHandle)
	ISOLATE_UNIT_TEST_CASE (AllocateScopeHandle)
static void	NoopCallback (void *isolate_callback_data, void *peer)
	TEST_CASE (CheckHandleValidity)
uint32_t	CombineHashes (uint32_t hash, uint32_t other_hash)
uint32_t	FinalizeHash (uint32_t hash, intptr_t hashbits=kBitsPerInt32)
uint32_t	HashBytes (const uint8_t *bytes, intptr_t size)
	TEST_CASE (DirectChainedHashMap)
	TEST_CASE (DirectChainedHashMapInsertRemove)
	TEST_CASE (MallocDirectChainedHashMap)
	TEST_CASE (ZoneDirectChainedHashMap)
	TEST_CASE (DirectChainedHashMapIterator)
	TEST_CASE (DirectChainedHashMapIteratorWithCollisionInLastBucket)
	TEST_CASE (ZoneCStringSet)
	TEST_CASE (CStringIntMap)
	TEST_CASE (CStringIntMapUpdate)
template<typename Table >
void	Validate (const Table &table)
	ISOLATE_UNIT_TEST_CASE (HashTable)
std::string	ToStdString (const String &str)
template<typename Set >
void	VerifyStringSetsEqual (const std::set< std::string > &expected, const Set &actual, bool ordered)
template<typename Map >
void	VerifyStringMapsEqual (const std::map< std::string, int > &expected, const Map &actual, bool ordered)
template<typename Set >
void	TestSet (intptr_t initial_capacity, bool ordered)
template<typename Map >
void	TestMap (intptr_t initial_capacity, bool ordered)
	ISOLATE_UNIT_TEST_CASE (Sets)
	ISOLATE_UNIT_TEST_CASE (Maps)
static bool	IsForwardingObject (ObjectPtr object)
static ObjectPtr	GetForwardedObject (ObjectPtr object)
static void	ForwardObjectTo (ObjectPtr before_obj, ObjectPtr after_obj)
static bool	IsDummyObject (ObjectPtr object)
DART_NOINLINE static DART_NORETURN void	InvalidForwarding (ObjectPtr before, ObjectPtr after, const char *message)
void	TestBecomeForward (Heap::Space before_space, Heap::Space after_space)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardOldToOld)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardNewToNew)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardOldToNew)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardNewToOld)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardPeer)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardObjectId)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardMessageId)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardRememberedObject)
	ISOLATE_UNIT_TEST_CASE (BecomeForwardRememberedCards)
	DEFINE_FLAG (bool, force_evacuation, false, "Force compaction to move every movable object")
static uword	Allocate (FreeList *free_list, intptr_t size, bool is_protected)
static void	Free (FreeList *free_list, uword address, intptr_t size, bool is_protected)
static void	TestFreeList (VirtualMemory *region, FreeList *free_list, bool is_protected)
	TEST_CASE (FreeList)
	TEST_CASE (FreeListProtected)
	TEST_CASE (FreeListProtectedTinyObjects)
	TEST_CASE (FreeListProtectedVariableSizeObjects)
static void	TestRegress38528 (intptr_t header_overlap)
	TEST_CASE (Regress38528)
Heap::Space	SpaceForExternal (FinalizerEntryPtr raw_entry)
template<typename GCVisitorType >
void	RunNativeFinalizerCallback (NativeFinalizerPtr raw_finalizer, FinalizerEntryPtr raw_entry, Heap::Space before_gc_space, GCVisitorType *visitor)
template<typename GCVisitorType >
void	MournFinalizerEntry (GCVisitorType *visitor, FinalizerEntryPtr current_entry)
	DEFINE_FLAG (bool, write_protect_vm_isolate, true, "Write protect vm_isolate.")
	DEFINE_FLAG (bool, disable_heap_verification, false, "Explicitly disable heap verification.")
	DECLARE_FLAG (int, early_tenuring_threshold)
	TEST_CASE (OldGC)
	TEST_CASE (OldGC_Unsync)
	TEST_CASE (LargeSweep)
	TEST_CASE (ClassHeapStats)
	ISOLATE_UNIT_TEST_CASE (IterateReadOnly)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_DeadOldToNew)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_DeadNewToOld)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_DeadGenCycle)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_LiveNewToOld)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_LiveOldToNew)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_LiveOldDeadNew)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_LiveNewDeadOld)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_LiveNewToOldChain)
	ISOLATE_UNIT_TEST_CASE (CollectAllGarbage_LiveOldToNewChain)
static void	NoopFinalizer (void *isolate_callback_data, void *peer)
	ISOLATE_UNIT_TEST_CASE (ExternalPromotion)
	VM_UNIT_TEST_CASE (CleanupBequestNeverReceived)
	VM_UNIT_TEST_CASE (ReceivesSendAndExitMessage)
	ISOLATE_UNIT_TEST_CASE (ExternalAllocationStats)
	ISOLATE_UNIT_TEST_CASE (ExternalSizeLimit)
	ISOLATE_UNIT_TEST_CASE (ArrayTruncationRaces)
	ISOLATE_UNIT_TEST_CASE (ArrayTruncationPadding)
	ISOLATE_UNIT_TEST_CASE (ConcurrentForceGrowthScope)
	ISOLATE_UNIT_TEST_CASE (WeakSmi)
static void	WeakProperty_Generations (Generation property_space, Generation key_space, Generation value_space, bool cleared_after_minor, bool cleared_after_major, bool cleared_after_all)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_Generations)
static void	WeakReference_Generations (Generation reference_space, Generation target_space, bool cleared_after_minor, bool cleared_after_major, bool cleared_after_all)
	ISOLATE_UNIT_TEST_CASE (WeakReference_Generations)
static void	WeakArray_Generations (intptr_t length, Generation array_space, Generation element_space, bool cleared_after_minor, bool cleared_after_major, bool cleared_after_all)
	ISOLATE_UNIT_TEST_CASE (WeakArray_Generations)
	ISOLATE_UNIT_TEST_CASE (WeakArray_Large_Generations)
static void	FinalizerEntry_Generations (Generation entry_space, Generation value_space, bool cleared_after_minor, bool cleared_after_major, bool cleared_after_all)
	ISOLATE_UNIT_TEST_CASE (FinalizerEntry_Generations)
static void	TestCardRememberedArray (bool immutable, bool compact)
static void	TestCardRememberedWeakArray (bool compact)
	ISOLATE_UNIT_TEST_CASE (CardRememberedArray)
	ISOLATE_UNIT_TEST_CASE (CardRememberedImmutableArray)
	ISOLATE_UNIT_TEST_CASE (CardRememberedWeakArray)
static bool	IsUnreachable (const ObjectPtr obj)
static bool	CanUseCache (uword flags)
	DEFINE_FLAG (int, old_gen_growth_space_ratio, 20, "The desired maximum percentage of free space after old gen GC")
	DEFINE_FLAG (int, old_gen_growth_time_ratio, 3, "The desired maximum percentage of time spent in old gen GC")
	DEFINE_FLAG (int, old_gen_growth_rate, 280, "The max number of pages the old generation can grow at a time")
	DEFINE_FLAG (bool, print_free_list_before_gc, false, "Print free list statistics before a GC")
	DEFINE_FLAG (bool, print_free_list_after_gc, false, "Print free list statistics after a GC")
	DEFINE_FLAG (bool, log_growth, false, "Log PageSpace growth policy decisions.")
	DECLARE_FLAG (bool, write_protect_code)
	DEFINE_LEAF_RUNTIME_ENTRY (void, StoreBufferBlockProcess, 1, Thread *thread)
END_LEAF_RUNTIME_ENTRY	DEFINE_LEAF_RUNTIME_ENTRY (void, MarkingStackBlockProcess, 1, Thread *thread)
	DEFINE_FLAG (bool, trace_safepoint, false, "Trace Safepoint logic.")
	ISOLATE_UNIT_TEST_CASE (SafepointOperation_SafepointOpWhileDeoptSafepointOpBlocked)
	ISOLATE_UNIT_TEST_CASE (SafepointOperation_SafepointOpBlockedWhileDeoptSafepointOp)
	ISOLATE_UNIT_TEST_CASE (SafepointOperation_SafepointPointTest)
	ISOLATE_UNIT_TEST_CASE (SafepointOperation_StressTest)
	ISOLATE_UNIT_TEST_CASE (SafepointOperation_DeoptAndNonDeoptNesting)
	ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION (SafepointOperation_NonDeoptAndDeoptNesting, "Crash")
	ISOLATE_UNIT_TEST_CASE (ReloadScopes_Test)
	ISOLATE_UNIT_TEST_CASE (Reload_AtReloadSafepoint)
static void	EnsureValidOOBMessage (Thread *thread, Isolate *isolate, std::unique_ptr< Message > message)
	ISOLATE_UNIT_TEST_CASE (Reload_NotAtSafepoint)
	ISOLATE_UNIT_TEST_CASE (Reload_AtNonReloadSafepoint)
	DEFINE_FLAG (int, early_tenuring_threshold, 66, "When more than this percentage of promotion candidates survive, " "promote all survivors of next scavenge.")
	DEFINE_FLAG (int, new_gen_garbage_threshold, 90, "Grow new gen when less than this percentage is garbage.")
	DEFINE_FLAG (int, new_gen_growth_factor, 2, "Grow new gen by this factor.")
	COMPILE_ASSERT (static_cast< uword >(kForwarded)==static_cast< uword >(kHeapObjectTag))
static DART_FORCE_INLINE bool	IsForwarding (uword header)
static DART_FORCE_INLINE ObjectPtr	ForwardedObj (uword header)
static DART_FORCE_INLINE uword	ForwardingHeader (ObjectPtr target)
static NO_SANITIZE_THREAD void	objcpy (void *dst, const void *src, size_t size)
static DART_FORCE_INLINE uword	ReadHeaderRelaxed (ObjectPtr obj)
static DART_FORCE_INLINE void	WriteHeaderRelaxed (ObjectPtr obj, uword header)
static bool	IsUnreachable (ObjectPtr *ptr)
static bool	IsScavengeSurvivor (ObjectPtr obj)
bool	IsAllocatableInNewSpace (intptr_t size)
bool	IsAllocatableViaFreeLists (intptr_t size)
	ISOLATE_UNIT_TEST_CASE (WeakTables)
bool	ObjectAtPoolIndex (const Code &code, intptr_t index, Object *obj)
bool	DecodeLoadObjectFromPoolOrThread (uword pc, const Code &code, Object *obj)
intptr_t	IndexFromPPLoadDisp8 (uword start)
intptr_t	IndexFromPPLoadDisp32 (uword start)
	UNIT_TEST_CASE (IntrusiveDListMultiEntryTest)
	UNIT_TEST_CASE (IntrusiveDListRemoveFirstTest)
	UNIT_TEST_CASE (IntrusiveDListRemoveLastTest)
	UNIT_TEST_CASE (IntrusiveDListIsInList)
	UNIT_TEST_CASE (IntrusiveDListEraseIterator)
	UNIT_TEST_CASE (IntrusiveDListAppendListTest)
	DECLARE_FLAG (bool, print_metrics)
	DECLARE_FLAG (int, old_gen_growth_time_ratio)
	DECLARE_FLAG (int, reload_every)
	DECLARE_FLAG (bool, check_reloaded)
	DECLARE_FLAG (bool, reload_every_back_off)
	DECLARE_FLAG (bool, trace_reload)
static void	DeterministicModeHandler (bool value)
	DEFINE_FLAG_HANDLER (DeterministicModeHandler, deterministic, "Enable deterministic mode.")
	DEFINE_FLAG (bool, disable_thread_pool_limit, false, "Disables the limit of the thread pool (simulates custom embedder " "with custom message handler on unlimited number of threads).")
static std::unique_ptr< Message >	SerializeMessage (Dart_Port dest_port, const Instance &obj)
static std::unique_ptr< Message >	SerializeMessage (Zone *zone, Dart_Port dest_port, Dart_CObject *obj)
static MessageHandler::MessageStatus	StoreError (Thread *thread, const Error &error)
static void	ShutdownIsolate (uword parameter)
static const char *	ExceptionPauseInfoToServiceEnum (Dart_ExceptionPauseInfo pi)
static ServiceEvent	IsolatePauseEvent (Isolate *isolate)
	DEFINE_FLAG (int, reload_every, 0, "Reload every N stack overflow checks.")
	DEFINE_FLAG (bool, trace_reload, false, "Trace isolate reloading")
	DEFINE_FLAG (bool, trace_reload_verbose, false, "trace isolate reloading verbose")
	DEFINE_FLAG (bool, identity_reload, false, "Enable checks for identity reload.")
	DEFINE_FLAG (bool, reload_every_optimized, true, "Only from optimized code.")
	DEFINE_FLAG (bool, reload_every_back_off, false, "Double the --reload-every value after each reload.")
	DEFINE_FLAG (bool, reload_force_rollback, false, "Force all reloads to fail and rollback.")
	DEFINE_FLAG (bool, check_reloaded, false, "Assert that an isolate has reloaded at least once.") DEFINE_FLAG(bool
static bool	HasNoTasks (Heap *heap)
static const char *	BoxCidToCString (intptr_t box_cid)
static intptr_t	CommonSuffixLength (const char *a, const char *b)
static ObjectPtr	AcceptCompilation (Thread *thread)
static ObjectPtr	RejectCompilation (Thread *thread)
static void	PropagateLibraryModified (const ZoneGrowableArray< ZoneGrowableArray< intptr_t > * > *imported_by, intptr_t lib_index, BitVector *modified_libs)
	Copied in from https://dart-review.googlesource.com/c/sdk/+/77722.
static bool	ContainsScriptUri (const GrowableArray< const char * > &seen_uris, const char *uri)
int64_t	SimpleInvoke (Dart_Handle lib, const char *method)
const char *	SimpleInvokeStr (Dart_Handle lib, const char *method)
Dart_Handle	SimpleInvokeError (Dart_Handle lib, const char *method)
	TEST_CASE (IsolateReload_FunctionReplacement)
	TEST_CASE (IsolateReload_IncrementalCompile)
	TEST_CASE (IsolateReload_KernelIncrementalCompile)
	TEST_CASE (IsolateReload_KernelIncrementalCompileAppAndLib)
	TEST_CASE (IsolateReload_KernelIncrementalCompileGenerics)
	TEST_CASE (IsolateReload_KernelIncrementalCompileBaseClass)
	TEST_CASE (IsolateReload_BadClass)
	TEST_CASE (IsolateReload_StaticValuePreserved)
	TEST_CASE (IsolateReload_SavedClosure)
	TEST_CASE (IsolateReload_TopLevelFieldAdded)
	TEST_CASE (IsolateReload_ClassFieldAdded)
	TEST_CASE (IsolateReload_ClassFieldAdded2)
	TEST_CASE (IsolateReload_ClassFieldRemoved)
	TEST_CASE (IsolateReload_ClassAdded)
	TEST_CASE (IsolateReload_ClassRemoved)
	TEST_CASE (IsolateReload_LibraryImportAdded)
	TEST_CASE (IsolateReload_LibraryImportRemoved)
	TEST_CASE (IsolateReload_LibraryDebuggable)
	TEST_CASE (IsolateReload_ImplicitConstructorChanged)
	TEST_CASE (IsolateReload_ConstructorChanged)
	TEST_CASE (IsolateReload_SuperClassChanged)
	TEST_CASE (IsolateReload_Generics)
	TEST_CASE (IsolateReload_TypeIdentity)
	TEST_CASE (IsolateReload_TypeIdentityGeneric)
	TEST_CASE (IsolateReload_TypeIdentityParameter)
	TEST_CASE (IsolateReload_MixinChanged)
	TEST_CASE (IsolateReload_ComplexInheritanceChange)
	TEST_CASE (IsolateReload_LiveStack)
	TEST_CASE (IsolateReload_LibraryLookup)
	TEST_CASE (IsolateReload_LibraryHide)
	TEST_CASE (IsolateReload_LibraryShow)
	TEST_CASE (IsolateReload_SmiFastPathStubs)
	TEST_CASE (IsolateReload_ImportedMixinFunction)
	TEST_CASE (IsolateReload_TopLevelParseError)
	TEST_CASE (IsolateReload_PendingUnqualifiedCall_StaticToInstance)
	TEST_CASE (IsolateReload_PendingUnqualifiedCall_InstanceToStatic)
	TEST_CASE (IsolateReload_PendingConstructorCall_AbstractToConcrete)
	TEST_CASE (IsolateReload_PendingConstructorCall_ConcreteToAbstract)
	TEST_CASE (IsolateReload_PendingStaticCall_DefinedToNSM)
	TEST_CASE (IsolateReload_PendingStaticCall_NSMToDefined)
	TEST_CASE (IsolateReload_PendingSuperCall)
	TEST_CASE (IsolateReload_TearOff_Instance_Equality)
	TEST_CASE (IsolateReload_TearOff_Parameter_Count_Mismatch)
	TEST_CASE (IsolateReload_TearOff_Remove)
	TEST_CASE (IsolateReload_TearOff_Class_Identity)
	TEST_CASE (IsolateReload_TearOff_Library_Identity)
	TEST_CASE (IsolateReload_TearOff_List_Set)
	TEST_CASE (IsolateReload_TearOff_AddArguments)
	TEST_CASE (IsolateReload_TearOff_AddArguments2)
	TEST_CASE (IsolateReload_EnumEquality)
	TEST_CASE (IsolateReload_EnumIdentical)
	TEST_CASE (IsolateReload_EnumReorderIdentical)
	TEST_CASE (IsolateReload_EnumAddition)
	TEST_CASE (IsolateReload_EnumToNotEnum)
	TEST_CASE (IsolateReload_NotEnumToEnum)
	TEST_CASE (IsolateReload_EnumDelete)
	TEST_CASE (IsolateReload_EnumIdentityReload)
	TEST_CASE (IsolateReload_EnumShapeChange)
	TEST_CASE (IsolateReload_EnumShapeChangeAdd)
	TEST_CASE (IsolateReload_EnumShapeChangeRemove)
	TEST_CASE (IsolateReload_EnumReferentShapeChangeAdd)
	TEST_CASE (IsolateReload_ConstantIdentical)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelFunction)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelFunctionArityChange)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelAddTypeArguments)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelRemoveTypeArguments)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelMissingPassingTypeArguments)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelFunctionEvaluationOrder)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelFunctionLibraryDeleted)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelGetter)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelSetter)
	TEST_CASE (IsolateReload_CallDeleted_TopLevelSetterEvaluationOrder)
	TEST_CASE (IsolateReload_CallDeleted_ClassFunction)
	TEST_CASE (IsolateReload_CallDeleted_ClassFunctionArityChange)
	TEST_CASE (IsolateReload_CallDeleted_ClassFunctionEvaluationOrder)
	TEST_CASE (IsolateReload_CallDeleted_ClassGetter)
	TEST_CASE (IsolateReload_CallDeleted_ClassSetter)
	TEST_CASE (IsolateReload_CallDeleted_ClassSetterEvaluationOrder)
	TEST_CASE (IsolateReload_CallDeleted_ClassGenerativeConstructor)
	TEST_CASE (IsolateReload_CallDeleted_ClassGenerativeConstructorArityChange)
	TEST_CASE (IsolateReload_CallDeleted_ClassGenerativeConstructorClassDeleted)
	TEST_CASE (IsolateReload_CallDeleted_ClassFactoryConstructor)
	TEST_CASE (IsolateReload_CallDeleted_ClassFactoryConstructorArityChange)
	TEST_CASE (IsolateReload_CallDeleted_ClassFactoryConstructorClassDeleted)
	TEST_CASE (IsolateReload_CallDeleted_SuperFunction)
	TEST_CASE (IsolateReload_CallDeleted_SuperFunctionArityChange)
	TEST_CASE (IsolateReload_CallDeleted_SuperGetter)
	TEST_CASE (IsolateReload_CallDeleted_SuperSetter)
	TEST_CASE (IsolateReload_CallDeleted_SuperFieldGetter)
	TEST_CASE (IsolateReload_CallDeleted_SuperFieldSetter)
	TEST_CASE (IsolateReload_EnumValuesToString)
	ISOLATE_UNIT_TEST_CASE (IsolateReload_DirectSubclasses_Success)
	ISOLATE_UNIT_TEST_CASE (IsolateReload_DirectSubclasses_GhostSubclass)
	ISOLATE_UNIT_TEST_CASE (IsolateReload_DirectSubclasses_Failure)
	TEST_CASE (IsolateReload_ChangeInstanceFormat0)
	TEST_CASE (IsolateReload_ChangeInstanceFormat1)
	TEST_CASE (IsolateReload_ChangeInstanceFormat2)
	TEST_CASE (IsolateReload_ChangeInstanceFormat3)
	TEST_CASE (IsolateReload_ChangeInstanceFormat4)
	TEST_CASE (IsolateReload_ChangeInstanceFormat5)
	TEST_CASE (IsolateReload_ChangeInstanceFormat6)
	TEST_CASE (IsolateReload_ChangeInstanceFormat7)
	TEST_CASE (IsolateReload_ChangeInstanceFormat8)
	TEST_CASE (IsolateReload_ChangeInstanceFormat9)
	TEST_CASE (IsolateReload_ShapeChangeMutualReference)
	TEST_CASE (IsolateReload_ShapeChangeRetainsHash)
	TEST_CASE (IsolateReload_ShapeChangeRetainsHash_Const)
	TEST_CASE (IsolateReload_ShapeChange_Const_AddSlot)
	TEST_CASE (IsolateReload_ShapeChange_Const_RemoveSlot)
	TEST_CASE (IsolateReload_DeeplyImmutableChange)
	TEST_CASE (IsolateReload_DeeplyImmutableChange_2)
	TEST_CASE (IsolateReload_DeeplyImmutableChange_MultiLib)
	TEST_CASE (IsolateReload_DeeplyImmutableChange_TypeBound)
	TEST_CASE (IsolateReload_ConstToNonConstClass)
	TEST_CASE (IsolateReload_ConstToNonConstClass_Empty)
	TEST_CASE (IsolateReload_StaticTearOffRetainsHash)
static bool	NothingModifiedCallback (const char *url, int64_t since)
	TEST_CASE (IsolateReload_NoLibsModified)
static bool	MainModifiedCallback (const char *url, int64_t since)
	TEST_CASE (IsolateReload_MainLibModified)
static bool	ImportModifiedCallback (const char *url, int64_t since)
	TEST_CASE (IsolateReload_ImportedLibModified)
	TEST_CASE (IsolateReload_PrefixImportedLibModified)
static bool	ExportModifiedCallback (const char *url, int64_t since)
	TEST_CASE (IsolateReload_ExportedLibModified)
	TEST_CASE (IsolateReload_SimpleConstFieldUpdate)
	TEST_CASE (IsolateReload_ConstFieldUpdate)
	TEST_CASE (IsolateReload_RunNewFieldInitializers)
	TEST_CASE (IsolateReload_RunNewFieldInitializersReferenceStaticField)
	TEST_CASE (IsolateReload_RunNewFieldInitializersLazy)
	TEST_CASE (IsolateReload_RunNewFieldInitializersLazyConst)
	TEST_CASE (IsolateReload_RunNewFieldInitializersLazyTransitive)
	TEST_CASE (IsolateReload_RunNewFieldInitializersThrows)
	TEST_CASE (IsolateReload_RunNewFieldInitializersCyclicInitialization)
	TEST_CASE (IsolateReload_RunNewFieldInitializersSyntaxError)
	TEST_CASE (IsolateReload_RunNewFieldInitializersSyntaxError2)
	TEST_CASE (IsolateReload_RunNewFieldInitializersSyntaxError3)
	TEST_CASE (IsolateReload_RunNewFieldInitializersSuperClass)
	TEST_CASE (IsolateReload_RunNewFieldInitializersWithConsts)
	TEST_CASE (IsolateReload_RunNewFieldInitializersWithGenerics)
	TEST_CASE (IsolateReload_AddNewStaticField)
	TEST_CASE (IsolateReload_StaticFieldInitialValueDoesnotChange)
	TEST_CASE (IsolateReload_DeleteStaticField)
static void	TestReloadWithFieldChange (const char *prefix, const char *suffix, const char *verify, const char *from_type, const char *from_init, const char *to_type, const char *to_init)
	TEST_CASE (IsolateReload_ExistingFieldChangesType)
	TEST_CASE (IsolateReload_ExistingFieldChangesTypeWithOtherUnboxedFields)
	TEST_CASE (IsolateReload_ExistingFieldUnboxedToBoxed)
	TEST_CASE (IsolateReload_ExistingFieldBoxedToUnboxed)
	TEST_CASE (IsolateReload_ExistingFieldUnboxedToUnboxed)
	TEST_CASE (IsolateReload_ExistingStaticFieldChangesType)
	TEST_CASE (IsolateReload_ExistingFieldChangesTypeIndirect)
	TEST_CASE (IsolateReload_ExistingStaticFieldChangesTypeIndirect)
	TEST_CASE (IsolateReload_ExistingFieldChangesTypeIndirectGeneric)
	TEST_CASE (IsolateReload_ExistingStaticFieldChangesTypeIndirectGeneric)
	TEST_CASE (IsolateReload_ExistingFieldChangesTypeIndirectFunction)
	TEST_CASE (IsolateReload_ExistingStaticFieldChangesTypeIndirectFunction)
	TEST_CASE (IsolateReload_TypedefToNotTypedef)
	TEST_CASE (IsolateReload_NotTypedefToTypedef)
	TEST_CASE (IsolateReload_TypedefAddParameter)
	TEST_CASE (IsolateReload_PatchStaticInitializerWithClosure)
	TEST_CASE (IsolateReload_StaticTargetArityChange)
	TEST_CASE (IsolateReload_SuperGetterReboundToMethod)
	TEST_CASE (IsolateReload_RegressB179030011)
	TEST_CASE (IsolateReload_GenericConstructorTearOff)
	TEST_CASE (IsolateReload_ImplicitGetterWithLoadGuard)
	TEST_CASE (IsolateReload_EnumInMainLibraryModified)
	TEST_CASE (IsolateReload_KeepPragma1)
	TEST_CASE (IsolateReload_EnumWithSet)
	TEST_CASE (IsolateReload_KeepPragma2)
	TEST_CASE (IsolateReload_KeepPragma3)
	VM_UNIT_TEST_CASE (IsolateCurrent)
void	IsolateSpawn (const char *platform_script_value)
	TEST_CASE (IsolateSpawn_FileUri)
	TEST_CASE (IsolateSpawn_PackageUri)
	TEST_CASE (StackLimitInterrupts)
	ISOLATE_UNIT_TEST_CASE (Isolate_Ports)
	ISOLATE_UNIT_TEST_CASE (Isolate_MayExit_True)
	ISOLATE_UNIT_TEST_CASE (Isolate_MayExit_False)
static const char *	GetJSONRpcErrorMessage (intptr_t code)
static void	PrintRequest (JSONObject *obj, JSONStream *js)
static void	Finalizer (void *isolate_callback_data, void *buffer)
	TEST_CASE (JSON_TextBuffer)
	TEST_CASE (JSON_JSONStream_Primitives)
	TEST_CASE (JSON_JSONStream_Array)
	TEST_CASE (JSON_JSONStream_Base64String)
	TEST_CASE (JSON_JSONStream_Object)
	TEST_CASE (JSON_JSONStream_NestedObject)
	TEST_CASE (JSON_JSONStream_ObjectArray)
	TEST_CASE (JSON_JSONStream_ArrayArray)
	TEST_CASE (JSON_JSONStream_Printf)
	TEST_CASE (JSON_JSONStream_ObjectPrintf)
	ISOLATE_UNIT_TEST_CASE (JSON_JSONStream_DartObject)
	TEST_CASE (JSON_JSONStream_EscapedString)
	TEST_CASE (JSON_JSONStream_DartString)
	TEST_CASE (JSON_JSONStream_Params)
	DEFINE_FLAG (bool, trace_kernel, false, "Trace Kernel service requests.")
	DEFINE_FLAG (charp, kernel_multiroot_filepaths, nullptr, "Comma-separated list of file paths that should be treated as roots" " by frontend compiler.")
	DEFINE_FLAG (charp, kernel_multiroot_scheme, nullptr, "URI scheme that replaces filepaths prefixes specified" " by kernel_multiroot_filepaths option")
static Dart_CObject	BuildFilesPairs (int source_files_count, Dart_SourceFile source_files[])
static void	ReleaseFilesPairs (const Dart_CObject &files)
static void	PassThroughFinalizer (void *isolate_callback_data, void *peer)
	DEFINE_OPTION_HANDLER (KernelIsolate::AddExperimentalFlag, enable_experiment, "Comma separated list of experimental features.")
const dart::TypedData &	CreateLineStartsData ()
	ISOLATE_UNIT_TEST_CASE (KernelLineStartsReader_MaxPosition)
void	ExpectLocationForPosition (const kernel::KernelLineStartsReader &reader, intptr_t position, intptr_t expected_line, intptr_t expected_col)
	ISOLATE_UNIT_TEST_CASE (KernelLineStartsReader_LocationForPosition)
void	ExpectTokenRangeAtLine (const kernel::KernelLineStartsReader &reader, intptr_t line, intptr_t expected_first_token, intptr_t expected_last_token)
	ISOLATE_UNIT_TEST_CASE (KernelLineStartsReader_TokenRangeAtLine)
	DEFINE_FLAG (bool, force_log_flush, false, "Always flush log messages.")
	DEFINE_FLAG (int, force_log_flush_at_size, 0, "Flush log messages when buffer exceeds given size (disabled when 0).")
	DEFINE_FLAG (charp, isolate_log_filter, nullptr, "Log isolates whose name include the filter. " "Default: service isolate log messages are suppressed " "(specify 'vm-service' to log them).")
	DEFINE_FLAG (charp, redirect_isolate_log_to, nullptr, "Log isolate messages into the given file.")
static void	TestPrinter (const char *buffer)
	TEST_CASE (Log_Macro)
	TEST_CASE (Log_Basic)
	TEST_CASE (Log_Block)
static void	LongJumpHelper (LongJumpScope *jump)
	ISOLATE_UNIT_TEST_CASE (LongJump)
static void *	NewRegion (uword size)
static void	DeleteRegion (const MemoryRegion &region)
	VM_UNIT_TEST_CASE (NullRegion)
	VM_UNIT_TEST_CASE (NewRegion)
	VM_UNIT_TEST_CASE (Subregion)
	VM_UNIT_TEST_CASE (ExtendedRegion)
	DECLARE_FLAG (bool, trace_service_pause_events)
MessageHandler::MessageStatus	TestStartFunction (uword data)
void	TestEndFunction (uword data)
static std::unique_ptr< Message >	BlankMessage (Dart_Port dest, Message::Priority priority)
	VM_UNIT_TEST_CASE (MessageHandler_PostMessage)
	VM_UNIT_TEST_CASE (MessageHandler_HasOOBMessages)
	VM_UNIT_TEST_CASE (MessageHandler_ClosePort)
	VM_UNIT_TEST_CASE (MessageHandler_CloseAllPorts)
	VM_UNIT_TEST_CASE (MessageHandler_HandleNextMessage)
	VM_UNIT_TEST_CASE (MessageHandler_HandleNextMessage_ProcessOOBAfterError)
	VM_UNIT_TEST_CASE (MessageHandler_HandleNextMessage_Shutdown)
	VM_UNIT_TEST_CASE (MessageHandler_HandleOOBMessages)
static void	SendMessages (uword param)
	VM_UNIT_TEST_CASE (MessageHandler_Run)
static void	IsolateMessageTypedDataFinalizer (void *isolate_callback_data, void *buffer)
std::unique_ptr< Message >	WriteMessage (bool same_group, const Object &obj, Dart_Port dest_port, Message::Priority priority)
std::unique_ptr< Message >	WriteApiMessage (Zone *zone, Dart_CObject *obj, Dart_Port dest_port, Message::Priority priority)
ObjectPtr	ReadObjectGraphCopyMessage (Thread *thread, PersistentHandle *handle)
ObjectPtr	ReadMessage (Thread *thread, Message *message)
Dart_CObject *	ReadApiMessage (Zone *zone, Message *message)
static uint8_t *	AllocMsg (const char *str)
	TEST_CASE (MessageQueue_BasicOperations)
	TEST_CASE (MessageQueue_Clear)
	DEFINE_FLAG (bool, print_metrics, false, "Print metrics when isolates (and the VM) are shutdown.")
static const char *	UnitString (intptr_t unit)
	VM_UNIT_TEST_CASE (Metric_Simple)
	VM_UNIT_TEST_CASE (Metric_OnDemand)
	ISOLATE_UNIT_TEST_CASE (Metric_EmbedderAPI)
	TEST_CASE (Mixin_PrivateSuperResolution)
	TEST_CASE (Mixin_PrivateSuperResolutionCrossLibraryShouldFail)
static bool	PostCObjectHelper (Dart_Port port_id, Dart_CObject *message)
DART_EXPORT bool	Dart_PostCObject (Dart_Port port_id, Dart_CObject *message)
DART_EXPORT bool	Dart_PostInteger (Dart_Port port_id, int64_t message)
DART_EXPORT Dart_Port	Dart_NewNativePort (const char *name, Dart_NativeMessageHandler handler, bool handle_concurrently)
DART_EXPORT bool	Dart_CloseNativePort (Dart_Port native_port_id)
DART_EXPORT bool	Dart_InvokeVMServiceMethod (uint8_t *request_json, intptr_t request_json_length, uint8_t **response_json, intptr_t *response_json_length, char **error)
DART_EXPORT Dart_Handle	Dart_CompileAll ()
DART_EXPORT Dart_Handle	Dart_FinalizeAllClasses ()
DART_EXPORT void *	Dart_ExecuteInternalCommand (const char *command, void *arg)
void	DartNativeThrowTypeArgumentCountException (int num_type_args, int num_type_args_expected)
void	DartNativeThrowArgumentException (const Instance &instance)
static NativeFunction	ResolveNativeFunction (Zone *zone, const Function &func, bool *is_bootstrap_native, bool *is_auto_scope)
void	TestSmiSub (Dart_NativeArguments args)
void	TestSmiSum (Dart_NativeArguments args)
void	TestNonNullSmiSum (Dart_NativeArguments args)
	DEFINE_FLAG (uint64_t, huge_method_cutoff_in_code_size, 200000, "Huge method cutoff in unoptimized code size (in bytes).")
	DEFINE_FLAG (bool, show_internal_names, false, "Show names of internal classes (e.g. \"OneByteString\") in error messages " "instead of showing the corresponding interface names (e.g. \"String\"). " "Also show legacy nullability in type names.")
	DEFINE_FLAG (bool, remove_script_timestamps_for_test, false, "Remove script timestamps to allow for deterministic testing.")
	DEFINE_FLAG (bool, use_register_cc, true, "Use register calling conventions")
	DECLARE_FLAG (int, max_polymorphic_checks)
static void	AppendSubString (BaseTextBuffer *buffer, const char *name, intptr_t start_pos, intptr_t len)
template<typename type >
static bool	IsSpecialCharacter (type value)
static bool	IsAsciiNonprintable (int32_t c)
static int32_t	EscapeOverhead (int32_t c)
template<typename type >
static type	SpecialCharacter (type value)
static void	ReportTooManyTypeArguments (const Class &cls)
bool	FindPragmaInMetadata (Thread *T, const Object &metadata_obj, const String &pragma_name, bool multiple, Object *options)
static ObjectPtr	ThrowNoSuchMethod (const Instance &receiver, const String &function_name, const Array &arguments, const Array &argument_names, const InvocationMirror::Level level, const InvocationMirror::Kind kind)
static ObjectPtr	ThrowTypeError (const TokenPosition token_pos, const Instance &src_value, const AbstractType &dst_type, const String &dst_name)
static ArrayPtr	CreateCallableArgumentsFromStatic (Zone *zone, const Instance &receiver, const Array &static_args, const Array &arg_names, const ArgumentsDescriptor &static_args_descriptor)
static ObjectPtr	LoadExpressionEvaluationFunction (Zone *zone, const ExternalTypedData &kernel_buffer, const String &library_url, const String &klass)
static bool	EvaluationFunctionNeedsReceiver (Thread *thread, Zone *zone, const Function &eval_function)
static ObjectPtr	EvaluateCompiledExpressionHelper (Zone *zone, const Function &eval_function, const Array &type_definitions, const Array &arguments, const TypeArguments &type_arguments)
static bool	MatchesAccessorName (const String &name, const char *prefix, intptr_t prefix_length, const String &accessor_name)
static uword	Hash64To32 (uint64_t v)
static void	ReportTooManyTypeParameters (const FunctionType &sig)
static bool	InVmTests (const Function &function)
static TypeArgumentsPtr	RetrieveFunctionTypeArguments (Thread *thread, Zone *zone, const Function &function, const Instance &receiver, const TypeArguments &instantiator_type_args, const Array &args, const ArgumentsDescriptor &args_desc)
static TypeArgumentsPtr	RetrieveInstantiatorTypeArguments (Zone *zone, const Function &function, const Instance &receiver)
static intptr_t	ConstructFunctionFullyQualifiedCString (const Function &function, char **chars, intptr_t reserve_len, bool with_lib, QualifiedFunctionLibKind lib_kind)
static void	FunctionPrintNameHelper (const Function &fun, const NameFormattingParams &params, BaseTextBuffer *printer)
static intptr_t	GetListLength (const Object &value)
static intptr_t	GetListLengthOffset (intptr_t cid)
static StaticTypeExactnessState	TrivialTypeExactnessFor (const Class &cls)
static const char *	SafeTypeArgumentsToCString (const TypeArguments &args)
static bool	IsLetter (int32_t c)
static bool	IsDecimalDigit (int32_t c)
static bool	IsIdentStartChar (int32_t c)
static bool	IsIdentChar (int32_t c)
static intptr_t	GetRelativeSourceIndex (const String &src, intptr_t line, intptr_t line_offset=0, intptr_t column=1, intptr_t column_offset=0, intptr_t starting_index=0)
static void	ReportTooManyImports (const Library &lib)
static bool	HasPragma (const Object &declaration)
static bool	ShouldBePrivate (const String &name)
static void	AddScriptIfUnique (const GrowableObjectArray &scripts, const Script &candidate)
static ArrayPtr	NewDictionary (intptr_t initial_size)
static ObjectPtr	InvokeInstanceFunction (Thread *thread, const Instance &receiver, const Function &function, const String &target_name, const Array &args, const Array &args_descriptor_array, bool respect_reflectable, const TypeArguments &instantiator_type_args)
static int	PrintVarInfo (char *buffer, int len, intptr_t i, const String &var_name, const UntaggedLocalVarDescriptors::VarInfo &info)
static void	IndentN (int count)
static bool	SubtypeTestCacheEntryMatches (const SubtypeTestCacheTable::TupleView &t, intptr_t num_inputs, const Object &instance_class_id_or_signature, const AbstractType &destination_type, const TypeArguments &instance_type_arguments, const TypeArguments &instantiator_type_arguments, const TypeArguments &function_type_arguments, const TypeArguments &instance_parent_function_type_arguments, const TypeArguments &instance_delayed_type_arguments)
static classid_t	NormalizeClassIdForSyntacticalTypeEquality (classid_t cid)
static bool	IsPercent (int32_t c)
static bool	IsHexCharacter (int32_t c)
static bool	IsURISafeCharacter (int32_t c)
static int32_t	GetHexCharacter (int32_t c)
static int32_t	GetHexValue (int32_t c)
static int32_t	MergeHexCharacters (int32_t c1, int32_t c2)
static FinalizablePersistentHandle *	AddFinalizer (const Object &referent, void *peer, Dart_HandleFinalizer callback, intptr_t external_size)
template<typename T1 , typename T2 >
static bool	EqualsIgnoringPrivateKey (const String &str1, const String &str2)
static void	TransferableTypedDataFinalizer (void *isolate_callback_data, void *peer)
static void	PrintSymbolicStackFrameIndex (BaseTextBuffer *buffer, intptr_t frame_index)
static void	PrintSymbolicStackFrameBody (BaseTextBuffer *buffer, const char *function_name, const char *url, intptr_t line=-1, intptr_t column=-1)
static void	PrintSymbolicStackFrame (Zone *zone, BaseTextBuffer *buffer, const Function &function, TokenPosition token_pos_or_line, intptr_t frame_index, bool is_line=false)
static bool	IsVisibleAsFutureListener (const Function &function)
static void	DwarfStackTracesHandler (bool value)
	DEFINE_FLAG_HANDLER (DwarfStackTracesHandler, dwarf_stack_traces, "Omit CodeSourceMaps in precompiled snapshots and don't " "symbolize stack traces in the precompiled runtime.")
void	DumpTypeTable (Isolate *isolate)
void	DumpFunctionTypeTable (Isolate *isolate)
void	DumpRecordTypeTable (Isolate *isolate)
void	DumpTypeParameterTable (Isolate *isolate)
void	DumpTypeArgumentsTable (Isolate *isolate)
EntryPointPragma	FindEntryPointPragma (IsolateGroup *IG, const Array &metadata, Field *reusable_field_handle, Object *pragma)
DART_WARN_UNUSED_RESULT ErrorPtr	VerifyEntryPoint (const Library &lib, const Object &member, const Object &annotated, std::initializer_list< EntryPointPragma > allowed_kinds)
DART_WARN_UNUSED_RESULT ErrorPtr	EntryPointFieldInvocationError (const String &getter_name)
DART_WARN_UNUSED_RESULT ErrorPtr	EntryPointMemberInvocationError (const Object &member)
void	DFLRT_ExitSafepoint (NativeArguments __unusable_)
	DEFINE_FLAG (bool, enable_fast_object_copy, true, "Enable fast path for fast object copy.")
	DEFINE_FLAG (bool, gc_on_foc_slow_path, false, "Cause a GC when falling off the fast path for fast object copy.")
static DART_FORCE_INLINE ObjectPtr	Marker ()
static DART_FORCE_INLINE bool	CanShareObject (ObjectPtr obj, uword tags)
bool	CanShareObjectAcrossIsolates (ObjectPtr obj)
static DART_FORCE_INLINE bool	MightNeedReHashing (ObjectPtr object)
DART_FORCE_INLINE uword	TagsFromUntaggedObject (UntaggedObject *obj)
DART_FORCE_INLINE void	SetNewSpaceTaggingWord (ObjectPtr to, classid_t cid, uint32_t size)
DART_FORCE_INLINE ObjectPtr	AllocateObject (intptr_t cid, intptr_t size, intptr_t allocated_bytes)
DART_FORCE_INLINE void	UpdateLengthField (intptr_t cid, ObjectPtr from, ObjectPtr to)
void	InitializeExternalTypedData (intptr_t cid, ExternalTypedDataPtr from, ExternalTypedDataPtr to)
template<typename T >
void	CopyTypedDataBaseWithSafepointChecks (Thread *thread, const T &from, const T &to, intptr_t length)
void	InitializeExternalTypedDataWithSafepointChecks (Thread *thread, intptr_t cid, const ExternalTypedData &from, const ExternalTypedData &to)
void	InitializeTypedDataView (TypedDataViewPtr obj)
void	FreeExternalTypedData (void *isolate_callback_data, void *buffer)
void	FreeTransferablePeer (void *isolate_callback_data, void *peer)
static ObjectPtr	Ptr (ObjectPtr obj)
static ObjectPtr	Ptr (const Object &obj)
const char *	FindRetainingPath (Zone *zone_, Isolate *isolate, const Object &from, const Object &to, TraversalRules traversal_rules)
ObjectPtr	CopyMutableObjectGraph (const Object &object)
	ISOLATE_UNIT_TEST_CASE (ObjectGraph)
static void	WeakHandleFinalizer (void *isolate_callback_data, void *peer)
	ISOLATE_UNIT_TEST_CASE (RetainingPathGCRoot)
	ISOLATE_UNIT_TEST_CASE (ObjectIdRingSerialWrapTest)
	TEST_CASE (ObjectIdRingScavengeMoveTest)
	ISOLATE_UNIT_TEST_CASE (ObjectIdRingOldGCTest)
	ISOLATE_UNIT_TEST_CASE (ObjectIdRingExpiredEntryTest)
	DECLARE_FLAG (bool, trace_reload_verbose)
	DECLARE_FLAG (bool, two_args_smi_icd)
static void	FindICData (const Array &ic_data_array, intptr_t deopt_id, ICData *ic_data)
static void	AddNameProperties (JSONObject *jsobj, const char *name, const char *vm_name)
static void	PrintShowHideNamesToJSON (JSONObject *jsobj, const Namespace &ns)
static StackTracePtr	CreatePreallocatedStackTrace (Zone *zone)
static InstancePtr	AllocateObjectByClassName (const Library &library, const String &class_name)
static ClassPtr	CreateDummyClass (const String &class_name, const Script &script)
	ISOLATE_UNIT_TEST_CASE (Class)
	ISOLATE_UNIT_TEST_CASE (SixtyThousandDartClasses)
	ISOLATE_UNIT_TEST_CASE (TypeArguments)
	TEST_CASE (Class_EndTokenPos)
	ISOLATE_UNIT_TEST_CASE (InstanceClass)
	ISOLATE_UNIT_TEST_CASE (Smi)
	ISOLATE_UNIT_TEST_CASE (StringCompareTo)
	ISOLATE_UNIT_TEST_CASE (StringEncodeIRI)
	ISOLATE_UNIT_TEST_CASE (StringDecodeIRI)
	ISOLATE_UNIT_TEST_CASE (StringDecodeIRIInvalid)
	ISOLATE_UNIT_TEST_CASE (StringIRITwoByte)
	ISOLATE_UNIT_TEST_CASE (Mint)
	ISOLATE_UNIT_TEST_CASE (Double)
	ISOLATE_UNIT_TEST_CASE (Integer)
	ISOLATE_UNIT_TEST_CASE (String)
	ISOLATE_UNIT_TEST_CASE (StringFormat)
	ISOLATE_UNIT_TEST_CASE (StringConcat)
	ISOLATE_UNIT_TEST_CASE (StringHashConcat)
	ISOLATE_UNIT_TEST_CASE (StringSubStringDifferentWidth)
	ISOLATE_UNIT_TEST_CASE (StringFromUtf8Literal)
	ISOLATE_UNIT_TEST_CASE (StringEqualsUtf8)
	ISOLATE_UNIT_TEST_CASE (StringEqualsUTF32)
	ISOLATE_UNIT_TEST_CASE (EscapeSpecialCharactersOneByteString)
	ISOLATE_UNIT_TEST_CASE (EscapeSpecialCharactersTwoByteString)
	ISOLATE_UNIT_TEST_CASE (Symbol)
	ISOLATE_UNIT_TEST_CASE (SymbolUnicode)
	ISOLATE_UNIT_TEST_CASE (Bool)
	ISOLATE_UNIT_TEST_CASE (Array)
	ISOLATE_UNIT_TEST_CASE (Array_Grow)
	ISOLATE_UNIT_TEST_CASE (EmptyInstantiationsCacheArray)
static void	TestIllegalArrayLength (intptr_t length)
	TEST_CASE (ArrayLengthNegativeOne)
	TEST_CASE (ArrayLengthSmiMin)
	TEST_CASE (ArrayLengthOneTooMany)
	TEST_CASE (ArrayLengthMaxElements)
static void	TestIllegalTypedDataLength (const char *class_name, intptr_t length)
	TEST_CASE (Int8ListLengthNegativeOne)
	TEST_CASE (Int8ListLengthSmiMin)
	TEST_CASE (Int8ListLengthOneTooMany)
	TEST_CASE (Int8ListLengthMaxElements)
	ISOLATE_UNIT_TEST_CASE (StringCodePointIterator)
	ISOLATE_UNIT_TEST_CASE (StringCodePointIteratorRange)
	ISOLATE_UNIT_TEST_CASE (GrowableObjectArray)
	ISOLATE_UNIT_TEST_CASE (TypedData_Grow)
	ISOLATE_UNIT_TEST_CASE (InternalTypedData)
	ISOLATE_UNIT_TEST_CASE (ExternalTypedData)
	ISOLATE_UNIT_TEST_CASE (Script)
	ISOLATE_UNIT_TEST_CASE (Context)
	ISOLATE_UNIT_TEST_CASE (ContextScope)
	ISOLATE_UNIT_TEST_CASE (Closure)
	ISOLATE_UNIT_TEST_CASE (ObjectPrinting)
	ISOLATE_UNIT_TEST_CASE (CheckedHandle)
static LibraryPtr	CreateDummyLibrary (const String &library_name)
static FunctionPtr	CreateFunction (const char *name)
	ISOLATE_UNIT_TEST_CASE (Code)
	ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION (CodeImmutability, "Crash")
	ISOLATE_UNIT_TEST_CASE (EmbedStringInCode)
	ISOLATE_UNIT_TEST_CASE (EmbedSmiInCode)
	ISOLATE_UNIT_TEST_CASE (ExceptionHandlers)
	ISOLATE_UNIT_TEST_CASE (PcDescriptors)
	ISOLATE_UNIT_TEST_CASE (PcDescriptorsLargeDeltas)
static ClassPtr	CreateTestClass (const char *name)
static FieldPtr	CreateTestField (const char *name)
	ISOLATE_UNIT_TEST_CASE (ClassDictionaryIterator)
static FunctionPtr	GetDummyTarget (const char *name)
	ISOLATE_UNIT_TEST_CASE (ICData)
	ISOLATE_UNIT_TEST_CASE (SubtypeTestCache)
	ISOLATE_UNIT_TEST_CASE (MegamorphicCache)
	ISOLATE_UNIT_TEST_CASE (FieldTests)
bool	EqualsIgnoringPrivate (const String &name, const String &private_name)
	ISOLATE_UNIT_TEST_CASE (EqualsIgnoringPrivate)
	ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION (ArrayNew_Overflow_Crash, "Crash")
	TEST_CASE (StackTraceFormat)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_PreserveRecurse)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_PreserveOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_PreserveTwo_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_PreserveTwoShared_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_PreserveOne_OldSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_PreserveTwo_OldSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_PreserveTwoShared_OldSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_ClearOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_ClearTwoShared_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_ClearOne_OldSpace)
	ISOLATE_UNIT_TEST_CASE (WeakProperty_ClearTwoShared_OldSpace)
static void	WeakReference_PreserveOne (Thread *thread, Heap::Space space)
	ISOLATE_UNIT_TEST_CASE (WeakReference_PreserveOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakReference_PreserveOne_OldSpace)
static void	WeakReference_ClearOne (Thread *thread, Heap::Space space)
	ISOLATE_UNIT_TEST_CASE (WeakReference_ClearOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakReference_ClearOne_OldSpace)
static void	WeakReference_Clear_ReachableThroughWeakProperty (Thread *thread, Heap::Space space)
	ISOLATE_UNIT_TEST_CASE (WeakReference_Clear_ReachableThroughWeakProperty_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakReference_Clear_ReachableThroughWeakProperty_OldSpace)
static void	WeakReference_Preserve_ReachableThroughWeakProperty (Thread *thread, Heap::Space space)
	ISOLATE_UNIT_TEST_CASE (WeakReference_Preserve_ReachableThroughWeakProperty_NewSpace)
	ISOLATE_UNIT_TEST_CASE (WeakReference_Preserve_ReachableThroughWeakProperty_OldSpace)
	ISOLATE_UNIT_TEST_CASE (WeakArray_New)
	ISOLATE_UNIT_TEST_CASE (WeakArray_Old)
static int	NumEntries (const FinalizerEntry &entry, intptr_t acc=0)
static void	Finalizer_PreserveOne (Thread *thread, Heap::Space space, bool with_detach)
	ISOLATE_UNIT_TEST_CASE (Finalizer_PreserveNoDetachOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_PreserveNoDetachOne_OldSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_PreserveWithDetachOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_PreserveWithDetachOne_OldSpace)
static void	Finalizer_ClearDetachOne (Thread *thread, Heap::Space space)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearDetachOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearDetachOne_OldSpace)
static void	Finalizer_ClearValueOne (Thread *thread, Heap::Space space, bool null_token)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearValueOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearValueOne_OldSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearValueNullTokenOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearValueNullTokenOne_OldSpace)
static void	Finalizer_DetachOne (Thread *thread, Heap::Space space, bool clear_value)
	ISOLATE_UNIT_TEST_CASE (Finalizer_DetachOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_DetachOne_OldSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_DetachAndClearValueOne_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_DetachAndClearValueOne_OldSpace)
static void	Finalizer_GcFinalizer (Thread *thread, Heap::Space space)
	ISOLATE_UNIT_TEST_CASE (Finalizer_GcFinalizer_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_GcFinalizer_OldSpace)
static void	Finalizer_TwoEntriesCrossGen (Thread *thread, Heap::Space *spaces, bool collect_old_space, bool collect_new_space, bool evacuate_new_space_and_collect_old_space, bool clear_value_1, bool clear_value_2, bool clear_detach_1, bool clear_detach_2)
static void	Finalizer_TwoEntries (Thread *thread, Heap::Space space, bool clear_value_1, bool clear_value_2, bool clear_detach_1, bool clear_detach_2)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearValueTwo_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearValueTwo_OldSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearFirstValue_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearFirstValue_OldSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearSecondValue_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearSecondValue_OldSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_PreserveTwo_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_PreserveTwo_OldSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearDetachTwo_NewSpace)
	ISOLATE_UNIT_TEST_CASE (Finalizer_ClearDetachTwo_OldSpace)
static void	Finalizer_TwoEntriesCrossGen (Thread *thread, intptr_t test_i)
	ISOLATE_UNIT_TEST_CASE (Finalizer_Regress_48843)
void	NativeFinalizer_TwoEntriesCrossGen_Finalizer (void *peer)
static void	NativeFinalizer_TwoEntriesCrossGen (Thread *thread, Heap::Space *spaces, bool collect_new_space, bool evacuate_new_space_and_collect_old_space, bool clear_value_1, bool clear_value_2, bool clear_detach_1, bool clear_detach_2)
static void	NativeFinalizer_TwoEntriesCrossGen (Thread *thread, intptr_t test_i)
	TEST_CASE (IsIsolateUnsendable)
	TEST_CASE (ImplementorCid)
	ISOLATE_UNIT_TEST_CASE (MirrorReference)
static FunctionPtr	GetFunction (const Class &cls, const char *name)
static FunctionPtr	GetStaticFunction (const Class &cls, const char *name)
static FieldPtr	GetField (const Class &cls, const char *name)
	ISOLATE_UNIT_TEST_CASE (FindClosureIndex)
	ISOLATE_UNIT_TEST_CASE (FindInvocationDispatcherFunctionIndex)
static void	PrintMetadata (const char *name, const Object &data)
	TEST_CASE (Metadata)
	TEST_CASE (FunctionSourceFingerprint)
	TEST_CASE (FunctionWithBreakpointNotInlined)
void	SetBreakpoint (Dart_NativeArguments args)
static Dart_NativeFunction	SetBreakpointResolver (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (DeoptimizeFramesWhenSettingBreakpoint)
	TEST_CASE (DartAPI_BreakpointLockRace)
	ISOLATE_UNIT_TEST_CASE (SpecialClassesHaveEmptyArrays)
	ISOLATE_UNIT_TEST_CASE (ToCString)
	ISOLATE_UNIT_TEST_CASE (PrintJSON)
	ISOLATE_UNIT_TEST_CASE (PrintJSONPrimitives)
	TEST_CASE (InstanceEquality)
	TEST_CASE (HashCode)
static bool	HashCodeEqualsCanonicalizeHash (const char *value_script, uint32_t hashcode_canonicalize_vm=kCalculateCanonicalizeHash, bool check_identity=true, bool check_hashcode=true)
	TEST_CASE (HashCode_Double)
	TEST_CASE (HashCode_Mint)
	TEST_CASE (HashCode_Null)
	TEST_CASE (HashCode_Smi)
	TEST_CASE (HashCode_String)
	TEST_CASE (HashCode_Symbol)
	TEST_CASE (HashCode_True)
	TEST_CASE (HashCode_Type_Dynamic)
	TEST_CASE (HashCode_Type_Int)
	TEST_CASE (Map_iteration)
template<class LinkedHashBase >
static bool	LinkedHashBaseEqual (const LinkedHashBase &map1, const LinkedHashBase &map2, bool print_diff, bool check_data=true)
static MapPtr	ConstructImmutableMap (const Array &input_data, intptr_t used_data, const TypeArguments &type_arguments)
	TEST_CASE (ConstMap_vm)
static bool	IsLinkedHashBase (const Object &object)
template<class LinkedHashBase , int kMutableCid, int kImmutableCid>
static void	HashBaseNonConstEqualsConst (const char *script, bool check_data=true)
static void	HashMapNonConstEqualsConst (const char *script, bool check_data=true)
static void	HashSetNonConstEqualsConst (const char *script, bool check_data=true)
	TEST_CASE (ConstMap_small)
	TEST_CASE (ConstMap_null)
	TEST_CASE (ConstMap_larger)
	TEST_CASE (ConstMap_nested)
	TEST_CASE (Set_iteration)
static SetPtr	ConstructImmutableSet (const Array &input_data, intptr_t used_data, const TypeArguments &type_arguments)
	TEST_CASE (ConstSet_vm)
	TEST_CASE (ConstSet_small)
	TEST_CASE (ConstSet_larger)
static void	CheckConcatAll (const String *data[], intptr_t n)
	ISOLATE_UNIT_TEST_CASE (Symbols_FromConcatAll)
	ISOLATE_UNIT_TEST_CASE (String_ScrubName)
	ISOLATE_UNIT_TEST_CASE (String_EqualsUTF32)
	TEST_CASE (TypeParameterTypeRef)
static void	FinalizeAndCanonicalize (AbstractType *type)
static void	CheckSubtypeRelation (const Expect &expect, const AbstractType &sub, const AbstractType &super, bool is_subtype)
	ISOLATE_UNIT_TEST_CASE (ClosureType_SubtypeOfFunctionType)
	ISOLATE_UNIT_TEST_CASE (FunctionType_IsSubtypeOfNonNullableObject)
static void	ExpectTypesEquivalent (const Expect &expect, const AbstractType &expected, const AbstractType &got, TypeEquality kind)
	TEST_CASE (Class_GetInstantiationOf)
static TypePtr	CreateFutureOrType (const AbstractType &param, Nullability nullability)
static TypePtr	CreateFutureType (const AbstractType &param, Nullability nullability)
	ISOLATE_UNIT_TEST_CASE (AbstractType_NormalizeFutureOrType)
	TEST_CASE (AbstractType_InstantiatedFutureOrIsNormalized)
static void	GenerateInvokeInstantiateTAVStub (compiler::Assembler *assembler)
static CodePtr	CreateInvokeInstantiateTypeArgumentsStub (Thread *thread)
static void	TypeArgumentsHashCacheTest (Thread *thread, intptr_t num_classes)
	TEST_CASE (TypeArguments_Cache_SomeInstantiations)
	TEST_CASE (TypeArguments_Cache_ManyInstantiations)
static void	SubtypeTestCacheCheckContents (Zone *zone, const SubtypeTestCache &cache)
static void	SubtypeTestCacheEntryTest (Thread *thread, const SubtypeTestCache &cache, const Object &instance_class_id_or_signature, const AbstractType &destination_type, const TypeArguments &instance_type_arguments, const TypeArguments &instantiator_type_arguments, const TypeArguments &function_type_arguments, const TypeArguments &parent_function_type_arguments, const TypeArguments &delayed_type_arguments, const Bool &expected_result, Bool *got_result)
static void	SubtypeTestCacheTest (Thread *thread, intptr_t num_classes, bool expect_hash)
	TEST_CASE (STC_LinearLookup)
	TEST_CASE (STC_HashLookup)
	VM_UNIT_TEST_CASE (SNPrint)
	VM_UNIT_TEST_CASE (OsFuncs)
static void	DeleteThread (void *thread)
	COMPILE_ASSERT (kObjectStartAlignment >=kObjectAlignment)
	COMPILE_ASSERT (kObjectStartAlignment >=2 *kBoolValueMask)
	TEST_CASE (PortMap_CreateAndCloseOnePort)
	TEST_CASE (PortMap_CreateAndCloseTwoPorts)
	TEST_CASE (PortMap_ClosePorts)
	TEST_CASE (PortMap_CreateManyPorts)
	TEST_CASE (PortMap_PostMessage)
	TEST_CASE (PortMap_PostIntegerMessage)
	TEST_CASE (PortMap_PostNullMessage)
	TEST_CASE (PortMap_PostMessageClosedPort)
	DEFINE_FLAG (bool, trace_profiled_isolates, false, "Trace profiled isolates.")
	DEFINE_FLAG (int, profile_period, 1000, "Time between profiler samples in microseconds. Minimum 50.")
	DEFINE_FLAG (int, max_profile_depth, Sample::kPCArraySizeInWords *kMaxSamplesPerTick, "Maximum number stack frames walked. Minimum 1. Maximum 255.")
	DEFINE_FLAG (bool, profile_vm, false, "Always collect native stack traces.")
	DEFINE_FLAG (bool, profile_vm_allocation, false, "Collect native stack traces when tracing Dart allocations.")
	DEFINE_FLAG (int, sample_buffer_duration, 0, "Defines the size of the profiler sample buffer to contain at least " "N seconds of samples at a given sample rate. If not provided, the " "default is ~4 seconds. Large values will greatly increase memory " "consumption.")
static void	DumpStackFrame (uword pc, uword fp, const char *name, uword offset)
void	DumpStackFrame (intptr_t frame_index, uword pc, uword fp)
static bool	ValidateThreadStackBounds (uintptr_t fp, uintptr_t sp, uword stack_lower, uword stack_upper)
static bool	GetAndValidateThreadStackBounds (OSThread *os_thread, Thread *thread, uintptr_t fp, uintptr_t sp, uword *stack_lower, uword *stack_upper)
static void	DumpCompilerState (Thread *thread)
static intptr_t	SamplesPerSecond ()
static void	FlushSampleBlocks (Isolate *isolate)
static void	CopyStackBuffer (Sample *sample, uword sp_addr)
static void	CollectSample (Isolate *isolate, bool exited_dart_code, bool in_dart_code, Sample *sample, ProfilerNativeStackWalker *native_stack_walker, ProfilerDartStackWalker *dart_stack_walker, uword pc, uword fp, uword sp, ProfilerCounters *counters)
static Sample *	SetupSample (Thread *thread, bool allocation_sample, ThreadId tid)
static bool	CheckIsolate (Isolate *isolate)
	DECLARE_FLAG (int, max_profile_depth)
	DECLARE_FLAG (int, profile_period)
	DECLARE_FLAG (bool, profile_vm)
	DECLARE_FLAG (bool, profile_vm_allocation)
	DECLARE_FLAG (int, optimization_counter_threshold)
static void	VisitSamples (SampleBlockBuffer *buffer, SampleVisitor *visitor)
	TEST_CASE (Profiler_SampleBufferWrapTest)
	TEST_CASE (Profiler_SampleBufferIterateTest)
	TEST_CASE (Profiler_AllocationSampleTest)
static LibraryPtr	LoadTestScript (const char *script)
static void	Invoke (const Library &lib, const char *name, intptr_t argc=0, Dart_Handle *argv=nullptr)
static void	EnableProfiler ()
	ISOLATE_UNIT_TEST_CASE (Profiler_TrivialRecordAllocation)
	ISOLATE_UNIT_TEST_CASE (Profiler_NullSampleBuffer)
	ISOLATE_UNIT_TEST_CASE (Profiler_ToggleRecordAllocation)
	ISOLATE_UNIT_TEST_CASE (Profiler_CodeTicks)
	ISOLATE_UNIT_TEST_CASE (Profiler_FunctionTicks)
	ISOLATE_UNIT_TEST_CASE (Profiler_IntrinsicAllocation)
	ISOLATE_UNIT_TEST_CASE (Profiler_ArrayAllocation)
	ISOLATE_UNIT_TEST_CASE (Profiler_ContextAllocation)
	ISOLATE_UNIT_TEST_CASE (Profiler_ClosureAllocation)
	ISOLATE_UNIT_TEST_CASE (Profiler_TypedArrayAllocation)
	ISOLATE_UNIT_TEST_CASE (Profiler_StringAllocation)
	ISOLATE_UNIT_TEST_CASE (Profiler_StringInterpolation)
	ISOLATE_UNIT_TEST_CASE (Profiler_FunctionInline)
	ISOLATE_UNIT_TEST_CASE (Profiler_InliningIntervalBoundary)
	ISOLATE_UNIT_TEST_CASE (Profiler_ChainedSamples)
	ISOLATE_UNIT_TEST_CASE (Profiler_BasicSourcePosition)
	ISOLATE_UNIT_TEST_CASE (Profiler_BasicSourcePositionOptimized)
	ISOLATE_UNIT_TEST_CASE (Profiler_SourcePosition)
	ISOLATE_UNIT_TEST_CASE (Profiler_SourcePositionOptimized)
	ISOLATE_UNIT_TEST_CASE (Profiler_BinaryOperatorSourcePosition)
	ISOLATE_UNIT_TEST_CASE (Profiler_BinaryOperatorSourcePositionOptimized)
static void	InsertFakeSample (uword *pc_offsets)
static uword	FindPCForTokenPosition (const Code &code, TokenPosition tp)
	ISOLATE_UNIT_TEST_CASE (Profiler_GetSourceReport)
	ISOLATE_UNIT_TEST_CASE (Profiler_ProfileCodeTableTest)
	ISOLATE_UNIT_TEST_CASE (Profiler_EnterExitIsolate)
	DECLARE_FLAG (charp, trace_precompiler_to)
	DECLARE_FLAG (charp, write_v8_snapshot_profile_to)
	DEFINE_FLAG (uint64_t, random_seed, 0, "Override the random seed for debugging.")
	DECLARE_FLAG (uint64_t, random_seed)
	VARIABLE_COMPRESSED_VISITOR (WeakArray, Smi::Value(raw_obj->untag() ->length())) VARIABLE_COMPRESSED_VISITOR(TypeArguments
raw_obj	untag () -> num_entries()) VARIABLE_COMPRESSED_VISITOR(Array, Smi::Value(raw_obj->untag() ->length())) VARIABLE_COMPRESSED_VISITOR(TypedData, TypedData::ElementSizeInBytes(raw_obj->GetClassId()) *Smi::Value(raw_obj->untag() ->length())) VARIABLE_COMPRESSED_VISITOR(Record, RecordShape(raw_obj->untag() ->shape()).num_fields()) VARIABLE_NULL_VISITOR(CompressedStackMaps, CompressedStackMaps::PayloadSizeOf(raw_obj)) VARIABLE_NULL_VISITOR(OneByteString, Smi::Value(raw_obj->untag() ->length())) VARIABLE_NULL_VISITOR(TwoByteString, Smi::Value(raw_obj->untag() ->length())) intptr_t UntaggedField::VisitFieldPointers(FieldPtr raw_obj, ObjectPointerVisitor *visitor)
	DEFINE_LEAF_RUNTIME_ENTRY (void, RememberCard, 2, uword object_in, ObjectPtr *slot)
	COMPILE_ASSERT (sizeof(UntaggedMint)==16)
	COMPILE_ASSERT (sizeof(UntaggedDouble)==16)
	COMPILE_ASSERT (sizeof(UntaggedFloat32x4)==24)
	COMPILE_ASSERT (sizeof(UntaggedInt32x4)==24)
	COMPILE_ASSERT (sizeof(UntaggedFloat64x2)==24)
ContainedInLattice	AddRange (ContainedInLattice containment, const int32_t *ranges, intptr_t ranges_length, Interval new_range)
static RegExpEngine::CompilationResult	IrregexpRegExpTooBig ()
static intptr_t	GetCaseIndependentLetters (uint16_t character, bool one_byte_subject, int32_t *letters)
static bool	EmitSimpleCharacter (Zone *zone, RegExpCompiler *compiler, uint16_t c, BlockLabel *on_failure, intptr_t cp_offset, bool check, bool preloaded)
static bool	EmitAtomNonLetter (Zone *zone, RegExpCompiler *compiler, uint16_t c, BlockLabel *on_failure, intptr_t cp_offset, bool check, bool preloaded)
static bool	ShortCutEmitCharacterPair (RegExpMacroAssembler *macro_assembler, bool one_byte, uint16_t c1, uint16_t c2, BlockLabel *on_failure)
static bool	EmitAtomLetter (Zone *zone, RegExpCompiler *compiler, uint16_t c, BlockLabel *on_failure, intptr_t cp_offset, bool check, bool preloaded)
static void	EmitBoundaryTest (RegExpMacroAssembler *masm, uint16_t border, BlockLabel *fall_through, BlockLabel *above_or_equal, BlockLabel *below)
static void	EmitDoubleBoundaryTest (RegExpMacroAssembler *masm, uint16_t first, uint16_t last, BlockLabel *fall_through, BlockLabel *in_range, BlockLabel *out_of_range)
static void	EmitUseLookupTable (RegExpMacroAssembler *masm, ZoneGrowableArray< uint16_t > *ranges, intptr_t start_index, intptr_t end_index, uint16_t min_char, BlockLabel *fall_through, BlockLabel *even_label, BlockLabel *odd_label)
static void	CutOutRange (RegExpMacroAssembler *masm, ZoneGrowableArray< uint16_t > *ranges, intptr_t start_index, intptr_t end_index, intptr_t cut_index, BlockLabel *even_label, BlockLabel *odd_label)
static void	SplitSearchSpace (ZoneGrowableArray< uint16_t > *ranges, intptr_t start_index, intptr_t end_index, intptr_t *new_start_index, intptr_t *new_end_index, uint16_t *border)
static void	GenerateBranches (RegExpMacroAssembler *masm, ZoneGrowableArray< uint16_t > *ranges, intptr_t start_index, intptr_t end_index, uint16_t min_char, uint16_t max_char, BlockLabel *fall_through, BlockLabel *even_label, BlockLabel *odd_label)
static void	EmitCharClass (RegExpMacroAssembler *macro_assembler, RegExpCharacterClass *cc, bool one_byte, BlockLabel *on_failure, intptr_t cp_offset, bool check_offset, bool preloaded, Zone *zone)
static uint32_t	SmearBitsRight (uint32_t v)
static bool	RangeContainsLatin1Equivalents (CharacterRange range)
static bool	RangesContainLatin1Equivalents (ZoneGrowableArray< CharacterRange > *ranges)
static uint16_t	ConvertNonLatin1ToLatin1 (uint16_t c)
static void	EmitWordCheck (RegExpMacroAssembler *assembler, BlockLabel *word, BlockLabel *non_word, bool fall_through_on_word)
static void	EmitHat (RegExpCompiler *compiler, RegExpNode *on_success, Trace *trace)
static bool	DeterminedAlready (QuickCheckDetails *quick_check, intptr_t offset)
static void	UpdateBoundsCheck (intptr_t index, intptr_t *checked_up_to)
static bool	CompareInverseRanges (ZoneGrowableArray< CharacterRange > *ranges, const int32_t *special_class, intptr_t length)
static bool	CompareRanges (ZoneGrowableArray< CharacterRange > *ranges, const int32_t *special_class, intptr_t length)
void	AddBmpCharacters (RegExpCompiler *compiler, ChoiceNode *result, RegExpNode *on_success, UnicodeRangeSplitter *splitter)
void	AddNonBmpSurrogatePairs (RegExpCompiler *compiler, ChoiceNode *result, RegExpNode *on_success, UnicodeRangeSplitter *splitter)
RegExpNode *	NegativeLookaroundAgainstReadDirectionAndMatch (RegExpCompiler *compiler, ZoneGrowableArray< CharacterRange > *lookbehind, ZoneGrowableArray< CharacterRange > *match, RegExpNode *on_success, bool read_backward, RegExpFlags flags)
RegExpNode *	MatchAndNegativeLookaroundInReadDirection (RegExpCompiler *compiler, ZoneGrowableArray< CharacterRange > *match, ZoneGrowableArray< CharacterRange > *lookahead, RegExpNode *on_success, bool read_backward, RegExpFlags flags)
void	AddLoneLeadSurrogates (RegExpCompiler *compiler, ChoiceNode *result, RegExpNode *on_success, UnicodeRangeSplitter *splitter)
void	AddLoneTrailSurrogates (RegExpCompiler *compiler, ChoiceNode *result, RegExpNode *on_success, UnicodeRangeSplitter *splitter)
RegExpNode *	UnanchoredAdvance (RegExpCompiler *compiler, RegExpNode *on_success)
void	AddUnicodeCaseEquivalents (ZoneGrowableArray< CharacterRange > *ranges)
static void	AddClass (const int32_t *elmv, intptr_t elmc, ZoneGrowableArray< CharacterRange > *ranges)
static void	AddClassNegated (const int32_t *elmv, intptr_t elmc, ZoneGrowableArray< CharacterRange > *ranges)
static void	MoveRanges (ZoneGrowableArray< CharacterRange > *list, intptr_t from, intptr_t to, intptr_t count)
static intptr_t	InsertRangeInCanonicalList (ZoneGrowableArray< CharacterRange > *list, intptr_t count, CharacterRange insert)
static bool	ArrayContains (ZoneGrowableArray< unsigned > *array, unsigned value)
	COMPILE_ASSERT (BoyerMoorePositionInfo::kMapSize==RegExpMacroAssembler::kTableSize)
RegExpNode *	OptionallyStepBackToLeadSurrogate (RegExpCompiler *compiler, RegExpNode *on_success, RegExpFlags flags)
void	CreateSpecializedFunction (Thread *thread, Zone *zone, const RegExp &regexp, intptr_t specialization_cid, bool sticky, const Object &owner)
ContainedInLattice	Combine (ContainedInLattice a, ContainedInLattice b)
ContainedInLattice	AddRange (ContainedInLattice a, const intptr_t *ranges, intptr_t ranges_size, Interval new_range)
void	PrintUtf16 (uint16_t c)
uword	CaseInsensitiveCompareUCS2 (uword str_raw, uword lhs_index_raw, uword rhs_index_raw, uword length_raw)
uword	CaseInsensitiveCompareUTF16 (uword str_raw, uword lhs_index_raw, uword rhs_index_raw, uword length_raw)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (CaseInsensitiveCompareUCS2, 4, false, CaseInsensitiveCompareUCS2)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (CaseInsensitiveCompareUTF16, 4, false, CaseInsensitiveCompareUTF16)
static intptr_t	Prepare (const RegExp &regexp, const String &subject, bool sticky, Zone *zone)
static ObjectPtr	ExecRaw (const RegExp &regexp, const String &subject, int32_t index, bool sticky, int32_t *output, intptr_t output_size, Zone *zone)
static Interval	ListCaptureRegisters (ZoneGrowableArray< RegExpTree * > *children)
static intptr_t	IncreaseBy (intptr_t previous, intptr_t increase)
	DEFINE_FLAG (bool, trace_regexp_bytecodes, false, "trace_regexp_bytecodes")
	DEFINE_FLAG (int, regexp_backtrack_stack_size_kb, 256, "Size of backtracking stack")
template<typename Char >
static bool	BackRefMatchesNoCase (Canonicalize *interp_canonicalize, intptr_t from, intptr_t current, intptr_t len, const String &subject, bool unicode)
template<>
bool	BackRefMatchesNoCase< uint16_t > (Canonicalize *interp_canonicalize, intptr_t from, intptr_t current, intptr_t len, const String &subject, bool unicode)
template<>
bool	BackRefMatchesNoCase< uint8_t > (Canonicalize *interp_canonicalize, intptr_t from, intptr_t current, intptr_t len, const String &subject, bool unicode)
static int32_t	Load32Aligned (const uint8_t *pc)
static int32_t	Load16Aligned (const uint8_t *pc)
template<typename Char >
static ObjectPtr	RawMatch (const TypedData &bytecode, const String &subject, int32_t *registers, int32_t current, uint32_t current_char)
static void	PushCodeUnit (RegExpCaptureName *v, uint32_t code_unit)
static intptr_t	HexValue (uint32_t c)
static ArrayPtr	Match (const String &pat, const String &str)
	ISOLATE_UNIT_TEST_CASE (RegExp_OneByteString)
	ISOLATE_UNIT_TEST_CASE (RegExp_TwoByteString)
	DEFINE_FLAG (bool, silent_warnings, false, "Silence warnings.")
	DEFINE_FLAG (bool, warning_as_error, false, "Treat warnings as errors.")
	DEFINE_FLAG (bool, trace_resolving, false, "Trace resolving.")
static FunctionPtr	ResolveDynamicAnyArgsWithCustomLookup (Zone *zone, const Class &receiver_class, const String &function_name, bool allow_add, std::function< FunctionPtr(Class &, const String &)> lookup)
static FunctionPtr	ResolveDynamicForReceiverClassWithCustomLookup (const Class &receiver_class, const String &function_name, const ArgumentsDescriptor &args_desc, bool allow_add, std::function< FunctionPtr(Class &, const String &)> lookup)
	TEST_CASE (RingBuffer)
	DEFINE_FLAG (int, max_subtype_cache_entries, kDefaultMaxSubtypeCacheEntries, "Maximum number of subtype cache entries (number of checks cached).")
	DEFINE_FLAG (int, regexp_optimization_counter_threshold, 1000, "RegExp's usage-counter value before it is optimized, -1 means never")
	DEFINE_FLAG (int, reoptimization_counter_threshold, 4000, "Counter threshold before a function gets reoptimized.")
	DEFINE_FLAG (bool, runtime_allocate_old, false, "Use old-space for allocation via runtime calls.")
	DEFINE_FLAG (bool, runtime_allocate_spill_tlab, false, "Ensure results of allocation via runtime calls are not in an " "active TLAB.")
	DEFINE_FLAG (bool, trace_deoptimization, false, "Trace deoptimization")
	DEFINE_FLAG (bool, trace_deoptimization_verbose, false, "Trace deoptimization verbose")
	DEFINE_FLAG (bool, trace_osr, false, "Trace attempts at on-stack replacement.")
	DEFINE_FLAG (int, gc_every, 0, "Run major GC on every N stack overflow checks")
	DEFINE_FLAG (int, stacktrace_every, 0, "Compute debugger stacktrace on every N stack overflow checks")
	DEFINE_FLAG (charp, stacktrace_filter, nullptr, "Compute stacktrace in named function on stack overflow checks")
	DEFINE_FLAG (charp, deoptimize_filter, nullptr, "Deoptimize in named function on stack overflow checks")
	DEFINE_FLAG (charp, deoptimize_on_runtime_call_name_filter, nullptr, "Runtime call name filter for --deoptimize-on-runtime-call-every.")
	DEFINE_FLAG (bool, unopt_monomorphic_calls, true, "Enable specializing monomorphic calls from unoptimized code.")
	DEFINE_FLAG (bool, unopt_megamorphic_calls, true, "Enable specializing megamorphic calls from unoptimized code.")
	DEFINE_FLAG (bool, verbose_stack_overflow, false, "Print additional details about stack overflow.")
	DECLARE_FLAG (bool, reload_every_optimized)
	DEFINE_RUNTIME_ENTRY (RangeError, 2)
	DEFINE_RUNTIME_ENTRY (RangeErrorUnboxedInt64, 0)
	DEFINE_RUNTIME_ENTRY (WriteError, 2)
static void	NullErrorHelper (Zone *zone, const String &selector, bool is_param_name=false)
static void	DoThrowNullError (Isolate *isolate, Thread *thread, Zone *zone, bool is_param)
	DEFINE_RUNTIME_ENTRY (NullError, 0)
void	ReportImpossibleNullError (intptr_t cid, StackFrame *caller_frame, Thread *thread)
	DEFINE_RUNTIME_ENTRY (DispatchTableNullError, 1)
	DEFINE_RUNTIME_ENTRY (NullErrorWithSelector, 1)
	DEFINE_RUNTIME_ENTRY (NullCastError, 0)
	DEFINE_RUNTIME_ENTRY (ArgumentNullError, 0)
	DEFINE_RUNTIME_ENTRY (ArgumentError, 1)
	DEFINE_RUNTIME_ENTRY (ArgumentErrorUnboxedInt64, 0)
	DEFINE_RUNTIME_ENTRY (DoubleToInteger, 1)
	DEFINE_RUNTIME_ENTRY (IntegerDivisionByZeroException, 0)
static Heap::Space	SpaceForRuntimeAllocation ()
static void	RuntimeAllocationEpilogue (Thread *thread)
	DEFINE_RUNTIME_ENTRY (AllocateArray, 2)
	DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT (AllocateDouble, 0)
	DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT (BoxDouble, 0)
	DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT (BoxFloat32x4, 0)
	DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT (BoxFloat64x2, 0)
	DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT (AllocateMint, 0)
	DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT (AllocateFloat32x4, 0)
	DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT (AllocateFloat64x2, 0)
	DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT (AllocateInt32x4, 0)
	DEFINE_RUNTIME_ENTRY (AllocateTypedData, 2)
static TokenPosition	GetCallerLocation ()
static void	ThrowIfError (const Object &result)
	DEFINE_RUNTIME_ENTRY (AllocateObject, 2)
	DEFINE_LEAF_RUNTIME_ENTRY (uword, EnsureRememberedAndMarkingDeferred, 2, uword object_in, Thread *thread)
END_LEAF_RUNTIME_ENTRY	DEFINE_RUNTIME_ENTRY (InstantiateType, 3)
	DEFINE_RUNTIME_ENTRY (InstantiateTypeArguments, 3)
static void	PrintSubtypeCheck (const AbstractType &subtype, const AbstractType &supertype, const bool result)
	DEFINE_RUNTIME_ENTRY (SubtypeCheck, 5)
	DEFINE_RUNTIME_ENTRY (AllocateClosure, 4)
	DEFINE_RUNTIME_ENTRY (AllocateContext, 1)
	DEFINE_RUNTIME_ENTRY (CloneContext, 1)
	DEFINE_RUNTIME_ENTRY (AllocateRecord, 1)
	DEFINE_RUNTIME_ENTRY (AllocateSmallRecord, 4)
	DEFINE_RUNTIME_ENTRY (AllocateSuspendState, 2)
	DEFINE_RUNTIME_ENTRY (CloneSuspendState, 1)
static void	PrintTypeCheck (const char *message, const Instance &instance, const AbstractType &type, const TypeArguments &instantiator_type_arguments, const TypeArguments &function_type_arguments, const Bool &result)
static void	UpdateTypeTestCache (Zone *zone, Thread *thread, const Instance &instance, const AbstractType &destination_type, const TypeArguments &instantiator_type_arguments, const TypeArguments &function_type_arguments, const Bool &result, const SubtypeTestCache &new_cache)
	DEFINE_RUNTIME_ENTRY (Instanceof, 5)
	DEFINE_RUNTIME_ENTRY (TypeCheck, 7)
	DEFINE_RUNTIME_ENTRY (NonBoolTypeError, 1)
	DEFINE_RUNTIME_ENTRY (Throw, 1)
	DEFINE_RUNTIME_ENTRY (ReThrow, 3)
	DEFINE_RUNTIME_ENTRY (PatchStaticCall, 0)
	DEFINE_RUNTIME_ENTRY (BreakpointRuntimeHandler, 0)
	DEFINE_RUNTIME_ENTRY (SingleStepHandler, 0)
static bool	ResolveCallThroughGetter (const Class &receiver_class, const String &target_name, const String &demangled, const Array &arguments_descriptor, Function *result)
FunctionPtr	InlineCacheMissHelper (const Class &receiver_class, const Array &args_descriptor, const String &target_name)
static void	TrySwitchInstanceCall (Thread *thread, StackFrame *caller_frame, const Code &caller_code, const Function &caller_function, const ICData &ic_data, const Function &target_function)
static FunctionPtr	ComputeTypeCheckTarget (const Instance &receiver, const AbstractType &type, const ArgumentsDescriptor &desc)
static FunctionPtr	Resolve (Thread *thread, Zone *zone, const GrowableArray< const Instance * > &caller_arguments, const Class &receiver_class, const String &name, const Array &descriptor)
	DEFINE_RUNTIME_ENTRY (StaticCallMissHandlerOneArg, 2)
	DEFINE_RUNTIME_ENTRY (StaticCallMissHandlerTwoArgs, 3)
static void	InlineCacheMissHandler (Thread *thread, Zone *zone, const GrowableArray< const Instance * > &args, const ICData &ic_data, NativeArguments native_arguments)
	DEFINE_RUNTIME_ENTRY (InlineCacheMissHandlerOneArg, 2)
	DEFINE_RUNTIME_ENTRY (InlineCacheMissHandlerTwoArgs, 3)
	DEFINE_RUNTIME_ENTRY (SwitchableCallMiss, 2)
static ObjectPtr	InvokeCallThroughGetterOrNoSuchMethod (Thread *thread, Zone *zone, const Instance &receiver, const String &target_name, const Array &orig_arguments, const Array &orig_arguments_desc)
	DEFINE_RUNTIME_ENTRY (NoSuchMethodFromCallStub, 4)
	DEFINE_RUNTIME_ENTRY (NoSuchMethodFromPrologue, 4)
static void	HandleStackOverflowTestCases (Thread *thread)
static void	HandleOSRRequest (Thread *thread)
	DEFINE_RUNTIME_ENTRY (InterruptOrStackOverflow, 0)
	DEFINE_RUNTIME_ENTRY (TraceICCall, 2)
	DEFINE_RUNTIME_ENTRY (OptimizeInvokedFunction, 1)
	DEFINE_RUNTIME_ENTRY (FixCallersTarget, 0)
	DEFINE_RUNTIME_ENTRY (FixCallersTargetMonomorphic, 2)
	DEFINE_RUNTIME_ENTRY (FixAllocationStubTarget, 0)
const char *	DeoptReasonToCString (ICData::DeoptReasonId deopt_reason)
static bool	IsSuspendedFrame (Zone *zone, const Function &function, StackFrame *frame)
void	DeoptimizeAt (Thread *mutator_thread, const Code &optimized_code, StackFrame *frame)
void	DeoptimizeFunctionsOnStack ()
static void	DeoptimizeLastDartFrameIfOptimized ()
static void	CopySavedRegisters (uword saved_registers_address, fpu_register_t **fpu_registers, intptr_t **cpu_registers)
	DEFINE_LEAF_RUNTIME_ENTRY (bool, TryDoubleAsInteger, 1, Thread *thread)
END_LEAF_RUNTIME_ENTRY	DEFINE_LEAF_RUNTIME_ENTRY (intptr_t, DeoptimizeCopyFrame, 2, uword saved_registers_address, uword is_lazy_deopt)
END_LEAF_RUNTIME_ENTRY	DEFINE_LEAF_RUNTIME_ENTRY (void, DeoptimizeFillFrame, 1, uword last_fp)
END_LEAF_RUNTIME_ENTRY	DEFINE_RUNTIME_ENTRY (DeoptimizeMaterialize, 0)
	DEFINE_RUNTIME_ENTRY (RewindPostDeopt, 0)
	DEFINE_RUNTIME_ENTRY (ResumeFrame, 2)
void	OnEveryRuntimeEntryCall (Thread *thread, const char *runtime_call_name, bool can_lazy_deopt)
double	DartModulo (double left, double right)
	DEFINE_RUNTIME_ENTRY (UpdateFieldCid, 2)
	DEFINE_RUNTIME_ENTRY (InitInstanceField, 2)
	DEFINE_RUNTIME_ENTRY (InitStaticField, 1)
	DEFINE_RUNTIME_ENTRY (LateFieldAssignedDuringInitializationError, 1)
	DEFINE_RUNTIME_ENTRY (LateFieldNotInitializedError, 1)
	DEFINE_RUNTIME_ENTRY (NotLoaded, 0)
	DEFINE_RUNTIME_ENTRY (FfiAsyncCallbackSend, 1)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcPow, 2, true, static_cast< BinaryMathCFunction >(pow))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (DartModulo, 2, true, static_cast< BinaryMathCFunction >(DartModulo))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcAtan2, 2, true, static_cast< BinaryMathCFunction >(atan2_ieee))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcFloor, 1, true, static_cast< UnaryMathCFunction >(floor))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcCeil, 1, true, static_cast< UnaryMathCFunction >(ceil))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcTrunc, 1, true, static_cast< UnaryMathCFunction >(trunc))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcRound, 1, true, static_cast< UnaryMathCFunction >(round))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcCos, 1, true, static_cast< UnaryMathCFunction >(cos))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcSin, 1, true, static_cast< UnaryMathCFunction >(sin))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcAsin, 1, true, static_cast< UnaryMathCFunction >(asin))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcAcos, 1, true, static_cast< UnaryMathCFunction >(acos))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcTan, 1, true, static_cast< UnaryMathCFunction >(tan))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcAtan, 1, true, static_cast< UnaryMathCFunction >(atan))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcExp, 1, true, static_cast< UnaryMathCFunction >(exp))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (LibcLog, 1, true, static_cast< UnaryMathCFunction >(log))
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (MemoryMove, 3, false, static_cast< MemMoveCFunction >(memmove))
void	DFLRT_EnterSafepoint (NativeArguments __unusable_)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (EnterSafepoint, 0, false, DFLRT_EnterSafepoint)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (ExitSafepoint, 0, false, DFLRT_ExitSafepoint)
void	DFLRT_ExitSafepointIgnoreUnwindInProgress (NativeArguments __unusable_)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (ExitSafepointIgnoreUnwindInProgress, 0, false, DFLRT_ExitSafepointIgnoreUnwindInProgress)
Thread *	DLRT_GetFfiCallbackMetadata (FfiCallbackMetadata::Trampoline trampoline, uword *out_entry_point, uword *out_trampoline_type)
void	DLRT_ExitTemporaryIsolate ()
ApiLocalScope *	DLRT_EnterHandleScope (Thread *thread)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (EnterHandleScope, 1, false, DLRT_EnterHandleScope)
void	DLRT_ExitHandleScope (Thread *thread)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (ExitHandleScope, 1, false, DLRT_ExitHandleScope)
LocalHandle *	DLRT_AllocateHandle (ApiLocalScope *scope)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (AllocateHandle, 1, false, DLRT_AllocateHandle)
void	DLRT_PropagateError (Dart_Handle handle)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (PropagateError, 1, false, DLRT_PropagateError)
void	__msan_unpoison (const volatile void *, size_t)
void	__msan_unpoison_param (size_t)
void	__tsan_acquire (void *addr)
void	__tsan_release (void *addr)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (MsanUnpoison, 2, false, __msan_unpoison)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (MsanUnpoisonParam, 1, false, __msan_unpoison_param)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (TsanLoadAcquire, 1, false, __tsan_acquire)
	DEFINE_RAW_LEAF_RUNTIME_ENTRY (TsanStoreRelease, 1, false, __tsan_release)
	DEFINE_FLAG (bool, share_enclosing_context, true, "Allocate captured variables in the existing context of an " "enclosing scope (up to innermost loop) and spare the allocation " "of a local context.")
	ISOLATE_UNIT_TEST_CASE (LocalScope)
	DEFINE_FLAG (charp, vm_name, "vm", "The default name of this vm as reported by the VM service " "protocol")
	DEFINE_FLAG (bool, warn_on_pause_with_no_debugger, false, "Print a message when an isolate is paused but there is no " "debugger attached.")
	DEFINE_FLAG (charp, log_service_response_sizes, nullptr, "Log sizes of service responses and events to a file in CSV format.")
static void	PrintInvalidParamError (JSONStream *js, const char *param)
static const char *	GetVMName ()
const ServiceMethodDescriptor *	FindMethod (const char *method_name)
static void	PrintSuccess (JSONStream *js)
static bool	CheckDebuggerDisabled (Thread *thread, JSONStream *js)
static bool	CheckProfilerDisabled (Thread *thread, JSONStream *js)
static bool	GetIntegerId (const char *s, intptr_t *id, int base=10)
static bool	GetUnsignedIntegerId (const char *s, uintptr_t *id, int base=10)
static bool	GetInteger64Id (const char *s, int64_t *id, int base=10)
static const char *	ScanUntilDash (const char *s)
static bool	GetCodeId (const char *s, int64_t *timestamp, uword *address)
static bool	GetPrefixedIntegerId (const char *s, const char *prefix, intptr_t *service_id)
static bool	IsValidClassId (Isolate *isolate, intptr_t cid)
static ClassPtr	GetClassForId (Isolate *isolate, intptr_t cid)
template<typename T >
T	EnumMapper (const char *value, const char *const *enums, T *values)
static void	PrintMissingParamError (JSONStream *js, const char *param)
static void	PrintUnrecognizedMethodError (JSONStream *js)
static bool	ValidateParameters (const MethodParameter *const *parameters, JSONStream *js)
static void	Finalizer (void *isolate_callback_data, void *buffer)
static void	ReportPauseOnConsole (ServiceEvent *event)
static void	GetIsolate (Thread *thread, JSONStream *js)
static void	PrintSentinel (JSONStream *js, SentinelType sentinel_type)
static void	SetStreamIncludePrivateMembers (Thread *thread, JSONStream *js)
static void	ActOnIsolateGroup (JSONStream *js, std::function< void(IsolateGroup *)> visitor)
static void	GetIsolateGroup (Thread *thread, JSONStream *js)
static void	GetMemoryUsage (Thread *thread, JSONStream *js)
static void	GetIsolateGroupMemoryUsage (Thread *thread, JSONStream *js)
static void	GetIsolatePauseEvent (Thread *thread, JSONStream *js)
static void	GetScripts (Thread *thread, JSONStream *js)
static void	GetStack (Thread *thread, JSONStream *js)
static void	HandleCommonEcho (JSONObject *jsobj, JSONStream *js)
static void	TriggerEchoEvent (Thread *thread, JSONStream *js)
static void	Echo (Thread *thread, JSONStream *js)
static bool	ContainsNonInstance (const Object &obj)
static ObjectPtr	LookupObjectId (Thread *thread, const char *arg, ObjectIdRing::LookupResult *kind)
static ObjectPtr	LookupClassMembers (Thread *thread, const Class &klass, char **parts, int num_parts)
static ObjectPtr	LookupHeapObjectLibraries (IsolateGroup *isolate_group, char **parts, int num_parts)
static ObjectPtr	LookupHeapObjectClasses (Thread *thread, char **parts, int num_parts)
static ObjectPtr	LookupHeapObjectTypeArguments (Thread *thread, char **parts, int num_parts)
static ObjectPtr	LookupHeapObjectCode (char **parts, int num_parts)
static ObjectPtr	LookupHeapObjectMessage (Thread *thread, char **parts, int num_parts)
static ObjectPtr	LookupHeapObject (Thread *thread, const char *id_original, ObjectIdRing::LookupResult *result)
static Breakpoint *	LookupBreakpoint (Isolate *isolate, const char *id, ObjectIdRing::LookupResult *result)
static void	AddParentFieldToResponseBasedOnRecord (Thread *thread, Array *field_names_handle, String *name_handle, const JSONObject &jsresponse, const Record &record, const intptr_t field_slot_offset)
static void	PrintInboundReferences (Thread *thread, Object *target, intptr_t limit, JSONStream *js)
static void	GetInboundReferences (Thread *thread, JSONStream *js)
static void	PrintRetainingPath (Thread *thread, Object *obj, intptr_t limit, JSONStream *js)
static void	GetRetainingPath (Thread *thread, JSONStream *js)
static void	GetRetainedSize (Thread *thread, JSONStream *js)
static void	GetReachableSize (Thread *thread, JSONStream *js)
static void	Invoke (Thread *thread, JSONStream *js)
static bool	IsAlpha (char c)
static bool	IsAlphaOrDollar (char c)
static bool	IsAlphaNum (char c)
static bool	IsAlphaNumOrDollar (char c)
static bool	IsWhitespace (char c)
static bool	IsObjectIdChar (char c)
static bool	ParseScope (const char *scope, GrowableArray< const char * > *names, GrowableArray< const char * > *ids)
static bool	BuildScope (Thread *thread, JSONStream *js, const GrowableObjectArray &names, const GrowableObjectArray &values)
static void	Evaluate (Thread *thread, JSONStream *js)
static void	CollectStringifiedType (Thread *thread, Zone *zone, const AbstractType &type, const GrowableObjectArray &output)
static void	BuildExpressionEvaluationScope (Thread *thread, JSONStream *js)
static bool	ParseCSVList (const char *csv_list, const GrowableObjectArray &values)
static void	CompileExpression (Thread *thread, JSONStream *js)
ExternalTypedDataPtr	DecodeKernelBuffer (const char *kernel_buffer_base64)
static void	EvaluateCompiledExpression (Thread *thread, JSONStream *js)
static void	EvaluateInFrame (Thread *thread, JSONStream *js)
static void	MarkClasses (const Class &root, bool include_subclasses, bool include_implementors)
static void	UnmarkClasses ()
static void	GetInstances (Thread *thread, JSONStream *js)
static void	GetInstancesAsList (Thread *thread, JSONStream *js)
template<typename Adder >
static intptr_t	ParseJSONCollection (Thread *thread, const char *str, const Adder &add)
intptr_t	ParseJSONArray (Thread *thread, const char *str, const GrowableObjectArray &elements)
static intptr_t	ParseJSONSet (Thread *thread, const char *str, ZoneCStringSet *elements)
static void	GetPorts (Thread *thread, JSONStream *js)
static void	GetSourceReport (Thread *thread, JSONStream *js)
static void	ReloadSources (Thread *thread, JSONStream *js)
static void	AddBreakpointCommon (Thread *thread, JSONStream *js, const String &script_uri)
static void	AddBreakpoint (Thread *thread, JSONStream *js)
static void	AddBreakpointWithScriptUri (Thread *thread, JSONStream *js)
static void	AddBreakpointAtEntry (Thread *thread, JSONStream *js)
static void	AddBreakpointAtActivation (Thread *thread, JSONStream *js)
static void	RemoveBreakpoint (Thread *thread, JSONStream *js)
static void	HandleNativeMetricsList (Thread *thread, JSONStream *js)
static void	HandleNativeMetric (Thread *thread, JSONStream *js, const char *id)
static void	GetIsolateMetricList (Thread *thread, JSONStream *js)
static void	GetIsolateMetric (Thread *thread, JSONStream *js)
static void	GetCpuSamplesCommon (TimelineOrSamplesResponseFormat format, Thread *thread, JSONStream *js)
void	GetVMTimelineCommon (TimelineOrSamplesResponseFormat format, Thread *thread, JSONStream *js)
static void	SetVMTimelineFlags (Thread *thread, JSONStream *js)
static void	GetVMTimelineFlags (Thread *thread, JSONStream *js)
static void	GetVMTimelineMicros (Thread *thread, JSONStream *js)
static void	ClearVMTimeline (Thread *thread, JSONStream *js)
static void	GetVMTimeline (Thread *thread, JSONStream *js)
static void	Resume (Thread *thread, JSONStream *js)
static void	Kill (Thread *thread, JSONStream *js)
static void	Pause (Thread *thread, JSONStream *js)
static void	EnableProfiler (Thread *thread, JSONStream *js)
static void	GetTagProfile (Thread *thread, JSONStream *js)
static void	GetCpuSamples (Thread *thread, JSONStream *js)
static void	GetAllocationTraces (Thread *thread, JSONStream *js)
static void	ClearCpuSamples (Thread *thread, JSONStream *js)
static void	GetAllocationProfileImpl (Thread *thread, JSONStream *js, bool internal)
static void	GetAllocationProfilePublic (Thread *thread, JSONStream *js)
static void	GetAllocationProfile (Thread *thread, JSONStream *js)
static void	CollectAllGarbage (Thread *thread, JSONStream *js)
static void	GetHeapMap (Thread *thread, JSONStream *js)
static void	RequestHeapSnapshot (Thread *thread, JSONStream *js)
static intptr_t	GetProcessMemoryUsageHelper (JSONStream *js)
static void	GetProcessMemoryUsage (Thread *thread, JSONStream *js)
static void	GetPersistentHandles (Thread *thread, JSONStream *js)
static void	GetPortsPrivate (Thread *thread, JSONStream *js)
static void	RespondWithMalformedJson (Thread *thread, JSONStream *js)
static void	RespondWithMalformedObject (Thread *thread, JSONStream *js)
static bool	GetHeapObjectCommon (Thread *thread, JSONStream *js, const char *id, Object *obj, ObjectIdRing::LookupResult *lookup_result)
static void	GetObject (Thread *thread, JSONStream *js)
static void	GetImplementationFields (Thread *thread, JSONStream *js)
static void	GetObjectStore (Thread *thread, JSONStream *js)
static void	GetIsolateObjectStore (Thread *thread, JSONStream *js)
static void	GetClassList (Thread *thread, JSONStream *js)
static void	GetTypeArgumentsList (Thread *thread, JSONStream *js)
static void	GetVersion (Thread *thread, JSONStream *js)
static void	GetVM (Thread *thread, JSONStream *js)
static void	PopulateUriMappings (Thread *thread)
static void	LookupScriptUrisImpl (Thread *thread, JSONStream *js, bool lookup_resolved)
static void	LookupResolvedPackageUris (Thread *thread, JSONStream *js)
static void	LookupPackageUris (Thread *thread, JSONStream *js)
static void	SetExceptionPauseMode (Thread *thread, JSONStream *js)
static void	SetIsolatePauseMode (Thread *thread, JSONStream *js)
static void	SetBreakpointState (Thread *thread, JSONStream *js)
static void	GetFlagList (Thread *thread, JSONStream *js)
static void	SetFlag (Thread *thread, JSONStream *js)
static void	SetLibraryDebuggable (Thread *thread, JSONStream *js)
static void	SetName (Thread *thread, JSONStream *js)
static void	SetVMName (Thread *thread, JSONStream *js)
static void	SetTraceClassAllocation (Thread *thread, JSONStream *js)
static void	GetDefaultClassesAliases (Thread *thread, JSONStream *js)
	DEFINE_FLAG (bool, trace_service, false, "Trace VM service requests.")
	DEFINE_FLAG (bool, trace_service_pause_events, false, "Trace VM service isolate pause events.")
	DEFINE_FLAG (bool, trace_service_verbose, false, "Provide extra service tracing information.")
static ArrayPtr	MakeServerControlMessage (const SendPort &sp, intptr_t code, bool enable, const Bool &silenceOutput)
	DEFINE_FLAG (bool, service_testing_flag, false, "Comment")
static ArrayPtr	Eval (Dart_Handle lib, const char *expr)
static ArrayPtr	EvalF (Dart_Handle lib, const char *fmt,...)
static FunctionPtr	GetFunction (const Class &cls, const char *name)
static void	HandleIsolateMessage (Isolate *isolate, const Array &msg)
static void	HandleRootMessage (const Array &message)
	ISOLATE_UNIT_TEST_CASE (Service_IsolateStickyError)
	ISOLATE_UNIT_TEST_CASE (Service_IdZones)
	ISOLATE_UNIT_TEST_CASE (Service_Code)
	ISOLATE_UNIT_TEST_CASE (Service_PcDescriptors)
	ISOLATE_UNIT_TEST_CASE (Service_LocalVarDescriptors)
static void	WeakHandleFinalizer (void *isolate_callback_data, void *peer)
	ISOLATE_UNIT_TEST_CASE (Service_PersistentHandles)
static bool	alpha_callback (const char *name, const char **option_keys, const char **option_values, intptr_t num_options, void *user_data, const char **result)
static bool	beta_callback (const char *name, const char **option_keys, const char **option_values, intptr_t num_options, void *user_data, const char **result)
	ISOLATE_UNIT_TEST_CASE (Service_EmbedderRootHandler)
	ISOLATE_UNIT_TEST_CASE (Service_EmbedderIsolateHandler)
static void	EnableProfiler ()
	ISOLATE_UNIT_TEST_CASE (Service_Profile)
	ISOLATE_UNIT_TEST_CASE (Service_ParseJSONArray)
static bool	IsSnapshotCompatible (Snapshot::Kind vm_kind, Snapshot::Kind isolate_kind)
static bool	Equals (const Object &expected, const Object &actual)
static void	CompareDartCObjects (Dart_CObject *first, Dart_CObject *second)
static void	CheckEncodeDecodeMessage (Zone *zone, Dart_CObject *root)
static void	ExpectEncodeFail (Zone *zone, Dart_CObject *root)
	ISOLATE_UNIT_TEST_CASE (SerializeNull)
	ISOLATE_UNIT_TEST_CASE (SerializeSmi1)
	ISOLATE_UNIT_TEST_CASE (SerializeSmi2)
Dart_CObject *	SerializeAndDeserializeMint (Zone *zone, const Mint &mint)
void	CheckMint (int64_t value)
	ISOLATE_UNIT_TEST_CASE (SerializeMints)
	ISOLATE_UNIT_TEST_CASE (SerializeDouble)
	ISOLATE_UNIT_TEST_CASE (SerializeTrue)
	ISOLATE_UNIT_TEST_CASE (SerializeFalse)
	ISOLATE_UNIT_TEST_CASE (SerializeCapability)
	ISOLATE_UNIT_TEST_CASE (SerializeSingletons)
static void	TestString (const char *cstr)
	ISOLATE_UNIT_TEST_CASE (SerializeString)
	ISOLATE_UNIT_TEST_CASE (SerializeArray)
	ISOLATE_UNIT_TEST_CASE (SerializeArrayWithTypeArgument)
	TEST_CASE (FailSerializeLargeArray)
	TEST_CASE (FailSerializeLargeNestedArray)
	TEST_CASE (FailSerializeLargeTypedDataInt8)
	TEST_CASE (FailSerializeLargeTypedDataUint8)
	TEST_CASE (FailSerializeLargeExternalTypedData)
	TEST_CASE (FailSerializeLargeUnmodifiableExternalTypedData)
	ISOLATE_UNIT_TEST_CASE (SerializeEmptyArray)
	ISOLATE_UNIT_TEST_CASE (SerializeByteArray)
	ISOLATE_UNIT_TEST_CASE (SerializeTypedArray)
	ISOLATE_UNIT_TEST_CASE (SerializeExternalTypedArray)
	ISOLATE_UNIT_TEST_CASE (SerializeUnmodifiableExternalTypedArray)
	ISOLATE_UNIT_TEST_CASE (SerializeEmptyByteArray)
	VM_UNIT_TEST_CASE (FullSnapshot)
static std::unique_ptr< Message >	GetSerialized (Dart_Handle lib, const char *dart_function)
static void	CheckString (Dart_Handle dart_string, const char *expected)
static void	CheckStringInvalid (Dart_Handle dart_string)
	VM_UNIT_TEST_CASE (DartGeneratedMessages)
	VM_UNIT_TEST_CASE (DartGeneratedListMessages)
	VM_UNIT_TEST_CASE (DartGeneratedArrayLiteralMessages)
	VM_UNIT_TEST_CASE (DartGeneratedListMessagesWithBackref)
	VM_UNIT_TEST_CASE (DartGeneratedArrayLiteralMessagesWithBackref)
static void	CheckTypedData (Dart_CObject *object, Dart_TypedData_Type typed_data_type, int len)
	VM_UNIT_TEST_CASE (DartGeneratedListMessagesWithTypedData)
static void	MallocFinalizer (void *isolate_callback_data, void *peer)
static void	NoopFinalizer (void *isolate_callback_data, void *peer)
	VM_UNIT_TEST_CASE (PostCObject)
	TEST_CASE (IsKernelNegative)
static ObjectPtr	ExecuteScript (const char *script, bool allow_errors=false)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_NoCalls)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_Filters_single)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_Filters_empty)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_SimpleCall)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_ForceCompile)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_UnusedClass_NoForceCompile)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_UnusedClass_ForceCompile)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_UnusedClass_ForceCompileError)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_LibrariesAlreadyCompiled)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_NestedFunctions)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_RestrictedRange)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_AllFunctions)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_AllFunctions_ForceCompile)
	ISOLATE_UNIT_TEST_CASE (SourceReport_CallSites_SimpleCall)
	ISOLATE_UNIT_TEST_CASE (SourceReport_CallSites_PolymorphicCall)
	ISOLATE_UNIT_TEST_CASE (SourceReport_MultipleReports)
	ISOLATE_UNIT_TEST_CASE (SourceReport_PossibleBreakpoints_Simple)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_Issue35453_NoSuchMethod)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_Issue47017_Assert)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_Issue47021_StaticOnlyClasses)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_IssueCov341_LateFinalVars)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Coverage_IssueCov386_EnhancedEnums)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Regress95008_RedirectingFactory)
	ISOLATE_UNIT_TEST_CASE (SourceReport_Regress53519_Destructuring)
	ISOLATE_UNIT_TEST_CASE (SourceReport_BranchCoverage_if)
	ISOLATE_UNIT_TEST_CASE (SourceReport_BranchCoverage_loops)
	ISOLATE_UNIT_TEST_CASE (SourceReport_BranchCoverage_switch)
	ISOLATE_UNIT_TEST_CASE (SourceReport_BranchCoverage_try)
static DART_FORCE_INLINE intptr_t	LocalVarIndex (intptr_t fp_offset, intptr_t var_index)
static DART_FORCE_INLINE uword	ParamAddress (uword fp, intptr_t reverse_index)
static DART_FORCE_INLINE bool	IsCalleeFrameOf (uword fp, uword other_fp)
static DART_FORCE_INLINE uword	LocalVarAddress (uword fp, intptr_t index)
	COMPILE_ASSERT (kAbiPreservedCpuRegCount==7)
	COMPILE_ASSERT (kAbiPreservedFpuRegCount==4)
	ISOLATE_UNIT_TEST_CASE (EmptyStackFrameIteration)
	ISOLATE_UNIT_TEST_CASE (EmptyDartStackFrameIteration)
void FUNCTION_NAME()	StackFrame_equals (Dart_NativeArguments args)
void FUNCTION_NAME()	StackFrame_frameCount (Dart_NativeArguments args)
void FUNCTION_NAME()	StackFrame_dartFrameCount (Dart_NativeArguments args)
void FUNCTION_NAME()	StackFrame_validateFrame (Dart_NativeArguments args)
static Dart_NativeFunction	native_lookup (Dart_Handle name, int argument_count, bool *auto_setup_scope)
	TEST_CASE (ValidateStackFrameIteration)
	TEST_CASE (ValidateNoSuchMethodStackFrameIteration)
const Function &	RegisterFakeFunction (const char *name, const Code &code)
StringPtr	StringFrom (const uint8_t *data, intptr_t len, Heap::Space space)
StringPtr	StringFrom (const uint16_t *data, intptr_t len, Heap::Space space)
intptr_t	RawSmiValue (const SmiPtr raw_value)
	DECLARE_FLAG (bool, trace_service_verbose)
static bool	ShouldSuspend (bool isolate_shutdown, Thread *thread)
static bool	IsInterruptLimit (uword limit)
	VM_UNIT_TEST_CASE (ThreadBarrier)
	DEFINE_FLAG (bool, trace_thread_interrupter, false, "Trace thread interrupter")
	DEFINE_FLAG (int, worker_timeout_millis, 5000, "Free workers when they have been idle for this amount of time.")
static int64_t	ComputeTimeout (int64_t idle_start)
	DECLARE_FLAG (int, worker_timeout_millis)
	THREAD_POOL_UNIT_TEST_CASE (ThreadPool_Create)
	THREAD_POOL_UNIT_TEST_CASE (ThreadPool_RunOne)
	THREAD_POOL_UNIT_TEST_CASE (ThreadPool_RunMany)
	THREAD_POOL_UNIT_TEST_CASE (ThreadPool_WorkerShutdown)
	THREAD_POOL_UNIT_TEST_CASE (ThreadPool_WorkerTimeout)
	THREAD_POOL_UNIT_TEST_CASE (ThreadPool_RecursiveSpawn)
	VM_UNIT_TEST_CASE (Mutex)
	VM_UNIT_TEST_CASE (Monitor)
	ISOLATE_UNIT_TEST_CASE (ManyTasksWithZones)
	ISOLATE_UNIT_TEST_CASE (ManySimpleTasksWithZones)
	TEST_CASE (ThreadRegistry)
static Function *	CreateFunction (const char *name)
	ISOLATE_UNIT_TEST_CASE (ICDataTest)
	TEST_CASE (SafepointTestDart)
	ISOLATE_UNIT_TEST_CASE (SafepointTestVM)
	ISOLATE_UNIT_TEST_CASE (RecursiveSafepointTest1)
	ISOLATE_UNIT_TEST_CASE (ThreadIterator_Count)
	ISOLATE_UNIT_TEST_CASE (ThreadIterator_FindSelf)
void	ThreadIteratorTestMain (uword parameter)
	TEST_CASE (ThreadIterator_AddFindRemove)
	ISOLATE_UNIT_TEST_CASE (SafepointTestVM2)
	ISOLATE_UNIT_TEST_CASE (RecursiveSafepointTest2)
	ISOLATE_UNIT_TEST_CASE (HelperAllocAndGC)
	ISOLATE_UNIT_TEST_CASE (ExerciseTLABs)
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockWithReadLock)
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockWithWriteLock)
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockWithoutAnyLocks)
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockReentrantReadLock)
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockReentrantWriteLock)
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockWriteToReadLock)
template<typename LockType , typename LockerType >
static void	RunLockerWithLongJumpTest ()
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockWriteWithLongJmp)
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockReadWithLongJmp)
	ISOLATE_UNIT_TEST_CASE (SafepointMutexLockerWithLongJmp)
void	Helper (uword arg)
	ISOLATE_UNIT_TEST_CASE (SafepointRwLockExclusiveNestedWriter_Regress44000)
	ISOLATE_UNIT_TEST_CASE (SafepointMonitorUnlockScope)
	TEST_CASE (TimelineEventIsValid)
	TEST_CASE (TimelineEventDuration)
	TEST_CASE (TimelineEventDurationPrintJSON)
	TEST_CASE (TimelineEventArguments)
	TEST_CASE (TimelineEventArgumentsPrintJSON)
	TEST_CASE (TimelineEventBufferPrintJSON)
	TEST_CASE (TimelineEventCallbackRecorderBasic)
	TEST_CASE (TimelineRingRecorderJSONOrder)
	TEST_CASE (TimelineRingRecorderRace)
	TEST_CASE (TimelineTrackMetadataRace)
	SENTINEL_TOKEN_DESCRIPTORS (DEFINE_VALUES)
static CodePtr	RetryCompilationWithFarBranches (Thread *thread, std::function< CodePtr(compiler::Assembler &)> fun)
static void	CommentCheckedClasses (compiler::Assembler *assembler, const CidRangeVector &ranges)
static CheckType	SubtypeChecksForClass (Zone *zone, const Type &type, const Class &type_class, const Class &to_check)
static void	CommentSkippedClasses (compiler::Assembler *assembler, const Type &type, const Class &type_class, const CidRangeVector &ranges)
static void	SplitByTypeArgumentsFieldOffset (Thread *T, const Class &type_class, const CidRangeVector &ranges, GrowableArray< CidRangeVector * > *output)
static void	SplitOnTypeArgumentTests (HierarchyInfo *hi, const Type &type, const Class &type_class, const CidRangeVector &ranges, CidRangeVector *cid_check_only, CidRangeVector *type_argument_checks, CidRangeVector *not_checked)
void	RegisterTypeArgumentsUse (const Function &function, TypeUsageInfo *type_usage_info, const Class &klass, Definition *type_arguments)
void	DeoptimizeTypeTestingStubs ()
	DECLARE_FLAG (int, max_subtype_cache_entries)
	DEFINE_FLAG (bool, trace_type_testing_stub_tests, false, "Trace type testing stub tests")
	DEFINE_FLAG (bool, print_type_testing_stub_test_headers, true, "Print headers for executed type testing stub tests")
static void	GenerateInvokeTTSStub (compiler::Assembler *assembler)
static void	FinalizeAndCanonicalize (AbstractType *type)
static void	CanonicalizeTAV (TypeArguments *tav)
static TTSTestCase	Failure (const TTSTestCase &original)
static TTSTestCase	STCCheck (const TTSTestCase &original)
static TTSTestCase	FalseNegative (const TTSTestCase &original)
static TTSTestCase	RuntimeCheck (const TTSTestCase &original)
static TTSTestCase	Respecialization (const TTSTestCase &original)
static void	RunTTSTest (const AbstractType &dst_type, const TTSTestCase &test_case, bool should_specialize=true)
	ISOLATE_UNIT_TEST_CASE (TTS_SubtypeRangeCheck)
	ISOLATE_UNIT_TEST_CASE (TTS_GenericSubtypeRangeCheck)
	ISOLATE_UNIT_TEST_CASE (TTS_RecordSubtypeRangeCheck)
	ISOLATE_UNIT_TEST_CASE (TTS_Generic_Implements_Instantiated_Interface)
	ISOLATE_UNIT_TEST_CASE (TTS_Future)
	ISOLATE_UNIT_TEST_CASE (TTS_Regress40964)
	ISOLATE_UNIT_TEST_CASE (TTS_TypeParameter)
	ISOLATE_UNIT_TEST_CASE (TTS_Smi)
	ISOLATE_UNIT_TEST_CASE (TTS_Int)
	ISOLATE_UNIT_TEST_CASE (TTS_Num)
	ISOLATE_UNIT_TEST_CASE (TTS_Double)
	ISOLATE_UNIT_TEST_CASE (TTS_Object)
	ISOLATE_UNIT_TEST_CASE (TTS_Function)
	ISOLATE_UNIT_TEST_CASE (TTS_Partial)
	ISOLATE_UNIT_TEST_CASE (TTS_Partial_Incremental)
	ISOLATE_UNIT_TEST_CASE (Utf8Encode)
	ISOLATE_UNIT_TEST_CASE (Utf8InvalidByte)
	ISOLATE_UNIT_TEST_CASE (Utf8Decode)
	DECLARE_FLAG (bool, gc_during_reload)
	DECLARE_FLAG (bool, force_evacuation)
void	SetupCoreLibrariesForUnitTest ()
static const char *	IsolateReloadTestLibUri ()
	RELOAD_NATIVE_LIST (DECLARE_FUNCTION)
static Dart_NativeFunction	IsolateReloadTestNativeResolver (Dart_Handle name, int argument_count, bool *auto_setup_scope)
void FUNCTION_NAME()	Test_Reload (Dart_NativeArguments native_args)
void FUNCTION_NAME()	Test_CollectNewSpace (Dart_NativeArguments native_args)
void FUNCTION_NAME()	Test_CollectOldSpace (Dart_NativeArguments native_args)
static void	LoadIsolateReloadTestLibIfNeeded (const char *script)
static Dart_Handle	LibraryTagHandler (Dart_LibraryTag tag, Dart_Handle library, Dart_Handle url)
static intptr_t	BuildSourceFilesArray (Dart_SourceFile **sourcefiles, const char *script, const char *script_url=RESOLVED_USER_TEST_URI)
static void	MallocFinalizer (void *isolate_callback_data, void *peer)
void	ElideJSONSubstring (const char *prefix, const char *in, char *out, const char *postfix)
void	StripTokenPositions (char *buffer)
static bool	IsUnreservedChar (intptr_t value)
static bool	IsDelimiter (intptr_t value)
static bool	IsHexDigit (char value)
static int	HexValue (char digit)
static int	GetEscapedValue (const char *str, intptr_t pos, intptr_t len)
static char *	NormalizeEscapes (const char *str, intptr_t len)
static void	StringLower (char *str)
static void	ClearParsedUri (ParsedUri *parsed_uri)
static intptr_t	ParseAuthority (const char *authority, ParsedUri *parsed_uri)
bool	ParseUri (const char *uri, ParsedUri *parsed_uri)
static char *	RemoveLastSegment (char *current, char *base)
static intptr_t	SegmentLength (const char *input)
static const char *	RemoveDotSegments (const char *path)
static const char *	MergePaths (const char *base_path, const char *ref_path)
static char *	BuildUri (const ParsedUri &uri)
bool	ResolveUri (const char *ref_uri, const char *base_uri, const char **target_uri)
	TEST_CASE (ParseUri_WithScheme_NoQueryNoUser)
	TEST_CASE (ParseUri_WithScheme_WithQuery)
	TEST_CASE (ParseUri_WithScheme_WithFragment)
	TEST_CASE (ParseUri_WithScheme_WithQueryWithFragment)
	TEST_CASE (ParseUri_WithScheme_WithUser)
	TEST_CASE (ParseUri_WithScheme_ShortPath)
	TEST_CASE (ParseUri_WithScheme_EmptyPath)
	TEST_CASE (ParseUri_WithScheme_Rootless1)
	TEST_CASE (ParseUri_WithScheme_Rootless2)
	TEST_CASE (ParseUri_NoScheme_AbsPath_WithAuthority)
	TEST_CASE (ParseUri_NoScheme_AbsPath_NoAuthority)
	TEST_CASE (ParseUri_NoScheme_AbsPath_StrayColon)
	TEST_CASE (ParseUri_NoScheme_Rootless1)
	TEST_CASE (ParseUri_NoScheme_Rootless2)
	TEST_CASE (ParseUri_NoScheme_Empty)
	TEST_CASE (ParseUri_NoScheme_QueryOnly)
	TEST_CASE (ParseUri_NoScheme_FragmentOnly)
	TEST_CASE (ParseUri_LowerCaseScheme)
	TEST_CASE (ParseUri_NormalizeEscapes_PathQueryFragment)
	TEST_CASE (ParseUri_NormalizeEscapes_UppercaseEscapesPreferred)
	TEST_CASE (ParseUri_NormalizeEscapes_Authority)
	TEST_CASE (ParseUri_NormalizeEscapes_UppercaseEscapeInHost)
	TEST_CASE (ParseUri_BrokenEscapeSequence)
	TEST_CASE (ResolveUri_WithScheme_NoAuthorityNoQuery)
	TEST_CASE (ResolveUri_WithScheme_WithAuthorityWithQuery)
	TEST_CASE (ResolveUri_NoScheme_WithAuthority)
	TEST_CASE (ResolveUri_NoSchemeNoAuthority_AbsolutePath)
	TEST_CASE (ResolveUri_NoSchemeNoAuthority_RelativePath)
	TEST_CASE (ResolveUri_NoSchemeNoAuthority_RelativePathEmptyBasePath)
	TEST_CASE (ResolveUri_NoSchemeNoAuthority_RelativePathWeirdBasePath)
	TEST_CASE (ResolveUri_NoSchemeNoAuthority_EmptyPath)
	TEST_CASE (ResolveUri_NoSchemeNoAuthority_EmptyPathWithQuery)
	TEST_CASE (ResolveUri_NoSchemeNoAuthority_EmptyPathWithFragment)
	TEST_CASE (ResolveUri_RemoveDots_RemoveOneDotSegment)
	TEST_CASE (ResolveUri_RemoveDots_RemoveTwoDotSegments)
	TEST_CASE (ResolveUri_RemoveDots_RemoveOneDotDotSegment)
	TEST_CASE (ResolveUri_RemoveDots_RemoveTwoDotDotSegments)
	TEST_CASE (ResolveUri_RemoveDots_RemoveTooManyDotDotSegments)
	TEST_CASE (ResolveUri_RemoveDots_RemoveDotSegmentsNothingLeft1)
	TEST_CASE (ResolveUri_RemoveDots_RemoveDotSegmentsNothingLeft2)
	TEST_CASE (ResolveUri_RemoveDots_RemoveDotSegmentsInitialPrefix)
	TEST_CASE (ResolveUri_RemoveDots_RemoveDotSegmentsMixed)
	TEST_CASE (ResolveUri_NormalizeEscapes_PathQueryFragment)
	TEST_CASE (ResolveUri_NormalizeEscapes_UppercaseHexPreferred)
	TEST_CASE (ResolveUri_NormalizeEscapes_Authority)
	TEST_CASE (ResolveUri_NormalizeEscapes_BrokenEscapeSequence)
	TEST_CASE (ResolveUri_DataUri)
	TEST_CASE (ResolveUri_RelativeBase_NotImplemented)
static const char *	TestResolve (const char *base_uri, const char *uri)
	TEST_CASE (ResolveUri_TestUriPerRFCs)
	TEST_CASE (ResolveUri_MoreDotSegmentTests)
	TEST_CASE (ResolveUri_WindowsPaths_Forwardslash_NoScheme)
	TEST_CASE (ResolveUri_WindowsPaths_Forwardslash_FileScheme)
	TEST_CASE (ResolveUri_WindowsPaths_Backslash)
	VM_UNIT_TEST_CASE (StringHash)
	VM_UNIT_TEST_CASE (Minimum)
	VM_UNIT_TEST_CASE (Maximum)
	VM_UNIT_TEST_CASE (IsPowerOfTwo)
	VM_UNIT_TEST_CASE (ShiftForPowerOfTwo)
	VM_UNIT_TEST_CASE (IsAligned)
	VM_UNIT_TEST_CASE (RoundDown)
	VM_UNIT_TEST_CASE (RoundUp)
	VM_UNIT_TEST_CASE (RoundUpToPowerOfTwo)
	VM_UNIT_TEST_CASE (CountOneBits32)
	VM_UNIT_TEST_CASE (CountOneBits64)
	VM_UNIT_TEST_CASE (CountOneBitsWord)
	VM_UNIT_TEST_CASE (CountTrailingZeros32)
	VM_UNIT_TEST_CASE (CountTrailingZeros64)
	VM_UNIT_TEST_CASE (CountLeadingZeros32)
	VM_UNIT_TEST_CASE (CountLeadingZeros64)
	VM_UNIT_TEST_CASE (CountZerosWord)
	VM_UNIT_TEST_CASE (ReverseBits32)
	VM_UNIT_TEST_CASE (ReverseBits64)
	VM_UNIT_TEST_CASE (ReverseBitsWord)
	VM_UNIT_TEST_CASE (IsInt)
	VM_UNIT_TEST_CASE (IsUint)
	VM_UNIT_TEST_CASE (MagnitudeIsUint)
	VM_UNIT_TEST_CASE (LowBits)
	VM_UNIT_TEST_CASE (Endianity)
	VM_UNIT_TEST_CASE (DoublesBitEqual)
	VM_UNIT_TEST_CASE (NBitMask)
bool	IsZero (char *begin, char *end)
	VM_UNIT_TEST_CASE (AllocateVirtualMemory)
	VM_UNIT_TEST_CASE (AllocateAlignedVirtualMemory)
	VM_UNIT_TEST_CASE (FreeVirtualMemory)
static int	testFunction (int x)
	VM_UNIT_TEST_CASE (DuplicateRXVirtualMemory)
	VM_UNIT_TEST_CASE (AllocateZone)
	VM_UNIT_TEST_CASE (AllocGeneric_Success)
	VM_UNIT_TEST_CASE_WITH_EXPECTATION (AllocGeneric_Overflow, "Crash")
	VM_UNIT_TEST_CASE (ZoneRealloc)
	VM_UNIT_TEST_CASE (ZoneAllocated)
	TEST_CASE (PrintToString)
	TEST_CASE (StressMallocDirectly)
	ISOLATE_UNIT_TEST_CASE (StressMallocThroughZones)
	ISOLATE_UNIT_TEST_CASE (ZoneVerificationScaling)

Variables
intptr_t(*	my_callback_blocking_fp_ )(intptr_t)
Dart_Port	my_callback_blocking_send_port_
void(*	my_callback_non_blocking_fp_ )(intptr_t)
Dart_Port	my_callback_non_blocking_send_port_
Dart_Port	send_port_
void(*	callback_ )(Dart_Handle)
Dart_PersistentHandle	closure_to_callback_
std::mutex	ref_counted_resource_mutex
static intptr_t	kInitialSize = 8
static constexpr const char *	kNone = "No Test or Benchmarks"
static constexpr const char *	kList = "List all Tests and Benchmarks"
static constexpr const char *	kAllBenchmarks = "All Benchmarks"
static const char *	run_filter = kNone
static const char *	kernel_snapshot = nullptr
static int	run_matches = 0
static int64_t	kMaxAllowedSeconds = kMaxInt32
static const DartApiEntry	dart_api_entries []
static const DartApi	dart_api_data
const char *	file_schema = "file://"
const int	file_schema_length = 7
static constexpr intptr_t	kDefaultStackAllocation = 8
static constexpr intptr_t	kLengthSize = 11
static constexpr intptr_t	kLengthMask = (1 << kLengthSize) - 1
constexpr intptr_t	kInt8SizeLog2 = 0
constexpr intptr_t	kInt8Size = 1 << kInt8SizeLog2
constexpr intptr_t	kInt16SizeLog2 = 1
constexpr intptr_t	kInt16Size = 1 << kInt16SizeLog2
constexpr intptr_t	kInt32SizeLog2 = 2
constexpr intptr_t	kInt32Size = 1 << kInt32SizeLog2
constexpr intptr_t	kInt64SizeLog2 = 3
constexpr intptr_t	kInt64Size = 1 << kInt64SizeLog2
constexpr intptr_t	kDoubleSize = sizeof(double)
constexpr intptr_t	kFloatSize = sizeof(float)
constexpr intptr_t	kQuadSize = 4 * kFloatSize
constexpr intptr_t	kSimd128Size = sizeof(simd128_value_t)
constexpr intptr_t	kBitsPerByteLog2 = 3
constexpr intptr_t	kBitsPerByte = 1 << kBitsPerByteLog2
constexpr intptr_t	kBitsPerInt8 = kInt8Size * kBitsPerByte
constexpr intptr_t	kBitsPerInt16 = kInt16Size * kBitsPerByte
constexpr intptr_t	kBitsPerInt32 = kInt32Size * kBitsPerByte
constexpr intptr_t	kBitsPerInt64 = kInt64Size * kBitsPerByte
constexpr int8_t	kMinInt8 = 0x80
constexpr int8_t	kMaxInt8 = 0x7F
constexpr uint8_t	kMaxUint8 = 0xFF
constexpr int16_t	kMinInt16 = 0x8000
constexpr int16_t	kMaxInt16 = 0x7FFF
constexpr uint16_t	kMaxUint16 = 0xFFFF
constexpr int32_t	kMinInt32 = 0x80000000
constexpr int32_t	kMaxInt32 = 0x7FFFFFFF
constexpr uint32_t	kMaxUint32 = 0xFFFFFFFF
constexpr int64_t	kMinInt64 = DART_INT64_C(0x8000000000000000)
constexpr int64_t	kMaxInt64 = DART_INT64_C(0x7FFFFFFFFFFFFFFF)
constexpr uint64_t	kMaxUint64 = DART_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF)
constexpr int	kMinInt = INT_MIN
constexpr int	kMaxInt = INT_MAX
constexpr int	kMaxUint = UINT_MAX
constexpr int64_t	kMinInt64RepresentableAsDouble = kMinInt64
constexpr int64_t	kMaxInt64RepresentableAsDouble
constexpr int64_t	kSignBitDouble = DART_INT64_C(0x8000000000000000)
constexpr intptr_t	kWordSizeLog2 = kInt64SizeLog2
constexpr intptr_t	kWordSize = 1 << kWordSizeLog2
constexpr intptr_t	kBitsPerWordLog2 = kWordSizeLog2 + kBitsPerByteLog2
constexpr intptr_t	kBitsPerWord = 1 << kBitsPerWordLog2
constexpr word	kWordMin = static_cast<uword>(1) << (kBitsPerWord - 1)
constexpr word	kWordMax = (static_cast<uword>(1) << (kBitsPerWord - 1)) - 1
constexpr uword	kUwordMax = static_cast<uword>(-1)
constexpr intptr_t	KBLog2 = 10
constexpr intptr_t	KB = 1 << KBLog2
constexpr intptr_t	MBLog2 = KBLog2 + KBLog2
constexpr intptr_t	MB = 1 << MBLog2
constexpr intptr_t	GBLog2 = MBLog2 + KBLog2
constexpr intptr_t	GB = 1 << GBLog2
constexpr intptr_t	KBInWordsLog2 = KBLog2 - kWordSizeLog2
constexpr intptr_t	KBInWords = 1 << KBInWordsLog2
constexpr intptr_t	MBInWordsLog2 = KBLog2 + KBInWordsLog2
constexpr intptr_t	MBInWords = 1 << MBInWordsLog2
constexpr intptr_t	GBInWordsLog2 = MBLog2 + KBInWordsLog2
constexpr intptr_t	GBInWords = 1 << GBInWordsLog2
constexpr intptr_t	kIntptrOne = 1
constexpr intptr_t	kIntptrMin = (kIntptrOne << (kBitsPerWord - 1))
constexpr intptr_t	kIntptrMax = ~kIntptrMin
constexpr intptr_t	kMillisecondsPerSecond = 1000
constexpr intptr_t	kMicrosecondsPerMillisecond = 1000
constexpr intptr_t	kMicrosecondsPerSecond
constexpr intptr_t	kNanosecondsPerMicrosecond = 1000
constexpr intptr_t	kNanosecondsPerMillisecond
constexpr intptr_t	kNanosecondsPerSecond
static constexpr uint32_t	kStringHashM = 0x5bd1e995
static constexpr int	kStringHashR = 24
static constexpr intptr_t	kUnreachableReference = 0
static constexpr intptr_t	kFirstReference = 1
static constexpr intptr_t	kUnallocatedReference = -1
static const char *const	kObjectStoreFieldNames []
static const int8_t	decode_table []
static const char	PAD = '='
static constexpr uword	kUwordOne = 1U
static constexpr uint32_t	kTestPcOffset = 0x4
static constexpr intptr_t	kTestSpillSlotBitCount = 0
static const BootstrapLibProps	bootstrap_libraries []
static constexpr intptr_t	kBootstrapLibraryCount
static const struct dart::NativeEntries	BootStrapEntries []
static const struct dart::FfiNativeEntries	BootStrapFfiEntries []
const auto	kA = NewMove(1, 10)
const auto	kB = NewMove(2, 20)
const auto	kC = NewMove(3, 30)
const auto	kD = NewMove(4, 40)
const auto	kE = NewMove(5, 50)
const auto	kX = NewMove(-1, -10)
const CatchEntryMove	abcde [] = {kA, kB, kC, kD, kE}
const CatchEntryMove	abcdx [] = {kA, kB, kC, kD, kX}
const CatchEntryMove	xbcde [] = {kX, kB, kC, kD, kE}
const CatchEntryMove	abxde [] = {kA, kB, kX, kD, kE}
const CatchEntryMove	ab [] = {kA, kB}
const CatchEntryMove	de [] = {kD, kE}
static constexpr intptr_t	kClassIdTagMax = (1 << 20) - 1
const int	kTypedDataCidRemainderInternal = 0
const int	kTypedDataCidRemainderView = 1
const int	kTypedDataCidRemainderExternal = 2
const int	kTypedDataCidRemainderUnmodifiable = 3
const int	kNumTypedDataCidRemainders = kTypedDataCidRemainderUnmodifiable + 1
constexpr intptr_t	kFirstInternalOnlyCid = kClassCid
constexpr intptr_t	kLastInternalOnlyCid = kUnwindErrorCid
static const ClassId	kFirstErrorCid = kErrorCid
static const ClassId	kLastErrorCid = kUnwindErrorCid
static const ClassId	kFirstTypedDataCid = kTypedDataInt8ArrayCid
static const ClassId	kLastTypedDataCid
static constexpr intptr_t	kInvalidTryIndex = -1
static constexpr bool	kShouldWriteProtectCodeByDefault = false
const Register	kArg1Reg = CallingConventions::ArgumentRegisters[0]
const Register	kArg2Reg = CallingConventions::ArgumentRegisters[1]
static const intptr_t	kMaxElementSizeForEfficientCopy
static const Representation	kUnboxedBool = kTagged
static const SimdOpInfo	simd_op_information []
static constexpr intptr_t	kNoVirtualRegister = -1
static constexpr intptr_t	kTempVirtualRegister = -2
static constexpr intptr_t	kIllegalPosition = -1
static constexpr intptr_t	kMaxPosition = 0x7FFFFFFF
static constexpr intptr_t	kMaxLocationCount = 2
static constexpr Representation	kUnboxedWord
static constexpr Representation	kUnboxedUword
static constexpr Representation	kUnboxedIntPtr = kUnboxedWord
static constexpr Representation	kUnboxedAddress = kUnboxedUword
const char *	pointer_prefix = ""
static constexpr intptr_t	kMemoryTestLength = 1024
static constexpr uint8_t	kUnInitialized = 0xFE
static const intptr_t	simd_op_result_cids []
static const char *	kCompilerPassesUsage
const double	kCommonDoubleConstants []
struct {
const char *const   dart::class_name
const char *const   dart::function_name
const char *const   dart::enum_name
const uint32_t   dart::fp
}	recognized_methods [MethodRecognizer::kNumRecognizedMethods]
struct {
const intptr_t   dart::symbol_id
const intptr_t   dart::cid
const uint32_t   dart::finger_print
const char *const   dart::name
}	factory_recognizer_list []
static constexpr uword	kZapCodeReg = 0xf1f1f1f1
static constexpr uword	kZapReturnAddress = 0xe1e1e1e1
const QRegister	QTMP = Q7
const DRegister	DTMP = EvenDRegisterOf(QTMP)
const SRegister STMP	DART_USED = EvenSRegisterOf(DTMP)
const FpuRegister	FpuTMP = QTMP
const int	kFpuRegisterSize = 16
const int	kNumberOfFpuRegisters = kNumberOfQRegisters
const FpuRegister	kNoFpuRegister = kNoQRegister
const char *const	cpu_reg_names [kNumberOfCpuRegisters]
const char *const	cpu_reg_abi_names [kNumberOfCpuRegisters]
const char *const	fpu_reg_names [kNumberOfFpuRegisters]
const char *const	fpu_s_reg_names [kNumberOfSRegisters]
const char *const	fpu_d_reg_names [kNumberOfDRegisters]
const Register	TMP = IP
const Register	TMP2 = kNoRegister
const Register	PP = R5
const Register	DISPATCH_TABLE_REG = NOTFP
const Register	SPREG = SP
const Register	FPREG = FP
const Register	IC_DATA_REG = R9
const Register	ARGS_DESC_REG = R4
const Register	CODE_REG = R6
const Register	FUNCTION_REG = R0
const Register	THR = R10
const Register	CALLEE_SAVED_TEMP = R8
const Register	APSR = R15
const Register	kExceptionObjectReg = R0
const Register	kStackTraceObjectReg = R1
const Register	kWriteBarrierObjectReg = R1
const Register	kWriteBarrierValueReg = R0
const Register	kWriteBarrierSlotReg = R9
const RegList	kAllCpuRegistersList = 0xFFFF
const RegList	kAllFpuRegistersList = (1 << kNumberOfFpuRegisters) - 1
const RegList	kAbiArgumentCpuRegs
const RegList	kAbiVolatileCpuRegs = kAbiArgumentCpuRegs | (1 << IP) | (1 << LR)
const RegList	kAbiPreservedCpuRegs
const int	kAbiPreservedCpuRegCount = 7
const QRegister	kAbiFirstPreservedFpuReg = Q4
const QRegister	kAbiLastPreservedFpuReg = Q7
const int	kAbiPreservedFpuRegCount = 4
const RegList	kReservedCpuRegisters
constexpr intptr_t	kNumberOfReservedCpuRegisters
constexpr RegList	kDartAvailableCpuRegs
constexpr int	kNumberOfDartAvailableCpuRegs
constexpr int	kRegisterAllocationBias = 0
const intptr_t	kStoreBufferWrapperSize = 24
const RegList	kDartVolatileCpuRegs
const int	kDartVolatileCpuRegCount = 5
const RegList	kAbiVolatileFpuRegs = R(Q0) | R(Q1) | R(Q2) | R(Q3)
const RegList	kFpuRegistersWithoutSOverlap
constexpr uword	kBreakInstructionFiller = 0xE1200070
constexpr uword	kDataMemoryBarrier = 0xf57ff050 | 0xb
const intptr_t	kPreferredLoopAlignment = 1
const VRegister	VTMP = V31
const Register	CALLEE_SAVED_TEMP2 = R20
const Register	HEAP_BITS = R28
const Register	NULL_REG = R22
const int	kXRegSizeInBits = 64
const int	kWRegSizeInBits = 32
const int64_t	kXRegMask = 0xffffffffffffffffL
const int64_t	kWRegMask = 0x00000000ffffffffL
const Register	kAbiFirstPreservedCpuReg = R19
const Register	kAbiLastPreservedCpuReg = R28
const Register	kDartFirstVolatileCpuReg = R0
const Register	kDartLastVolatileCpuReg = R14
const int	kDartVolatileFpuRegCount = 24
const char *const	cpu_reg_byte_names [kNumberOfByteRegisters]
const int	MAX_NOP_SIZE = 8
const FRegister	FTMP = FT11
constexpr Register	FAR_TMP = S8
constexpr Register	WRITE_BARRIER_STATE = S11
constexpr RegList	kAbiArgumentFpuRegs
constexpr RegList	kAbiPreservedFpuRegs
constexpr intptr_t	kReservedFpuRegisters = 0
constexpr intptr_t	kNumberOfReservedFpuRegisters = 0
const intptr_t	kReleaseShift = 25
const intptr_t	kAcquireShift = 26
static constexpr ExtensionSet	RV_G = RV_I | RV_M | RV_A | RV_F | RV_D
static constexpr ExtensionSet	RV_GC = RV_G | RV_C
static constexpr ExtensionSet	RV_B = RV_Zba | RV_Zbb | RV_Zbc | RV_Zbs
static constexpr ExtensionSet	RV_GCB = RV_GC | RV_B
static const char *	kCustomIsolateScriptChars
EventQueue *	event_queue
char *	saved_echo = nullptr
static bool	use_set_return = false
static bool	use_throw_exception = false
static int	kLength = 16
static constexpr intptr_t	kExtLength = 16
static int8_t	data [kExtLength]
static bool	byte_data_finalizer_run = false
static constexpr intptr_t	kOptExtLength = 16
static int8_t	opt_data [kOptExtLength]
static Dart_FinalizableHandle	finalizable_new_ref = nullptr
static void *	finalizable_new_ref_peer = 0
static Dart_FinalizableHandle	finalizable_old_ref = nullptr
static void *	finalizable_old_ref_peer = 0
static Dart_PersistentHandle	persistent_handle1
static Dart_WeakPersistentHandle	weak_persistent_handle2
static Dart_WeakPersistentHandle	weak_persistent_handle3
static Dart_FinalizableHandle	finalizable_handle3
Dart_WeakPersistentHandle	delete_on_finalization
static Dart_WeakPersistentHandle	weak1 = nullptr
static Dart_WeakPersistentHandle	weak2 = nullptr
static Dart_WeakPersistentHandle	weak3 = nullptr
static constexpr int	kTestNumNativeFields = 2
static constexpr intptr_t	kNativeField1Value = 30
static constexpr intptr_t	kNativeField2Value = 40
static intptr_t	kNativeArgumentNativeField1Value = 30
static intptr_t	kNativeArgumentNativeField2Value = 40
static constexpr intptr_t	kSendLength = 16
static void *	shutdown_isolate_group_data
static void *	shutdown_isolate_data
static void *	cleanup_isolate_group_data
static void *	cleanup_isolate_data
static void *	cleanup_group_callback_data
static int64_t	add_result = 0
static Monitor *	loop_test_lock = new Monitor()
static bool	loop_test_exit = false
static bool	loop_reset_count = false
static void *	last_allocation_context = nullptr
static const char *	last_allocation_cls = nullptr
static intptr_t	heap_samples = 0
static const char *	expected_allocation_cls = nullptr
static bool	found_allocation = false
static constexpr int	kLocalHandleSizeInWords = sizeof(LocalHandle) / kWordSize
static constexpr int	kLocalHandlesPerChunk = 64
static constexpr int	kOffsetOfRawPtrInLocalHandle = 0
static constexpr int	kPersistentHandleSizeInWords
static constexpr int	kPersistentHandlesPerChunk = 64
static constexpr int	kOffsetOfRawPtrInPersistentHandle = 0
static constexpr int	kFinalizablePersistentHandleSizeInWords
static constexpr int	kFinalizablePersistentHandlesPerChunk = 64
static constexpr int	kOffsetOfRawPtrInFinalizablePersistentHandle = 0
static constexpr int8_t	kDataBitsPerByte = 7
static constexpr int8_t	kByteMask = (1 << kDataBitsPerByte) - 1
static constexpr int8_t	kMaxUnsignedDataPerByte = kByteMask
static constexpr int8_t	kMinDataPerByte = -(1 << (kDataBitsPerByte - 1))
static constexpr int8_t	kMaxDataPerByte
static constexpr uint8_t	kEndByteMarker = (255 - kMaxDataPerByte)
static constexpr uint8_t	kEndUnsignedByteMarker
static constexpr intptr_t	kUnsignedEnd = kMaxUint16
static constexpr intptr_t	kSignedStart = kMinInt16
static constexpr intptr_t	kSignedEnd = kMaxInt16
const uint8_t	kSafepointKind
static constexpr char	kExponentChar = 'e'
static constexpr const char *	kInfinitySymbol = "Infinity"
static constexpr const char *	kNaNSymbol = "NaN"
static constexpr intptr_t	kElfPageSize = 16 * KB
static struct dart::NativeEntries	BuiltinEntries [] = {UNHANDLED_NATIVE_LIST(REGISTER_FUNCTION)}
const intptr_t	kSmiBits = kBitsPerWord - 2
const intptr_t	kSmiMax = (static_cast<intptr_t>(1) << kSmiBits) - 1
const intptr_t	kSmiMin = -(static_cast<intptr_t>(1) << kSmiBits)
const intptr_t	kSmiBits32 = kBitsPerInt32 - 2
const intptr_t	kSmiMax32 = (static_cast<intptr_t>(1) << kSmiBits32) - 1
const intptr_t	kSmiMin32 = -(static_cast<intptr_t>(1) << kSmiBits32)
static constexpr intptr_t	kCompressedWordSize = kWordSize
static constexpr intptr_t	kCompressedWordSizeLog2 = kWordSizeLog2
const intptr_t	kMaxAddrSpaceMB = (kWordSize <= 4) ? 4096 : 268435456
const intptr_t	kMaxAddrSpaceInWords
const intptr_t	kBytesPerBigIntDigit = 4
const intptr_t	kDefaultMaxOldGenHeapSize = (kWordSize <= 4) ? 1536 : 30720
const intptr_t	kDefaultNewGenSemiMaxSize = (kWordSize <= 4) ? 8 : 16
const intptr_t	kOffsetOfPtr = 32
static constexpr uword	kZapUninitializedWord = 0xabababababababab
static constexpr intptr_t	kAllocationCanary = 123
static constexpr int	kVMHandleSizeInWords = 2
static constexpr int	kVMHandlesPerChunk = 63
static constexpr int	kOffsetOfRawPtr = kWordSize
static constexpr intptr_t	kPageCacheCapacity = 8 * kWordSize
static Mutex *	page_cache_mutex = nullptr
static VirtualMemory *	page_cache [kPageCacheCapacity] = {nullptr}
static intptr_t	page_cache_size = 0
static constexpr intptr_t	kPageSize = 512 * KB
static constexpr intptr_t	kPageSizeInWords = kPageSize / kWordSize
static constexpr intptr_t	kPageMask = ~(kPageSize - 1)
static constexpr intptr_t	kBitVectorWordsPerBlock = 1
static constexpr intptr_t	kBlockSize
static constexpr intptr_t	kBlockMask = ~(kBlockSize - 1)
static constexpr intptr_t	kBlocksPerPage = kPageSize / kBlockSize
static constexpr intptr_t	kAllocationRedZoneSize = kObjectAlignment
static constexpr intptr_t	kConservativeInitialMarkSpeed = 20
static constexpr int	kStoreBufferBlockSize = 1024
static constexpr int	kMarkingStackBlockSize = 64
static constexpr int	kPromotionStackBlockSize = 64
static constexpr intptr_t	kConservativeInitialScavengeSpeed = 40
static constexpr intptr_t	kNewAllocatableSize = 256 * KB
static constexpr intptr_t	kAllocatablePageSize = 64 * KB
static constexpr uword	kReadOnlyGCBits
	gc_during_reload
	false
Cause GC during	reload
static const char	base64_digits [65]
static const char	base64_pad = '='
const bool	kNoSafepointScope = true
const bool	kDontAssertNoSafepointScope = false
static const char *	test_output_ = nullptr
static Dart_CObject	cobj_sentinel = {Dart_CObject_kUnsupported, {false}}
static Dart_CObject	cobj_transition_sentinel
static Dart_CObject	cobj_dynamic_type = {Dart_CObject_kUnsupported, {false}}
static Dart_CObject	cobj_void_type = {Dart_CObject_kUnsupported, {false}}
static Dart_CObject	cobj_empty_type_arguments
static Dart_CObject	cobj_true = {Dart_CObject_kBool, {true}}
static Dart_CObject	cobj_false = {Dart_CObject_kBool, {false}}
static constexpr intptr_t	kFirstReference = 1
static constexpr intptr_t	kUnallocatedReference = -1
static const char *const	kGetterPrefix = "get:"
static const intptr_t	kGetterPrefixLength = strlen(kGetterPrefix)
static const char *const	kSetterPrefix = "set:"
static const intptr_t	kSetterPrefixLength = strlen(kSetterPrefix)
static const char *const	kInitPrefix = "init:"
static const intptr_t	kInitPrefixLength = strlen(kInitPrefix)
bool	TESTING_runtime_fail_on_existing_cache_entry = false
static constexpr intptr_t	kNullIdentityHash = 2011
static constexpr intptr_t	kTrueIdentityHash = 1231
static constexpr intptr_t	kFalseIdentityHash = 1237
const char *	kFastAllocationFailed = "fast allocation failed"
const intptr_t	kFinalizerTwoEntriesNumObjects = 9
const uint32_t	kCalculateCanonicalizeHash = 0
static const ThreadLocalKey	kUnsetThreadLocalKey
static const ThreadLocalKey	kUnsetThreadLocalKey
static const ThreadLocalKey	kUnsetThreadLocalKey
static const ThreadLocalKey	kUnsetThreadLocalKey
static const ThreadLocalKey	kUnsetThreadLocalKey
static const ThreadLocalKey	kUnsetThreadLocalKey = TLS_OUT_OF_INDEXES
static constexpr intptr_t	kNewObjectAlignmentOffset
static constexpr intptr_t	kOldObjectAlignmentOffset
static constexpr intptr_t	kNewObjectBitPosition
static constexpr intptr_t	kObjectAlignment
static constexpr intptr_t	kObjectAlignmentLog2
static constexpr intptr_t	kObjectAlignmentMask
static constexpr intptr_t	kBoolValueBitPosition
static constexpr intptr_t	kBoolValueMask = HostObjectAlignment::kBoolValueMask
static constexpr intptr_t	kBoolVsNullBitPosition
static constexpr intptr_t	kBoolVsNullMask
static constexpr intptr_t	kTrueOffsetFromNull
static constexpr intptr_t	kFalseOffsetFromNull
static constexpr intptr_t	kObjectStartAlignment = 64
static constexpr uintptr_t	kHeapBaseMask = 0
static constexpr intptr_t	kMaxSamplesPerTick = 4
const int64_t	kValidTimeStamp = 1
const uword	kValidPc = 0xFF
static Random *	global_random = nullptr
static Mutex *	global_random_mutex = nullptr
static constexpr bool	kRegexpOptimization = true
static constexpr intptr_t	kMaxLookaheadForBoyerMoore = 8
static constexpr int32_t	kRangeEndMarker = Utf::kMaxCodePoint + 1
static constexpr int32_t	kSpaceRanges []
static constexpr intptr_t	kSpaceRangeCount = ARRAY_SIZE(kSpaceRanges)
static constexpr int32_t	kWordRanges []
static constexpr intptr_t	kWordRangeCount = ARRAY_SIZE(kWordRanges)
static constexpr int32_t	kDigitRanges [] = {'0', '9' + 1, kRangeEndMarker}
static constexpr intptr_t	kDigitRangeCount = ARRAY_SIZE(kDigitRanges)
static constexpr int32_t	kSurrogateRanges [] = {0xd800, 0xe000, kRangeEndMarker}
static constexpr intptr_t	kSurrogateRangeCount = ARRAY_SIZE(kSurrogateRanges)
static constexpr int32_t	kLineTerminatorRanges []
static constexpr intptr_t	kLineTerminatorRangeCount
const int	BYTECODE_MASK = 0xff
const unsigned int	MAX_FIRST_ARG = 0x7fffffu
const int	BYTECODE_SHIFT = 8
static constexpr bool	FLAG_regexp_possessive_quantifier = false
static const char *	kUnicodeIdentity
static constexpr intptr_t	kDefaultMaxSubtypeCacheEntries
static constexpr intptr_t	kNumberOfSavedCpuRegisters = kNumberOfCpuRegisters
static constexpr intptr_t	kNumberOfSavedFpuRegisters = kNumberOfFpuRegisters
static char *	vm_name = nullptr
static StreamInfo *const	streams_ []
static const MethodParameter *const	get_isolate_params []
static const MethodParameter *const	get_isolate_group_params []
static const MethodParameter *const	set_stream_include_private_members_params []
static const MethodParameter *const	get_memory_usage_params []
static const MethodParameter *const	get_isolate_group_memory_usage_params []
static const MethodParameter *const	get_isolate_pause_event_params []
static const MethodParameter *const	get_scripts_params []
static const MethodParameter *const	get_stack_params []
static const MethodParameter *const	get_inbound_references_params []
static const MethodParameter *const	get_retaining_path_params []
static const MethodParameter *const	get_retained_size_params []
static const MethodParameter *const	get_reachable_size_params []
static const MethodParameter *const	invoke_params []
static const MethodParameter *const	evaluate_params []
static const MethodParameter *const	build_expression_evaluation_scope_params []
static const MethodParameter *const	compile_expression_params []
static const MethodParameter *const	evaluate_compiled_expression_params []
static const MethodParameter *const	evaluate_in_frame_params []
static const MethodParameter *const	get_instances_params []
static const MethodParameter *const	get_instances_as_list_params []
static const MethodParameter *const	get_ports_params []
static const char *const	report_enum_names []
static const MethodParameter *const	get_source_report_params []
static const MethodParameter *const	reload_sources_params []
static const MethodParameter *const	add_breakpoint_params []
static const MethodParameter *const	add_breakpoint_with_script_uri_params []
static const MethodParameter *const	add_breakpoint_at_entry_params []
static const MethodParameter *const	add_breakpoint_at_activation_params []
static const MethodParameter *const	remove_breakpoint_params []
static const MethodParameter *const	get_isolate_metric_list_params []
static const MethodParameter *const	get_isolate_metric_params []
static const MethodParameter *const	get_vm_timeline_flags_params []
static const MethodParameter *const	get_vm_timeline_micros_params []
static const MethodParameter *const	clear_vm_timeline_params []
static const MethodParameter *const	get_vm_timeline_params []
static const char *const	step_enum_names []
static const Debugger::ResumeAction	step_enum_values []
static const MethodParameter *const	resume_params []
static const MethodParameter *const	kill_params []
static const MethodParameter *const	pause_params []
static const MethodParameter *const	enable_profiler_params []
static const MethodParameter *const	get_tag_profile_params []
static const MethodParameter *const	get_cpu_samples_params []
static const MethodParameter *const	get_allocation_traces_params []
static const MethodParameter *const	clear_cpu_samples_params []
static const MethodParameter *const	get_allocation_profile_params []
static const MethodParameter *const	collect_all_garbage_params []
static const MethodParameter *const	get_heap_map_params []
static const MethodParameter *const	request_heap_snapshot_params []
static const MethodParameter *const	get_process_memory_usage_params []
static const MethodParameter *const	get_persistent_handles_params []
static const MethodParameter *const	get_ports_private_params []
static const MethodParameter *const	get_object_params []
static const MethodParameter *const	get_implementation_fields_params []
static const MethodParameter *const	get_object_store_params []
static const MethodParameter *const	get_isolate_object_store_params []
static const MethodParameter *const	get_class_list_params []
static const MethodParameter *const	get_type_arguments_list_params []
static const MethodParameter *const	get_version_params []
static const MethodParameter *const	get_vm_params []
static const MethodParameter *const	lookup_resolved_package_uris_params []
static const MethodParameter *const	lookup_package_uris_params []
static const char *const	exception_pause_mode_names []
static Dart_ExceptionPauseInfo	exception_pause_mode_values []
static const MethodParameter *const	set_exception_pause_mode_params []
static const MethodParameter *const	set_isolate_pause_mode_params []
static const MethodParameter *const	set_breakpoint_state_params []
static const MethodParameter *const	get_flag_list_params []
static const MethodParameter *const	set_flags_params []
static const MethodParameter *const	set_library_debuggable_params []
static const MethodParameter *const	set_name_params []
static const MethodParameter *const	set_vm_name_params []
static const MethodParameter *const	set_trace_class_allocation_params []
static const MethodParameter *const	get_default_classes_aliases_params []
static const ServiceMethodDescriptor	service_methods_ []
const FrameLayout	invalid_frame_layout
const FrameLayout	default_frame_layout
const FrameLayout	bare_instructions_frame_layout
FrameLayout	runtime_frame_layout = invalid_frame_layout
static constexpr uword	kInterruptStackLimit = ~static_cast<uword>(0)
static constexpr int	kDartFrameFixedSize = 4
static constexpr int	kSavedPcSlotFromSp = -1
static constexpr int	kFirstObjectSlotFromFp
static constexpr int	kLastFixedObjectSlotFromFp = -2
static constexpr int	kFirstLocalSlotFromFp = -3
static constexpr int	kSavedCallerPpSlotFromFp = -2
static constexpr int	kPcMarkerSlotFromFp = -1
static constexpr int	kSavedCallerFpSlotFromFp = 0
static constexpr int	kSavedCallerPcSlotFromFp = 1
static constexpr int	kParamEndSlotFromFp = 1
static constexpr int	kCallerSpSlotFromFp = 2
static constexpr int	kLastParamSlotFromEntrySp = 0
static constexpr int	kExitLinkSlotFromEntryFp = -28
constexpr intptr_t	kCallbackSlotsBeforeSavedArguments = 2
static constexpr int	kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp + 1
static constexpr int	kDartFrameFixedSize = 4
static constexpr int	kSavedPcSlotFromSp = -1
static constexpr int	kFirstObjectSlotFromFp
static constexpr int	kLastFixedObjectSlotFromFp = -2
static constexpr int	kFirstLocalSlotFromFp = -3
static constexpr int	kSavedCallerPpSlotFromFp = -2
static constexpr int	kPcMarkerSlotFromFp = -1
static constexpr int	kSavedCallerFpSlotFromFp = 0
static constexpr int	kSavedCallerPcSlotFromFp = 1
static constexpr int	kParamEndSlotFromFp = 1
static constexpr int	kCallerSpSlotFromFp = 2
static constexpr int	kLastParamSlotFromEntrySp = 0
static constexpr int	kExitLinkSlotFromEntryFp = -23
static constexpr int	kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp
static constexpr int	kDartFrameFixedSize = 3
static constexpr int	kSavedPcSlotFromSp = -1
static constexpr int	kFirstObjectSlotFromFp
static constexpr int	kLastFixedObjectSlotFromFp = -1
static constexpr int	kFirstLocalSlotFromFp = -2
static constexpr int	kPcMarkerSlotFromFp = -1
static constexpr int	kSavedCallerFpSlotFromFp = 0
static constexpr int	kSavedCallerPcSlotFromFp = 1
static constexpr int	kParamEndSlotFromFp = 1
static constexpr int	kCallerSpSlotFromFp = 2
static constexpr int	kLastParamSlotFromEntrySp = 1
static constexpr int	kSavedCallerPpSlotFromFp = kSavedCallerFpSlotFromFp
static constexpr int	kExitLinkSlotFromEntryFp = -8
static constexpr int	kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp
static constexpr int	kDartFrameFixedSize = 4
static constexpr int	kSavedPcSlotFromSp = -1
static constexpr int	kFirstObjectSlotFromFp
static constexpr int	kLastFixedObjectSlotFromFp = -4
static constexpr int	kFirstLocalSlotFromFp = -5
static constexpr int	kSavedCallerPpSlotFromFp = -4
static constexpr int	kPcMarkerSlotFromFp = -3
static constexpr int	kSavedCallerFpSlotFromFp = -2
static constexpr int	kSavedCallerPcSlotFromFp = -1
static constexpr int	kParamEndSlotFromFp = -1
static constexpr int	kCallerSpSlotFromFp = 0
static constexpr int	kLastParamSlotFromEntrySp = 0
static constexpr int	kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp
static struct dart::NativeEntries	BuiltinEntries [] = {STACKFRAME_NATIVE_LIST(REGISTER_FUNCTION)}
static constexpr int	kDartFrameFixedSize = 4
static constexpr int	kSavedPcSlotFromSp = -1
static constexpr int	kFirstObjectSlotFromFp
static constexpr int	kLastFixedObjectSlotFromFp = -2
static constexpr int	kFirstLocalSlotFromFp = -3
static constexpr int	kSavedCallerPpSlotFromFp = -2
static constexpr int	kPcMarkerSlotFromFp = -1
static constexpr int	kSavedCallerFpSlotFromFp = 0
static constexpr int	kSavedCallerPcSlotFromFp = 1
static constexpr int	kParamEndSlotFromFp = 1
static constexpr int	kCallerSpSlotFromFp = 2
static constexpr int	kLastParamSlotFromEntrySp = 1
static constexpr int	kExitLinkSlotFromEntryFp = -11
static constexpr int	kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp
static const char *const	names []
static const double	double_nan_constant = NAN
static const struct dart::ALIGN16	double_negate_constant = {0x8000000000000000ULL, 0x8000000000000000ULL}
static const struct dart::ALIGN16	double_abs_constant = {0x7FFFFFFFFFFFFFFFULL, 0x7FFFFFFFFFFFFFFFULL}
static const struct dart::ALIGN16	float_not_constant = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}
static const struct dart::ALIGN16	float_negate_constant = {0x80000000, 0x80000000, 0x80000000, 0x80000000}
static const struct dart::ALIGN16	float_absolute_constant = {0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF}
static const struct dart::ALIGN16	float_zerow_constant = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000}
static const char *	kTestResultStrings []
const char *	kSubtypeRangeCheckScript
const char *	kRecordSubtypeRangeCheckScript
static constexpr uintptr_t	kAsciiWordMask = 0x80808080u
const uint8_t *	platform_strong_dill = kPlatformStrongDill
const intptr_t	platform_strong_dill_size = kPlatformStrongDillSize
static MallocGrowableArray< TestLibEntry > *	test_libs_ = nullptr
static const char *	kIsolateReloadTestLibSource
static struct dart::NativeEntries	ReloadEntries [] = {RELOAD_NATIVE_LIST(REGISTER_FUNCTION)}
static constexpr intptr_t	kSegmentCacheCapacity = 16
static Mutex *	segment_cache_mutex = nullptr
static VirtualMemory *	segment_cache [kSegmentCacheCapacity] = {nullptr}
static intptr_t	segment_cache_size = 0
static constexpr int64_t	kRssSlack = 20 * MB
static const size_t	kSizes []

Typedef Documentation

AbstractTypeSet

typedef DirectChainedHashMap<AbstractTypeKeyValueTrait> dart::AbstractTypeSet

Definition at line 125 of file precompiler.h.

BaseRuntimeEntry

using dart::BaseRuntimeEntry = typedef compiler::RuntimeEntry

Definition at line 23 of file runtime_entry.h.

BinaryMathCFunction

typedef double(* dart::BinaryMathCFunction) (double x, double y)

Definition at line 3876 of file runtime_entry.cc.

BootstrapNativeFunction

typedef ObjectPtr(* dart::BootstrapNativeFunction) (Thread *thread, Zone *zone, NativeArguments *arguments)

Definition at line 35 of file native_entry.h.

BoundaryOp

typedef bool(* dart::BoundaryOp) (RangeBoundary *)

Definition at line 1959 of file range_analysis.cc.

CanonicalFunctionTypeSet

typedef UnorderedHashSet<CanonicalFunctionTypeTraits> dart::CanonicalFunctionTypeSet

Definition at line 214 of file canonical_tables.h.

CanonicalInstancesSet

typedef UnorderedHashSet<CanonicalInstanceTraits> dart::CanonicalInstancesSet

Definition at line 416 of file canonical_tables.h.

Canonicalize

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

Definition at line 28 of file regexp_interpreter.cc.

CanonicalRecordTypeSet

typedef UnorderedHashSet<CanonicalRecordTypeTraits> dart::CanonicalRecordTypeSet

Definition at line 253 of file canonical_tables.h.

CanonicalRegExpSet

typedef UnorderedHashSet<CanonicalRegExpTraits, WeakAcqRelStorageTraits> dart::CanonicalRegExpSet

Definition at line 475 of file canonical_tables.h.

CanonicalStringSet

typedef UnorderedHashSet<SymbolTraits, WeakAcqRelStorageTraits> dart::CanonicalStringSet

Definition at line 136 of file canonical_tables.h.

CanonicalTypeArgumentsSet

typedef UnorderedHashSet<CanonicalTypeArgumentsTraits> dart::CanonicalTypeArgumentsSet

Definition at line 335 of file canonical_tables.h.

CanonicalTypeParameterSet

typedef UnorderedHashSet<CanonicalTypeParameterTraits> dart::CanonicalTypeParameterSet

Definition at line 293 of file canonical_tables.h.

CanonicalTypeSet

typedef UnorderedHashSet<CanonicalTypeTraits> dart::CanonicalTypeSet

Definition at line 175 of file canonical_tables.h.

CatchEntryMovesCache

typedef FixedCache<intptr_t, CatchEntryMovesRefPtr, 16> dart::CatchEntryMovesCache

Definition at line 130 of file isolate.h.

CidRangeVector

typedef MallocGrowableArray<CidRangeValue> dart::CidRangeVector

Definition at line 253 of file il.h.

ClassFunctionsSet

typedef UnorderedHashSet<ClassFunctionsTraits> dart::ClassFunctionsSet

Definition at line 3312 of file object.cc.

classid_t

typedef int32_t dart::classid_t

Definition at line 524 of file globals.h.

ClassIdTagType

typedef int32_t dart::ClassIdTagType

Definition at line 20 of file class_id.h.

ClassSet

typedef DirectChainedHashMap<ClassKeyValueTrait> dart::ClassSet

Definition at line 105 of file precompiler.h.

compressed_uword

typedef uintptr_t dart::compressed_uword

Definition at line 44 of file globals.h.

compressed_word

typedef intptr_t dart::compressed_word

Definition at line 45 of file globals.h.

CompressedObjectPtr

typedef ObjectPtr dart::CompressedObjectPtr

Definition at line 265 of file tagged_pointer.h.

CoordUnOp

typedef Coord *(* dart::CoordUnOp) (Coord *coord)

Definition at line 576 of file ffi_test_functions.cc.

cpp_vtable

typedef uword dart::cpp_vtable

Definition at line 163 of file globals.h.

CpuRegisterSource

typedef RegisterSource<Register> dart::CpuRegisterSource

Definition at line 466 of file deopt_instructions.h.

Dart_ActivationFrame

typedef struct _Dart_ActivationFrame* dart::Dart_ActivationFrame

Definition at line 17 of file debugger_api_impl_test.h.

Dart_Breakpoint

typedef struct _Dart_Breakpoint* dart::Dart_Breakpoint

Definition at line 13 of file debugger_api_impl_test.h.

Dart_BreakpointResolvedHandler

typedef void dart::Dart_BreakpointResolvedHandler(Dart_IsolateId isolate_id, intptr_t bp_id, const Dart_CodeLocation &location)

Definition at line 63 of file debugger_api_impl_test.h.

Dart_ExceptionThrownHandler

typedef void dart::Dart_ExceptionThrownHandler(Dart_IsolateId isolate_id, Dart_Handle exception_object, Dart_StackTrace stack_trace)

Definition at line 37 of file debugger_api_impl_test.h.

Dart_IsolateEventHandler

typedef void dart::Dart_IsolateEventHandler(Dart_IsolateId isolate_id, Dart_IsolateEvent kind)

Definition at line 56 of file debugger_api_impl_test.h.

Dart_IsolateId

typedef Dart_Port dart::Dart_IsolateId

An id used to uniquely represent an Isolate in the debugger wire protocol messages.

Definition at line 23 of file debugger_api_impl_test.h.

Dart_PausedEventHandler

typedef void dart::Dart_PausedEventHandler(Dart_IsolateId isolate_id, intptr_t bp_id, const Dart_CodeLocation &location)

Definition at line 59 of file debugger_api_impl_test.h.

Dart_StackTrace

typedef struct _Dart_StackTrace* dart::Dart_StackTrace

Definition at line 15 of file debugger_api_impl_test.h.

DefinitionIndexMap

typedef DirectChainedHashMap<DefinitionIndexPairTrait> dart::DefinitionIndexMap

Definition at line 40 of file write_barrier_elimination.cc.

DeoptDoubleInstr

typedef DeoptFpuInstr<DeoptInstr::kDouble, CatchEntryMove::SourceKind::kDoubleSlot, double, DoublePtr> dart::DeoptDoubleInstr

Definition at line 680 of file deopt_instructions.cc.

DeoptFloat32x4Instr

typedef DeoptFpuInstr<DeoptInstr::kFloat32x4, CatchEntryMove::SourceKind::kFloat32x4Slot, simd128_value_t, Float32x4Ptr> dart::DeoptFloat32x4Instr

Definition at line 687 of file deopt_instructions.cc.

DeoptFloat64x2Instr

typedef DeoptFpuInstr<DeoptInstr::kFloat64x2, CatchEntryMove::SourceKind::kFloat64x2Slot, simd128_value_t, Float64x2Ptr> dart::DeoptFloat64x2Instr

Definition at line 692 of file deopt_instructions.cc.

DeoptFloatInstr

typedef DeoptFpuInstr<DeoptInstr::kFloat, CatchEntryMove::SourceKind::kFloatSlot, float, DoublePtr> dart::DeoptFloatInstr

Definition at line 674 of file deopt_instructions.cc.

DeoptInt32Instr

typedef DeoptIntInstr<DeoptInstr::kInt32, CatchEntryMove::SourceKind::kInt32Slot, int32_t> dart::DeoptInt32Instr

Definition at line 631 of file deopt_instructions.cc.

DeoptInt32x4Instr

typedef DeoptFpuInstr<DeoptInstr::kInt32x4, CatchEntryMove::SourceKind::kInt32x4Slot, simd128_value_t, Int32x4Ptr> dart::DeoptInt32x4Instr

Definition at line 697 of file deopt_instructions.cc.

DeoptMintInstr

typedef DeoptIntInstr<DeoptInstr::kMint, CatchEntryMove::SourceKind::kInt64Slot, int64_t> dart::DeoptMintInstr

Definition at line 635 of file deopt_instructions.cc.

DeoptUint32Instr

typedef DeoptIntInstr<DeoptInstr::kUint32, CatchEntryMove::SourceKind::kUint32Slot, uint32_t> dart::DeoptUint32Instr

Definition at line 627 of file deopt_instructions.cc.

DispatcherSet

typedef UnorderedHashSet<DispatcherTraits, AcqRelStorageTraits> dart::DispatcherSet

Definition at line 389 of file canonical_tables.h.

EmitCharacterFunction

typedef bool dart::EmitCharacterFunction(Zone *zone, RegExpCompiler *compiler, uint16_t c, BlockLabel *on_failure, intptr_t cp_offset, bool check, bool preloaded)

Definition at line 971 of file regexp.cc.

FfiCallbackFunctionSet

using dart::FfiCallbackFunctionSet = typedef UnorderedHashSet<CanonicalFfiCallbackFunctionTraits>

Definition at line 433 of file canonical_tables.h.

FieldMappingArray

using dart::FieldMappingArray = typedef ZoneGrowableArray<FieldMapping>

Definition at line 62 of file isolate_reload.h.

FieldOffsetArray

using dart::FieldOffsetArray = typedef ZoneGrowableArray<intptr_t>

Definition at line 63 of file isolate_reload.h.

FieldSet

typedef DirectChainedHashMap<FieldKeyValueTrait> dart::FieldSet

Definition at line 66 of file parser.h.

FlagHandler

typedef void(* dart::FlagHandler) (bool value)

Definition at line 28 of file flags.h.

fpu_register_t

typedef simd128_value_t dart::fpu_register_t

Definition at line 299 of file constants_arm.h.

FpuRegister

typedef XmmRegister dart::FpuRegister

Definition at line 295 of file constants_arm.h.

FpuRegisterSource

typedef RegisterSource<FpuRegister> dart::FpuRegisterSource

Definition at line 467 of file deopt_instructions.h.

FunctionHashMap

using dart::FunctionHashMap = typedef UnorderedHashMap<FunctionHashMapTraits>

Definition at line 24 of file closure_functions_cache.cc.

FunctionSet

typedef UnorderedHashSet<FunctionKeyTraits> dart::FunctionSet

Definition at line 83 of file precompiler.h.

FunctionTypeSet

typedef DirectChainedHashMap<FunctionTypeKeyValueTrait> dart::FunctionTypeSet

Definition at line 145 of file precompiler.h.

HandlerInfoCache

typedef FixedCache<intptr_t, ExceptionHandlerInfo, 16> dart::HandlerInfoCache

Definition at line 128 of file isolate.h.

HostObjectAlignment

using dart::HostObjectAlignment = typedef ObjectAlignment<kWordSize, kWordSizeLog2>

Definition at line 48 of file pointer_tagging.h.

InputsArray

typedef GrowableArray<Value*> dart::InputsArray

Definition at line 895 of file il.h.

InstanceSet

typedef DirectChainedHashMap<InstanceKeyValueTrait> dart::InstanceSet

Definition at line 240 of file precompiler.h.

InstantiationsCacheTable

using dart::InstantiationsCacheTable = typedef ArrayOfTuplesView<TypeArguments::Cache::Entry, std::tuple<Object, TypeArguments, TypeArguments>, TypeArguments::Cache::kHeaderSize>

Definition at line 13537 of file object.h.

IntHashMap

typedef UnorderedHashMap<SmiTraits> dart::IntHashMap

Definition at line 902 of file hash_table.h.

IntKeyHash

typedef uint32_t(* dart::IntKeyHash) (uint32_t key)

Definition at line 15 of file hashmap_test.cc.

IntptrBinOp

typedef intptr_t(* dart::IntptrBinOp) (intptr_t a, intptr_t b)

Definition at line 588 of file ffi_test_functions.cc.

invokestub

typedef uword(* dart::invokestub) (uword target_code, uword arguments_descriptor, uword arguments, Thread *thread)

Definition at line 75 of file dart_entry.cc.

Latin1Array

typedef CharArray<uint8_t> dart::Latin1Array

Definition at line 40 of file canonical_tables.h.

LibraryLookupMap

typedef UnorderedHashMap<LibraryLookupTraits> dart::LibraryLookupMap

Definition at line 14643 of file object.cc.

LocationArray

typedef ZoneGrowableArray<Location> dart::LocationArray

Definition at line 20 of file locations_helpers_test.cc.

LogPrinter

typedef void(* dart::LogPrinter) (const char *data)

Definition at line 25 of file log.h.

MarkerWorkList

typedef BlockWorkList<MarkingStack> dart::MarkerWorkList

Definition at line 294 of file pointer_block.h.

MarkingStackBlock

typedef MarkingStack::Block dart::MarkingStackBlock

Definition at line 293 of file pointer_block.h.

MegamorphicCacheEntries

using dart::MegamorphicCacheEntries = typedef ArrayOfTuplesView<MegamorphicCache::EntryType, std::tuple<Smi, Object> >

Definition at line 13534 of file object.h.

MemMoveCFunction

typedef void *(* dart::MemMoveCFunction) (void *dest, const void *src, size_t n)

Definition at line 3877 of file runtime_entry.cc.

MetadataMap

typedef UnorderedHashMap<MetadataMapTraits> dart::MetadataMap

Definition at line 344 of file canonical_tables.h.

MoveArgumentsArray

typedef ZoneGrowableArray<MoveArgumentInstr*> dart::MoveArgumentsArray

Definition at line 896 of file il.h.

NativeAssetsMap

typedef UnorderedHashMap<NativeAssetsMapTraits> dart::NativeAssetsMap

Definition at line 31 of file native_assets.h.

NativeFunction

typedef void(* dart::NativeFunction) (NativeArguments *arguments)

Definition at line 29 of file native_function.h.

NativeFunctionWrapper

typedef void(* dart::NativeFunctionWrapper) (Dart_NativeArguments args, Dart_NativeFunction func)

Definition at line 30 of file native_function.h.

ObjectOffsetMap

typedef DirectChainedHashMap<ObjectOffsetTrait> dart::ObjectOffsetMap

Definition at line 192 of file image_snapshot.h.

OptionHandler

typedef void(* dart::OptionHandler) (const char *value)

Definition at line 29 of file flags.h.

ParallelScavengerVisitor

typedef ScavengerVisitorBase<true> dart::ParallelScavengerVisitor

Definition at line 586 of file scavenger.cc.

PointerSet

template<typename T >

using dart::PointerSet = typedef DirectChainedHashMap<PointerSetKeyValueTrait<T> >

Definition at line 382 of file hash_map.h.

ProgramElementSet

typedef DirectChainedHashMap<ProgramElementKeyValueTrait> dart::ProgramElementSet

Definition at line 220 of file precompiler.h.

PromotionStackBlock

typedef PromotionStack::Block dart::PromotionStackBlock

Definition at line 305 of file pointer_block.h.

PromotionWorkList

typedef BlockWorkList<PromotionStack> dart::PromotionWorkList

Definition at line 306 of file pointer_block.h.

RecordFieldNamesMap

typedef UnorderedHashMap<RecordFieldNamesMapTraits> dart::RecordFieldNamesMap

Definition at line 27978 of file object.cc.

RegExpCaptureName

using dart::RegExpCaptureName = typedef ZoneGrowableArray<uint16_t>

Definition at line 73 of file regexp_parser.h.

RegList

typedef uint32_t dart::RegList

Definition at line 642 of file constants_arm.h.

ReloadParticipationScope

using dart::ReloadParticipationScope = typedef AsThreadStackResource<RawReloadParticipationScope>

Definition at line 1611 of file thread.h.

RuntimeFunction

typedef void(* dart::RuntimeFunction) (NativeArguments arguments)

Definition at line 20 of file runtime_entry.h.

serializable_type_t

template<typename T >

using dart::serializable_type_t = typedef typename unwrap_enum<std::remove_cv_t<T>, std::is_enum<T>::value>::type

Definition at line 632 of file il.h.

SerialScavengerVisitor

typedef ScavengerVisitorBase<false> dart::SerialScavengerVisitor

Definition at line 585 of file scavenger.cc.

ServiceMethodEntry

typedef void(* dart::ServiceMethodEntry) (Thread *thread, JSONStream *js)

Definition at line 877 of file service.cc.

SignalAction

typedef void(* dart::SignalAction) (int signal, siginfo_t *info, void *context)

Definition at line 43 of file signal_handler.h.

StackMapEntryIntMap

typedef DirectChainedHashMap<StackMapEntryKeyIntValueTrait> dart::StackMapEntryIntMap

Definition at line 561 of file program_visitor.cc.

StaticCallsTable

using dart::StaticCallsTable = typedef ArrayOfTuplesView<Code::SCallTableEntry, std::tuple<Smi, Object, Function> >

Definition at line 13519 of file object.h.

StaticCallsTableEntry

using dart::StaticCallsTableEntry = typedef StaticCallsTable::TupleView

Definition at line 13522 of file object.h.

StoreBufferBlock

typedef StoreBuffer::Block dart::StoreBufferBlock

Definition at line 282 of file pointer_block.h.

SubtypeTestCacheTable

using dart::SubtypeTestCacheTable = typedef ArrayOfTuplesView<SubtypeTestCache::Entries, std::tuple<Object, TypeArguments, TypeArguments, TypeArguments, TypeArguments, TypeArguments, AbstractType, Bool> >

Definition at line 13524 of file object.h.

SymbolSet

typedef DirectChainedHashMap<SymbolKeyValueTrait> dart::SymbolSet

Definition at line 71 of file precompiler.h.

SyncMarkingVisitor

typedef MarkingVisitorBase<true> dart::SyncMarkingVisitor

Definition at line 545 of file marker.cc.

TableSelectorSet

typedef DirectChainedHashMap<TableSelectorKeyValueTrait> dart::TableSelectorSet

Definition at line 51 of file precompiler.h.

ThreadDestructor

typedef void(* dart::ThreadDestructor) (void *parameter)

Definition at line 69 of file os_thread_win.h.

ThreadId

typedef DWORD dart::ThreadId

Definition at line 21 of file os_thread_absl.h.

ThreadJoinId

typedef HANDLE dart::ThreadJoinId

Definition at line 22 of file os_thread_absl.h.

ThreadLocalKey

typedef DWORD dart::ThreadLocalKey

Definition at line 20 of file os_thread_absl.h.

TypeArgumentsSet

typedef DirectChainedHashMap<TypeArgumentsKeyValueTrait> dart::TypeArgumentsSet

Definition at line 185 of file precompiler.h.

TypeParameterSet

typedef DirectChainedHashMap<TypeParameterKeyValueTrait> dart::TypeParameterSet

Definition at line 165 of file precompiler.h.

UnaryMathCFunction

typedef double(* dart::UnaryMathCFunction) (double x)

Definition at line 3875 of file runtime_entry.cc.

UniqueFunctionsMap

typedef UnorderedHashMap<FunctionsTraits> dart::UniqueFunctionsMap

Definition at line 430 of file precompiler.h.

UnsyncMarkingVisitor

typedef MarkingVisitorBase<false> dart::UnsyncMarkingVisitor

Definition at line 544 of file marker.cc.

UriMapping

typedef UnorderedHashMap<UriMappingTraits> dart::UriMapping

Definition at line 5359 of file service.cc.

URIs

typedef ZoneGrowableHandlePtrArray<const String> dart::URIs

Definition at line 1110 of file object.h.

UTF16Array

typedef CharArray<uint16_t> dart::UTF16Array

Definition at line 41 of file canonical_tables.h.

UTF32Array

typedef CharArray<int32_t> dart::UTF32Array

Definition at line 42 of file canonical_tables.h.

uword

typedef uintptr_t dart::uword

Definition at line 501 of file globals.h.

WeakCodeSet

typedef UnorderedHashSet<CodeTraits, WeakArrayStorageTraits> dart::WeakCodeSet

Definition at line 27 of file weak_code.cc.

word

typedef intptr_t dart::word

Definition at line 500 of file globals.h.

Work

typedef std::function<void()> dart::Work

Definition at line 451 of file ffi_test_functions_vmspecific.cc.

YieldPoints

using dart::YieldPoints = typedef ZoneGrowableArray<TokenPosition>

Definition at line 15 of file yield_position_test.cc.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kForwardingMask
kNotForwarded
kForwarded

Definition at line 54 of file scavenger.cc.

     {
  kForwardingMask = 1 << UntaggedObject::kCardRememberedBit,
  kNotForwarded = 0,
  kForwarded = kForwardingMask,
};

anonymous enum

anonymous enum

Enumerator
kNoneFree
kCurrentAndEnclosingFree
kAllFree

Definition at line 2905 of file object.h.

     {
  kNoneFree = 0,
 
  // 'kCurrentAndEnclosingFree' is used when partially applying a signature
  // function to a set of type arguments. It indicates that the set of type
  // parameters declared by the current function and enclosing functions should
  // be considered free, and the current function type parameters should be
  // substituted as well.
  //
  // For instance, if the signature "<T>(T, R) => T" is instantiated with
  // function type arguments [int, String] and kCurrentAndEnclosingFree is
  // supplied, the result of the instantiation will be "(String, int) => int".
  kCurrentAndEnclosingFree = kMaxInt32 - 1,
 
  // Only parameters declared by enclosing functions are free.
  kAllFree = kMaxInt32,
};

anonymous enum

anonymous enum

Enumerator
kSmiTag
kHeapObjectTag
kSmiTagSize
kSmiTagMask
kSmiTagShift

Definition at line 88 of file pointer_tagging.h.

     {
  kSmiTag = 0,
  kHeapObjectTag = 1,
  kSmiTagSize = 1,
  kSmiTagMask = 1,
  kSmiTagShift = 1,
};

anonymous enum

anonymous enum

Enumerator
kPathsUriOffset
kPathsSourceOffset
kPathsEntryLength

Definition at line 31 of file bootstrap.cc.

{ kPathsUriOffset = 0, kPathsSourceOffset = 1, kPathsEntryLength = 2 };

AddSubImmOp

enum dart::AddSubImmOp

Enumerator
AddSubImmMask
AddSubImmFixed
ADDI
SUBI

Definition at line 860 of file constants_arm64.h.

                 {
  AddSubImmMask = 0x1f000000,
  AddSubImmFixed = DPImmediateFixed | B24,
  ADDI = AddSubImmFixed,
  SUBI = AddSubImmFixed | B30,
};

AddSubShiftExtOp

enum dart::AddSubShiftExtOp

Enumerator
AddSubShiftExtMask
AddSubShiftExtFixed
ADD
SUB

Definition at line 905 of file constants_arm64.h.

                      {
  AddSubShiftExtMask = 0x1f000000,
  AddSubShiftExtFixed = DPRegisterFixed | B24,
  ADD = AddSubShiftExtFixed,
  SUB = AddSubShiftExtFixed | B30,
};

AddSubWithCarryOp

enum dart::AddSubWithCarryOp

Enumerator
AddSubWithCarryMask
AddSubWithCarryFixed
ADC
SBC

Definition at line 913 of file constants_arm64.h.

                       {
  AddSubWithCarryMask = 0x1fe00000,
  AddSubWithCarryFixed = DPRegisterFixed | B28,
  ADC = AddSubWithCarryFixed,
  SBC = AddSubWithCarryFixed | B30,
};

AlignmentStrategy

enum dart::AlignmentStrategy

Enumerator
kAlignedToValueSize
kAlignedToValueSizeBut8AlignedTo4
kAlignedToWordSize
kAlignedToWordSizeAndValueSize

Definition at line 11 of file constants_base.h.

                       {
  // Align to the size of the value.
  kAlignedToValueSize,
  // Align to the size of the value, but align 8 byte-sized values to 4 bytes.
  // Both double and int64.
  kAlignedToValueSizeBut8AlignedTo4,
  // Align to the architecture size.
  kAlignedToWordSize,
  // Align to the greater of architecture size or value size.
  kAlignedToWordSizeAndValueSize,
};

AlignmentType

enum dart::AlignmentType

Enumerator
kUnalignedAccess
kAlignedAccess

Definition at line 6720 of file il.h.

                   {
  kUnalignedAccess,
  kAlignedAccess,
};

AtomicMemoryOp

enum dart::AtomicMemoryOp

Enumerator
AtomicMemoryMask
AtomicMemoryFixed
LDCLR
LDSET

Definition at line 829 of file constants_arm64.h.

                    {
  AtomicMemoryMask = 0x3f200c00,
  AtomicMemoryFixed = B29 | B28 | B27 | B21,
  LDCLR = AtomicMemoryFixed | B12,
  LDSET = AtomicMemoryFixed | B13 | B12,
};

BitfieldOp

enum dart::BitfieldOp

Enumerator
BitfieldMask
BitfieldFixed
SBFM
BFM
UBFM
Bitfield64

Definition at line 868 of file constants_arm64.h.

                {
  BitfieldMask = 0x1f800000,
  BitfieldFixed = 0x13000000,
  SBFM = BitfieldFixed,
  BFM = BitfieldFixed | B29,
  UBFM = BitfieldFixed | B30,
  Bitfield64 = B31 | B22,
};

Bits

enum dart::Bits

Enumerator
B0
B1
B2
B3
B4
B5
B6
B7
B8
B9
B10
B11
B12
B13
B14
B15
B16
B17
B18
B19
B20
B21
B22
B23
B24
B25
B26
B27
B28
B29
B30
B31

Definition at line 694 of file constants_arm64.h.

          {
  B0 = (1 << 0),
  B1 = (1 << 1),
  B2 = (1 << 2),
  B3 = (1 << 3),
  B4 = (1 << 4),
  B5 = (1 << 5),
  B6 = (1 << 6),
  B7 = (1 << 7),
  B8 = (1 << 8),
  B9 = (1 << 9),
  B10 = (1 << 10),
  B11 = (1 << 11),
  B12 = (1 << 12),
  B13 = (1 << 13),
  B14 = (1 << 14),
  B15 = (1 << 15),
  B16 = (1 << 16),
  B17 = (1 << 17),
  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),
  B29 = (1 << 29),
  B30 = (1 << 30),
  B31 = (1 << 31),
};

BlockAddressMode

enum dart::BlockAddressMode

Enumerator
DA
IA
DB
IB
DA_W
IA_W
DB_W
IB_W

Definition at line 37 of file assembler_arm.h.

                      {
  // bit encoding P U W
  DA = (0 | 0 | 0) << 21,    // decrement after
  IA = (0 | 4 | 0) << 21,    // increment after
  DB = (8 | 0 | 0) << 21,    // decrement before
  IB = (8 | 4 | 0) << 21,    // increment before
  DA_W = (0 | 0 | 1) << 21,  // decrement after with writeback to base
  IA_W = (0 | 4 | 1) << 21,  // increment after with writeback to base
  DB_W = (8 | 0 | 1) << 21,  // decrement before with writeback to base
  IB_W = (8 | 4 | 1) << 21   // increment before with writeback to base
};

ByteRegister [1/2]

enum dart::ByteRegister

Enumerator
AL
CL
DL
BL
AH
CH
DH
BH
kNumberOfByteRegisters
kNoByteRegister
AL
CL
DL
BL
AH
CH
DH
BH
SPL
BPL
SIL
DIL
R8B
R9B
R10B
R11B
R12B
R13B
R14B
R15B
kNumberOfByteRegisters
kNoByteRegister

Definition at line 37 of file constants_ia32.h.

                  {
  AL = 0,
  CL = 1,
  DL = 2,
  BL = 3,
  AH = 4,
  CH = 5,
  DH = 6,
  BH = 7,
  kNumberOfByteRegisters = 8,
  kNoByteRegister = -1  // Signals an illegal register.
};

ByteRegister [2/2]

enum dart::ByteRegister

Enumerator
AL
CL
DL
BL
AH
CH
DH
BH
kNumberOfByteRegisters
kNoByteRegister
AL
CL
DL
BL
AH
CH
DH
BH
SPL
BPL
SIL
DIL
R8B
R9B
R10B
R11B
R12B
R13B
R14B
R15B
kNumberOfByteRegisters
kNoByteRegister

Definition at line 43 of file constants_x64.h.

                  {
  AL = 0,
  CL = 1,
  DL = 2,
  BL = 3,
  AH = 4,
  CH = 5,
  DH = 6,
  BH = 7,
  SPL = 4 | 0x10,
  BPL = 5 | 0x10,
  SIL = 6 | 0x10,
  DIL = 7 | 0x10,
  R8B = 8,
  R9B = 9,
  R10B = 10,
  R11B = 11,
  R12B = 12,
  R13B = 13,
  R14B = 14,
  R15B = 15,
  kNumberOfByteRegisters = 16,
  kNoByteRegister = -1  // Signals an illegal register.
};

CheckType

enum class dart::CheckType

strong

Enumerator
kCannotBeChecked
kNotSubtype
kCidCheckOnly
kNeedsFinalization
kInstanceTypeArgumentsAreSubtypes

Definition at line 464 of file type_testing_stubs.cc.

                     {
  kCannotBeChecked,
  kNotSubtype,
  kCidCheckOnly,
  kNeedsFinalization,
  kInstanceTypeArgumentsAreSubtypes,
};

ClassId

enum dart::ClassId : intptr_t

Enumerator
kIllegalCid
kNativePointer
kFreeListElement
kForwardingCorpse
kByteDataViewCid
kUnmodifiableByteDataViewCid
kByteBufferCid
kNullCid
kDynamicCid
kVoidCid
kNeverCid
kNumPredefinedCids

Definition at line 212 of file class_id.h.

             : intptr_t {
  // Illegal class id.
  kIllegalCid = 0,
 
  // Pseudo class id for native pointers, the heap should never see an
  // object with this class id.
  kNativePointer,
 
  // The following entries describes classes for pseudo-objects in the heap
  // that should never be reachable from live objects. Free list elements
  // maintain the free list for old space, and forwarding corpses are used to
  // implement one-way become.
  kFreeListElement,
  kForwardingCorpse,
 
// List of Ids for predefined classes.
#define DEFINE_OBJECT_KIND(clazz) k##clazz##Cid,
  CLASS_LIST(DEFINE_OBJECT_KIND)
#undef DEFINE_OBJECT_KIND
 
// clang-format off
#define DEFINE_OBJECT_KIND(clazz) kFfi##clazz##Cid,
  CLASS_LIST_FFI(DEFINE_OBJECT_KIND)
#undef DEFINE_OBJECT_KIND
 
#define DEFINE_OBJECT_KIND(clazz)                                              \
  kTypedData##clazz##Cid,                                                      \
  kTypedData##clazz##ViewCid,                                                  \
  kExternalTypedData##clazz##Cid,                                              \
  kUnmodifiableTypedData##clazz##ViewCid,
  CLASS_LIST_TYPED_DATA(DEFINE_OBJECT_KIND)
#undef DEFINE_OBJECT_KIND
  kByteDataViewCid,
  kUnmodifiableByteDataViewCid,
 
  kByteBufferCid,
  // clang-format on
 
  // The following entries do not describe a predefined class, but instead
  // are class indexes for pre-allocated instances (Null, dynamic, void, Never).
  kNullCid,
  kDynamicCid,
  kVoidCid,
  kNeverCid,
 
  kNumPredefinedCids,
};

CodeEntryKind

enum class dart::CodeEntryKind

strong

Enumerator
kNormal
kUnchecked
kMonomorphic
kMonomorphicUnchecked

Definition at line 15 of file code_entry_kind.h.

                         {
  // Normal entry into the function.
  //
  // Usually such entries perform type checks for all parameters which are not
  // guaranteed to be type checked on the callee side. This can happen if
  // parameter type depends on the type parameter of an enclosing class.
  kNormal,
 
  // Unchecked entry into the function.
  //
  // These entries usually skip most of the type checks that normal entries
  // perform and are used when optimizing compiler can prove that those
  // checks are not needed at a specific call site.
  kUnchecked,
 
  // Monomorphic entry into the function.
  //
  // In AOT mode we might patch call-site to directly invoke target function,
  // which would then validate that it is invoked with the expected type of
  // the receiver. This validation is handled by monomorphic entry, which then
  // falls through to the normal entry.
  kMonomorphic,
 
  // Similar to monomorphic entry but with a fallthrough into unchecked entry.
  kMonomorphicUnchecked,
};

CompareAndBranchOp

enum dart::CompareAndBranchOp

Enumerator
CompareAndBranchMask
CompareAndBranchFixed
CBZ
CBNZ

Definition at line 755 of file constants_arm64.h.

                        {
  CompareAndBranchMask = 0x7e000000,
  CompareAndBranchFixed = CompareBranchFixed | B29,
  CBZ = CompareAndBranchFixed,
  CBNZ = CompareAndBranchFixed | B24,
};

CompilerTracing

enum class dart::CompilerTracing

strong

Enumerator
kOn
kOff

Definition at line 28 of file compiler_state.h.

                           {
  kOn,
  kOff,
};

Condition [1/4]

enum dart::Condition

Enumerator
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
kSpecialCondition
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
NV
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
NV
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
OVERFLOW
NO_OVERFLOW
BELOW
ABOVE_EQUAL
EQUAL
NOT_EQUAL
BELOW_EQUAL
ABOVE
SIGN
NOT_SIGN
PARITY_EVEN
PARITY_ODD
LESS
GREATER_EQUAL
LESS_EQUAL
GREATER
ZERO
NOT_ZERO
NEGATIVE
POSITIVE
CARRY
NOT_CARRY
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
kInvalidCondition

Definition at line 765 of file constants_arm.h.

               {
  kNoCondition = -1,
  EQ = 0,                  // equal
  NE = 1,                  // not equal
  CS = 2,                  // carry set/unsigned higher or same
  CC = 3,                  // carry clear/unsigned lower
  MI = 4,                  // minus/negative
  PL = 5,                  // plus/positive or zero
  VS = 6,                  // overflow
  VC = 7,                  // no overflow
  HI = 8,                  // unsigned higher
  LS = 9,                  // unsigned lower or same
  GE = 10,                 // signed greater than or equal
  LT = 11,                 // signed less than
  GT = 12,                 // signed greater than
  LE = 13,                 // signed less than or equal
  AL = 14,                 // always (unconditional)
  kSpecialCondition = 15,  // special condition (refer to section A3.2.1)
  kNumberOfConditions = 16,
 
  // Platform-independent variants declared for all platforms
  EQUAL = EQ,
  ZERO = EQUAL,
  NOT_EQUAL = NE,
  NOT_ZERO = NOT_EQUAL,
  LESS = LT,
  LESS_EQUAL = LE,
  GREATER_EQUAL = GE,
  GREATER = GT,
  UNSIGNED_LESS = CC,
  UNSIGNED_LESS_EQUAL = LS,
  UNSIGNED_GREATER = HI,
  UNSIGNED_GREATER_EQUAL = CS,
  OVERFLOW = VS,
  NO_OVERFLOW = VC,
 
  kInvalidCondition = 16
};

Condition [2/4]

enum dart::Condition

Enumerator
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
kSpecialCondition
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
NV
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
NV
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
OVERFLOW
NO_OVERFLOW
BELOW
ABOVE_EQUAL
EQUAL
NOT_EQUAL
BELOW_EQUAL
ABOVE
SIGN
NOT_SIGN
PARITY_EVEN
PARITY_ODD
LESS
GREATER_EQUAL
LESS_EQUAL
GREATER
ZERO
NOT_ZERO
NEGATIVE
POSITIVE
CARRY
NOT_CARRY
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
kInvalidCondition

Definition at line 641 of file constants_arm64.h.

               {
  kNoCondition = -1,
  EQ = 0,   // equal
  NE = 1,   // not equal
  CS = 2,   // carry set/unsigned higher or same
  CC = 3,   // carry clear/unsigned lower
  MI = 4,   // minus/negative
  PL = 5,   // plus/positive or zero
  VS = 6,   // overflow
  VC = 7,   // no overflow
  HI = 8,   // unsigned higher
  LS = 9,   // unsigned lower or same
  GE = 10,  // signed greater than or equal
  LT = 11,  // signed less than
  GT = 12,  // signed greater than
  LE = 13,  // signed less than or equal
  AL = 14,  // always (unconditional)
  NV = 15,  // special condition (refer to section C1.2.3)
  kNumberOfConditions = 16,
 
  // Platform-independent variants declared for all platforms
  EQUAL = EQ,
  ZERO = EQUAL,
  NOT_EQUAL = NE,
  NOT_ZERO = NOT_EQUAL,
  LESS = LT,
  LESS_EQUAL = LE,
  GREATER_EQUAL = GE,
  GREATER = GT,
  UNSIGNED_LESS = CC,
  UNSIGNED_LESS_EQUAL = LS,
  UNSIGNED_GREATER = HI,
  UNSIGNED_GREATER_EQUAL = CS,
  OVERFLOW = VS,
  NO_OVERFLOW = VC,
 
  kInvalidCondition = 16
};

Condition [3/4]

enum dart::Condition

Enumerator
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
kSpecialCondition
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
NV
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
NV
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
OVERFLOW
NO_OVERFLOW
BELOW
ABOVE_EQUAL
EQUAL
NOT_EQUAL
BELOW_EQUAL
ABOVE
SIGN
NOT_SIGN
PARITY_EVEN
PARITY_ODD
LESS
GREATER_EQUAL
LESS_EQUAL
GREATER
ZERO
NOT_ZERO
NEGATIVE
POSITIVE
CARRY
NOT_CARRY
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
kInvalidCondition

Definition at line 603 of file constants_riscv.h.

               {
  kNoCondition = -1,
  EQ = 0,   // equal
  NE = 1,   // not equal
  CS = 2,   // carry set/unsigned higher or same
  CC = 3,   // carry clear/unsigned lower
  MI = 4,   // minus/negative
  PL = 5,   // plus/positive or zero
  VS = 6,   // overflow
  VC = 7,   // no overflow
  HI = 8,   // unsigned higher
  LS = 9,   // unsigned lower or same
  GE = 10,  // signed greater than or equal
  LT = 11,  // signed less than
  GT = 12,  // signed greater than
  LE = 13,  // signed less than or equal
  AL = 14,  // always (unconditional)
  NV = 15,  // special condition (refer to section C1.2.3)
  kNumberOfConditions = 16,
 
  // Platform-independent variants declared for all platforms
  EQUAL = EQ,
  ZERO = EQUAL,
  NOT_EQUAL = NE,
  NOT_ZERO = NOT_EQUAL,
  LESS = LT,
  LESS_EQUAL = LE,
  GREATER_EQUAL = GE,
  GREATER = GT,
  UNSIGNED_LESS = CC,
  UNSIGNED_LESS_EQUAL = LS,
  UNSIGNED_GREATER = HI,
  UNSIGNED_GREATER_EQUAL = CS,
  OVERFLOW = VS,
  NO_OVERFLOW = VC,
 
  kInvalidCondition = 16
};

Condition [4/4]

enum dart::Condition

Enumerator
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
kSpecialCondition
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
NV
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
kNoCondition
EQ
NE
CS
CC
MI
PL
VS
VC
HI
LS
GE
LT
GT
LE
AL
NV
kNumberOfConditions
EQUAL
ZERO
NOT_EQUAL
NOT_ZERO
LESS
LESS_EQUAL
GREATER_EQUAL
GREATER
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
OVERFLOW
NO_OVERFLOW
kInvalidCondition
OVERFLOW
NO_OVERFLOW
BELOW
ABOVE_EQUAL
EQUAL
NOT_EQUAL
BELOW_EQUAL
ABOVE
SIGN
NOT_SIGN
PARITY_EVEN
PARITY_ODD
LESS
GREATER_EQUAL
LESS_EQUAL
GREATER
ZERO
NOT_ZERO
NEGATIVE
POSITIVE
CARRY
NOT_CARRY
UNSIGNED_LESS
UNSIGNED_LESS_EQUAL
UNSIGNED_GREATER
UNSIGNED_GREATER_EQUAL
kInvalidCondition

Definition at line 12 of file constants_x86.h.

               {
  OVERFLOW = 0,
  NO_OVERFLOW = 1,
  BELOW = 2,
  ABOVE_EQUAL = 3,
  EQUAL = 4,
  NOT_EQUAL = 5,
  BELOW_EQUAL = 6,
  ABOVE = 7,
  SIGN = 8,
  NOT_SIGN = 9,
  PARITY_EVEN = 10,
  PARITY_ODD = 11,
  LESS = 12,
  GREATER_EQUAL = 13,
  LESS_EQUAL = 14,
  GREATER = 15,
 
  ZERO = EQUAL,
  NOT_ZERO = NOT_EQUAL,
  NEGATIVE = SIGN,
  POSITIVE = NOT_SIGN,
  CARRY = BELOW,
  NOT_CARRY = ABOVE_EQUAL,
 
  // Platform-independent variants declared for all platforms
  // EQUAL,
  // NOT_EQUAL,
  // LESS,
  // LESS_EQUAL,
  // GREATER_EQUAL,
  // GREATER,
  UNSIGNED_LESS = BELOW,
  UNSIGNED_LESS_EQUAL = BELOW_EQUAL,
  UNSIGNED_GREATER = ABOVE,
  UNSIGNED_GREATER_EQUAL = ABOVE_EQUAL,
 
  kInvalidCondition = 16
};

ConditionalBranchOp

enum dart::ConditionalBranchOp

Enumerator
ConditionalBranchMask
ConditionalBranchFixed
BCOND

Definition at line 763 of file constants_arm64.h.

                         {
  ConditionalBranchMask = 0xfe000000,
  ConditionalBranchFixed = CompareBranchFixed | B30,
  BCOND = ConditionalBranchFixed,
};

ConditionalSelectOp

enum dart::ConditionalSelectOp

Enumerator
ConditionalSelectMask
ConditionalSelectFixed
CSEL
CSINC
CSINV
CSNEG

Definition at line 921 of file constants_arm64.h.

                         {
  ConditionalSelectMask = 0x1fe00000,
  ConditionalSelectFixed = DPRegisterFixed | B28 | B23,
  CSEL = ConditionalSelectFixed,
  CSINC = ConditionalSelectFixed | B10,
  CSINV = ConditionalSelectFixed | B30,
  CSNEG = ConditionalSelectFixed | B10 | B30,
};

ContainedInLattice

enum dart::ContainedInLattice

Enumerator
kNotYet
kLatticeIn
kLatticeOut
kLatticeUnknown

Definition at line 1080 of file regexp.h.

                        {
  kNotYet = 0,
  kLatticeIn = 1,
  kLatticeOut = 2,
  kLatticeUnknown = 3  // Can also mean both in and out.
};

COpcode

enum dart::COpcode

Enumerator
C_OP_MASK
C_ADDI4SPN
C_FLD
C_LW
C_FLW
C_LD
C_FSD
C_SW
C_FSW
C_SD
C_ADDI
C_JAL
C_ADDIW
C_LI
C_ADDI16SP
C_LUI
C_MISCALU
C_MISCALU_MASK
C_SRLI
C_SRAI
C_ANDI
C_RR
C_RR_MASK
C_SUB
C_XOR
C_OR
C_AND
C_SUBW
C_ADDW
C_J
C_BEQZ
C_BNEZ
C_SLLI
C_FLDSP
C_LWSP
C_FLWSP
C_LDSP
C_JR
C_MV
C_JALR
C_ADD
C_FSDSP
C_SWSP
C_FSWSP
C_SDSP
C_NOP
C_EBREAK

Definition at line 1424 of file constants_riscv.h.

             {
  C_OP_MASK = 0b1110000000000011,
 
  C_ADDI4SPN = 0b0000000000000000,
  C_FLD = 0b0010000000000000,
  C_LW = 0b0100000000000000,
  C_FLW = 0b0110000000000000,
  C_LD = 0b0110000000000000,
  C_FSD = 0b1010000000000000,
  C_SW = 0b1100000000000000,
  C_FSW = 0b1110000000000000,
  C_SD = 0b1110000000000000,
 
  C_ADDI = 0b0000000000000001,
  C_JAL = 0b0010000000000001,
  C_ADDIW = 0b0010000000000001,
  C_LI = 0b0100000000000001,
  C_ADDI16SP = 0b0110000000000001,
  C_LUI = 0b0110000000000001,
 
  C_MISCALU = 0b1000000000000001,
  C_MISCALU_MASK = 0b1110110000000011,
  C_SRLI = 0b1000000000000001,
  C_SRAI = 0b1000010000000001,
  C_ANDI = 0b1000100000000001,
  C_RR = 0b1000110000000001,
  C_RR_MASK = 0b1111110001100011,
  C_SUB = 0b1000110000000001,
  C_XOR = 0b1000110000100001,
  C_OR = 0b1000110001000001,
  C_AND = 0b1000110001100001,
  C_SUBW = 0b1001110000000001,
  C_ADDW = 0b1001110000100001,
 
  C_J = 0b1010000000000001,
  C_BEQZ = 0b1100000000000001,
  C_BNEZ = 0b1110000000000001,
 
  C_SLLI = 0b0000000000000010,
  C_FLDSP = 0b0010000000000010,
  C_LWSP = 0b0100000000000010,
  C_FLWSP = 0b0110000000000010,
  C_LDSP = 0b0110000000000010,
  C_JR = 0b1000000000000010,
  C_MV = 0b1000000000000010,
  C_JALR = 0b1001000000000010,
  C_ADD = 0b1001000000000010,
  C_FSDSP = 0b1010000000000010,
  C_SWSP = 0b1100000000000010,
  C_FSWSP = 0b1110000000000010,
  C_SDSP = 0b1110000000000010,
 
  C_NOP = 0b0000000000000001,
  C_EBREAK = 0b1001000000000010,
};

CpuInfoIndices

enum dart::CpuInfoIndices

Enumerator
kCpuInfoProcessor
kCpuInfoModel
kCpuInfoHardware
kCpuInfoFeatures
kCpuInfoArchitecture
kCpuInfoMax

Definition at line 15 of file cpuinfo.h.

                    {
  kCpuInfoProcessor = 0,
  kCpuInfoModel = 1,
  kCpuInfoHardware = 2,
  kCpuInfoFeatures = 3,
  kCpuInfoArchitecture = 4,
  kCpuInfoMax = 5,
};

CpuInfoMethod

enum dart::CpuInfoMethod

Enumerator
kCpuInfoCpuId
kCpuInfoSystem
kCpuInfoNone
kCpuInfoDefault

Definition at line 25 of file cpuinfo.h.

                   {
  // Use the cpuid instruction.
  kCpuInfoCpuId,
 
  // Use system calls.
  kCpuInfoSystem,
 
  // Don't query anything.
  kCpuInfoNone,
 
  // Use whatever the default is for a particular OS:
  // Linux, Windows -> CpuId,
  // Android, MacOS -> System.
  kCpuInfoDefault,
};

CSEMode

enum dart::CSEMode

Enumerator
kOptimizeLoads
kOptimizeStores

Definition at line 1369 of file redundancy_elimination.cc.

{ kOptimizeLoads, kOptimizeStores };

Dart_ExceptionPauseInfo

enum dart::Dart_ExceptionPauseInfo

Enumerator
kNoPauseOnExceptions
kPauseOnUnhandledExceptions
kPauseOnAllExceptions
kInvalidExceptionPauseInfo

Definition at line 502 of file debugger.h.

             {
  kNoPauseOnExceptions = 1,
  kPauseOnUnhandledExceptions,
  kPauseOnAllExceptions,
  kInvalidExceptionPauseInfo
} Dart_ExceptionPauseInfo;

Dart_IsolateEvent

enum dart::Dart_IsolateEvent

Enumerator
kCreated
kInterrupted
kShutdown

Definition at line 41 of file debugger_api_impl_test.h.

             {
  kCreated = 0,
  kInterrupted,
  kShutdown,
} Dart_IsolateEvent;

DeoptStubKind

enum dart::DeoptStubKind

Enumerator
kLazyDeoptFromReturn
kLazyDeoptFromThrow
kEagerDeopt

Definition at line 255 of file stub_code_compiler.h.

{ kLazyDeoptFromReturn, kLazyDeoptFromThrow, kEagerDeopt };

DRegister

enum dart::DRegister

Enumerator
kNoDRegister
D0
D1
D2
D3
D4
D5
D6
D7
D8
D9
D10
D11
D12
D13
D14
D15
D16
D17
D18
D19
D20
D21
D22
D23
D24
D25
D26
D27
D28
D29
D30
D31
kNumberOfDRegisters
kNumberOfOverlappingDRegisters

Definition at line 154 of file constants_arm.h.

               {
  kNoDRegister = -1,
  D0 = 0,
  D1 = 1,
  D2 = 2,
  D3 = 3,
  D4 = 4,
  D5 = 5,
  D6 = 6,
  D7 = 7,
  D8 = 8,
  D9 = 9,
  D10 = 10,
  D11 = 11,
  D12 = 12,
  D13 = 13,
  D14 = 14,
  D15 = 15,
#if defined(VFPv3_D16)
  kNumberOfDRegisters = 16,
  // Leaving these defined, but marking them as kNoDRegister to avoid polluting
  // other parts of the code with #ifdef's. Instead, query kNumberOfDRegisters
  // to see which registers are valid.
  D16 = kNoDRegister,
  D17 = kNoDRegister,
  D18 = kNoDRegister,
  D19 = kNoDRegister,
  D20 = kNoDRegister,
  D21 = kNoDRegister,
  D22 = kNoDRegister,
  D23 = kNoDRegister,
  D24 = kNoDRegister,
  D25 = kNoDRegister,
  D26 = kNoDRegister,
  D27 = kNoDRegister,
  D28 = kNoDRegister,
  D29 = kNoDRegister,
  D30 = kNoDRegister,
  D31 = kNoDRegister,
#else
  D16 = 16,
  D17 = 17,
  D18 = 18,
  D19 = 19,
  D20 = 20,
  D21 = 21,
  D22 = 22,
  D23 = 23,
  D24 = 24,
  D25 = 25,
  D26 = 26,
  D27 = 27,
  D28 = 28,
  D29 = 29,
  D30 = 30,
  D31 = 31,
  kNumberOfDRegisters = 32,
#endif
  // Number of D registers that overlap S registers.
  // One D register overlaps two S registers, so regardless of the numbers of D
  // registers, there are only 32 S registers that are overlapped.
  kNumberOfOverlappingDRegisters = 16,
};

EntryPointPragma

enum class dart::EntryPointPragma

strong

Enumerator
kAlways
kNever
kGetterOnly
kSetterOnly
kCallOnly

Definition at line 4344 of file object.h.

                            {
  kAlways,
  kNever,
  kGetterOnly,
  kSetterOnly,
  kCallOnly
};

ExceptionGenOp

enum dart::ExceptionGenOp

Enumerator
ExceptionGenMask
ExceptionGenFixed
SVC
BRK
HLT

Definition at line 770 of file constants_arm64.h.

                    {
  ExceptionGenMask = 0xff000000,
  ExceptionGenFixed = CompareBranchFixed | B31 | B30,
  SVC = ExceptionGenFixed | B0,
  BRK = ExceptionGenFixed | B21,
  HLT = ExceptionGenFixed | B22,
};

ExperimentalFeature

enum class dart::ExperimentalFeature

strong

Enumerator
inference_update_3
inline_class
inference_update_2
sealed_class
class_modifiers
records
patterns
unnamed_libraries
inference_update_1
enhanced_enums
named_arguments_anywhere
super_parameters
constructor_tearoffs
generic_metadata
triple_shift
nonfunction_type_aliases
non_nullable
extension_methods
constant_update_2018
control_flow_collections
set_literals
spread_collections

Definition at line 14 of file experimental_features.h.

                               {
  inference_update_3,
  inline_class,
  inference_update_2,
  sealed_class,
  class_modifiers,
  records,
  patterns,
  unnamed_libraries,
  inference_update_1,
  enhanced_enums,
  named_arguments_anywhere,
  super_parameters,
  constructor_tearoffs,
  generic_metadata,
  triple_shift,
  nonfunction_type_aliases,
  non_nullable,
  extension_methods,
  constant_update_2018,
  control_flow_collections,
  set_literals,
  spread_collections,
};

Extend

enum dart::Extend

Enumerator
kNoExtend
UXTB
UXTH
UXTW
UXTX
SXTB
SXTH
SXTW
SXTX
kMaxExtend

Definition at line 1142 of file constants_arm64.h.

            {
  kNoExtend = -1,
  UXTB = 0,  // Zero extend byte.
  UXTH = 1,  // Zero extend halfword (16 bits).
  UXTW = 2,  // Zero extend word (32 bits).
  UXTX = 3,  // Zero extend doubleword (64 bits).
  SXTB = 4,  // Sign extend byte.
  SXTH = 5,  // Sign extend halfword (16 bits).
  SXTW = 6,  // Sign extend word (32 bits).
  SXTX = 7,  // Sign extend doubleword (64 bits).
  kMaxExtend = 8,
};

ExtensionStrategy

enum dart::ExtensionStrategy

Enumerator
kNotExtended
kExtendedTo4
kExtendedTo8

Definition at line 24 of file constants_base.h.

                       {
  // Values can have arbitrary small size with the upper bits undefined.
  kNotExtended,
  // Values smaller than 4 bytes are passed around zero- or sign-extended to
  // 4 bytes.
  kExtendedTo4,
  // Values smaller than 8 bytes are passed around zero- or sign-extended to
  // 8 bytes.
  kExtendedTo8,
};

FClass

enum dart::FClass

Enumerator
kFClassNegInfinity
kFClassNegNormal
kFClassNegSubnormal
kFClassNegZero
kFClassPosZero
kFClassPosSubnormal
kFClassPosNormal
kFClassPosInfinity
kFClassSignallingNan
kFClassQuietNan

Definition at line 924 of file constants_riscv.h.

            {
  kFClassNegInfinity = 1 << 0,
  kFClassNegNormal = 1 << 1,
  kFClassNegSubnormal = 1 << 2,
  kFClassNegZero = 1 << 3,
  kFClassPosZero = 1 << 4,
  kFClassPosSubnormal = 1 << 5,
  kFClassPosNormal = 1 << 6,
  kFClassPosInfinity = 1 << 7,
  kFClassSignallingNan = 1 << 8,
  kFClassQuietNan = 1 << 9,
};

FcvtRs2

enum dart::FcvtRs2

Enumerator
W
WU
L
LU

Definition at line 917 of file constants_riscv.h.

             {
  W = 0b00000,
  WU = 0b00001,
  L = 0b00010,
  LU = 0b00011,
};

FfiCallbackKind

enum class dart::FfiCallbackKind : uint8_t

strong

Enumerator
kIsolateLocalStaticCallback
kIsolateLocalClosureCallback
kAsyncCallback

Definition at line 2964 of file object.h.

                           : uint8_t {
  kIsolateLocalStaticCallback,
  kIsolateLocalClosureCallback,
  kAsyncCallback,
};

FPCompareOp

enum dart::FPCompareOp

Enumerator
FPCompareMask
FPCompareFixed
FCMPD
FCMPZD

Definition at line 1041 of file constants_arm64.h.

                 {
  FPCompareMask = 0xffa0fc07,
  FPCompareFixed = FPFixed | B21 | B13,
  FCMPD = FPCompareFixed | B22,
  FCMPZD = FPCompareFixed | B22 | B3,
};

FPImmOp

enum dart::FPImmOp

Enumerator
FPImmMask
FPImmFixed
FMOVSI
FMOVDI

Definition at line 1071 of file constants_arm64.h.

             {
  FPImmMask = 0x5f201c00,
  FPImmFixed = FPFixed | B21 | B12,
  FMOVSI = FPImmFixed,
  FMOVDI = FPImmFixed | B22,
};

FPIntCvtOp

enum dart::FPIntCvtOp

Enumerator
FPIntCvtMask
FPIntCvtFixed
FMOVRS
FMOVSR
FMOVRD
FMOVDR
FCVTZS_D
FCVTMS_D
FCVTPS_D
SCVTFD

Definition at line 1079 of file constants_arm64.h.

                {
  FPIntCvtMask = 0x5f00fc00,
  FPIntCvtFixed = FPFixed | B21,
  FMOVRS = FPIntCvtFixed | B18 | B17,
  FMOVSR = FPIntCvtFixed | B18 | B17 | B16,
  FMOVRD = FPIntCvtFixed | B22 | B18 | B17,
  FMOVDR = FPIntCvtFixed | B22 | B18 | B17 | B16,
  FCVTZS_D = FPIntCvtFixed | B22 | B20 | B19,
  FCVTMS_D = FPIntCvtFixed | B22 | B20,
  FCVTPS_D = FPIntCvtFixed | B22 | B19,
  SCVTFD = FPIntCvtFixed | B22 | B17,
};

FPOneSourceOp

enum dart::FPOneSourceOp

Enumerator
FPOneSourceMask
FPOneSourceFixed
FMOVDD
FABSD
FNEGD
FSQRTD
FCVTDS
FCVTSD

Definition at line 1049 of file constants_arm64.h.

                   {
  FPOneSourceMask = 0x5f207c00,
  FPOneSourceFixed = FPFixed | B21 | B14,
  FMOVDD = FPOneSourceFixed | B22,
  FABSD = FPOneSourceFixed | B22 | B15,
  FNEGD = FPOneSourceFixed | B22 | B16,
  FSQRTD = FPOneSourceFixed | B22 | B16 | B15,
  FCVTDS = FPOneSourceFixed | B15 | B17,
  FCVTSD = FPOneSourceFixed | B22 | B17,
};

FPTwoSourceOp

enum dart::FPTwoSourceOp

Enumerator
FPTwoSourceMask
FPTwoSourceFixed
FMULD
FDIVD
FADDD
FSUBD

Definition at line 1061 of file constants_arm64.h.

                   {
  FPTwoSourceMask = 0xff200c00,
  FPTwoSourceFixed = FPFixed | B21 | B11,
  FMULD = FPTwoSourceFixed | B22,
  FDIVD = FPTwoSourceFixed | B22 | B12,
  FADDD = FPTwoSourceFixed | B22 | B13,
  FSUBD = FPTwoSourceFixed | B22 | B13 | B12,
};

FRegister

enum dart::FRegister

Enumerator
FT0
FT1
FT2
FT3
FT4
FT5
FT6
FT7
FS0
FS1
FA0
FA1
FA2
FA3
FA4
FA5
FA6
FA7
FS2
FS3
FS4
FS5
FS6
FS7
FS8
FS9
FS10
FS11
FT8
FT9
FT10
FT11

Definition at line 99 of file constants_riscv.h.

               {
  FT0 = 0,
  FT1 = 1,
  FT2 = 2,
  FT3 = 3,
  FT4 = 4,
  FT5 = 5,
  FT6 = 6,
  FT7 = 7,
  FS0 = 8,
  FS1 = 9,
  FA0 = 10,
  FA1 = 11,
  FA2 = 12,
  FA3 = 13,
  FA4 = 14,
  FA5 = 15,
  FA6 = 16,
  FA7 = 17,
  FS2 = 18,
  FS3 = 19,
  FS4 = 20,
  FS5 = 21,
  FS6 = 22,
  FS7 = 23,
  FS8 = 24,
  FS9 = 25,
  FS10 = 26,
  FS11 = 27,
  FT8 = 28,
  FT9 = 29,
  FT10 = 30,
  FT11 = 31,
  kNumberOfFpuRegisters = 32,
  kNoFpuRegister = -1,
};

Funct12

enum dart::Funct12

Enumerator
ECALL
EBREAK

Definition at line 730 of file constants_riscv.h.

             {
  ECALL = 0,
  EBREAK = 1,
};

Funct2

enum dart::Funct2

Enumerator
F2_S
F2_D

Definition at line 903 of file constants_riscv.h.

            {
  F2_S = 0b00,
  F2_D = 0b01,
};

Funct3

enum dart::Funct3

Enumerator
F3_0
F3_1
BEQ
BNE
BLT
BGE
BLTU
BGEU
LB
LH
LW
LBU
LHU
LWU
LD
SB
SH
SW
SD
ADDI
SLLI
SLTI
SLTIU
XORI
SRI
ORI
ANDI
ADD
SLL
SLT
SLTU
XOR
SR
OR
AND
FENCE
FENCEI
CSRRW
CSRRS
CSRRC
CSRRWI
CSRRSI
CSRRCI
MUL
MULH
MULHSU
MULHU
DIV
DIVU
REM
REMU
MULW
DIVW
DIVUW
REMW
REMUW
WIDTH32
WIDTH64
S
D
J
JN
JX
FMIN
FMAX
FEQ
FLT
FLE
SH1ADD
SH2ADD
SH3ADD
F3_COUNT
MAX
MAXU
MIN
MINU
CLMUL
CLMULH
CLMULR
SEXT
ZEXT
ROL
ROR
BCLR
BEXT
F3_BINV
F3_BSET

Definition at line 735 of file constants_riscv.h.

            {
  F3_0 = 0,
  F3_1 = 1,
 
  BEQ = 0b000,
  BNE = 0b001,
  BLT = 0b100,
  BGE = 0b101,
  BLTU = 0b110,
  BGEU = 0b111,
 
  LB = 0b000,
  LH = 0b001,
  LW = 0b010,
  LBU = 0b100,
  LHU = 0b101,
  LWU = 0b110,
  LD = 0b011,
 
  SB = 0b000,
  SH = 0b001,
  SW = 0b010,
  SD = 0b011,
 
  ADDI = 0b000,
  SLLI = 0b001,
  SLTI = 0b010,
  SLTIU = 0b011,
  XORI = 0b100,
  SRI = 0b101,
  ORI = 0b110,
  ANDI = 0b111,
 
  ADD = 0b000,
  SLL = 0b001,
  SLT = 0b010,
  SLTU = 0b011,
  XOR = 0b100,
  SR = 0b101,
  OR = 0b110,
  AND = 0b111,
 
  FENCE = 0b000,
  FENCEI = 0b001,
 
  CSRRW = 0b001,
  CSRRS = 0b010,
  CSRRC = 0b011,
  CSRRWI = 0b101,
  CSRRSI = 0b110,
  CSRRCI = 0b111,
 
  MUL = 0b000,
  MULH = 0b001,
  MULHSU = 0b010,
  MULHU = 0b011,
  DIV = 0b100,
  DIVU = 0b101,
  REM = 0b110,
  REMU = 0b111,
 
  MULW = 0b000,
  DIVW = 0b100,
  DIVUW = 0b101,
  REMW = 0b110,
  REMUW = 0b111,
 
  WIDTH32 = 0b010,
  WIDTH64 = 0b011,
 
  S = 0b010,
  D = 0b011,
  J = 0b000,
  JN = 0b001,
  JX = 0b010,
  FMIN = 0b000,
  FMAX = 0b001,
  FEQ = 0b010,
  FLT = 0b001,
  FLE = 0b000,
 
  SH1ADD = 0b010,
  SH2ADD = 0b100,
  SH3ADD = 0b110,
 
  F3_COUNT = 0b001,
 
  MAX = 0b110,
  MAXU = 0b111,
  MIN = 0b100,
  MINU = 0b101,
  CLMUL = 0b001,
  CLMULH = 0b011,
  CLMULR = 0b010,
 
  SEXT = 0b001,
  ZEXT = 0b100,
 
  ROL = 0b001,
  ROR = 0b101,
 
  BCLR = 0b001,
  BEXT = 0b101,
  F3_BINV = 0b001,
  F3_BSET = 0b001,
};

Funct5

enum dart::Funct5

Enumerator
LR
SC
AMOSWAP
AMOADD
AMOXOR
AMOAND
AMOOR
AMOMIN
AMOMAX
AMOMINU
AMOMAXU

Definition at line 889 of file constants_riscv.h.

            {
  LR = 0b00010,
  SC = 0b00011,
  AMOSWAP = 0b00001,
  AMOADD = 0b00000,
  AMOXOR = 0b00100,
  AMOAND = 0b01100,
  AMOOR = 0b01000,
  AMOMIN = 0b10000,
  AMOMAX = 0b10100,
  AMOMINU = 0b11000,
  AMOMAXU = 0b11100,
};

Funct7

enum dart::Funct7

Enumerator
F7_0
SRA
SUB
MULDIV
FADDS
FSUBS
FMULS
FDIVS
FSQRTS
FSGNJS
FMINMAXS
FCMPS
FCLASSS
FCVTintS
FCVTSint
FMVXW
FMVWX
FADDD
FSUBD
FMULD
FDIVD
FSQRTD
FSGNJD
FMINMAXD
FCVTS
FCVTD
FCMPD
FCLASSD
FCVTintD
FCVTDint
FMVXD
FMVDX
ADDUW
SHADD
SLLIUW
COUNT
MINMAXCLMUL
ROTATE
BCLRBEXT
BINV
BSET

Definition at line 842 of file constants_riscv.h.

            {
  F7_0 = 0,
  SRA = 0b0100000,
  SUB = 0b0100000,
  MULDIV = 0b0000001,
 
  FADDS = 0b0000000,
  FSUBS = 0b0000100,
  FMULS = 0b0001000,
  FDIVS = 0b0001100,
  FSQRTS = 0b0101100,
  FSGNJS = 0b0010000,
  FMINMAXS = 0b0010100,
  FCMPS = 0b1010000,
  FCLASSS = 0b1110000,
  FCVTintS = 0b1100000,
  FCVTSint = 0b1101000,
  FMVXW = 0b1110000,
  FMVWX = 0b1111000,
 
  FADDD = 0b0000001,
  FSUBD = 0b0000101,
  FMULD = 0b0001001,
  FDIVD = 0b0001101,
  FSQRTD = 0b0101101,
  FSGNJD = 0b0010001,
  FMINMAXD = 0b0010101,
  FCVTS = 0b0100000,
  FCVTD = 0b0100001,
  FCMPD = 0b1010001,
  FCLASSD = 0b1110001,
  FCVTintD = 0b1100001,
  FCVTDint = 0b1101001,
  FMVXD = 0b1110001,
  FMVDX = 0b1111001,
 
  ADDUW = 0b0000100,
  SHADD = 0b0010000,
  SLLIUW = 0b0000100,
  COUNT = 0b0110000,
  MINMAXCLMUL = 0b0000101,
  ROTATE = 0b0110000,
  BCLRBEXT = 0b0100100,
  BINV = 0b0110100,
  BSET = 0b0010100,
};

GCReason

enum class dart::GCReason

strong

Enumerator
kNewSpace
kStoreBuffer
kPromotion
kOldSpace
kFinalize
kFull
kExternal
kIdle
kDestroyed
kDebugging
kCatchUp

Definition at line 40 of file spaces.h.

                    {
  kNewSpace,     // New space is full.
  kStoreBuffer,  // Store buffer is too big.
  kPromotion,    // Old space limit crossed after a scavenge.
  kOldSpace,     // Old space limit crossed, or old space allocation failed.
  kFinalize,     // Concurrent marking finished.
  kFull,         // Heap::CollectAllGarbage
  kExternal,     // Dart_NewFinalizableHandle Dart_NewWeakPersistentHandle
  kIdle,         // Dart_NotifyIdle
  kDestroyed,    // Dart_NotifyDestroyed
  kDebugging,    // service request, etc.
  kCatchUp,      // End of ForceGrowthScope or Dart_PerformanceMode_Latency.
};

GCType

enum class dart::GCType

strong

Enumerator
kScavenge
kEvacuate
kStartConcurrentMark
kMarkSweep
kMarkCompact

Definition at line 32 of file spaces.h.

                  {
  kScavenge,
  kEvacuate,
  kStartConcurrentMark,
  kMarkSweep,
  kMarkCompact,
};

Generation

enum dart::Generation

Enumerator
kNew
kOld
kImm

Definition at line 890 of file heap_test.cc.

                {
  kNew,
  kOld,
  kImm,
};

Genericity

enum dart::Genericity

Enumerator
kAny
kCurrentClass
kFunctions

Definition at line 2228 of file object.h.

                {
  kAny,           // Consider type params of current class and functions.
  kCurrentClass,  // Consider type params of current class only.
  kFunctions,     // Consider type params of current and parent functions.
};

HartEffects

enum dart::HartEffects

Enumerator
kWrite
kRead
kOutput
kInput
kMemory
kIO
kAll

Definition at line 937 of file constants_riscv.h.

                 {
  kWrite = 1 << 0,
  kRead = 1 << 1,
  kOutput = 1 << 2,
  kInput = 1 << 3,
  kMemory = kWrite | kRead,
  kIO = kOutput | kInput,
  kAll = kMemory | kIO,
};

IdSpace

enum class dart::IdSpace : uint8_t

strong

Enumerator
kInvalid
kSnapshot
kVmText
kIsolateText
kVmData
kIsolateData
kArtificial

Definition at line 19 of file v8_snapshot_writer.h.

                   : uint8_t {
  kInvalid = 0,   // So default-constructed ObjectIds are invalid.
  kSnapshot = 1,  // Can be VM or Isolate heap, they share ids.
  kVmText = 2,
  kIsolateText = 3,
  kVmData = 4,
  kIsolateData = 5,
  kArtificial = 6,  // Artificial objects (e.g. the global root).
  // Change ObjectId::kIdSpaceBits to use last entry if more are added.
};

InnerPointerAccess

enum class dart::InnerPointerAccess

strong

Enumerator
kNotUntagged
kMayBeInnerPointer
kCannotBeInnerPointer

Definition at line 6246 of file il.h.

                              {
  kNotUntagged,
  kMayBeInnerPointer,
  kCannotBeInnerPointer,
};

InstantiationMode

enum class dart::InstantiationMode : uint8_t

strong

Enumerator
kNeedsInstantiation
kIsInstantiated
kSharesInstantiatorTypeArguments
kSharesFunctionTypeArguments

Definition at line 1446 of file raw_object.h.

                             : uint8_t {
  // Must instantiate the type arguments normally.
  kNeedsInstantiation,
  // The type arguments are already instantiated.
  kIsInstantiated,
  // Use the instantiator type arguments that would be used to instantiate
  // the default type arguments, as instantiating produces the same result.
  kSharesInstantiatorTypeArguments,
  // Use the function type arguments that would be used to instantiate
  // the default type arguments, as instantiating produces the same result.
  kSharesFunctionTypeArguments,
};

InstructionFields [1/2]

enum dart::InstructionFields

Enumerator
kConditionShift
kConditionBits
kTypeShift
kTypeBits
kLinkShift
kLinkBits
kUShift
kUBits
kOpcodeShift
kOpcodeBits
kSShift
kSBits
kRnShift
kRnBits
kRdShift
kRdBits
kRsShift
kRsBits
kRmShift
kRmBits
kRotateShift
kRotateBits
kImmed8Shift
kImmed8Bits
kShiftImmShift
kShiftRegisterShift
kShiftImmBits
kShiftShift
kShiftBits
kOffset12Shift
kOffset12Bits
kOffset12Mask
kMulRdShift
kMulRdBits
kMulRnShift
kMulRnBits
kLdrExRnShift
kLdrExRtShift
kStrExRnShift
kStrExRdShift
kStrExRtShift
kMediaOp1Shift
kMediaOp1Bits
kMediaOp2Shift
kMediaOp2Bits
kDivRdShift
kDivRdBits
kDivRmShift
kDivRmBits
kDivRnShift
kDivRnBits
kBitFieldExtractWidthShift
kBitFieldExtractWidthBits
kBitFieldExtractLSBShift
kBitFieldExtractLSBBits
kBitFieldExtractRnShift
kBitFieldExtractRnBits
kCRmShift
kCRmBits
kOpc2Shift
kOpc2Bits
kCoprocShift
kCoprocBits
kCRnShift
kCRnBits
kOpc1Shift
kOpc1Bits
kBranchOffsetMask
kSShift
kSBits
kSFShift
kSFBits
kSzShift
kSzBits
kRdShift
kRdBits
kRnShift
kRnBits
kRaShift
kRaBits
kRmShift
kRmBits
kRtShift
kRtBits
kRt2Shift
kRt2Bits
kRsShift
kRsBits
kVdShift
kVdBits
kVnShift
kVnBits
kVmShift
kVmBits
kVtShift
kVtBits
kVt2Shift
kVt2Bits
kImm3Shift
kImm3Bits
kImm4Shift
kImm4Bits
kImm5Shift
kImm5Bits
kImm6Shift
kImm6Bits
kImm7Shift
kImm7Bits
kImm7Mask
kImm8Shift
kImm8Bits
kImm9Shift
kImm9Bits
kImm12Shift
kImm12Bits
kImm12Mask
kImm12ShiftShift
kImm12ShiftBits
kImm14Shift
kImm14Bits
kImm14Mask
kImm16Shift
kImm16Bits
kImm16Mask
kImm19Shift
kImm19Bits
kImm19Mask
kImm26Shift
kImm26Bits
kImm26Mask
kCondShift
kCondBits
kCondMask
kSelCondShift
kSelCondBits
kNShift
kNBits
kImmRShift
kImmRBits
kImmSShift
kImmSBits
kHWShift
kHWBits
kAddShiftExtendShift
kAddShiftExtendBits
kShiftTypeShift
kShiftTypeBits
kExtendTypeShift
kExtendTypeBits
kHintCRmShift
kHintCRmBits
kHintOp2Shift
kHintOp2Bits

Definition at line 853 of file constants_arm.h.

                       {
  kConditionShift = 28,
  kConditionBits = 4,
  kTypeShift = 25,
  kTypeBits = 3,
  kLinkShift = 24,
  kLinkBits = 1,
  kUShift = 23,
  kUBits = 1,
  kOpcodeShift = 21,
  kOpcodeBits = 4,
  kSShift = 20,
  kSBits = 1,
  kRnShift = 16,
  kRnBits = 4,
  kRdShift = 12,
  kRdBits = 4,
  kRsShift = 8,
  kRsBits = 4,
  kRmShift = 0,
  kRmBits = 4,
 
  // Immediate instruction fields encoding.
  kRotateShift = 8,
  kRotateBits = 4,
  kImmed8Shift = 0,
  kImmed8Bits = 8,
 
  // Shift instruction register fields encodings.
  kShiftImmShift = 7,
  kShiftRegisterShift = 8,
  kShiftImmBits = 5,
  kShiftShift = 5,
  kShiftBits = 2,
 
  // Load/store instruction offset field encoding.
  kOffset12Shift = 0,
  kOffset12Bits = 12,
  kOffset12Mask = 0x00000fff,
 
  // Mul instruction register field encodings.
  kMulRdShift = 16,
  kMulRdBits = 4,
  kMulRnShift = 12,
  kMulRnBits = 4,
 
  // ldrex/strex register field encodings.
  kLdrExRnShift = 16,
  kLdrExRtShift = 12,
  kStrExRnShift = 16,
  kStrExRdShift = 12,
  kStrExRtShift = 0,
 
  // Media operation field encodings.
  kMediaOp1Shift = 20,
  kMediaOp1Bits = 5,
  kMediaOp2Shift = 5,
  kMediaOp2Bits = 3,
 
  // udiv/sdiv instruction register field encodings.
  kDivRdShift = 16,
  kDivRdBits = 4,
  kDivRmShift = 8,
  kDivRmBits = 4,
  kDivRnShift = 0,
  kDivRnBits = 4,
 
  // sbfx/ubfx instruction register and immediate field encodings.
  kBitFieldExtractWidthShift = 16,
  kBitFieldExtractWidthBits = 5,
  kBitFieldExtractLSBShift = 7,
  kBitFieldExtractLSBBits = 5,
  kBitFieldExtractRnShift = 0,
  kBitFieldExtractRnBits = 4,
 
  // MRC instruction offset field encoding.
  kCRmShift = 0,
  kCRmBits = 4,
  kOpc2Shift = 5,
  kOpc2Bits = 3,
  kCoprocShift = 8,
  kCoprocBits = 4,
  kCRnShift = 16,
  kCRnBits = 4,
  kOpc1Shift = 21,
  kOpc1Bits = 3,
 
  kBranchOffsetMask = 0x00ffffff
};

InstructionFields [2/2]

enum dart::InstructionFields

Enumerator
kConditionShift
kConditionBits
kTypeShift
kTypeBits
kLinkShift
kLinkBits
kUShift
kUBits
kOpcodeShift
kOpcodeBits
kSShift
kSBits
kRnShift
kRnBits
kRdShift
kRdBits
kRsShift
kRsBits
kRmShift
kRmBits
kRotateShift
kRotateBits
kImmed8Shift
kImmed8Bits
kShiftImmShift
kShiftRegisterShift
kShiftImmBits
kShiftShift
kShiftBits
kOffset12Shift
kOffset12Bits
kOffset12Mask
kMulRdShift
kMulRdBits
kMulRnShift
kMulRnBits
kLdrExRnShift
kLdrExRtShift
kStrExRnShift
kStrExRdShift
kStrExRtShift
kMediaOp1Shift
kMediaOp1Bits
kMediaOp2Shift
kMediaOp2Bits
kDivRdShift
kDivRdBits
kDivRmShift
kDivRmBits
kDivRnShift
kDivRnBits
kBitFieldExtractWidthShift
kBitFieldExtractWidthBits
kBitFieldExtractLSBShift
kBitFieldExtractLSBBits
kBitFieldExtractRnShift
kBitFieldExtractRnBits
kCRmShift
kCRmBits
kOpc2Shift
kOpc2Bits
kCoprocShift
kCoprocBits
kCRnShift
kCRnBits
kOpc1Shift
kOpc1Bits
kBranchOffsetMask
kSShift
kSBits
kSFShift
kSFBits
kSzShift
kSzBits
kRdShift
kRdBits
kRnShift
kRnBits
kRaShift
kRaBits
kRmShift
kRmBits
kRtShift
kRtBits
kRt2Shift
kRt2Bits
kRsShift
kRsBits
kVdShift
kVdBits
kVnShift
kVnBits
kVmShift
kVmBits
kVtShift
kVtBits
kVt2Shift
kVt2Bits
kImm3Shift
kImm3Bits
kImm4Shift
kImm4Bits
kImm5Shift
kImm5Bits
kImm6Shift
kImm6Bits
kImm7Shift
kImm7Bits
kImm7Mask
kImm8Shift
kImm8Bits
kImm9Shift
kImm9Bits
kImm12Shift
kImm12Bits
kImm12Mask
kImm12ShiftShift
kImm12ShiftBits
kImm14Shift
kImm14Bits
kImm14Mask
kImm16Shift
kImm16Bits
kImm16Mask
kImm19Shift
kImm19Bits
kImm19Mask
kImm26Shift
kImm26Bits
kImm26Mask
kCondShift
kCondBits
kCondMask
kSelCondShift
kSelCondBits
kNShift
kNBits
kImmRShift
kImmRBits
kImmSShift
kImmSBits
kHWShift
kHWBits
kAddShiftExtendShift
kAddShiftExtendBits
kShiftTypeShift
kShiftTypeBits
kExtendTypeShift
kExtendTypeBits
kHintCRmShift
kHintCRmBits
kHintOp2Shift
kHintOp2Bits

Definition at line 1162 of file constants_arm64.h.

                       {
  // S-bit (modify condition register)
  kSShift = 29,
  kSBits = 1,
 
  // sf field.
  kSFShift = 31,
  kSFBits = 1,
 
  // size field,
  kSzShift = 30,
  kSzBits = 2,
 
  // Registers.
  kRdShift = 0,
  kRdBits = 5,
  kRnShift = 5,
  kRnBits = 5,
  kRaShift = 10,
  kRaBits = 5,
  kRmShift = 16,
  kRmBits = 5,
  kRtShift = 0,
  kRtBits = 5,
  kRt2Shift = 10,
  kRt2Bits = 5,
  kRsShift = 16,
  kRsBits = 5,
 
  // V Registers.
  kVdShift = 0,
  kVdBits = 5,
  kVnShift = 5,
  kVnBits = 5,
  kVmShift = 16,
  kVmBits = 5,
  kVtShift = 0,
  kVtBits = 5,
  kVt2Shift = 10,
  kVt2Bits = 5,
 
  // Immediates.
  kImm3Shift = 10,
  kImm3Bits = 3,
  kImm4Shift = 11,
  kImm4Bits = 4,
  kImm5Shift = 16,
  kImm5Bits = 5,
  kImm6Shift = 10,
  kImm6Bits = 6,
  kImm7Shift = 15,
  kImm7Bits = 7,
  kImm7Mask = 0x7f << kImm7Shift,
  kImm8Shift = 13,
  kImm8Bits = 8,
  kImm9Shift = 12,
  kImm9Bits = 9,
  kImm12Shift = 10,
  kImm12Bits = 12,
  kImm12Mask = 0xfff << kImm12Shift,
  kImm12ShiftShift = 22,
  kImm12ShiftBits = 2,
  kImm14Shift = 5,
  kImm14Bits = 14,
  kImm14Mask = 0x3fff << kImm14Shift,
  kImm16Shift = 5,
  kImm16Bits = 16,
  kImm16Mask = 0xffff << kImm16Shift,
  kImm19Shift = 5,
  kImm19Bits = 19,
  kImm19Mask = 0x7ffff << kImm19Shift,
  kImm26Shift = 0,
  kImm26Bits = 26,
  kImm26Mask = 0x03ffffff << kImm26Shift,
 
  kCondShift = 0,
  kCondBits = 4,
  kCondMask = 0xf << kCondShift,
 
  kSelCondShift = 12,
  kSelCondBits = 4,
 
  // Bitfield immediates.
  kNShift = 22,
  kNBits = 1,
  kImmRShift = 16,
  kImmRBits = 6,
  kImmSShift = 10,
  kImmSBits = 6,
 
  kHWShift = 21,
  kHWBits = 2,
 
  // Shift and Extend.
  kAddShiftExtendShift = 21,
  kAddShiftExtendBits = 1,
  kShiftTypeShift = 22,
  kShiftTypeBits = 2,
  kExtendTypeShift = 13,
  kExtendTypeBits = 3,
 
  // Hint Fields.
  kHintCRmShift = 8,
  kHintCRmBits = 4,
  kHintOp2Shift = 5,
  kHintOp2Bits = 3,
};

JSONRpcErrorCode

enum dart::JSONRpcErrorCode

Enumerator
kParseError
kInvalidRequest
kMethodNotFound
kInvalidParams
kInternalError
kExtensionError
kFeatureDisabled
kCannotAddBreakpoint
kStreamAlreadySubscribed
kStreamNotSubscribed
kIsolateMustBeRunnable
kIsolateMustBePaused
kCannotResume
kIsolateIsReloading
kIsolateReloadBarred
kIsolateMustHaveReloaded
kServiceAlreadyRegistered
kServiceDisappeared
kExpressionCompilationError
kInvalidTimelineRequest
kFileSystemAlreadyExists
kFileSystemDoesNotExist
kFileDoesNotExist

Definition at line 44 of file json_stream.h.

                      {
  kParseError = -32700,
  kInvalidRequest = -32600,
  kMethodNotFound = -32601,
  kInvalidParams = -32602,
  kInternalError = -32603,
 
  kExtensionError = -32000,
 
  kFeatureDisabled = 100,
  kCannotAddBreakpoint = 102,
  kStreamAlreadySubscribed = 103,
  kStreamNotSubscribed = 104,
  kIsolateMustBeRunnable = 105,
  kIsolateMustBePaused = 106,
  kCannotResume = 107,
  kIsolateIsReloading = 108,
  kIsolateReloadBarred = 109,
  kIsolateMustHaveReloaded = 110,
  kServiceAlreadyRegistered = 111,
  kServiceDisappeared = 112,
  kExpressionCompilationError = 113,
  kInvalidTimelineRequest = 114,
 
  // Experimental (used in private rpcs).
  kFileSystemAlreadyExists = 1001,
  kFileSystemDoesNotExist = 1002,
  kFileDoesNotExist = 1003,
};

LoadRegLiteralOp

enum dart::LoadRegLiteralOp

Enumerator
LoadRegLiteralMask
LoadRegLiteralFixed
LDRpc

Definition at line 813 of file constants_arm64.h.

                      {
  LoadRegLiteralMask = 0x3b000000,
  LoadRegLiteralFixed = LoadStoreFixed | B28,
  LDRpc = LoadRegLiteralFixed,
};

LoadStoreExclusiveOp

enum dart::LoadStoreExclusiveOp

Enumerator
LoadStoreExclusiveMask
LoadStoreExclusiveFixed
LDXR
STXR
LDAR
STLR

Definition at line 820 of file constants_arm64.h.

                          {
  LoadStoreExclusiveMask = 0x3f000000,
  LoadStoreExclusiveFixed = B27,
  LDXR = LoadStoreExclusiveFixed | B22,
  STXR = LoadStoreExclusiveFixed,
  LDAR = LoadStoreExclusiveFixed | B23 | B22 | B15,
  STLR = LoadStoreExclusiveFixed | B23 | B15,
};

LoadStoreRegOp

enum dart::LoadStoreRegOp

Enumerator
LoadStoreRegMask
LoadStoreRegFixed
STR
LDR
LDRS
FSTR
FLDR
FSTRQ
FLDRQ

Definition at line 837 of file constants_arm64.h.

                    {
  LoadStoreRegMask = 0x3a000000,
  LoadStoreRegFixed = LoadStoreFixed | B29 | B28,
  STR = LoadStoreRegFixed,
  LDR = LoadStoreRegFixed | B22,
  LDRS = LoadStoreRegFixed | B23,
  FSTR = STR | B26,
  FLDR = LDR | B26,
  FSTRQ = STR | B26 | B23,
  FLDRQ = LDR | B26 | B23,
};

LoadStoreRegPairOp

enum dart::LoadStoreRegPairOp

Enumerator
LoadStoreRegPairMask
LoadStoreRegPairFixed
STP
LDP
FSTP
FLDP

Definition at line 850 of file constants_arm64.h.

                        {
  LoadStoreRegPairMask = 0x3a000000,
  LoadStoreRegPairFixed = LoadStoreFixed | B29,
  STP = LoadStoreRegPairFixed,
  LDP = LoadStoreRegPairFixed | B22,
  FSTP = STP | B26,
  FLDP = LDP | B26,
};

LogicalImmOp

enum dart::LogicalImmOp

Enumerator
LogicalImmMask
LogicalImmFixed
ANDI
ORRI
EORI
ANDIS

Definition at line 878 of file constants_arm64.h.

                  {
  LogicalImmMask = 0x1f800000,
  LogicalImmFixed = DPImmediateFixed | B25,
  ANDI = LogicalImmFixed,
  ORRI = LogicalImmFixed | B29,
  EORI = LogicalImmFixed | B30,
  ANDIS = LogicalImmFixed | B30 | B29,
};

LogicalShiftOp

enum dart::LogicalShiftOp

Enumerator
LogicalShiftMask
LogicalShiftFixed
AND
BIC
ORR
ORN
EOR
EON
ANDS
BICS

Definition at line 966 of file constants_arm64.h.

                    {
  LogicalShiftMask = 0x1f000000,
  LogicalShiftFixed = DPRegisterFixed,
  AND = LogicalShiftFixed,
  BIC = LogicalShiftFixed | B21,
  ORR = LogicalShiftFixed | B29,
  ORN = LogicalShiftFixed | B29 | B21,
  EOR = LogicalShiftFixed | B30,
  EON = LogicalShiftFixed | B30 | B21,
  ANDS = LogicalShiftFixed | B30 | B29,
  BICS = LogicalShiftFixed | B30 | B29 | B21,
};

MainOp

enum dart::MainOp

Enumerator
DPImmediateMask
DPImmediateFixed
CompareBranchMask
CompareBranchFixed
LoadStoreMask
LoadStoreFixed
DPRegisterMask
DPRegisterFixed
DPSimd1Mask
DPSimd1Fixed
DPSimd2Mask
DPSimd2Fixed
FPMask
FPFixed

Definition at line 731 of file constants_arm64.h.

            {
  DPImmediateMask = 0x1c000000,
  DPImmediateFixed = B28,
 
  CompareBranchMask = 0x1c000000,
  CompareBranchFixed = B28 | B26,
 
  LoadStoreMask = B27 | B25,
  LoadStoreFixed = B27,
 
  DPRegisterMask = 0x0e000000,
  DPRegisterFixed = B27 | B25,
 
  DPSimd1Mask = 0x1e000000,
  DPSimd1Fixed = B27 | B26 | B25,
 
  DPSimd2Mask = 0x1e000000,
  DPSimd2Fixed = B28 | DPSimd1Fixed,
 
  FPMask = 0x5e000000,
  FPFixed = B28 | B27 | B26 | B25,
};

MarkExpectation

enum dart::MarkExpectation

Enumerator
kForbidMarked
kAllowMarked
kRequireMarked

Definition at line 21 of file verifier.h.

{ kForbidMarked, kAllowMarked, kRequireMarked };

MatchOpCode

enum dart::MatchOpCode

Enumerator
kMatchAndMoveBranchTrue
kMatchAndMoveBranchFalse
kNop
kMoveAny
kMoveParallelMoves
kMoveGlob
kMoveDebugStepChecks
kInvalidMatchOpCode

Definition at line 117 of file il_test_helper.h.

                 {
// Emit a match and match-and-move code for every instruction.
#define DEFINE_MATCH_OPCODES(Instruction, _)                                   \
  kMatch##Instruction, kMatchAndMove##Instruction,                             \
      kMatchAndMoveOptional##Instruction,
  FOR_EACH_INSTRUCTION(DEFINE_MATCH_OPCODES)
      FOR_EACH_ABSTRACT_INSTRUCTION(DEFINE_MATCH_OPCODES)
#undef DEFINE_MATCH_OPCODES
 
  // Matches a branch and moves left.
  kMatchAndMoveBranchTrue,
 
  // Matches a branch and moves right.
  kMatchAndMoveBranchFalse,
 
  // Is ignored.
  kNop,
 
  // Moves forward across any instruction.
  kMoveAny,
 
  // Moves over all parallel moves.
  kMoveParallelMoves,
 
  // Moves forward until the next match code matches.
  kMoveGlob,
 
  // Moves over any DebugStepChecks.
  kMoveDebugStepChecks,
 
  // Invalid match opcode used as default [insert_before] argument to TryMatch
  // to signal that no insertions should occur.
  kInvalidMatchOpCode,
};

MessagePhase

enum class dart::MessagePhase

strong

Enumerator
kBeforeTypes
kTypes
kCanonicalInstances
kNonCanonicalInstances
kNumPhases

Definition at line 66 of file message_snapshot.cc.

                        {
  kBeforeTypes = 0,
  kTypes = 1,
  kCanonicalInstances = 2,
  kNonCanonicalInstances = 3,
 
  kNumPhases = 4,
};

MiscDP1SourceOp

enum dart::MiscDP1SourceOp

Enumerator
MiscDP1SourceMask
MiscDP1SourceFixed
CLZ
RBIT

Definition at line 931 of file constants_arm64.h.

                     {
  MiscDP1SourceMask = 0x5fe00000,
  MiscDP1SourceFixed = DPRegisterFixed | B30 | B28 | B23 | B22,
  CLZ = MiscDP1SourceFixed | B12,
  RBIT = MiscDP1SourceFixed,  // opc = '00'
};

MiscDP2SourceOp

enum dart::MiscDP2SourceOp

Enumerator
MiscDP2SourceMask
MiscDP2SourceFixed
UDIV
SDIV
LSLV
LSRV
ASRV

Definition at line 939 of file constants_arm64.h.

                     {
  MiscDP2SourceMask = 0x5fe00000,
  MiscDP2SourceFixed = DPRegisterFixed | B28 | B23 | B22,
  UDIV = MiscDP2SourceFixed | B11,
  SDIV = MiscDP2SourceFixed | B11 | B10,
  LSLV = MiscDP2SourceFixed | B13,
  LSRV = MiscDP2SourceFixed | B13 | B10,
  ASRV = MiscDP2SourceFixed | B13 | B11,
};

MiscDP3SourceOp

enum dart::MiscDP3SourceOp

Enumerator
MiscDP3SourceMask
MiscDP3SourceFixed
MADDW
MADD
MSUBW
MSUB
SMULH
UMULH
SMADDL
UMADDL
SMSUBL
UMSUBL

Definition at line 950 of file constants_arm64.h.

                     {
  MiscDP3SourceMask = 0x1f000000,
  MiscDP3SourceFixed = DPRegisterFixed | B28 | B24,
  MADDW = MiscDP3SourceFixed,
  MADD = MiscDP3SourceFixed | B31,
  MSUBW = MiscDP3SourceFixed | B15,
  MSUB = MiscDP3SourceFixed | B31 | B15,
  SMULH = MiscDP3SourceFixed | B31 | B22,
  UMULH = MiscDP3SourceFixed | B31 | B23 | B22,
  SMADDL = MiscDP3SourceFixed | B31 | B21,
  UMADDL = MiscDP3SourceFixed | B31 | B23 | B21,
  SMSUBL = MiscDP3SourceFixed | B31 | B21 | B15,
  UMSUBL = MiscDP3SourceFixed | B31 | B23 | B21 | B15,
};

MissHandler

enum class dart::MissHandler

strong

Enumerator
kInlineCacheMiss
kSwitchableCallMiss
kFixCallersTargetMonomorphic

Definition at line 1919 of file runtime_entry.cc.

                       {
  kInlineCacheMiss,
  kSwitchableCallMiss,
  kFixCallersTargetMonomorphic,
};

MoveWideOp

enum dart::MoveWideOp

Enumerator
MoveWideMask
MoveWideFixed
MOVN
MOVZ
MOVK

Definition at line 888 of file constants_arm64.h.

                {
  MoveWideMask = 0x1f800000,
  MoveWideFixed = DPImmediateFixed | B25 | B23,
  MOVN = MoveWideFixed,
  MOVZ = MoveWideFixed | B30,
  MOVK = MoveWideFixed | B30 | B29,
};

NativeSlotsEnumeration

enum dart::NativeSlotsEnumeration

Enumerator
kNativeSlotsCount

Definition at line 16 of file slot.cc.

                            {
#define DECLARE_KIND(CN, __, FN, ___, ____) k##CN##_##FN,
  NATIVE_SLOTS_LIST(DECLARE_KIND)
#undef DECLARE_KIND
      kNativeSlotsCount
};

NNBDCompiledMode

enum class dart::NNBDCompiledMode

strong

Enumerator
kStrong
kWeak
kAgnostic
kInvalid

Definition at line 1128 of file object.h.

                            {
  kStrong = 0,
  kWeak = 1,
  kAgnostic = 2,
  kInvalid = 3,
};

Nullability

enum class dart::Nullability : uint8_t

strong

Enumerator
kNullable
kNonNullable
kLegacy

Definition at line 1112 of file object.h.

                       : uint8_t {
  kNullable = 0,
  kNonNullable = 1,
  kLegacy = 2,
  // Adjust kNullabilityBitSize in app_snapshot.cc if adding new values.
};

Opcode [1/2]

enum dart::Opcode

Enumerator
kNoOperand
AND
EOR
SUB
RSB
ADD
ADC
SBC
RSC
TST
TEQ
CMP
CMN
ORR
MOV
BIC
MVN
kMaxOperand
LUI
AUIPC
JAL
JALR
BRANCH
LOAD
STORE
OPIMM
OP
MISCMEM
SYSTEM
OP32
OPIMM32
AMO
LOADFP
STOREFP
FMADD
FMSUB
FNMSUB
FNMADD
OPFP

Definition at line 820 of file constants_arm.h.

            {
  kNoOperand = -1,
  AND = 0,   // Logical AND
  EOR = 1,   // Logical Exclusive OR
  SUB = 2,   // Subtract
  RSB = 3,   // Reverse Subtract
  ADD = 4,   // Add
  ADC = 5,   // Add with Carry
  SBC = 6,   // Subtract with Carry
  RSC = 7,   // Reverse Subtract with Carry
  TST = 8,   // Test
  TEQ = 9,   // Test Equivalence
  CMP = 10,  // Compare
  CMN = 11,  // Compare Negated
  ORR = 12,  // Logical (inclusive) OR
  MOV = 13,  // Move
  BIC = 14,  // Bit Clear
  MVN = 15,  // Move Not
  kMaxOperand = 16
};

Opcode [2/2]

enum dart::Opcode

Enumerator
kNoOperand
AND
EOR
SUB
RSB
ADD
ADC
SBC
RSC
TST
TEQ
CMP
CMN
ORR
MOV
BIC
MVN
kMaxOperand
LUI
AUIPC
JAL
JALR
BRANCH
LOAD
STORE
OPIMM
OP
MISCMEM
SYSTEM
OP32
OPIMM32
AMO
LOADFP
STOREFP
FMADD
FMSUB
FNMSUB
FNMADD
OPFP

Definition at line 706 of file constants_riscv.h.

            {
  LUI = 0b0110111,
  AUIPC = 0b0010111,
  JAL = 0b1101111,
  JALR = 0b1100111,
  BRANCH = 0b1100011,
  LOAD = 0b0000011,
  STORE = 0b0100011,
  OPIMM = 0b0010011,
  OP = 0b0110011,
  MISCMEM = 0b0001111,
  SYSTEM = 0b1110011,
  OP32 = 0b0111011,
  OPIMM32 = 0b0011011,
  AMO = 0b0101111,
  LOADFP = 0b0000111,
  STOREFP = 0b0100111,
  FMADD = 0b1000011,
  FMSUB = 0b1000111,
  FNMSUB = 0b1001011,
  FNMADD = 0b1001111,
  OPFP = 0b1010011,
};

ParallelMovesHandling

enum class dart::ParallelMovesHandling

strong

Enumerator
kDefault
kSkip

Definition at line 179 of file il_test_helper.h.

                                 {
  // Matcher doesn't do anything special with ParallelMove instructions.
  kDefault,
  // All ParallelMove instructions are skipped.
  // This mode is useful when matching a flow graph after the whole
  // compiler pipeline, as it may have ParallelMove instructions
  // at arbitrary architecture-dependent places.
  kSkip,
};

PCRelOp

enum dart::PCRelOp

Enumerator
PCRelMask
PCRelFixed
ADR
ADRP

Definition at line 897 of file constants_arm64.h.

             {
  PCRelMask = 0x1f000000,
  PCRelFixed = DPImmediateFixed,
  ADR = PCRelFixed,
  ADRP = PCRelFixed | B31,
};

QRegister

enum dart::QRegister

Enumerator
kNoQRegister
Q0
Q1
Q2
Q3
Q4
Q5
Q6
Q7
Q8
Q9
Q10
Q11
Q12
Q13
Q14
Q15
kNumberOfQRegisters
kNumberOfOverlappingQRegisters

Definition at line 218 of file constants_arm.h.

               {
  kNoQRegister = -1,
  Q0 = 0,
  Q1 = 1,
  Q2 = 2,
  Q3 = 3,
  Q4 = 4,
  Q5 = 5,
  Q6 = 6,
  Q7 = 7,
#if defined(VFPv3_D16)
  kNumberOfQRegisters = 8,
  Q8 = kNoQRegister,
  Q9 = kNoQRegister,
  Q10 = kNoQRegister,
  Q11 = kNoQRegister,
  Q12 = kNoQRegister,
  Q13 = kNoQRegister,
  Q14 = kNoQRegister,
  Q15 = kNoQRegister,
#else
  Q8 = 8,
  Q9 = 9,
  Q10 = 10,
  Q11 = 11,
  Q12 = 12,
  Q13 = 13,
  Q14 = 14,
  Q15 = 15,
  kNumberOfQRegisters = 16,
#endif
  // Number of Q registers that overlap S registers.
  // One Q register overlaps four S registers, so regardless of the numbers of Q
  // registers, there are only 32 S registers that are overlapped.
  kNumberOfOverlappingQRegisters = 8,
};

QualifiedFunctionLibKind

enum dart::QualifiedFunctionLibKind

Enumerator
kQualifiedFunctionLibKindLibUrl
kQualifiedFunctionLibKindLibName

Definition at line 9754 of file object.cc.

                              {
  kQualifiedFunctionLibKindLibUrl,
  kQualifiedFunctionLibKindLibName
};

R31Type

enum dart::R31Type

Enumerator
R31IsSP
R31IsZR

Definition at line 1155 of file constants_arm64.h.

             {
  R31IsSP,
  R31IsZR,
};

Register [1/5]

enum dart::Register

Enumerator
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister
FP
NOTFP
IP
SP
LR
PC
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
R16
R17
R18
R19
R20
R21
R22
R23
R24
R25
R26
R27
R28
R29
R30
R31
kNumberOfCpuRegisters
kNoRegister
kNoRegister2
CSP
ZR
IP0
IP1
SP
FP
LR
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
kNumberOfCpuRegisters
kNoRegister
ZR
RA
SP
GP
TP
T0
T1
T2
FP
S1
A0
A1
A2
A3
A4
A5
A6
A7
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
T3
T4
T5
T6
kNumberOfCpuRegisters
kNoRegister
RA2
S0
RAX
RCX
RDX
RBX
RSP
RBP
RSI
RDI
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister

Definition at line 81 of file constants_arm.h.

              {
  R0 = 0,
  R1 = 1,
  R2 = 2,
  R3 = 3,
  R4 = 4,
  R5 = 5,  // PP
  R6 = 6,  // CODE_REG
  R7 = 7,  // FP on iOS, DISPATCH_TABLE_REG on non-iOS (AOT only)
  R8 = 8,
  R9 = 9,
  R10 = 10,  // THR
  R11 = 11,  // FP on non-iOS, DISPATCH_TABLE_REG on iOS (AOT only)
  R12 = 12,  // IP aka TMP
  R13 = 13,  // SP
  R14 = 14,  // LR
  R15 = 15,  // PC
  kNumberOfCpuRegisters = 16,
  kNoRegister = -1,  // Signals an illegal register.
 
// Aliases.
#if defined(DART_TARGET_OS_MACOS) || defined(DART_TARGET_OS_MACOS_IOS)
  FP = R7,
  NOTFP = R11,
#else
  FP = R11,
  NOTFP = R7,
#endif
  IP = R12,
  SP = R13,
  LR = R14,  // Note: direct access to this constant is not allowed. See above.
  PC = R15,
};

Register [2/5]

enum dart::Register

Enumerator
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister
FP
NOTFP
IP
SP
LR
PC
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
R16
R17
R18
R19
R20
R21
R22
R23
R24
R25
R26
R27
R28
R29
R30
R31
kNumberOfCpuRegisters
kNoRegister
kNoRegister2
CSP
ZR
IP0
IP1
SP
FP
LR
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
kNumberOfCpuRegisters
kNoRegister
ZR
RA
SP
GP
TP
T0
T1
T2
FP
S1
A0
A1
A2
A3
A4
A5
A6
A7
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
T3
T4
T5
T6
kNumberOfCpuRegisters
kNoRegister
RA2
S0
RAX
RCX
RDX
RBX
RSP
RBP
RSI
RDI
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister

Definition at line 34 of file constants_arm64.h.

              {
  R0 = 0,
  R1 = 1,
  R2 = 2,
  R3 = 3,
  R4 = 4,
  R5 = 5,
  R6 = 6,
  R7 = 7,
  R8 = 8,
  R9 = 9,
  R10 = 10,
  R11 = 11,
  R12 = 12,
  R13 = 13,
  R14 = 14,
  R15 = 15,  // SP in Dart code.
  R16 = 16,  // IP0 aka TMP
  R17 = 17,  // IP1 aka TMP2
  R18 = 18,  // reserved on iOS, shadow call stack on Fuchsia, TEB on Windows.
  R19 = 19,
  R20 = 20,
  R21 = 21,  // DISPATCH_TABLE_REG (AOT only)
  R22 = 22,  // NULL_REG
  R23 = 23,
  R24 = 24,  // CODE_REG
  R25 = 25,
  R26 = 26,  // THR
  R27 = 27,  // PP
  R28 = 28,  // HEAP_BITS
  R29 = 29,  // FP
  R30 = 30,  // LR
  R31 = 31,  // ZR, CSP
  kNumberOfCpuRegisters = 32,
  kNoRegister = -1,
  kNoRegister2 = -2,
 
  // These registers both use the encoding R31, but to avoid mistakes we give
  // them different values, and then translate before encoding.
  CSP = 32,
  ZR = 33,
 
  // Aliases.
  IP0 = R16,
  IP1 = R17,
  SP = R15,
  FP = R29,
  LR = R30,  // Note: direct access to this constant is not allowed. See above.
};

Register [3/5]

enum dart::Register

Enumerator
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister
FP
NOTFP
IP
SP
LR
PC
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
R16
R17
R18
R19
R20
R21
R22
R23
R24
R25
R26
R27
R28
R29
R30
R31
kNumberOfCpuRegisters
kNoRegister
kNoRegister2
CSP
ZR
IP0
IP1
SP
FP
LR
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
kNumberOfCpuRegisters
kNoRegister
ZR
RA
SP
GP
TP
T0
T1
T2
FP
S1
A0
A1
A2
A3
A4
A5
A6
A7
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
T3
T4
T5
T6
kNumberOfCpuRegisters
kNoRegister
RA2
S0
RAX
RCX
RDX
RBX
RSP
RBP
RSI
RDI
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister

Definition at line 22 of file constants_ia32.h.

              {
  EAX = 0,
  ECX = 1,
  EDX = 2,
  EBX = 3,
  ESP = 4,  // SP
  EBP = 5,  // FP
  ESI = 6,  // THR
  EDI = 7,
  kNumberOfCpuRegisters = 8,
  kNoRegister = -1,  // Signals an illegal register.
};

Register [4/5]

enum dart::Register

Enumerator
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister
FP
NOTFP
IP
SP
LR
PC
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
R16
R17
R18
R19
R20
R21
R22
R23
R24
R25
R26
R27
R28
R29
R30
R31
kNumberOfCpuRegisters
kNoRegister
kNoRegister2
CSP
ZR
IP0
IP1
SP
FP
LR
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
kNumberOfCpuRegisters
kNoRegister
ZR
RA
SP
GP
TP
T0
T1
T2
FP
S1
A0
A1
A2
A3
A4
A5
A6
A7
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
T3
T4
T5
T6
kNumberOfCpuRegisters
kNoRegister
RA2
S0
RAX
RCX
RDX
RBX
RSP
RBP
RSI
RDI
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister

Definition at line 43 of file constants_riscv.h.

              {
  // The correct name for this register is ZERO, but this conflicts with other
  // globals.
  ZR = 0,
  RA = 1,
  SP = 2,
  GP = 3,  // Shadow call stack on Fuchsia and Android
  TP = 4,
  T0 = 5,
  T1 = 6,
  T2 = 7,
  FP = 8,
  S1 = 9,  // THR
  A0 = 10,
  A1 = 11,
  A2 = 12,  // CODE_REG
  A3 = 13,  // TMP
  A4 = 14,  // TMP2
  A5 = 15,  // PP, untagged
  A6 = 16,
  A7 = 17,
  S2 = 18,
  S3 = 19,
  S4 = 20,  // ARGS_DESC_REG
  S5 = 21,  // IC_DATA_REG
  S6 = 22,
  S7 = 23,   // CALLEE_SAVED_TEMP2
  S8 = 24,   // CALLEE_SAVED_TEMP / FAR_TMP
  S9 = 25,   // DISPATCH_TABLE_REG
  S10 = 26,  // nullptr
  S11 = 27,  // WRITE_BARRIER_STATE
  T3 = 28,
  T4 = 29,
  T5 = 30,
  T6 = 31,
  kNumberOfCpuRegisters = 32,
  kNoRegister = -1,
 
  RA2 = T0,
  S0 = FP,
 
  // Note that some compressed instructions can only take registers x8-x15 for
  // some of their operands, so to reduce code size we assign the most popular
  // uses to these registers.
 
  // If the base register of a load/store is not SP, both the base register and
  // source/destination register must be in x8-x15 and the offset must be
  // aligned to make use a compressed instruction. So either,
  //   - PP, CODE_REG and IC_DATA_REG should all be assigned to x8-x15 and we
  //     should hold PP untagged like on ARM64. This makes the loads in the call
  //     sequence shorter, but adds extra PP tagging/untagging on entry and
  //     return.
  //   - PP should be assigned to a C-preserved register to avoid spilling it on
  //     leaf runtime calls.
};

Register [5/5]

enum dart::Register

Enumerator
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister
FP
NOTFP
IP
SP
LR
PC
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
R16
R17
R18
R19
R20
R21
R22
R23
R24
R25
R26
R27
R28
R29
R30
R31
kNumberOfCpuRegisters
kNoRegister
kNoRegister2
CSP
ZR
IP0
IP1
SP
FP
LR
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
kNumberOfCpuRegisters
kNoRegister
ZR
RA
SP
GP
TP
T0
T1
T2
FP
S1
A0
A1
A2
A3
A4
A5
A6
A7
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
T3
T4
T5
T6
kNumberOfCpuRegisters
kNoRegister
RA2
S0
RAX
RCX
RDX
RBX
RSP
RBP
RSI
RDI
R8
R9
R10
R11
R12
R13
R14
R15
kNumberOfCpuRegisters
kNoRegister

Definition at line 22 of file constants_x64.h.

              {
  RAX = 0,
  RCX = 1,
  RDX = 2,
  RBX = 3,
  RSP = 4,  // SP
  RBP = 5,  // FP
  RSI = 6,
  RDI = 7,
  R8 = 8,
  R9 = 9,
  R10 = 10,
  R11 = 11,  // TMP
  R12 = 12,  // CODE_REG
  R13 = 13,
  R14 = 14,  // THR
  R15 = 15,  // PP
  kNumberOfCpuRegisters = 16,
  kNoRegister = -1,  // Signals an illegal register.
};

Representation

enum dart::Representation

Enumerator
kNumRepresentations

Definition at line 66 of file locations.h.

                    {
#define DECLARE_REPRESENTATION(name, __, ___, ____) k##name,
  FOR_EACH_REPRESENTATION_KIND(DECLARE_REPRESENTATION)
#undef DECLARE_REPRESENTATION
      kNumRepresentations
};

RexBits

enum dart::RexBits

Enumerator
REX_NONE
REX_B
REX_X
REX_R
REX_W
REX_PREFIX

Definition at line 110 of file constants_x64.h.

             {
  REX_NONE = 0,
  REX_B = 1 << 0,
  REX_X = 1 << 1,
  REX_R = 1 << 2,
  REX_W = 1 << 3,
  REX_PREFIX = 1 << 6
};

RootSlices [1/2]

enum dart::RootSlices

Enumerator
kIsolate
kNumFixedRootSlices
kIsolate
kObjectIdRing
kStoreBuffer
kNumRootSlices

Definition at line 578 of file marker.cc.

                {
  kIsolate = 0,
  kNumFixedRootSlices = 1,
};

RootSlices [2/2]

enum dart::RootSlices

Enumerator
kIsolate
kNumFixedRootSlices
kIsolate
kObjectIdRing
kStoreBuffer
kNumRootSlices

Definition at line 1180 of file scavenger.cc.

                {
  kIsolate = 0,
  kObjectIdRing,
  kStoreBuffer,
  kNumRootSlices,
};

RoundingMode

enum dart::RoundingMode

Enumerator
RNE
RTZ
RDN
RUP
RMM
DYN

Definition at line 908 of file constants_riscv.h.

                  {
  RNE = 0b000,  // Round to Nearest, ties to Even
  RTZ = 0b001,  // Round toward Zero
  RDN = 0b010,  // Round Down (toward negative infinity)
  RUP = 0b011,  // Round Up (toward positive infinity)
  RMM = 0b100,  // Round to nearest, ties to Max Magnitude
  DYN = 0b111,  // Dynamic rounding mode
};

RuntimeCallDeoptAbility

enum class dart::RuntimeCallDeoptAbility

strong

Enumerator
kCanLazyDeopt
kCannotLazyDeopt

Definition at line 276 of file thread.h.

                                   {
  // There was no leaf call or a leaf call that can cause deoptimization
  // after-call.
  kCanLazyDeopt,
  // There was a leaf call and the VM cannot cause deoptimize after-call.
  kCannotLazyDeopt,
};

SafepointLevel

enum dart::SafepointLevel

Enumerator
kGC
kGCAndDeopt
kGCAndDeoptAndReload
kNumLevels
kNoSafepoint

Definition at line 289 of file thread.h.

                    {
  // Safe to GC
  kGC,
  // Safe to GC as well as Deopt.
  kGCAndDeopt,
  // Safe to GC, Deopt as well as Reload.
  kGCAndDeoptAndReload,
  // Number of levels.
  kNumLevels,
 
  // No safepoint.
  kNoSafepoint,
};

ScaleFactor [1/5]

enum dart::ScaleFactor

Enumerator
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE

Definition at line 943 of file constants_arm.h.

                 {
  TIMES_1 = 0,
  TIMES_2 = 1,
  TIMES_4 = 2,
  TIMES_8 = 3,
  TIMES_16 = 4,
// Don't use (dart::)kWordSizeLog2, as this needs to work for crossword as
// well. If this is included, we know the target is 32 bit.
#if defined(TARGET_ARCH_IS_32_BIT)
  // Used for Smi-boxed indices.
  TIMES_HALF_WORD_SIZE = kInt32SizeLog2 - 1,
  // Used for unboxed indices.
  TIMES_WORD_SIZE = kInt32SizeLog2,
#else
#error "Unexpected word size"
#endif
#if !defined(DART_COMPRESSED_POINTERS)
  TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE,
#else
#error Cannot compress ARM32
#endif
  // Used for Smi-boxed indices.
  TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1,
};

ScaleFactor [2/5]

enum dart::ScaleFactor

Enumerator
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE

Definition at line 1293 of file constants_arm64.h.

                 {
  TIMES_1 = 0,
  TIMES_2 = 1,
  TIMES_4 = 2,
  TIMES_8 = 3,
  TIMES_16 = 4,
// We can't include vm/compiler/runtime_api.h, so just be explicit instead
// of using (dart::)kWordSizeLog2.
#if defined(TARGET_ARCH_IS_64_BIT)
  // Used for Smi-boxed indices.
  TIMES_HALF_WORD_SIZE = kInt64SizeLog2 - 1,
  // Used for unboxed indices.
  TIMES_WORD_SIZE = kInt64SizeLog2,
#else
#error "Unexpected word size"
#endif
#if !defined(DART_COMPRESSED_POINTERS)
  TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE,
#else
  TIMES_COMPRESSED_WORD_SIZE = TIMES_HALF_WORD_SIZE,
#endif
  // Used for Smi-boxed indices.
  TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1,
};

ScaleFactor [3/5]

enum dart::ScaleFactor

Enumerator
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE

Definition at line 404 of file constants_ia32.h.

                 {
  TIMES_1 = 0,
  TIMES_2 = 1,
  TIMES_4 = 2,
  TIMES_8 = 3,
  TIMES_16 = 4,
// We can't include vm/compiler/runtime_api.h, so just be explicit instead
// of using (dart::)kWordSizeLog2.
#if defined(TARGET_ARCH_IS_32_BIT)
  // Used for Smi-boxed indices.
  TIMES_HALF_WORD_SIZE = kInt32SizeLog2 - 1,
  // Used for unboxed indices.
  TIMES_WORD_SIZE = kInt32SizeLog2,
#else
#error "Unexpected word size"
#endif
#if !defined(DART_COMPRESSED_POINTERS)
  TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE,
#else
#error Cannot compress IA32
#endif
  // Used for Smi-boxed indices.
  TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1,
};

ScaleFactor [4/5]

enum dart::ScaleFactor

Enumerator
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE

Definition at line 656 of file constants_riscv.h.

                 {
  TIMES_1 = 0,
  TIMES_2 = 1,
  TIMES_4 = 2,
  TIMES_8 = 3,
  TIMES_16 = 4,
// We can't include vm/compiler/runtime_api.h, so just be explicit instead
// of using (dart::)kWordSizeLog2.
#if defined(TARGET_ARCH_IS_64_BIT)
  // Used for Smi-boxed indices.
  TIMES_HALF_WORD_SIZE = kInt64SizeLog2 - 1,
  // Used for unboxed indices.
  TIMES_WORD_SIZE = kInt64SizeLog2,
#elif defined(TARGET_ARCH_IS_32_BIT)
  // Used for Smi-boxed indices.
  TIMES_HALF_WORD_SIZE = kInt32SizeLog2 - 1,
  // Used for unboxed indices.
  TIMES_WORD_SIZE = kInt32SizeLog2,
#else
#error "Unexpected word size"
#endif
#if !defined(DART_COMPRESSED_POINTERS)
  TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE,
#else
  TIMES_COMPRESSED_WORD_SIZE = TIMES_HALF_WORD_SIZE,
#endif
  // Used for Smi-boxed indices.
  TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1,
};

ScaleFactor [5/5]

enum dart::ScaleFactor

Enumerator
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE
TIMES_1
TIMES_2
TIMES_4
TIMES_8
TIMES_16
TIMES_COMPRESSED_WORD_SIZE
TIMES_COMPRESSED_HALF_WORD_SIZE

Definition at line 478 of file constants_x64.h.

                 {
  TIMES_1 = 0,
  TIMES_2 = 1,
  TIMES_4 = 2,
  TIMES_8 = 3,
  // Note that Intel addressing does not support this addressing.
  // > Scale factor — A value of 2, 4, or 8 that is multiplied by the index
  // > value.
  // https://software.intel.com/en-us/download/intel-64-and-ia-32-architectures-sdm-combined-volumes-1-2a-2b-2c-2d-3a-3b-3c-3d-and-4
  // 3.7.5 Specifying an Offset
  TIMES_16 = 4,
// We can't include vm/compiler/runtime_api.h, so just be explicit instead
// of using (dart::)kWordSizeLog2.
#if defined(TARGET_ARCH_IS_64_BIT)
  // Used for Smi-boxed indices.
  TIMES_HALF_WORD_SIZE = kInt64SizeLog2 - 1,
  // Used for unboxed indices.
  TIMES_WORD_SIZE = kInt64SizeLog2,
#else
#error "Unexpected word size"
#endif
#if !defined(DART_COMPRESSED_POINTERS)
  TIMES_COMPRESSED_WORD_SIZE = TIMES_WORD_SIZE,
#else
  TIMES_COMPRESSED_WORD_SIZE = TIMES_HALF_WORD_SIZE,
#endif
  // Used for Smi-boxed indices.
  TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1,
};

SentinelType

enum dart::SentinelType

Enumerator
kCollectedSentinel
kExpiredSentinel
kFreeSentinel

Definition at line 1529 of file service.cc.

                  {
  kCollectedSentinel,
  kExpiredSentinel,
  kFreeSentinel,
};

Shift [1/2]

enum dart::Shift

Enumerator
kNoShift
LSL
LSR
ASR
ROR
kMaxShift
kNoShift
LSL
LSR
ASR
ROR
kMaxShift

Definition at line 842 of file constants_arm.h.

           {
  kNoShift = -1,
  LSL = 0,  // Logical shift left
  LSR = 1,  // Logical shift right
  ASR = 2,  // Arithmetic shift right
  ROR = 3,  // Rotate right
  kMaxShift = 4
};

Shift [2/2]

enum dart::Shift

Enumerator
kNoShift
LSL
LSR
ASR
ROR
kMaxShift
kNoShift
LSL
LSR
ASR
ROR
kMaxShift

Definition at line 1133 of file constants_arm64.h.

           {
  kNoShift = -1,
  LSL = 0,  // Logical shift left
  LSR = 1,  // Logical shift right
  ASR = 2,  // Arithmetic shift right
  ROR = 3,  // Rotate right
  kMaxShift = 4,
};

SIMDCopyOp

enum dart::SIMDCopyOp

Enumerator
SIMDCopyMask
SIMDCopyFixed
VDUPI
VINSI
VMOVW
VMOVX
VDUP
VINS

Definition at line 980 of file constants_arm64.h.

                {
  SIMDCopyMask = 0x9fe08400,
  SIMDCopyFixed = DPSimd1Fixed | B10,
  VDUPI = SIMDCopyFixed | B30 | B11,
  VINSI = SIMDCopyFixed | B30 | B12 | B11,
  VMOVW = SIMDCopyFixed | B13 | B12 | B11,
  VMOVX = SIMDCopyFixed | B30 | B13 | B12 | B11,
  VDUP = SIMDCopyFixed | B30,
  VINS = SIMDCopyFixed | B30 | B29,
};

SIMDThreeSameOp

enum dart::SIMDThreeSameOp

Enumerator
SIMDThreeSameMask
SIMDThreeSameFixed
VAND
VORR
VEOR
VADDW
VADDX
VSUBW
VSUBX
VADDS
VADDD
VSUBS
VSUBD
VMULS
VMULD
VDIVS
VDIVD
VCEQS
VCEQD
VCGES
VCGED
VCGTS
VCGTD
VMAXS
VMAXD
VMINS
VMIND
VRECPSS
VRSQRTSS

Definition at line 992 of file constants_arm64.h.

                     {
  SIMDThreeSameMask = 0x9f200400,
  SIMDThreeSameFixed = DPSimd1Fixed | B21 | B10,
  VAND = SIMDThreeSameFixed | B30 | B12 | B11,
  VORR = SIMDThreeSameFixed | B30 | B23 | B12 | B11,
  VEOR = SIMDThreeSameFixed | B30 | B29 | B12 | B11,
  VADDW = SIMDThreeSameFixed | B30 | B23 | B15,
  VADDX = SIMDThreeSameFixed | B30 | B23 | B22 | B15,
  VSUBW = SIMDThreeSameFixed | B30 | B29 | B23 | B15,
  VSUBX = SIMDThreeSameFixed | B30 | B29 | B23 | B22 | B15,
  VADDS = SIMDThreeSameFixed | B30 | B15 | B14 | B12,
  VADDD = SIMDThreeSameFixed | B30 | B22 | B15 | B14 | B12,
  VSUBS = SIMDThreeSameFixed | B30 | B23 | B15 | B14 | B12,
  VSUBD = SIMDThreeSameFixed | B30 | B23 | B22 | B15 | B14 | B12,
  VMULS = SIMDThreeSameFixed | B30 | B29 | B15 | B14 | B12 | B11,
  VMULD = SIMDThreeSameFixed | B30 | B29 | B22 | B15 | B14 | B12 | B11,
  VDIVS = SIMDThreeSameFixed | B30 | B29 | B15 | B14 | B13 | B12 | B11,
  VDIVD = SIMDThreeSameFixed | B30 | B29 | B22 | B15 | B14 | B13 | B12 | B11,
  VCEQS = SIMDThreeSameFixed | B30 | B15 | B14 | B13,
  VCEQD = SIMDThreeSameFixed | B30 | B22 | B15 | B14 | B13,
  VCGES = SIMDThreeSameFixed | B30 | B29 | B15 | B14 | B13,
  VCGED = SIMDThreeSameFixed | B30 | B29 | B22 | B15 | B14 | B13,
  VCGTS = SIMDThreeSameFixed | B30 | B29 | B23 | B15 | B14 | B13,
  VCGTD = SIMDThreeSameFixed | B30 | B29 | B23 | B22 | B15 | B14 | B13,
  VMAXS = SIMDThreeSameFixed | B30 | B15 | B14 | B13 | B12,
  VMAXD = SIMDThreeSameFixed | B30 | B22 | B15 | B14 | B13 | B12,
  VMINS = SIMDThreeSameFixed | B30 | B23 | B15 | B14 | B13 | B12,
  VMIND = SIMDThreeSameFixed | B30 | B23 | B22 | B15 | B14 | B13 | B12,
  VRECPSS = SIMDThreeSameFixed | B30 | B15 | B14 | B13 | B12 | B11,
  VRSQRTSS = SIMDThreeSameFixed | B30 | B23 | B15 | B14 | B13 | B12 | B11,
};

SIMDTwoRegOp

enum dart::SIMDTwoRegOp

Enumerator
SIMDTwoRegMask
SIMDTwoRegFixed
VNOT
VABSS
VNEGS
VABSD
VNEGD
VSQRTS
VSQRTD
VRECPES
VRSQRTES

Definition at line 1025 of file constants_arm64.h.

                  {
  SIMDTwoRegMask = 0x9f3e0c00,
  SIMDTwoRegFixed = DPSimd1Fixed | B21 | B11,
  VNOT = SIMDTwoRegFixed | B30 | B29 | B14 | B12,
  VABSS = SIMDTwoRegFixed | B30 | B23 | B15 | B14 | B13 | B12,
  VNEGS = SIMDTwoRegFixed | B30 | B29 | B23 | B15 | B14 | B13 | B12,
  VABSD = SIMDTwoRegFixed | B30 | B23 | B22 | B15 | B14 | B13 | B12,
  VNEGD = SIMDTwoRegFixed | B30 | B29 | B23 | B22 | B15 | B14 | B13 | B12,
  VSQRTS = SIMDTwoRegFixed | B30 | B29 | B23 | B16 | B15 | B14 | B13 | B12,
  VSQRTD =
      SIMDTwoRegFixed | B30 | B29 | B23 | B22 | B16 | B15 | B14 | B13 | B12,
  VRECPES = SIMDTwoRegFixed | B30 | B23 | B16 | B15 | B14 | B12,
  VRSQRTES = SIMDTwoRegFixed | B30 | B29 | B23 | B16 | B15 | B14 | B12,
};

SRegister

enum dart::SRegister

Enumerator
kNoSRegister
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
S12
S13
S14
S15
S16
S17
S18
S19
S20
S21
S22
S23
S24
S25
S26
S27
S28
S29
S30
S31
kNumberOfSRegisters

Definition at line 116 of file constants_arm.h.

               {
  kNoSRegister = -1,
  S0 = 0,
  S1 = 1,
  S2 = 2,
  S3 = 3,
  S4 = 4,
  S5 = 5,
  S6 = 6,
  S7 = 7,
  S8 = 8,
  S9 = 9,
  S10 = 10,
  S11 = 11,
  S12 = 12,
  S13 = 13,
  S14 = 14,
  S15 = 15,
  S16 = 16,
  S17 = 17,
  S18 = 18,
  S19 = 19,
  S20 = 20,
  S21 = 21,
  S22 = 22,
  S23 = 23,
  S24 = 24,
  S25 = 25,
  S26 = 26,
  S27 = 27,
  S28 = 28,
  S29 = 29,
  S30 = 30,
  S31 = 31,
  kNumberOfSRegisters = 32,
};

StoreBarrierType

enum dart::StoreBarrierType

Enumerator
kNoStoreBarrier
kEmitStoreBarrier

Definition at line 6252 of file il.h.

{ kNoStoreBarrier, kEmitStoreBarrier };

SystemOp

enum dart::SystemOp

Enumerator
SystemMask
SystemFixed
HINT
CLREX

Definition at line 779 of file constants_arm64.h.

              {
  SystemMask = 0xffc00000,
  SystemFixed = CompareBranchFixed | B31 | B30 | B24,
  HINT = SystemFixed | B17 | B16 | B13 | B4 | B3 | B2 | B1 | B0,
  CLREX = SystemFixed | B17 | B16 | B13 | B12 | B11 | B10 | B9 | B8 | B6 | B4 |
          B3 | B2 | B1 | B0,
};

TestAndBranchOp

enum dart::TestAndBranchOp

Enumerator
TestAndBranchMask
TestAndBranchFixed
TBZ
TBNZ

Definition at line 788 of file constants_arm64.h.

                     {
  TestAndBranchMask = 0x7e000000,
  TestAndBranchFixed = CompareBranchFixed | B29 | B25,
  TBZ = TestAndBranchFixed,
  TBNZ = TestAndBranchFixed | B24,
};

TimelineOrSamplesResponseFormat

enum dart::TimelineOrSamplesResponseFormat : bool

Enumerator
JSON
Perfetto

Definition at line 4146 of file service.cc.

: bool { JSON = false, Perfetto = true };

TraversalRules

enum dart::TraversalRules

Enumerator
kInternalToIsolateGroup
kExternalBetweenIsolateGroups

Definition at line 34 of file object_graph_copy.h.

             {
  kInternalToIsolateGroup,
  kExternalBetweenIsolateGroups,
} TraversalRules;

TTSTestResult

enum dart::TTSTestResult

Enumerator
kFail
kTTS
kExistingSTCEntry
kNewSTCEntry
kRuntimeCheck
kSpecialize
kRespecialize
kNumTestResults

Definition at line 205 of file type_testing_stubs_test.cc.

                   {
  // The TTS invocation should enter the runtime and trigger a TypeError.
  kFail,
  // The TTS invocation should return a result from the TTS stub without
  // entering the runtime and without an associated STC entry.
  kTTS,
  // The TTS invocation should return a result from checking the STC without
  // entering the runtime. The STC prior to invocation should be non-null and
  // include a matching entry for the test case.
  kExistingSTCEntry,
  // The TTS invocation should enter the runtime and add a new entry to the
  // STC, creating a new STC if necessary.
  kNewSTCEntry,
  // The TTS invocation should enter the runtime and return a successful check
  // but without adding an entry to the STC. This should only happen when the
  // STC has hit the limit described by FLAG_max_subtype_cache_entries prior
  // to the invocation.
  kRuntimeCheck,
  // The TTS invocation should enter the runtime and the TTS is specialized
  // after this test case. This test case should not create a new STC or modify
  // an existing STC.
  //
  // Used only within TTSTestState::InvokeLazilySpecializedStub. This is
  // needed because there is a single special case for updating the STC that
  // happens only when specializing the lazy specialization stub, and so we
  // need to distinguish specialization and respecialization.
  kSpecialize,
  // The TTS invocation should enter the runtime and the TTS is respecialized
  // after this test case. This test case should not create a new STC or modify
  // an existing STC.
  //
  // Used only when calling TTSTestState::InvokeExistingStub.
  kRespecialize,
  // Used for static assert below only.
  kNumTestResults,
};

TypeCheckMode

enum dart::TypeCheckMode

Enumerator
kTypeCheckFromLazySpecializeStub
kTypeCheckFromSlowStub
kTypeCheckFromInline

Definition at line 12 of file type_check_mode.h.

                   {
  // TypeCheck is invoked from LazySpecializeTypeTest stub.
  // It should replace stub on the type with a specialized version.
  kTypeCheckFromLazySpecializeStub,
 
  // TypeCheck is invoked from the SlowTypeTest stub.
  // This means that cache can be lazily created (if needed)
  // and dst_name can be fetched from the pool.
  kTypeCheckFromSlowStub,
 
  // TypeCheck is invoked from normal inline AssertAssignable.
  // Both cache and dst_name must be already populated.
  kTypeCheckFromInline
};

TypeDataField

enum dart::TypeDataField

Enumerator
TypedDataBase_length
TypedDataView_offset_in_bytes
TypedDataView_typed_data

Definition at line 1249 of file il_test.cc.

                   {
  TypedDataBase_length,
  TypedDataView_offset_in_bytes,
  TypedDataView_typed_data,
};

TypedDataElementType

enum dart::TypedDataElementType

Definition at line 123 of file raw_object.h.

                          {
#define V(name) k##name##Element,
  CLASS_LIST_TYPED_DATA(V)
#undef V
};

TypedDataViewFormat

enum dart::TypedDataViewFormat

Enumerator
kTypedDataViewFromC
kTypedDataViewFromDart

Definition at line 1497 of file message_snapshot.cc.

                         {
  kTypedDataViewFromC,
  kTypedDataViewFromDart,
};

TypeEquality

enum class dart::TypeEquality

strong

Enumerator
kCanonical
kSyntactical
kInSubtypeTest

Definition at line 1120 of file object.h.

                        {
  kCanonical = 0,
  kSyntactical = 1,
  kInSubtypeTest = 2,
};

UnconditionalBranchOp

enum dart::UnconditionalBranchOp

Enumerator
UnconditionalBranchMask
UnconditionalBranchFixed
B
BL

Definition at line 796 of file constants_arm64.h.

                           {
  UnconditionalBranchMask = 0x7c000000,
  UnconditionalBranchFixed = CompareBranchFixed,
  B = UnconditionalBranchFixed,
  BL = UnconditionalBranchFixed | B31,
};

UnconditionalBranchRegOp

enum dart::UnconditionalBranchRegOp

Enumerator
UnconditionalBranchRegMask
UnconditionalBranchRegFixed
BR
BLR
RET

Definition at line 804 of file constants_arm64.h.

                              {
  UnconditionalBranchRegMask = 0xfe000000,
  UnconditionalBranchRegFixed = CompareBranchFixed | B31 | B30 | B25,
  BR = UnconditionalBranchRegFixed | B20 | B19 | B18 | B17 | B16,
  BLR = BR | B21,
  RET = BR | B22,
};

ValidationPolicy

enum class dart::ValidationPolicy

strong

Enumerator
kValidateFrames
kDontValidateFrames

Definition at line 271 of file thread.h.

                            {
  kValidateFrames = 0,
  kDontValidateFrames = 1,
};

VRegister

enum dart::VRegister

Enumerator
V0
V1
V2
V3
V4
V5
V6
V7
V8
V9
V10
V11
V12
V13
V14
V15
V16
V17
V18
V19
V20
V21
V22
V23
V24
V25
V26
V27
V28
V29
V30
V31
kNumberOfVRegisters
kNoVRegister

Definition at line 84 of file constants_arm64.h.

               {
  // v0 Volatile; Parameter/scratch register, result register.
  V0 = 0,
  // v1-v7 Volatile; Parameter/scratch register.
  V1 = 1,
  V2 = 2,
  V3 = 3,
  V4 = 4,
  V5 = 5,
  V6 = 6,
  V7 = 7,
  // v8-v15 Non-volatile; Scratch registers
  // Only the bottom 64 bits are non-volatile! [ARM IHI 0055B, 5.1.2]
  V8 = 8,
  V9 = 9,
  V10 = 10,
  V11 = 11,
  V12 = 12,
  V13 = 13,
  V14 = 14,
  V15 = 15,
  // v16-v31 Volatile; Scratch registers.
  V16 = 16,
  V17 = 17,
  V18 = 18,
  V19 = 19,
  V20 = 20,
  V21 = 21,
  V22 = 22,
  V23 = 23,
  V24 = 24,
  V25 = 25,
  V26 = 26,
  V27 = 27,
  V28 = 28,
  V29 = 29,
  V30 = 30,
  V31 = 31,
  kNumberOfVRegisters = 32,
  kNoVRegister = -1,
};

WeakSlices [1/2]

enum dart::WeakSlices

Enumerator
kWeakHandles
kWeakTables
kObjectIdRing
kRememberedSet
kNumWeakSlices
kWeakHandles
kWeakTables
kProgressBars
kRememberLiveTemporaries
kPruneWeak
kNumWeakSlices

Definition at line 618 of file marker.cc.

                {
  kWeakHandles = 0,
  kWeakTables,
  kObjectIdRing,
  kRememberedSet,
  kNumWeakSlices,
};

WeakSlices [2/2]

enum dart::WeakSlices

Enumerator
kWeakHandles
kWeakTables
kObjectIdRing
kRememberedSet
kNumWeakSlices
kWeakHandles
kWeakTables
kProgressBars
kRememberLiveTemporaries
kPruneWeak
kNumWeakSlices

Definition at line 1213 of file scavenger.cc.

                {
  kWeakHandles = 0,
  kWeakTables,
  kProgressBars,
  kRememberLiveTemporaries,
  kPruneWeak,
  kNumWeakSlices,
};

XmmRegister [1/2]

enum dart::XmmRegister

Enumerator
XMM0
XMM1
XMM2
XMM3
XMM4
XMM5
XMM6
XMM7
kNumberOfXmmRegisters
kNoXmmRegister
XMM0
XMM1
XMM2
XMM3
XMM4
XMM5
XMM6
XMM7
XMM8
XMM9
XMM10
XMM11
XMM12
XMM13
XMM14
XMM15
kNumberOfXmmRegisters
kNoXmmRegister

Definition at line 58 of file constants_ia32.h.

                 {
  XMM0 = 0,
  XMM1 = 1,
  XMM2 = 2,
  XMM3 = 3,
  XMM4 = 4,
  XMM5 = 5,
  XMM6 = 6,
  XMM7 = 7,
  kNumberOfXmmRegisters = 8,
  kNoXmmRegister = -1  // Signals an illegal register.
};

XmmRegister [2/2]

enum dart::XmmRegister

Enumerator
XMM0
XMM1
XMM2
XMM3
XMM4
XMM5
XMM6
XMM7
kNumberOfXmmRegisters
kNoXmmRegister
XMM0
XMM1
XMM2
XMM3
XMM4
XMM5
XMM6
XMM7
XMM8
XMM9
XMM10
XMM11
XMM12
XMM13
XMM14
XMM15
kNumberOfXmmRegisters
kNoXmmRegister

Definition at line 76 of file constants_x64.h.

                 {
  XMM0 = 0,
  XMM1 = 1,
  XMM2 = 2,
  XMM3 = 3,
  XMM4 = 4,
  XMM5 = 5,
  XMM6 = 6,
  XMM7 = 7,
  XMM8 = 8,
  XMM9 = 9,
  XMM10 = 10,
  XMM11 = 11,
  XMM12 = 12,
  XMM13 = 13,
  XMM14 = 14,
  XMM15 = 15,
  kNumberOfXmmRegisters = 16,
  kNoXmmRegister = -1  // Signals an illegal register.
};

Function Documentation

__msan_unpoison()

void dart::__msan_unpoison	(	const volatile void *	,
		size_t
	)

Definition at line 4220 of file runtime_entry.cc.

                                                              {
  UNREACHABLE();
}

__msan_unpoison_param()

void dart::__msan_unpoison_param

(

size_t

)

Definition at line 4223 of file runtime_entry.cc.

                                              {
  UNREACHABLE();
}

__tsan_acquire()

void dart::__tsan_acquire

(

void *

addr

)

Definition at line 4229 of file runtime_entry.cc.

                                           {
  UNREACHABLE();
}

__tsan_release()

void dart::__tsan_release

(

void *

addr

)

Definition at line 4232 of file runtime_entry.cc.

                                           {
  UNREACHABLE();
}

_currentThread()

GDB_HELPER void * dart::_currentThread

(

)

Definition at line 25 of file gdb_helpers.cc.

                       {
  return OSThread::CurrentVMThread();
}

_disassemble()

GDB_HELPER void dart::_disassemble

(

uword

pc

)

Definition at line 41 of file gdb_helpers.cc.

                            {
  Code& code = Code::Handle(Code::FindCodeUnsafe(pc));
  if (code.IsNull()) {
    OS::PrintErr("No code found\n");
  } else {
    Object& owner = Object::Handle(code.owner());
    if (owner.IsFunction()) {
      Disassembler::DisassembleCode(Function::Cast(owner), code,
                                    code.is_optimized());
    } else {
      Disassembler::DisassembleStub(code.Name(), code);
    }
  }
}

_handle()

GDB_HELPER Object * dart::_handle

(

uword

object

)

Definition at line 36 of file gdb_helpers.cc.

                              {
  return &Object::Handle(static_cast<ObjectPtr>(object));
}

_printDartStackTrace()

GDB_HELPER void dart::_printDartStackTrace

(

)

Definition at line 62 of file gdb_helpers.cc.

                            {
  const StackTrace& stacktrace = GetCurrentStackTrace(0);
  OS::PrintErr("=== Current Trace:\n%s===\n", stacktrace.ToCString());
}

_printGeneratedStackTrace()

GDB_HELPER void dart::_printGeneratedStackTrace	(	uword	fp,
		uword	sp,
		uword	pc
	)

Definition at line 79 of file gdb_helpers.cc.

                                                             {
  StackFrameIterator frames(fp, sp, pc, ValidationPolicy::kDontValidateFrames,
                            Thread::Current(),
                            StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = frames.NextFrame();
  while (frame != nullptr) {
    OS::PrintErr("%s\n", frame->ToCString());
    frame = frames.NextFrame();
  }
}

_printObjectPtr()

GDB_HELPER void dart::_printObjectPtr

(

uword

object

)

Definition at line 30 of file gdb_helpers.cc.

                                   {
  OS::PrintErr("%s\n",
               Object::Handle(static_cast<ObjectPtr>(object)).ToCString());
}

_printStackTrace()

GDB_HELPER void dart::_printStackTrace

(

)

Definition at line 70 of file gdb_helpers.cc.

                        {
  StackFrame::DumpCurrentTrace();
}

_printStackTraceWithLocals()

GDB_HELPER void dart::_printStackTraceWithLocals

(

)

Definition at line 115 of file gdb_helpers.cc.

                                  {
  PrintObjectPointersVisitor visitor;
  StackFrameIterator frames(ValidationPolicy::kDontValidateFrames,
                            Thread::Current(),
                            StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = frames.NextFrame();
  while (frame != nullptr) {
    OS::PrintErr("%s\n", frame->ToCString());
    frame->VisitObjectPointers(&visitor);
    frame = frames.NextFrame();
  }
}

AcceptCompilation()

static ObjectPtr dart::AcceptCompilation ( Thread *  thread )

static

Definition at line 641 of file isolate_reload.cc.

                                                   {
  TransitionVMToNative transition(thread);
  Dart_KernelCompilationResult result = KernelIsolate::AcceptCompilation();
  if (result.status != Dart_KernelCompilationStatus_Ok) {
    if (result.status != Dart_KernelCompilationStatus_MsgFailed) {
      FATAL(
          "An error occurred while accepting the most recent"
          " compilation results: %s",
          result.error);
    }
    TIR_Print(
        "An error occurred while accepting the most recent"
        " compilation results: %s",
        result.error);
    Zone* zone = thread->zone();
    const auto& error_str = String::Handle(zone, String::New(result.error));
    free(result.error);
    return ApiError::New(error_str);
  }
  return Object::null();
}

AccessForSlotInAllocatedObject()

static InnerPointerAccess dart::AccessForSlotInAllocatedObject ( Definition *  alloc, const Slot &  slot  )

static

Definition at line 3801 of file redundancy_elimination.cc.

                                                                           {
  if (slot.representation() != kUntagged) {
    return InnerPointerAccess::kNotUntagged;
  }
  if (!slot.may_contain_inner_pointer()) {
    return InnerPointerAccess::kCannotBeInnerPointer;
  }
  if (slot.IsIdentical(Slot::PointerBase_data())) {
    // The data field of external arrays is not unsafe, as it never contains
    // a GC-movable address.
    if (alloc->IsAllocateObject() &&
        IsExternalPayloadClassId(alloc->AsAllocateObject()->cls().id())) {
      return InnerPointerAccess::kCannotBeInnerPointer;
    }
  }
  return InnerPointerAccess::kMayBeInnerPointer;
}

ActOnIsolateGroup()

static void dart::ActOnIsolateGroup ( JSONStream *  js, std::function< void(IsolateGroup *)>  visitor  )

static

Definition at line 1582 of file service.cc.

                                                                        {
  const String& prefix =
      String::Handle(String::New(ISOLATE_GROUP_SERVICE_ID_PREFIX));
 
  const String& s =
      String::Handle(String::New(js->LookupParam("isolateGroupId")));
  if (!s.StartsWith(prefix)) {
    PrintInvalidParamError(js, "isolateGroupId");
    return;
  }
  uint64_t isolate_group_id = UInt64Parameter::Parse(
      String::Handle(String::SubString(s, prefix.Length())).ToCString());
  IsolateGroup::RunWithIsolateGroup(
      isolate_group_id,
      [&visitor](IsolateGroup* isolate_group) { visitor(isolate_group); },
      /*if_not_found=*/[&js]() { PrintSentinel(js, kExpiredSentinel); });
}

AddBmpCharacters()

void dart::AddBmpCharacters	(	RegExpCompiler *	compiler,
		ChoiceNode *	result,
		RegExpNode *	on_success,
		UnicodeRangeSplitter *	splitter
	)

Definition at line 3959 of file regexp.cc.

                                                      {
  ZoneGrowableArray<CharacterRange>* bmp = splitter->bmp();
  if (bmp == nullptr) return;
  result->AddAlternative(GuardedAlternative(TextNode::CreateForCharacterRanges(
      bmp, compiler->read_backward(), on_success, RegExpFlags())));
}

AddBreakpoint()

static void dart::AddBreakpoint ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3942 of file service.cc.

                                                          {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  const char* script_id_param = js->LookupParam("scriptId");
  Object& obj =
      Object::Handle(LookupHeapObject(thread, script_id_param, nullptr));
  if (obj.ptr() == Object::sentinel().ptr() || !obj.IsScript()) {
    PrintInvalidParamError(js, "scriptId");
    return;
  }
  const Script& script = Script::Cast(obj);
  const String& script_uri = String::Handle(script.url());
  ASSERT(!script_uri.IsNull());
  AddBreakpointCommon(thread, js, script_uri);
}

AddBreakpointAtActivation()

static void dart::AddBreakpointAtActivation ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4013 of file service.cc.

                                                                      {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  const char* object_id = js->LookupParam("objectId");
  Object& obj = Object::Handle(LookupHeapObject(thread, object_id, nullptr));
  if (obj.ptr() == Object::sentinel().ptr() || !obj.IsInstance()) {
    PrintInvalidParamError(js, "objectId");
    return;
  }
  const Instance& closure = Instance::Cast(obj);
  Breakpoint* bpt = thread->isolate()->debugger()->SetBreakpointAtActivation(
      closure, /*single_shot=*/false);
  if (bpt == nullptr) {
    js->PrintError(kCannotAddBreakpoint,
                   "%s: Cannot add breakpoint at activation", js->method());
    return;
  }
  bpt->PrintJSON(js);
}

AddBreakpointAtEntry()

static void dart::AddBreakpointAtEntry ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3984 of file service.cc.

                                                                 {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  const char* function_id = js->LookupParam("functionId");
  Object& obj = Object::Handle(LookupHeapObject(thread, function_id, nullptr));
  if (obj.ptr() == Object::sentinel().ptr() || !obj.IsFunction()) {
    PrintInvalidParamError(js, "functionId");
    return;
  }
  const Function& function = Function::Cast(obj);
  Breakpoint* bpt =
      thread->isolate()->debugger()->SetBreakpointAtEntry(function, false);
  if (bpt == nullptr) {
    js->PrintError(kCannotAddBreakpoint,
                   "%s: Cannot add breakpoint at function '%s'", js->method(),
                   function.ToCString());
    return;
  }
  bpt->PrintJSON(js);
}

AddBreakpointCommon()

static void dart::AddBreakpointCommon ( Thread *  thread, JSONStream *  js, const String &  script_uri  )

static

Definition at line 3902 of file service.cc.

                                                          {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  const char* line_param = js->LookupParam("line");
  intptr_t line = UIntParameter::Parse(line_param);
  const char* col_param = js->LookupParam("column");
  intptr_t col = -1;
  if (col_param != nullptr) {
    col = UIntParameter::Parse(col_param);
    if (col == 0) {
      // Column number is 1-based.
      PrintInvalidParamError(js, "column");
      return;
    }
  }
  ASSERT(!script_uri.IsNull());
  Breakpoint* bpt = nullptr;
  bpt = thread->isolate()->debugger()->SetBreakpointAtLineCol(script_uri, line,
                                                              col);
  if (bpt == nullptr) {
    js->PrintError(kCannotAddBreakpoint,
                   "%s: Cannot add breakpoint at line '%s'", js->method(),
                   line_param);
    return;
  }
  bpt->PrintJSON(js);
}

AddBreakpointWithScriptUri()

static void dart::AddBreakpointWithScriptUri ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3968 of file service.cc.

                                                                       {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  const char* script_uri_param = js->LookupParam("scriptUri");
  const String& script_uri = String::Handle(String::New(script_uri_param));
  AddBreakpointCommon(thread, js, script_uri);
}

AddClass()

static void dart::AddClass ( const int32_t *  elmv, intptr_t  elmc, ZoneGrowableArray< CharacterRange > *  ranges  )

static

Definition at line 4600 of file regexp.cc.

                                                                {
  elmc--;
  ASSERT(elmv[elmc] == kRangeEndMarker);
  for (intptr_t i = 0; i < elmc; i += 2) {
    ASSERT(elmv[i] < elmv[i + 1]);
    ranges->Add(CharacterRange(elmv[i], elmv[i + 1] - 1));
  }
}

AddClassNegated()

static void dart::AddClassNegated ( const int32_t *  elmv, intptr_t  elmc, ZoneGrowableArray< CharacterRange > *  ranges  )

static

Definition at line 4611 of file regexp.cc.

                                                                       {
  elmc--;
  ASSERT(elmv[elmc] == kRangeEndMarker);
  ASSERT(elmv[0] != 0x0000);
  ASSERT(elmv[elmc - 1] != Utf::kMaxCodePoint);
  uint16_t last = 0x0000;
  for (intptr_t i = 0; i < elmc; i += 2) {
    ASSERT(last <= elmv[i] - 1);
    ASSERT(elmv[i] < elmv[i + 1]);
    ranges->Add(CharacterRange(last, elmv[i] - 1));
    last = elmv[i + 1];
  }
  ranges->Add(CharacterRange(last, Utf::kMaxCodePoint));
}

AddFinalizer()

static FinalizablePersistentHandle * dart::AddFinalizer ( const Object &  referent, void *  peer, Dart_HandleFinalizer  callback, intptr_t  external_size  )

static

Definition at line 24238 of file object.cc.

                                                                         {
  ASSERT(callback != nullptr);
  FinalizablePersistentHandle* finalizable_ref =
      FinalizablePersistentHandle::New(IsolateGroup::Current(), referent, peer,
                                       callback, external_size,
                                       /*auto_delete=*/true);
  ASSERT(finalizable_ref != nullptr);
  return finalizable_ref;
}

AddHandleFieldAndHandleField()

intptr_t dart::AddHandleFieldAndHandleField	(	Dart_Handle	self,
		Dart_Handle	other
	)

Definition at line 1204 of file ffi_test_functions_vmspecific.cc.

                                                                           {
  intptr_t field1 = 0;
  ENSURE(!Dart_IsError(Dart_GetNativeInstanceField(self, 0, &field1)));
  intptr_t field2 = 0;
  ENSURE(!Dart_IsError(Dart_GetNativeInstanceField(other, 0, &field2)));
  return field1 + field2;
}

AddHandleFieldAndInt()

intptr_t dart::AddHandleFieldAndInt	(	Dart_Handle	self,
		intptr_t	x
	)

Definition at line 1188 of file ffi_test_functions_vmspecific.cc.

                                                            {
  intptr_t field = 0;
  ENSURE(!Dart_IsError(Dart_GetNativeInstanceField(self, 0, &field)));
  return field + x;
}

AddHandleFieldAndPtr()

intptr_t dart::AddHandleFieldAndPtr	(	Dart_Handle	self,
		void *	other
	)

Definition at line 1198 of file ffi_test_functions_vmspecific.cc.

                                                             {
  intptr_t field = 0;
  ENSURE(!Dart_IsError(Dart_GetNativeInstanceField(self, 0, &field)));
  return field + reinterpret_cast<intptr_t>(other);
}

AddInstruction()

template<typename T >

void dart::AddInstruction	(	GrowableArray< T * > *	list,
		T *	value
	)

Definition at line 3923 of file redundancy_elimination.cc.

                                                       {
  ASSERT(!value->IsGraphEntry() && !value->IsFunctionEntry());
  for (intptr_t i = 0; i < list->length(); i++) {
    if ((*list)[i] == value) {
      return;
    }
  }
  list->Add(value);
}

AddLoneLeadSurrogates()

void dart::AddLoneLeadSurrogates	(	RegExpCompiler *	compiler,
		ChoiceNode *	result,
		RegExpNode *	on_success,
		UnicodeRangeSplitter *	splitter
	)

Definition at line 4065 of file regexp.cc.

                                                           {
  auto lead_surrogates = splitter->lead_surrogates();
  if (lead_surrogates == nullptr) return;
  // E.g. \ud801 becomes \ud801(?![\udc00-\udfff]).
  auto trail_surrogates = CharacterRange::List(
      on_success->zone(), CharacterRange::Range(Utf16::kTrailSurrogateStart,
                                                Utf16::kTrailSurrogateEnd));
 
  RegExpNode* match;
  if (compiler->read_backward()) {
    // Reading backward. Assert that reading forward, there is no trail
    // surrogate, and then backward match the lead surrogate.
    match = NegativeLookaroundAgainstReadDirectionAndMatch(
        compiler, trail_surrogates, lead_surrogates, on_success, true,
        RegExpFlags());
  } else {
    // Reading forward. Forward match the lead surrogate and assert that
    // no trail surrogate follows.
    match = MatchAndNegativeLookaroundInReadDirection(
        compiler, lead_surrogates, trail_surrogates, on_success, false,
        RegExpFlags());
  }
  result->AddAlternative(GuardedAlternative(match));
}

AddLoneTrailSurrogates()

void dart::AddLoneTrailSurrogates	(	RegExpCompiler *	compiler,
		ChoiceNode *	result,
		RegExpNode *	on_success,
		UnicodeRangeSplitter *	splitter
	)

Definition at line 4093 of file regexp.cc.

                                                            {
  auto trail_surrogates = splitter->trail_surrogates();
  if (trail_surrogates == nullptr) return;
  // E.g. \udc01 becomes (?<![\ud800-\udbff])\udc01
  auto lead_surrogates = CharacterRange::List(
      on_success->zone(), CharacterRange::Range(Utf16::kLeadSurrogateStart,
                                                Utf16::kLeadSurrogateEnd));
 
  RegExpNode* match;
  if (compiler->read_backward()) {
    // Reading backward. Backward match the trail surrogate and assert that no
    // lead surrogate precedes it.
    match = MatchAndNegativeLookaroundInReadDirection(
        compiler, trail_surrogates, lead_surrogates, on_success, true,
        RegExpFlags());
  } else {
    // Reading forward. Assert that reading backward, there is no lead
    // surrogate, and then forward match the trail surrogate.
    match = NegativeLookaroundAgainstReadDirectionAndMatch(
        compiler, lead_surrogates, trail_surrogates, on_success, false,
        RegExpFlags());
  }
  result->AddAlternative(GuardedAlternative(match));
}

AddNameProperties()

static void dart::AddNameProperties ( JSONObject *  jsobj, const char *  name, const char *  vm_name  )

static

Definition at line 20 of file object_service.cc.

                                                   {
  jsobj->AddProperty("name", name);
  if (strcmp(name, vm_name) != 0) {
    jsobj->AddProperty("_vmName", vm_name);
  }
}

AddNonBmpSurrogatePairs()

void dart::AddNonBmpSurrogatePairs	(	RegExpCompiler *	compiler,
		ChoiceNode *	result,
		RegExpNode *	on_success,
		UnicodeRangeSplitter *	splitter
	)

Definition at line 3969 of file regexp.cc.

                                                             {
  ZoneGrowableArray<CharacterRange>* non_bmp = splitter->non_bmp();
  if (non_bmp == nullptr) return;
  ASSERT(!compiler->one_byte());
  CharacterRange::Canonicalize(non_bmp);
  for (int i = 0; i < non_bmp->length(); i++) {
    // Match surrogate pair.
    // E.g. [\u10005-\u11005] becomes
    //      \ud800[\udc05-\udfff]|
    //      [\ud801-\ud803][\udc00-\udfff]|
    //      \ud804[\udc00-\udc05]
    uint32_t from = non_bmp->At(i).from();
    uint32_t to = non_bmp->At(i).to();
    uint16_t from_points[2];
    Utf16::Encode(from, from_points);
    uint16_t to_points[2];
    Utf16::Encode(to, to_points);
    if (from_points[0] == to_points[0]) {
      // The lead surrogate is the same.
      result->AddAlternative(
          GuardedAlternative(TextNode::CreateForSurrogatePair(
              CharacterRange::Singleton(from_points[0]),
              CharacterRange::Range(from_points[1], to_points[1]),
              compiler->read_backward(), on_success, RegExpFlags())));
    } else {
      if (from_points[1] != Utf16::kTrailSurrogateStart) {
        // Add [from_l][from_t-\udfff]
        result->AddAlternative(
            GuardedAlternative(TextNode::CreateForSurrogatePair(
                CharacterRange::Singleton(from_points[0]),
                CharacterRange::Range(from_points[1],
                                      Utf16::kTrailSurrogateEnd),
                compiler->read_backward(), on_success, RegExpFlags())));
        from_points[0]++;
      }
      if (to_points[1] != Utf16::kTrailSurrogateEnd) {
        // Add [to_l][\udc00-to_t]
        result->AddAlternative(
            GuardedAlternative(TextNode::CreateForSurrogatePair(
                CharacterRange::Singleton(to_points[0]),
                CharacterRange::Range(Utf16::kTrailSurrogateStart,
                                      to_points[1]),
                compiler->read_backward(), on_success, RegExpFlags())));
        to_points[0]--;
      }
      if (from_points[0] <= to_points[0]) {
        // Add [from_l-to_l][\udc00-\udfff]
        result->AddAlternative(
            GuardedAlternative(TextNode::CreateForSurrogatePair(
                CharacterRange::Range(from_points[0], to_points[0]),
                CharacterRange::Range(Utf16::kTrailSurrogateStart,
                                      Utf16::kTrailSurrogateEnd),
                compiler->read_backward(), on_success, RegExpFlags())));
      }
    }
  }
}

AddParentFieldToResponseBasedOnRecord()

static void dart::AddParentFieldToResponseBasedOnRecord ( Thread *  thread, Array *  field_names_handle, String *  name_handle, const JSONObject &  jsresponse, const Record &  record, const intptr_t  field_slot_offset  )

inlinestatic

Definition at line 2265 of file service.cc.

                                      {
  *field_names_handle = record.GetFieldNames(thread);
  const intptr_t num_positional_fields =
      record.num_fields() - field_names_handle->Length();
  const intptr_t field_index =
      (field_slot_offset - Record::field_offset(0)) / Record::kBytesPerElement;
  if (field_index < num_positional_fields) {
    jsresponse.AddProperty("parentField", field_index);
  } else {
    *name_handle ^= field_names_handle->At(field_index - num_positional_fields);
    jsresponse.AddProperty("parentField", name_handle->ToCString());
  }
}

AddPtrAndHandleField()

intptr_t dart::AddPtrAndHandleField	(	void *	self,
		Dart_Handle	other
	)

Definition at line 1212 of file ffi_test_functions_vmspecific.cc.

                                                             {
  intptr_t field = 0;
  ENSURE(!Dart_IsError(Dart_GetNativeInstanceField(other, 0, &field)));
  return reinterpret_cast<intptr_t>(self) + field;
}

AddPtrAndInt()

intptr_t dart::AddPtrAndInt	(	void *	self,
		intptr_t	x
	)

Definition at line 1184 of file ffi_test_functions_vmspecific.cc.

                                              {
  return reinterpret_cast<intptr_t>(self) + x;
}

AddPtrAndPtr()

intptr_t dart::AddPtrAndPtr	(	void *	self,
		void *	other
	)

Definition at line 1194 of file ffi_test_functions_vmspecific.cc.

                                               {
  return reinterpret_cast<intptr_t>(self) + reinterpret_cast<intptr_t>(other);
}

AddRange() [1/2]

ContainedInLattice dart::AddRange	(	ContainedInLattice	a,
		const intptr_t *	ranges,
		intptr_t	ranges_size,
		Interval	new_range
	)

AddRange() [2/2]

ContainedInLattice dart::AddRange	(	ContainedInLattice	containment,
		const int32_t *	ranges,
		intptr_t	ranges_length,
		Interval	new_range
	)

Definition at line 36 of file regexp.cc.

                                                {
  ASSERT((ranges_length & 1) == 1);
  ASSERT(ranges[ranges_length - 1] == Utf::kMaxCodePoint + 1);
  if (containment == kLatticeUnknown) return containment;
  bool inside = false;
  int32_t last = 0;
  for (intptr_t i = 0; i < ranges_length;
       inside = !inside, last = ranges[i], i++) {
    // Consider the range from last to ranges[i].
    // We haven't got to the new range yet.
    if (ranges[i] <= new_range.from()) continue;
    // New range is wholly inside last-ranges[i].  Note that new_range.to() is
    // inclusive, but the values in ranges are not.
    if (last <= new_range.from() && new_range.to() < ranges[i]) {
      return Combine(containment, inside ? kLatticeIn : kLatticeOut);
    }
    return kLatticeUnknown;
  }
  return containment;
}

AddScriptIfUnique()

static void dart::AddScriptIfUnique ( const GrowableObjectArray &  scripts, const Script &  candidate  )

static

Definition at line 13969 of file object.cc.

                                                       {
  if (candidate.IsNull()) {
    return;
  }
  Script& script_obj = Script::Handle();
 
  for (int i = 0; i < scripts.Length(); i++) {
    script_obj ^= scripts.At(i);
    if (script_obj.ptr() == candidate.ptr()) {
      // We already have a reference to this script.
      return;
    }
  }
  // Add script to the list of scripts.
  scripts.Add(candidate);
}

AddSlot()

static void dart::AddSlot ( ZoneGrowableArray< const Slot * > *  slots, const Slot &  slot  )

static

Definition at line 3757 of file redundancy_elimination.cc.

                                                                             {
  if (!slots->Contains(&slot)) {
    slots->Add(&slot);
  }
}

AddSuperType()

static void dart::AddSuperType ( const AbstractType &  type, GrowableArray< intptr_t > *  finalized_super_classes  )

static

Definition at line 71 of file class_finalizer.cc.

                                                                           {
  ASSERT(type.HasTypeClass());
  ASSERT(!type.IsDynamicType());
  if (type.IsObjectType()) {
    return;
  }
  const Class& cls = Class::Handle(type.type_class());
  ASSERT(cls.is_finalized());
  const intptr_t cid = cls.id();
  for (intptr_t i = 0; i < finalized_super_classes->length(); i++) {
    if ((*finalized_super_classes)[i] == cid) {
      // Already added.
      return;
    }
  }
  finalized_super_classes->Add(cid);
  const AbstractType& super_type = AbstractType::Handle(cls.super_type());
  AddSuperType(super_type, finalized_super_classes);
}

AddToSortedListOfRanges()

static void dart::AddToSortedListOfRanges ( GrowableArray< LiveRange * > *  list, LiveRange *  range  )

static

Definition at line 2842 of file linearscan.cc.

                                                      {
  range->finger()->Initialize(range);
 
  if (list->is_empty()) {
    list->Add(range);
    return;
  }
 
  for (intptr_t i = list->length() - 1; i >= 0; i--) {
    if (ShouldBeAllocatedBefore(range, (*list)[i])) {
      list->InsertAt(i + 1, range);
      return;
    }
  }
  list->InsertAt(0, range);
}

AddUnicodeCaseEquivalents()

void dart::AddUnicodeCaseEquivalents

(

ZoneGrowableArray< CharacterRange > *

ranges

)

Definition at line 4135 of file regexp.cc.

                                                                          {
  ASSERT(CharacterRange::IsCanonical(ranges));
 
  // Micro-optimization to avoid passing large ranges to UnicodeSet::closeOver.
  // See also https://crbug.com/v8/6727.
  // TODO(sstrickl): This only covers the special case of the {0,0x10FFFF}
  // range, which we use frequently internally. But large ranges can also easily
  // be created by the user. We might want to have a more general caching
  // mechanism for such ranges.
  if (ranges->length() == 1 && ranges->At(0).IsEverything(Utf::kMaxCodePoint)) {
    return;
  }
 
  icu::UnicodeSet set;
  for (int i = 0; i < ranges->length(); i++) {
    set.add(ranges->At(i).from(), ranges->At(i).to());
  }
  ranges->Clear();
  set.closeOver(USET_CASE_INSENSITIVE);
  // Full case mapping map single characters to multiple characters.
  // Those are represented as strings in the set. Remove them so that
  // we end up with only simple and common case mappings.
  set.removeAllStrings();
  for (int i = 0; i < set.getRangeCount(); i++) {
    ranges->Add(
        CharacterRange::Range(set.getRangeStart(i), set.getRangeEnd(i)));
  }
  // No errors and everything we collected have been ranges.
  CharacterRange::Canonicalize(ranges);
}

AllInputsAreRedefinitions()

static bool dart::AllInputsAreRedefinitions ( PhiInstr *  phi )

static

Definition at line 6691 of file il.cc.

                                                     {
  for (intptr_t i = 0; i < phi->InputCount(); i++) {
    if (phi->InputAt(i)->definition()->RedefinedValue() == nullptr) {
      return false;
    }
  }
  return true;
}

Allocate() [1/2]

static uword dart::Allocate ( FreeList *  free_list, intptr_t  size, bool  is_protected  )

static

Definition at line 14 of file freelist_test.cc.

                                                                             {
  uword result = free_list->TryAllocate(size, is_protected);
  if ((result != 0u) && is_protected) {
    VirtualMemory::Protect(reinterpret_cast<void*>(result), size,
                           VirtualMemory::kReadExecute);
  }
  return result;
}

Allocate() [2/2]

static void * dart::Allocate ( uword  size, Zone *  zone  )

static

Definition at line 14 of file allocation.cc.

                                              {
  ASSERT(zone != nullptr);
  if (size > static_cast<uword>(kIntptrMax)) {
    FATAL("ZoneAllocated object has unexpectedly large size %" Pu "", size);
  }
  return reinterpret_cast<void*>(zone->AllocUnsafe(size));
}

AllocateFinalizableHandle() [1/2]

static Dart_FinalizableHandle dart::AllocateFinalizableHandle ( Thread *  T, Dart_Handle  object, void *  peer, intptr_t  external_allocation_size, Dart_HandleFinalizer  callback  )

static

Definition at line 1075 of file dart_api_impl.cc.

                                   {
  const auto& ref = Object::Handle(Z, Api::UnwrapHandle(object));
  return AllocateFinalizableHandle(T, ref, peer, external_allocation_size,
                                   callback);
}

AllocateFinalizableHandle() [2/2]

static Dart_FinalizableHandle dart::AllocateFinalizableHandle ( Thread *  thread, const Object &  ref, void *  peer, intptr_t  external_allocation_size, Dart_HandleFinalizer  callback  )

static

Definition at line 1051 of file dart_api_impl.cc.

                                   {
  if (!ref.ptr()->IsHeapObject()) {
    return nullptr;
  }
  if (ref.IsPointer()) {
    return nullptr;
  }
  if (IsFfiCompound(thread, ref)) {
    return nullptr;
  }
 
  FinalizablePersistentHandle* finalizable_ref =
      FinalizablePersistentHandle::New(thread->isolate_group(), ref, peer,
                                       callback, external_allocation_size,
                                       /*auto_delete=*/true);
  return finalizable_ref == nullptr ? nullptr
                                    : finalizable_ref->ApiFinalizableHandle();
}

AllocateFreeFpuRegister()

static FpuRegister dart::AllocateFreeFpuRegister ( bool *  blocked_registers )

static

Definition at line 1651 of file flow_graph_compiler.cc.

                                                                    {
  for (intptr_t regno = 0; regno < kNumberOfFpuRegisters; regno++) {
    if (!blocked_registers[regno]) {
      blocked_registers[regno] = true;
      return static_cast<FpuRegister>(regno);
    }
  }
  UNREACHABLE();
  return kNoFpuRegister;
}

AllocateFreeRegister()

static Register dart::AllocateFreeRegister ( bool *  blocked_registers )

static

Definition at line 1638 of file flow_graph_compiler.cc.

                                                              {
  for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
    intptr_t regno = (i + kRegisterAllocationBias) % kNumberOfCpuRegisters;
    if (!blocked_registers[regno]) {
      blocked_registers[regno] = true;
      return static_cast<Register>(regno);
    }
  }
  UNREACHABLE();
  return kNoRegister;
}

AllocateNewString()

static Dart_Handle dart::AllocateNewString ( const char *  c_str )

static

Definition at line 3448 of file dart_api_impl_test.cc.

                                                        {
  Thread* thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  return Api::NewHandle(thread, String::New(c_str, Heap::kNew));
}

AllocateObject() [1/2]

DART_FORCE_INLINE ObjectPtr dart::AllocateObject	(	intptr_t	cid,
		intptr_t	size,
		intptr_t	allocated_bytes
	)

Definition at line 248 of file object_graph_copy.cc.

                                                   {
#if defined(DART_COMPRESSED_POINTERS)
  const bool compressed = true;
#else
  const bool compressed = false;
#endif
  const intptr_t kLargeMessageThreshold = 16 * MB;
  const Heap::Space space =
      allocated_bytes > kLargeMessageThreshold ? Heap::kOld : Heap::kNew;
  // Mimic the old initialization behavior of Object::InitializeObject where
  // the contents are initialized to Object::null(), except for TypedDataBase
  // subclasses which are initialized to 0, as the contents of the original
  // are translated and copied over prior to returning the object graph root.
  if (IsTypedDataBaseClassId(cid)) {
    return Object::Allocate(cid, size, space, compressed,
                            Object::from_offset<TypedDataBase>(),
                            Object::to_offset<TypedDataBase>());
 
  } else {
    // Remember that ptr_field_end_offset is the offset to the last Ptr
    // field, not the offset just past it.
    const uword ptr_field_end_offset =
        size - (compressed ? kCompressedWordSize : kWordSize);
    return Object::Allocate(cid, size, space, compressed,
                            Object::from_offset<Object>(),
                            ptr_field_end_offset);
  }
}

AllocateObject() [2/2]

static InstancePtr dart::AllocateObject ( Thread *  thread, const Class &  cls  )

static

Definition at line 4348 of file dart_api_impl.cc.

                                                                    {
  if (!cls.is_fields_marked_nullable()) {
    // Mark all fields as nullable.
    Zone* zone = thread->zone();
    Class& iterate_cls = Class::Handle(zone, cls.ptr());
    Field& field = Field::Handle(zone);
    Array& fields = Array::Handle(zone);
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    if (!cls.is_fields_marked_nullable()) {
      while (!iterate_cls.IsNull()) {
        ASSERT(iterate_cls.is_finalized());
        iterate_cls.set_is_fields_marked_nullable();
        fields = iterate_cls.fields();
        iterate_cls = iterate_cls.SuperClass();
        for (int field_num = 0; field_num < fields.Length(); field_num++) {
          field ^= fields.At(field_num);
          if (field.is_static()) {
            continue;
          }
          field.RecordStore(Object::null_object());
        }
      }
    }
  }
 
  // Allocate an object for the given class.
  return Instance::New(cls);
}

AllocateObjectByClassName()

static InstancePtr dart::AllocateObjectByClassName ( const Library &  library, const String &  class_name  )

static

Definition at line 163 of file object_store.cc.

                                                                       {
  const Class& cls = Class::Handle(library.LookupClassAllowPrivate(class_name));
  ASSERT(!cls.IsNull());
  return Instance::New(cls);
}

AllocateOldString()

static Dart_Handle dart::AllocateOldString ( const char *  c_str )

static

Definition at line 3454 of file dart_api_impl_test.cc.

                                                        {
  Thread* thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  return Api::NewHandle(thread, String::New(c_str, Heap::kOld));
}

AllocateRefcountedResource()

DART_EXPORT RefCountedResource * dart::AllocateRefcountedResource

(

)

Definition at line 1335 of file ffi_test_functions_vmspecific.cc.

                                                             {
  auto peer =
      static_cast<RefCountedResource*>(malloc(sizeof(RefCountedResource)));
  auto resource = malloc(128);
  memset(resource, 0, 128);
  peer->resource = resource;
  peer->refcount = 0;  // We're not going to count the reference here.
  return peer;
}

AllocateResource()

intptr_t * dart::AllocateResource

(

intptr_t

value

)

Definition at line 1163 of file ffi_test_functions_vmspecific.cc.

                                           {
  return new intptr_t(value);
}

AllocateWeakPersistentHandle() [1/2]

static Dart_WeakPersistentHandle dart::AllocateWeakPersistentHandle ( Thread *  T, Dart_Handle  object, void *  peer, intptr_t  external_allocation_size, Dart_HandleFinalizer  callback  )

static

Definition at line 1040 of file dart_api_impl.cc.

                                   {
  const auto& ref = Object::Handle(Z, Api::UnwrapHandle(object));
  return AllocateWeakPersistentHandle(T, ref, peer, external_allocation_size,
                                      callback);
}

AllocateWeakPersistentHandle() [2/2]

static Dart_WeakPersistentHandle dart::AllocateWeakPersistentHandle ( Thread *  thread, const Object &  ref, void *  peer, intptr_t  external_allocation_size, Dart_HandleFinalizer  callback  )

static

Definition at line 1015 of file dart_api_impl.cc.

                                   {
  if (!ref.ptr()->IsHeapObject()) {
    return nullptr;
  }
  if (ref.IsPointer()) {
    return nullptr;
  }
  if (IsFfiCompound(thread, ref)) {
    return nullptr;
  }
 
  FinalizablePersistentHandle* finalizable_ref =
      FinalizablePersistentHandle::New(thread->isolate_group(), ref, peer,
                                       callback, external_allocation_size,
                                       /*auto_delete=*/false);
  return finalizable_ref == nullptr
             ? nullptr
             : finalizable_ref->ApiWeakPersistentHandle();
}

AllocMsg()

static uint8_t * dart::AllocMsg ( const char *  str )

static

Definition at line 11 of file message_test.cc.

                                          {
  return reinterpret_cast<uint8_t*>(Utils::StrDup(str));
}

AllocStruct9Uint8()

DART_EXPORT Struct9Uint8 * dart::AllocStruct9Uint8

(

)

Definition at line 756 of file ffi_test_functions.cc.

                                              {
  size_t size = sizeof(Struct9Uint8) * 64 * 1024;
#if defined(_WIN32)
  void* result =
      VirtualAlloc(nullptr, size * 2, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
  void* guard_page =
      reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(result) + size);
  DWORD old_prot;
  if (VirtualProtect(guard_page, size, PAGE_NOACCESS, &old_prot) == 0) {
    fprintf(stderr, "VirtualProtect failed\n");
    abort();
  }
#else
  void* result = mmap(nullptr, size * 2, PROT_READ | PROT_WRITE,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  void* guard_page =
      reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(result) + size);
  if (mprotect(guard_page, size, PROT_NONE) != 0) {
    fprintf(stderr, "mprotect failed\n");
    abort();
  }
#endif
  return reinterpret_cast<Struct9Uint8*>(result);
}

alpha_callback()

static bool dart::alpha_callback ( const char *  name, const char **  option_keys, const char **  option_values, intptr_t  num_options, void *  user_data, const char **  result  )

static

Definition at line 563 of file service_test.cc.

                                                {
  *result = Utils::StrDup("alpha");
  return true;
}

AotCallCountApproximation()

static intptr_t dart::AotCallCountApproximation ( intptr_t  nesting_depth )

static

Definition at line 244 of file inliner.cc.

                                                                  {
  switch (nesting_depth) {
    case 0:
      // The value 1 makes most sense, but it may give a high ratio to call
      // sites outside loops. Therefore, such call sites are subject to
      // subsequent stricter heuristic to limit code size increase.
      return 1;
    case 1:
      return 10;
    case 2:
      return 10 * 10;
    default:
      return 10 * 10 * 10;
  }
}

AppendFrames()

static void dart::AppendFrames ( const GrowableObjectArray &  code_list, GrowableArray< uword > *  pc_offset_list, int  skip_frames  )

static

Definition at line 65 of file stacktrace.cc.

                                          {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  StackFrameIterator frames(ValidationPolicy::kDontValidateFrames, thread,
                            StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = frames.NextFrame();
  ASSERT(frame != nullptr);  // We expect to find a dart invocation frame.
  Code& code = Code::Handle(zone);
  for (; frame != nullptr; frame = frames.NextFrame()) {
    if (!frame->IsDartFrame()) {
      continue;
    }
    if (skip_frames > 0) {
      skip_frames--;
      continue;
    }
 
    code = frame->LookupDartCode();
    const intptr_t pc_offset = frame->pc() - code.PayloadStart();
    code_list.Add(code);
    pc_offset_list->Add(pc_offset);
  }
}

AppendInstruction()

static Instruction * dart::AppendInstruction ( Instruction *  first, Instruction *  second  )

static

Definition at line 2099 of file inliner.cc.

                                                                               {
  for (intptr_t i = second->InputCount() - 1; i >= 0; --i) {
    Value* input = second->InputAt(i);
    input->definition()->AddInputUse(input);
  }
  first->LinkTo(second);
  return second;
}

AppendSubString()

static void dart::AppendSubString ( BaseTextBuffer *  buffer, const char *  name, intptr_t  start_pos, intptr_t  len  )

static

Definition at line 193 of file object.cc.

                                          {
  buffer->Printf("%.*s", static_cast<int>(len), &name[start_pos]);
}

ApplyBCE()

static std::pair< intptr_t, intptr_t > dart::ApplyBCE ( const char *  script_chars, CompilerPass::PipelineMode  mode  )

static

Definition at line 36 of file bce_test.cc.

                                                                             {
  // Load the script and exercise the code once
  // while exercising the given compiler passes.
  const auto& root_library = Library::Handle(LoadTestScript(script_chars));
  Invoke(root_library, "main");
  std::initializer_list<CompilerPass::Id> passes = {
      CompilerPass::kComputeSSA,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyICData,
      CompilerPass::kInlining,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyICData,
      CompilerPass::kSelectRepresentations,
      CompilerPass::kCanonicalize,
      CompilerPass::kConstantPropagation,
      CompilerPass::kCSE,
      CompilerPass::kLICM,
  };
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, mode);
  FlowGraph* flow_graph = pipeline.RunPasses(passes);
  // Count the number of before/after bounds checks.
  const intptr_t num_bc_before = CountBoundChecks(flow_graph);
  RangeAnalysis range_analysis(flow_graph);
  range_analysis.Analyze();
  const intptr_t num_bc_after = CountBoundChecks(flow_graph);
  return {num_bc_before, num_bc_after};
}

ApplyTo42And74()

DART_EXPORT intptr_t dart::ApplyTo42And74

(

IntptrBinOp

binop

)

Definition at line 602 of file ffi_test_functions.cc.

                                                       {
  std::cout << "ApplyTo42And74()\n";
  intptr_t retval = binop(42, 74);
  std::cout << "returning " << retval << "\n";
  return retval;
}

AreEqualDefinitions()

static bool dart::AreEqualDefinitions ( Definition *  a, Definition *  b  )

static

Definition at line 320 of file range_analysis.cc.

                                                              {
  a = UnwrapConstraint(a);
  b = UnwrapConstraint(b);
  return (a == b) || (a->AllowsCSE() && b->AllowsCSE() && a->Equals(*b));
}

AreLocationsAllTheSame()

static bool dart::AreLocationsAllTheSame ( const GrowableArray< Location > &  locs )

static

Definition at line 2974 of file linearscan.cc.

                                                                        {
  for (intptr_t j = 1; j < locs.length(); j++) {
    if (!locs[j].Equals(locs[0])) {
      return false;
    }
  }
  return true;
}

ArrayContains()

static bool dart::ArrayContains ( ZoneGrowableArray< unsigned > *  array, unsigned  value  )

static

Definition at line 4938 of file regexp.cc.

                                                                              {
  for (intptr_t i = 0; i < array->length(); i++) {
    if (array->At(i) == value) {
      return true;
    }
  }
  return false;
}

AsHandle() [1/2]

static Dart_Handle dart::AsHandle ( Dart_PersistentHandle  weak )

static

Definition at line 3460 of file dart_api_impl_test.cc.

                                                        {
  return Dart_HandleFromPersistent(weak);
}

AsHandle() [2/2]

static Dart_Handle dart::AsHandle ( Dart_WeakPersistentHandle  weak )

static

Definition at line 3464 of file dart_api_impl_test.cc.

                                                            {
  return Dart_HandleFromWeakPersistent(weak);
}

ASSEMBLER_TEST_RUN() [1/2]

dart::ASSEMBLER_TEST_RUN	(	InstantiateTypeArgumentsHashKeys	,
		test
	)

Definition at line 92 of file assembler_test.cc.

                                                           {
  typedef uint32_t (*HashKeysCode)(uword hash, uword other) DART_UNUSED;
 
  auto hash_test = [&](const Expect& expect, uword hash1, uword hash2) {
    const uint32_t expected = FinalizeHash(CombineHashes(hash1, hash2));
    const uint32_t got = EXECUTE_TEST_CODE_UWORD_UWORD_UINT32(
        HashKeysCode, test->entry(), hash1, hash2);
    if (got == expected) return;
    TextBuffer buffer(128);
    buffer.Printf("For hash1 = %" Pu " and hash2 = %" Pu
                  ": expected result %u, got result %u",
                  hash1, hash2, expected, got);
    expect.Fail("%s", buffer.buffer());
  };
 
#define HASH_TEST(hash1, hash2)                                                \
  hash_test(Expect(__FILE__, __LINE__), hash1, hash2)
 
  const intptr_t kNumRandomTests = 500;
  Random random;
 
  // First, fixed and random 32 bit tests for all architectures.
  HASH_TEST(1, 1);
  HASH_TEST(10, 20);
  HASH_TEST(20, 10);
  HASH_TEST(kMaxUint16, kMaxUint32 - kMaxUint16);
  HASH_TEST(kMaxUint32 - kMaxUint16, kMaxUint16);
 
  for (intptr_t i = 0; i < kNumRandomTests; i++) {
    const uword hash1 = random.NextUInt32();
    const uword hash2 = random.NextUInt32();
    HASH_TEST(hash1, hash2);
  }
 
#if defined(TARGET_ARCH_IS_64_BIT)
  // Now 64-bit tests on 64-bit architectures.
  HASH_TEST(kMaxUint16, kMaxUint64 - kMaxUint16);
  HASH_TEST(kMaxUint64 - kMaxUint16, kMaxUint16);
 
  for (intptr_t i = 0; i < kNumRandomTests; i++) {
    const uword hash1 = random.NextUInt64();
    const uword hash2 = random.NextUInt64();
    HASH_TEST(hash1, hash2);
  }
#endif
#undef HASH_TEST
}

ASSEMBLER_TEST_RUN() [2/2]

dart::ASSEMBLER_TEST_RUN	(	StoreIntoObject	,
		test
	)

Definition at line 21 of file assembler_test.cc.

                                          {
#define TEST_CODE(value, growable_array, thread)                               \
  test->Invoke<void, ObjectPtr, ObjectPtr, Thread*>(value, growable_array,     \
                                                    thread)
 
  const Array& old_array = Array::Handle(Array::New(3, Heap::kOld));
  const Array& new_array = Array::Handle(Array::New(3, Heap::kNew));
  const GrowableObjectArray& grow_old_array = GrowableObjectArray::Handle(
      GrowableObjectArray::New(old_array, Heap::kOld));
  const GrowableObjectArray& grow_new_array = GrowableObjectArray::Handle(
      GrowableObjectArray::New(old_array, Heap::kNew));
  Smi& smi = Smi::Handle();
  Thread* thread = Thread::Current();
 
  EXPECT(old_array.ptr() == grow_old_array.data());
  EXPECT(!thread->StoreBufferContains(grow_old_array.ptr()));
  EXPECT(old_array.ptr() == grow_new_array.data());
  EXPECT(!thread->StoreBufferContains(grow_new_array.ptr()));
 
  // Store Smis into the old object.
  for (int i = -128; i < 128; i++) {
    smi = Smi::New(i);
    TEST_CODE(smi.ptr(), grow_old_array.ptr(), thread);
    EXPECT(static_cast<CompressedObjectPtr>(smi.ptr()) ==
           static_cast<CompressedObjectPtr>(grow_old_array.data()));
    EXPECT(!thread->StoreBufferContains(grow_old_array.ptr()));
  }
 
  // Store an old object into the old object.
  TEST_CODE(old_array.ptr(), grow_old_array.ptr(), thread);
  EXPECT(old_array.ptr() == grow_old_array.data());
  EXPECT(!thread->StoreBufferContains(grow_old_array.ptr()));
 
  // Store a new object into the old object.
  TEST_CODE(new_array.ptr(), grow_old_array.ptr(), thread);
  EXPECT(new_array.ptr() == grow_old_array.data());
  EXPECT(thread->StoreBufferContains(grow_old_array.ptr()));
 
  // Store a new object into the new object.
  TEST_CODE(new_array.ptr(), grow_new_array.ptr(), thread);
  EXPECT(new_array.ptr() == grow_new_array.data());
  EXPECT(!thread->StoreBufferContains(grow_new_array.ptr()));
 
  // Store an old object into the new object.
  TEST_CODE(old_array.ptr(), grow_new_array.ptr(), thread);
  EXPECT(old_array.ptr() == grow_new_array.data());
  EXPECT(!thread->StoreBufferContains(grow_new_array.ptr()));
}

Assign1337Index1()

DART_EXPORT int64_t * dart::Assign1337Index1

(

int64_t *

a

)

Definition at line 538 of file ffi_test_functions.cc.

                                                  {
  std::cout << "Assign1337Index1(" << a << ")\n";
  std::cout << "val[0] = " << a[0] << "\n";
  std::cout << "val[1] = " << a[1] << "\n";
  a[1] = 1337;
  std::cout << "val[1] = " << a[1] << "\n";
  int64_t* retval = a + 1;
  std::cout << "returning " << retval << "\n";
  return retval;
}

AsSmiShiftLeftInstruction()

static BinarySmiOpInstr * dart::AsSmiShiftLeftInstruction ( Definition *  d )

static

Definition at line 2915 of file flow_graph.cc.

                                                                  {
  BinarySmiOpInstr* instr = d->AsBinarySmiOp();
  if ((instr != nullptr) && (instr->op_kind() == Token::kSHL)) {
    return instr;
  }
  return nullptr;
}

AsTypedListFinalizerCallback()

void dart::AsTypedListFinalizerCallback

(

void *

peer

)

Definition at line 152 of file ffi.cc.

                                              {
  const auto* data = reinterpret_cast<AsTypedListFinalizerData*>(peer);
  data->callback(data->token);
  free(peer);
}

AvailableAssetsToCString()

static char * dart::AvailableAssetsToCString ( Thread *const  thread )

static

Definition at line 350 of file ffi_dynamic_library.cc.

                                                            {
  Zone* const zone = thread->zone();
 
  const auto& native_assets_map =
      Array::Handle(zone, GetNativeAssetsMap(thread));
  ZoneTextBuffer buffer(zone, 1024);
 
  if (native_assets_map.IsNull()) {
    buffer.Printf("No available native assets.");
  } else {
    bool first = true;
    buffer.Printf("Available native assets: ");
    NativeAssetsMap map(native_assets_map.ptr());
    NativeAssetsMap::Iterator it(&map);
    auto& asset_id = String::Handle(zone);
    while (it.MoveNext()) {
      if (!first) {
        buffer.Printf(" ,");
      }
      auto entry = it.Current();
      asset_id ^= map.GetKey(entry);
      buffer.Printf("%s", asset_id.ToCString());
    }
    buffer.Printf(".");
    map.Release();
  }
  return buffer.buffer();
}

BackRefMatchesNoCase()

template<typename Char >

static bool dart::BackRefMatchesNoCase ( Canonicalize *  interp_canonicalize, intptr_t  from, intptr_t  current, intptr_t  len, const String &  subject, bool  unicode  )

static

BackRefMatchesNoCase< uint16_t >()

template<>

bool dart::BackRefMatchesNoCase< uint16_t >	(	Canonicalize *	interp_canonicalize,
		intptr_t	from,
		intptr_t	current,
		intptr_t	len,
		const String &	subject,
		bool	unicode
	)

Definition at line 39 of file regexp_interpreter.cc.

                                                  {
  Bool& ret = Bool::Handle();
  if (unicode) {
    ret = static_cast<BoolPtr>(CaseInsensitiveCompareUTF16(
        static_cast<uword>(subject.ptr()), static_cast<uword>(Smi::New(from)),
        static_cast<uword>(Smi::New(current)),
        static_cast<uword>(Smi::New(len))));
  } else {
    ret = static_cast<BoolPtr>(CaseInsensitiveCompareUCS2(
        static_cast<uword>(subject.ptr()), static_cast<uword>(Smi::New(from)),
        static_cast<uword>(Smi::New(current)),
        static_cast<uword>(Smi::New(len))));
  }
  return ret.value();
}

BackRefMatchesNoCase< uint8_t >()

template<>

bool dart::BackRefMatchesNoCase< uint8_t >	(	Canonicalize *	interp_canonicalize,
		intptr_t	from,
		intptr_t	current,
		intptr_t	len,
		const String &	subject,
		bool	unicode
	)

Definition at line 61 of file regexp_interpreter.cc.

                                                 {
  // For Latin1 characters the unicode flag makes no difference.
  for (int i = 0; i < len; i++) {
    unsigned int old_char = subject.CharAt(from++);
    unsigned int new_char = subject.CharAt(current++);
    if (old_char == new_char) continue;
    // Convert both characters to lower case.
    old_char |= 0x20;
    new_char |= 0x20;
    if (old_char != new_char) return false;
    // Not letters in the ASCII range and Latin-1 range.
    if (!(old_char - 'a' <= 'z' - 'a') &&
        !(old_char - 224 <= 254 - 224 && old_char != 247)) {
      return false;
    }
  }
  return true;
}

BENCHMARK() [1/11]

dart::BENCHMARK

(

CorelibCompileAll

)

Definition at line 45 of file benchmark_test.cc.

                             {
  bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
  bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
  bin::Builtin::SetNativeResolver(bin::Builtin::kCLILibrary);
  TransitionNativeToVM transition(thread);
  StackZone zone(thread);
  Timer timer;
  timer.Start();
  const Error& error =
      Error::Handle(Library::CompileAll(/*ignore_error=*/true));
  if (!error.IsNull()) {
    OS::PrintErr("Unexpected error in CorelibCompileAll benchmark:\n%s",
                 error.ToErrorCString());
  }
  timer.Stop();
  int64_t elapsed_time = timer.TotalElapsedTime();
  benchmark->set_score(elapsed_time);
}

BENCHMARK() [2/11]

dart::BENCHMARK

(

CorelibIsolateStartup

)

Definition at line 94 of file benchmark_test.cc.

                                 {
  const int kNumIterations = 1000;
  Timer timer;
  Isolate* isolate = thread->isolate();
  Dart_ExitIsolate();
  for (int i = 0; i < kNumIterations; i++) {
    timer.Start();
    TestCase::CreateTestIsolate();
    timer.Stop();
    Dart_ShutdownIsolate();
  }
  benchmark->set_score(timer.TotalElapsedTime() / kNumIterations);
  Dart_EnterIsolate(reinterpret_cast<Dart_Isolate>(isolate));
}

BENCHMARK() [3/11]

dart::BENCHMARK

(

CreateMirrorSystem

)

Definition at line 389 of file benchmark_test.cc.

                                       {
  const char* kScriptChars =
      "import 'dart:async';\n"
      "import 'dart:core';\n"
      "import 'dart:collection';\n"
      "import 'dart:convert';\n"
      "import 'dart:math';\n"
      "import 'dart:isolate';\n"
      "import 'dart:mirrors';\n"
      "import 'dart:typed_data';\n"
      "import 'dart:io';\n"
      "import 'dart:cli';\n"
      "\n";
 
  // Start an Isolate, load a script and create a full snapshot.
  // Need to load the script into the dart: core library due to

BENCHMARK() [4/11]

dart::BENCHMARK

(

EnterExitIsolate

)

Definition at line 408 of file benchmark_test.cc.

                              {
  const char* kScriptChars =

BENCHMARK() [5/11]

dart::BENCHMARK

(

FrameLookup

)

Definition at line 303 of file benchmark_test.cc.

                       {
  const char* kScriptChars =
      R"(
      class StackFrame {
        @pragma('vm:external-name', 'StackFrame_accessFrame')
        external static int accessFrame();
      }
      class First {
        First() { }
        int method1(int param) {
          if (param == 1) {
            param = method2(200);
          } else {

BENCHMARK() [6/11]

dart::BENCHMARK

(

KernelServiceCompileAll

)

Definition at line 221 of file benchmark_test.cc.

                                   {
  // kernel_service.dill is built with sound null safety.
  bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
  bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
  bin::Builtin::SetNativeResolver(bin::Builtin::kCLILibrary);
  char* dill_path = ComputeKernelServicePath(Benchmark::Executable());
  File* file = File::Open(nullptr, dill_path, File::kRead);
  EXPECT(file != nullptr);
  bin::RefCntReleaseScope<File> rs(file);
  intptr_t kernel_buffer_size = file->Length();
  uint8_t* kernel_buffer =
      reinterpret_cast<uint8_t*>(malloc(kernel_buffer_size));
  bool read_fully = file->ReadFully(kernel_buffer, kernel_buffer_size);
  EXPECT(read_fully);
  Dart_Handle result =
      Dart_LoadScriptFromKernel(kernel_buffer, kernel_buffer_size);
  EXPECT_VALID(result);
  Dart_Handle service_lib = Dart_LookupLibrary(NewString("dart:vmservice_io"));
  ASSERT(!Dart_IsError(service_lib));
  Dart_SetNativeResolver(service_lib, NativeResolver, nullptr);
  result = Dart_FinalizeLoading(false);
  EXPECT_VALID(result);
 
  Timer timer;
  timer.Start();
#if !defined(PRODUCT)
  const bool old_flag = FLAG_background_compilation;
  FLAG_background_compilation = false;
#endif
  result = Dart_CompileAll();
#if !defined(PRODUCT)
  FLAG_background_compilation = old_flag;
#endif
  EXPECT_VALID(result);
  timer.Stop();
  int64_t elapsed_time = timer.TotalElapsedTime();
  benchmark->set_score(elapsed_time);
  free(dill_path);
  free(kernel_buffer);
}

BENCHMARK() [7/11]

dart::BENCHMARK

(

LargeMap

)

Definition at line 496 of file benchmark_test.cc.

                                            {
    StackZone zone(thread);
    std::unique_ptr<Message> message =
        WriteMessage(/* same_group */ false, smi_object, ILLEGAL_PORT,
                     Message::kNormalPriority);
 
    // Read object back from the snapshot.
    ReadMessage(thread, message.get());
  }
  timer.Stop();
  int64_t elapsed_time = timer.TotalElapsedTime();
  benchmark->set_score(elapsed_time);
}
 
BENCHMARK(SimpleMessage) {
  TransitionNativeToVM transition(thread);
  StackZone zone(thread);
  const Array& array_object = Array::Handle(Array::New(2));
  array_object.SetAt(0, Integer::Handle(Smi::New(42)));
  array_object.SetAt(1, Object::Handle());
  const intptr_t kLoopCount = 1000000;
  Timer timer;
  timer.Start();
  for (intptr_t i = 0; i < kLoopCount; i++) {
    StackZone zone(thread);
    std::unique_ptr<Message> message =
        WriteMessage(/* same_group */ false, array_object, ILLEGAL_PORT,
                     Message::kNormalPriority);

BENCHMARK() [8/11]

dart::BENCHMARK

(

SerializeNull

)

Definition at line 431 of file benchmark_test.cc.

                        {\n"
      "  currentMirrorSystem();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Timer timer;
  timer.Start();
  Dart_Handle result = Dart_Invoke(lib, NewString("benchmark"), 0, nullptr);
  EXPECT_VALID(result);
  timer.Stop();
  int64_t elapsed_time = timer.TotalElapsedTime();
  benchmark->set_score(elapsed_time);
}
 
BENCHMARK(EnterExitIsolate) {
  const char* kScriptChars =
      "import 'dart:core';\n"
      "\n";

BENCHMARK() [9/11]

dart::BENCHMARK

(

SerializeSmi

)

Definition at line 452 of file benchmark_test.cc.

  {
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
    Api::CheckAndFinalizePendingClasses(thread);
  }
  Dart_Isolate isolate = Dart_CurrentIsolate();
  Timer timer;
  timer.Start();
  for (intptr_t i = 0; i < kLoopCount; i++) {
    Dart_ExitIsolate();
    Dart_EnterIsolate(isolate);
  }
  timer.Stop();
  int64_t elapsed_time = timer.TotalElapsedTime();
  benchmark->set_score(elapsed_time);
}
 
BENCHMARK(SerializeNull) {
  TransitionNativeToVM transition(thread);

BENCHMARK() [10/11]

dart::BENCHMARK

(

SimpleMessage

)

Definition at line 473 of file benchmark_test.cc.

                                            {
    StackZone zone(thread);
    std::unique_ptr<Message> message =
        WriteMessage(/* same_group */ false, null_object, ILLEGAL_PORT,
                     Message::kNormalPriority);
 
    // Read object back from the snapshot.
    ReadMessage(thread, message.get());
  }
  timer.Stop();
  int64_t elapsed_time = timer.TotalElapsedTime();
  benchmark->set_score(elapsed_time);
}
 
BENCHMARK(SerializeSmi) {
  TransitionNativeToVM transition(thread);
  StackZone zone(thread);
  const Integer& smi_object = Integer::Handle(Smi::New(42));

BENCHMARK() [11/11]

dart::BENCHMARK

(

UseDartApi

)

Definition at line 167 of file benchmark_test.cc.

                      {
  const int kNumIterations = 1000000;
  const char* kScriptChars = R"(
import 'dart:nativewrappers';
 
base class Class extends NativeFieldWrapperClass1 {
  @pragma("vm:external-name", "init")
  external void init();
  @pragma("vm:external-name", "method")
  external int method(int param1, int param2);
}
 
void benchmark(int count) {
  Class c = Class();
  c.init();
  for (int i = 0; i < count; i++) {
    c.method(i,7);
  }
})";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, bm_uda_lookup,
                                             RESOLVED_USER_TEST_URI, false);
  Dart_Handle result = Dart_FinalizeLoading(false);
  EXPECT_VALID(result);
 
  Dart_Handle args[1];
  args[0] = Dart_NewInteger(kNumIterations);
 
  // Warmup first to avoid compilation jitters.
  result = Dart_Invoke(lib, NewString("benchmark"), 1, args);
  EXPECT_VALID(result);
 
  Timer timer;
  timer.Start();
  result = Dart_Invoke(lib, NewString("benchmark"), 1, args);
  EXPECT_VALID(result);
  timer.Stop();
  int64_t elapsed_time = timer.TotalElapsedTime();
  benchmark->set_score(elapsed_time);
}

BENCHMARK_MEMORY()

dart::BENCHMARK_MEMORY

(

InitialRSS

)

Definition at line 527 of file benchmark_test.cc.

BENCHMARK_SIZE() [1/2]

dart::BENCHMARK_SIZE

(

CoreSnapshotSize

)

Definition at line 317 of file benchmark_test.cc.

                               {
          if (param == 200) {
            return First.staticmethod(this, param);
          } else {
            return First.staticmethod(this, 10);
          }
        }
        static int staticmethod(First obj, int param) {
          if (param == 10) {
            return obj.method3(10);
          } else {
            return obj.method3(200);
          }
        }
        int method3(int param) {
          return StackFrame.accessFrame();
        }
      }
      class StackFrameTest {
        static int testMain() {
          First obj = new First();
          return obj.method1(1);
        }
      }
  )";
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, StackFrameNativeResolver);
  Dart_Handle cls = Dart_GetClass(lib, NewString("StackFrameTest"));
  Dart_Handle result = Dart_Invoke(cls, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
  int64_t elapsed_time = 0;

BENCHMARK_SIZE() [2/2]

dart::BENCHMARK_SIZE

(

StandaloneSnapshotSize

)

Definition at line 352 of file benchmark_test.cc.

                                 {
  const char* kScriptChars =
      "import 'dart:async';\n"
      "import 'dart:core';\n"
      "import 'dart:collection';\n"
      "import 'dart:_internal';\n"
      "import 'dart:math';\n"
      "import 'dart:isolate';\n"
      "import 'dart:mirrors';\n"
      "import 'dart:typed_data';\n"
      "\n";
 
  // Start an Isolate, load a script and create a full snapshot.
  // Need to load the script into the dart: core library due to
  // the import of dart:_internal.
  TestCase::LoadCoreTestScript(kScriptChars, nullptr);
 
  TransitionNativeToVM transition(thread);
  StackZone zone(thread);
 
  Api::CheckAndFinalizePendingClasses(thread);
 
  // Write snapshot with object content.
  MallocWriteStream vm_snapshot_data(FullSnapshotWriter::kInitialSize);
  MallocWriteStream isolate_snapshot_data(FullSnapshotWriter::kInitialSize);
  FullSnapshotWriter writer(
      Snapshot::kFullCore, &vm_snapshot_data, &isolate_snapshot_data,
      /*vm_image_writer=*/nullptr, /*iso_image_writer=*/nullptr);
  writer.WriteFullSnapshot();
  const Snapshot* snapshot =
      Snapshot::SetupFromBuffer(isolate_snapshot_data.buffer());
  ASSERT(snapshot->kind() == Snapshot::kFullCore);

beta_callback()

static bool dart::beta_callback ( const char *  name, const char **  option_keys, const char **  option_values, intptr_t  num_options, void *  user_data, const char **  result  )

static

Definition at line 573 of file service_test.cc.

                                               {
  *result = Utils::StrDup("beta");
  return false;
}

BinaryIntegerEvaluateRaw()

static IntegerPtr dart::BinaryIntegerEvaluateRaw ( const Integer &  left, const Integer &  right, Token::Kind  token_kind  )

static

Definition at line 9 of file evaluator.cc.

                                                                 {
  switch (token_kind) {
    case Token::kTRUNCDIV:
      FALL_THROUGH;
    case Token::kMOD:
      // Check right value for zero.
      if (right.AsInt64Value() == 0) {
        break;  // Will throw.
      }
      FALL_THROUGH;
    case Token::kADD:
      FALL_THROUGH;
    case Token::kSUB:
      FALL_THROUGH;
    case Token::kMUL:
      return left.ArithmeticOp(token_kind, right, Heap::kOld);
    case Token::kSHL:
      FALL_THROUGH;
    case Token::kSHR:
      FALL_THROUGH;
    case Token::kUSHR:
      if (right.AsInt64Value() >= 0) {
        return left.ShiftOp(token_kind, right, Heap::kOld);
      }
      break;
    case Token::kBIT_AND:
      FALL_THROUGH;
    case Token::kBIT_OR:
      FALL_THROUGH;
    case Token::kBIT_XOR:
      return left.BitOp(token_kind, right, Heap::kOld);
    case Token::kDIV:
      break;
    default:
      UNREACHABLE();
  }
 
  return Integer::null();
}

BindsToGivenConstant()

static bool dart::BindsToGivenConstant ( Value *  v, intptr_t  expected  )

static

Definition at line 3605 of file il.cc.

                                                              {
  return v->BindsToConstant() && v->BoundConstant().IsSmi() &&
         (Smi::Cast(v->BoundConstant()).Value() == expected);
}

bit_cast()

template<class D , class S >

DART_FORCE_INLINE D dart::bit_cast

(

const S &

source

)

Definition at line 646 of file globals.h.

                                              {
  static_assert(sizeof(D) == sizeof(S),
                "Source and destination must have the same size");
 
  D destination;
  // This use of memcpy is safe: source and destination cannot overlap.
  memcpy(&destination, &source, sizeof(destination));
  return destination;
}

bit_copy()

template<class D , class S >

DART_FORCE_INLINE D dart::bit_copy

(

const S &

source

)

Definition at line 662 of file globals.h.

                                              {
  D destination;
  // This use of memcpy is safe: source and destination cannot overlap.
  memcpy(&destination, reinterpret_cast<const void*>(&source),
         sizeof(destination));
  return destination;
}

BitLengthEvaluateRaw()

static IntegerPtr dart::BitLengthEvaluateRaw ( const Integer &  value, Zone *  zone  )

static

Definition at line 71 of file evaluator.cc.

                                                                         {
  if (value.IsSmi()) {
    return Integer::New(Utils::BitLength(Smi::Cast(value).Value()), Heap::kOld);
  } else if (value.IsMint()) {
    return Integer::New(Utils::BitLength(Mint::Cast(value).value()),
                        Heap::kOld);
  }
  return Integer::null();
}

BitSize()

static int dart::BitSize ( const Range *  range )

static

Definition at line 2342 of file range_analysis.cc.

                                       {
  const int64_t min = Range::ConstantMin(range).ConstantValue();
  const int64_t max = Range::ConstantMax(range).ConstantValue();
  return Utils::Maximum(Utils::BitLength(min), Utils::BitLength(max));
}

BlankMessage()

static std::unique_ptr< Message > dart::BlankMessage ( Dart_Port  dest, Message::Priority  priority  )

static

Definition at line 131 of file message_handler_test.cc.

                                                                       {
  return Message::New(dest, reinterpret_cast<uint8_t*>(malloc(1)), 1, nullptr,
                      priority);
}

BlockOrderForAllocation()

static const GrowableArray< BlockEntryInstr * > & dart::BlockOrderForAllocation ( const FlowGraph &  flow_graph )

static

Definition at line 80 of file linearscan.cc.

                                 {
  // Currently CodegenBlockOrder is not topologically sorted in JIT and can't
  // be used for register allocation.
  return CompilerState::Current().is_aot() ? *flow_graph.CodegenBlockOrder()
                                           : flow_graph.reverse_postorder();
}

bm_uda_lookup()

static Dart_NativeFunction dart::bm_uda_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 152 of file benchmark_test.cc.

                                                                 {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  const char* cstr = nullptr;
  Dart_Handle result = Dart_StringToCString(name, &cstr);
  EXPECT_VALID(result);
  if (strcmp(cstr, "init") == 0) {
    return InitNativeFields;
  } else {
    return UseDartApi;
  }
}

BootstrapFromKernel()

static ErrorPtr dart::BootstrapFromKernel ( Thread *  thread, const uint8_t *  kernel_buffer, intptr_t  kernel_buffer_size  )

static

Definition at line 159 of file bootstrap.cc.

                                                                 {
  Zone* zone = thread->zone();
  const char* error = nullptr;
  std::unique_ptr<kernel::Program> program = kernel::Program::ReadFromBuffer(
      kernel_buffer, kernel_buffer_size, &error);
  if (program == nullptr) {
    const intptr_t kMessageBufferSize = 512;
    char message_buffer[kMessageBufferSize];
    Utils::SNPrint(message_buffer, kMessageBufferSize,
                   "Can't load Kernel binary: %s.", error);
    const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
    return ApiError::New(msg, Heap::kOld);
  }
 
  if (program->is_single_program()) {
    return BootstrapFromKernelSingleProgram(thread, std::move(program));
  }
 
  GrowableArray<intptr_t> subprogram_file_starts;
  {
    kernel::Reader reader(program->binary());
    kernel::KernelLoader::index_programs(&reader, &subprogram_file_starts);
  }
  intptr_t subprogram_count = subprogram_file_starts.length() - 1;
 
  // Create "fake programs" for each sub-program.
  auto& load_result = Error::Handle(zone);
  for (intptr_t i = 0; i < subprogram_count; i++) {
    intptr_t subprogram_start = subprogram_file_starts.At(i);
    intptr_t subprogram_end = subprogram_file_starts.At(i + 1);
    const auto& component = TypedDataBase::Handle(
        program->binary().ViewFromTo(subprogram_start, subprogram_end));
    kernel::Reader reader(component);
    const char* error = nullptr;
    std::unique_ptr<kernel::Program> subprogram =
        kernel::Program::ReadFrom(&reader, &error);
    if (subprogram == nullptr) {
      FATAL("Failed to load kernel file: %s", error);
    }
    ASSERT(subprogram->is_single_program());
    if (i == 0) {
      // The first subprogram must be the main Dart program.
      load_result ^=
          BootstrapFromKernelSingleProgram(thread, std::move(subprogram));
    } else {
      // Restrictions on the subsequent programs: Must contain only
      // contain dummy libraries with VM recognized classes (or classes kept
      // fully intact by tree-shaking).
      // Currently only used for concatenating native assets mappings.
      kernel::KernelLoader loader(subprogram.get(),
                                  /*uri_to_source_table=*/nullptr);
      load_result ^= loader.LoadProgram(false);
    }
    if (load_result.IsError()) return load_result.ptr();
  }
  return Error::null();
}

BootstrapFromKernelSingleProgram()

static ErrorPtr dart::BootstrapFromKernelSingleProgram ( Thread *  thread, std::unique_ptr< kernel::Program >  program  )

static

Definition at line 112 of file bootstrap.cc.

                                          {
  Zone* zone = thread->zone();
  LongJumpScope jump;
  if (setjmp(*jump.Set()) == 0) {
    kernel::KernelLoader loader(program.get(), /*uri_to_source_table=*/nullptr);
 
    auto isolate_group = thread->isolate_group();
 
    if (isolate_group->obfuscate()) {
      loader.ReadObfuscationProhibitions();
    }
 
    // Load the bootstrap libraries in order (see object_store.h).
    Library& library = Library::Handle(zone);
    for (intptr_t i = 0; i < kBootstrapLibraryCount; ++i) {
      ObjectStore::BootstrapLibraryId id = bootstrap_libraries[i].index;
      library = isolate_group->object_store()->bootstrap_library(id);
      loader.LoadLibrary(library);
    }
 
    // Finish bootstrapping, including class finalization.
    Finish(thread);
 
    isolate_group->object_store()->InitKnownObjects();
 
    // The platform binary may contain other libraries (e.g., dart:_builtin or
    // dart:io) that will not be bundled with application.  Load them now.
    const Object& result = Object::Handle(zone, loader.LoadProgram());
    program.reset();
    if (result.IsError()) {
      return Error::Cast(result).ptr();
    }
 
    if (FLAG_precompiled_mode) {
      loader.ReadLoadingUnits();
    }
 
    return Error::null();
  }
 
  // Either class finalization failed or we caught a compile-time error.
  // In both cases sticky error would be set.
  return Thread::Current()->StealStickyError();
}

BoxCidToCString()

static const char * dart::BoxCidToCString ( intptr_t  box_cid )

static

Definition at line 364 of file isolate_reload.cc.

                                                     {
  switch (box_cid) {
    case kDoubleCid:
      return "double";
    case kFloat32x4Cid:
      return "float32x4";
    case kFloat64x2Cid:
      return "float64x2";
    case kIntegerCid:
      return "int64";
  }
  return "?";
}

BuildExpressionEvaluationScope()

static void dart::BuildExpressionEvaluationScope ( Thread *  thread, JSONStream *  js  )

static

Definition at line 2955 of file service.cc.

                                                                           {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  Isolate* isolate = thread->isolate();
  DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
  intptr_t framePos = UIntParameter::Parse(js->LookupParam("frameIndex"));
  if (framePos >= stack->Length()) {
    PrintInvalidParamError(js, "frameIndex");
    return;
  }
 
  Zone* zone = thread->zone();
  const GrowableObjectArray& param_names =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  const GrowableObjectArray& param_values =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  const GrowableObjectArray& type_params_names =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  const GrowableObjectArray& type_params_bounds =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  const GrowableObjectArray& type_params_defaults =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  String& klass_name = String::Handle(zone);
  String& method_name = String::Handle(zone);
  String& library_uri = String::Handle(zone);
  bool isStatic = false;
  String& script_uri = String::Handle(zone);
  TokenPosition token_pos = TokenPosition::kNoSource;
 
  if (BuildScope(thread, js, param_names, param_values)) {
    return;
  }
 
  if (js->HasParam("frameIndex")) {
    // building scope in the context of a given frame
    DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
    intptr_t framePos = UIntParameter::Parse(js->LookupParam("frameIndex"));
    if (framePos >= stack->Length()) {
      PrintInvalidParamError(js, "frameIndex");
      return;
    }
 
    ActivationFrame* frame = stack->FrameAt(framePos);
    script_uri = frame->SourceUrl();
    token_pos = frame->TokenPos();
    frame->BuildParameters(param_names, param_values, type_params_names,
                           type_params_bounds, type_params_defaults);
 
    if (frame->function().is_static()) {
      const Class& cls = Class::Handle(zone, frame->function().Owner());
      if (!cls.IsTopLevel()) {
        klass_name = cls.UserVisibleName();
      }
      library_uri = Library::Handle(zone, cls.library()).url();
      method_name = frame->function().UserVisibleName();
      isStatic = true;
    } else {
      Class& method_cls = Class::Handle(zone, frame->function().Owner());
      method_cls = method_cls.Mixin();
      library_uri = Library::Handle(zone, method_cls.library()).url();
      klass_name = method_cls.UserVisibleName();
      method_name = frame->function().UserVisibleName();
      isStatic = false;
    }
  } else {
    // building scope in the context of a given object
    if (!js->HasParam("targetId")) {
      js->PrintError(kInvalidParams,
                     "Either targetId or frameIndex has to be provided.");
      return;
    }
    const char* target_id = js->LookupParam("targetId");
 
    ObjectIdRing::LookupResult lookup_result;
    Object& obj = Object::Handle(
        zone, LookupHeapObject(thread, target_id, &lookup_result));
    if (obj.ptr() == Object::sentinel().ptr()) {
      PrintInvalidParamError(js, "targetId");
      return;
    }
    if (obj.IsLibrary()) {
      const Library& lib = Library::Cast(obj);
      library_uri = lib.url();
      isStatic = true;
    } else if (obj.IsClass() || ((obj.IsInstance() || obj.IsNull()) &&
                                 !ContainsNonInstance(obj))) {
      Class& cls = Class::Handle(zone);
      if (obj.IsClass()) {
        cls ^= obj.ptr();
        isStatic = true;
      } else {
        Instance& instance = Instance::Handle(zone);
        instance ^= obj.ptr();
        cls = instance.clazz();
        cls = cls.Mixin();
        isStatic = false;
      }
      if (!cls.IsTopLevel() &&
          (IsInternalOnlyClassId(cls.id()) || cls.id() == kTypeArgumentsCid)) {
        js->PrintError(
            kInvalidParams,
            "Expressions can be evaluated only with regular Dart instances");
        return;
      }
 
      if (!cls.IsTopLevel()) {
        klass_name = cls.UserVisibleName();
      }
      library_uri = Library::Handle(zone, cls.library()).url();
    } else {
      js->PrintError(kInvalidParams,
                     "%s: invalid 'targetId' parameter: "
                     "Cannot evaluate against a VM-internal object",
                     js->method());
      return;
    }
  }
 
  JSONObject report(js);
  {
    JSONArray jsonParamNames(&report, "param_names");
 
    String& param_name = String::Handle(zone);
    for (intptr_t i = 0; i < param_names.Length(); i++) {
      param_name ^= param_names.At(i);
      jsonParamNames.AddValue(param_name.ToCString());
    }
  }
  {
    const JSONArray jsonParamTypes(&report, "param_types");
    Object& obj = Object::Handle();
    Instance& instance = Instance::Handle();
    const GrowableObjectArray& param_types =
        GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
    AbstractType& type = AbstractType::Handle();
    for (intptr_t i = 0; i < param_names.Length(); i++) {
      obj = param_values.At(i);
      if (obj.IsNull()) {
        param_types.Add(obj);
      } else if (obj.IsInstance()) {
        instance ^= param_values.At(i);
        type = instance.GetType(Heap::kNew);
        CollectStringifiedType(thread, zone, type, param_types);
      }
    }
    for (intptr_t i = 0; i < param_types.Length(); i++) {
      instance ^= param_types.At(i);
      jsonParamTypes.AddValue(instance.ToCString());
    }
  }
 
  {
    JSONArray jsonTypeParamsNames(&report, "type_params_names");
    String& type_param_name = String::Handle(zone);
    for (intptr_t i = 0; i < type_params_names.Length(); i++) {
      type_param_name ^= type_params_names.At(i);
      jsonTypeParamsNames.AddValue(type_param_name.ToCString());
    }
  }
  {
    const JSONArray jsonParamTypes(&report, "type_params_bounds");
    const GrowableObjectArray& type_params_bounds_strings =
        GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
    AbstractType& type = AbstractType::Handle();
    for (intptr_t i = 0; i < type_params_bounds.Length(); i++) {
      type ^= type_params_bounds.At(i);
      CollectStringifiedType(thread, zone, type, type_params_bounds_strings);
    }
    Instance& instance = Instance::Handle();
    for (intptr_t i = 0; i < type_params_bounds_strings.Length(); i++) {
      instance ^= type_params_bounds_strings.At(i);
      jsonParamTypes.AddValue(instance.ToCString());
    }
  }
  {
    const JSONArray jsonParamTypes(&report, "type_params_defaults");
    const GrowableObjectArray& type_params_defaults_strings =
        GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
    AbstractType& type = AbstractType::Handle();
    for (intptr_t i = 0; i < type_params_defaults.Length(); i++) {
      type ^= type_params_defaults.At(i);
      CollectStringifiedType(thread, zone, type, type_params_defaults_strings);
    }
    Instance& instance = Instance::Handle();
    for (intptr_t i = 0; i < type_params_defaults_strings.Length(); i++) {
      instance ^= type_params_defaults_strings.At(i);
      jsonParamTypes.AddValue(instance.ToCString());
    }
  }
  report.AddProperty("libraryUri", library_uri.ToCString());
  if (!klass_name.IsNull()) {
    report.AddProperty("klass", klass_name.ToCString());
  }
  if (!method_name.IsNull()) {
    report.AddProperty("method", method_name.ToCString());
  }
  report.AddProperty("tokenPos", token_pos);
  if (!script_uri.IsNull()) {
    report.AddProperty("scriptUri", script_uri.ToCString());
  }
  report.AddProperty("isStatic", isStatic);
}

BuildFilesPairs()

static Dart_CObject dart::BuildFilesPairs ( int  source_files_count, Dart_SourceFile  source_files[]  )

static

Definition at line 330 of file kernel_isolate.cc.

                                                                    {
  Dart_CObject files;
  files.type = Dart_CObject_kArray;
  files.value.as_array.length = source_files_count * 2;
  // typedef Dart_CObject* Dart_CObjectPtr;
  Dart_CObject** fileNamePairs = new Dart_CObject*[source_files_count * 2];
  for (int i = 0; i < source_files_count; i++) {
    Dart_CObject* source_uri = new Dart_CObject();
    source_uri->type = Dart_CObject_kString;
    source_uri->value.as_string = const_cast<char*>(source_files[i].uri);
    fileNamePairs[i * 2] = source_uri;
    Dart_CObject* source_code = new Dart_CObject();
 
    if (source_files[i].source != nullptr) {
      source_code->type = Dart_CObject_kTypedData;
      source_code->value.as_typed_data.type = Dart_TypedData_kUint8;
      source_code->value.as_typed_data.length = strlen(source_files[i].source);
      source_code->value.as_typed_data.values =
          reinterpret_cast<const uint8_t*>(source_files[i].source);
    } else {
      source_code->type = Dart_CObject_kNull;
    }
    fileNamePairs[(i * 2) + 1] = source_code;
  }
  files.value.as_array.values = fileNamePairs;
  return files;
}

BuildInstructions()

InstructionsPtr dart::BuildInstructions

(

std::function< void(compiler::Assembler *assembler)>

fun

)

Definition at line 97 of file il_test_helper.cc.

                                                         {
  auto thread = Thread::Current();
  compiler::Assembler assembler(nullptr);
 
  fun(&assembler);
 
  auto& code = Code::Handle();
  auto install_code_fun = [&] {
    code = Code::FinalizeCode(nullptr, &assembler,
                              Code::PoolAttachment::kNotAttachPool,
                              /*optimized=*/false, /*stats=*/nullptr);
  };
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  thread->isolate_group()->RunWithStoppedMutators(install_code_fun,
                                                  /*use_force_growth=*/true);
  return code.instructions();
}

BuildScope()

static bool dart::BuildScope ( Thread *  thread, JSONStream *  js, const GrowableObjectArray &  names, const GrowableObjectArray &  values  )

static

Definition at line 2830 of file service.cc.

                                                          {
  const char* scope = js->LookupParam("scope");
  GrowableArray<const char*> cnames;
  GrowableArray<const char*> cids;
  if (scope != nullptr) {
    if (!ParseScope(scope, &cnames, &cids)) {
      PrintInvalidParamError(js, "scope");
      return true;
    }
    String& name = String::Handle();
    Object& obj = Object::Handle();
    for (intptr_t i = 0; i < cids.length(); i++) {
      ObjectIdRing::LookupResult lookup_result;
      obj = LookupHeapObject(thread, cids[i], &lookup_result);
      if (obj.ptr() == Object::sentinel().ptr()) {
        if (lookup_result == ObjectIdRing::kCollected) {
          PrintSentinel(js, kCollectedSentinel);
        } else if (lookup_result == ObjectIdRing::kExpired) {
          PrintSentinel(js, kExpiredSentinel);
        } else {
          PrintInvalidParamError(js, "targetId");
        }
        return true;
      }
      if ((!obj.IsInstance() && !obj.IsNull()) || ContainsNonInstance(obj)) {
        js->PrintError(kInvalidParams,
                       "%s: invalid scope 'targetId' parameter: "
                       "Cannot evaluate against a VM-internal object",
                       js->method());
        return true;
      }
      name = String::New(cnames[i]);
      names.Add(name);
      values.Add(obj);
    }
  }
  return false;
}

BuildSourceFilesArray()

static intptr_t dart::BuildSourceFilesArray ( Dart_SourceFile **  sourcefiles, const char *  script, const char *  script_url = RESOLVED_USER_TEST_URI  )

static

Definition at line 392 of file unit_test.cc.

                                                     {
  ASSERT(sourcefiles != nullptr);
  ASSERT(script != nullptr);
 
  intptr_t num_test_libs = 0;
  if (test_libs_ != nullptr) {
    num_test_libs = test_libs_->length();
  }
 
  *sourcefiles = new Dart_SourceFile[num_test_libs + 1];
  (*sourcefiles)[0].uri = script_url;
  (*sourcefiles)[0].source = script;
  for (intptr_t i = 0; i < num_test_libs; ++i) {
    (*sourcefiles)[i + 1].uri = test_libs_->At(i).url;
    (*sourcefiles)[i + 1].source = test_libs_->At(i).source;
  }
  return num_test_libs + 1;
}

BuildStackTrace()

static void dart::BuildStackTrace ( StackTraceBuilder *  builder )

static

Definition at line 101 of file exceptions.cc.

                                                        {
  StackFrameIterator frames(ValidationPolicy::kDontValidateFrames,
                            Thread::Current(),
                            StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = frames.NextFrame();
  ASSERT(frame != nullptr);  // We expect to find a dart invocation frame.
  Code& code = Code::Handle();
  for (; frame != nullptr; frame = frames.NextFrame()) {
    if (!frame->IsDartFrame()) {
      continue;
    }
    code = frame->LookupDartCode();
    ASSERT(code.ContainsInstructionAt(frame->pc()));
    const uword pc_offset = frame->pc() - code.PayloadStart();
    builder->AddFrame(code, pc_offset);
  }
}

BuildUri()

static char * dart::BuildUri ( const ParsedUri &  uri )

static

Definition at line 377 of file uri.cc.

                                            {
  Zone* zone = ThreadState::Current()->zone();
  ASSERT(uri.path != nullptr);
 
  const char* fragment = uri.fragment == nullptr ? "" : uri.fragment;
  const char* fragment_separator = uri.fragment == nullptr ? "" : "#";
  const char* query = uri.query == nullptr ? "" : uri.query;
  const char* query_separator = uri.query == nullptr ? "" : "?";
 
  // If there is no scheme for this uri, just build a relative uri of
  // the form: "path[?query][#fragment]".  This occurs when we resolve
  // relative urls inside a "dart:" library.
  if (uri.scheme == nullptr) {
    ASSERT(uri.userinfo == nullptr && uri.host == nullptr &&
           uri.port == nullptr);
    return zone->PrintToString("%s%s%s%s%s", uri.path, query_separator, query,
                               fragment_separator, fragment);
  }
 
  // Uri with no authority: "scheme:path[?query][#fragment]"
  if (uri.host == nullptr) {
    ASSERT(uri.userinfo == nullptr && uri.port == nullptr);
    return zone->PrintToString("%s:%s%s%s%s%s", uri.scheme, uri.path,
                               query_separator, query, fragment_separator,
                               fragment);
  }
 
  const char* user = uri.userinfo == nullptr ? "" : uri.userinfo;
  const char* user_separator = uri.userinfo == nullptr ? "" : "@";
  const char* port = uri.port == nullptr ? "" : uri.port;
  const char* port_separator = uri.port == nullptr ? "" : ":";
 
  // If the path doesn't start with a '/', add one.  We need it to
  // separate the path from the authority.
  const char* path_separator =
      ((uri.path[0] == '\0' || uri.path[0] == '/') ? "" : "/");
 
  // Uri with authority:
  //   "scheme://[userinfo@]host[:port][/]path[?query][#fragment]"
  return zone->PrintToString(
      "%s://%s%s%s%s%s%s%s%s%s%s%s",  // There is *nothing* wrong with this.
      uri.scheme, user, user_separator, uri.host, port_separator, port,
      path_separator, uri.path, query_separator, query, fragment_separator,
      fragment);
}

ByteDataFinalizer()

void dart::ByteDataFinalizer	(	void *	isolate_data,
		void *	peer
	)

Definition at line 2330 of file dart_api_impl_test.cc.

                                                       {
  ASSERT(!byte_data_finalizer_run);
  free(peer);
  byte_data_finalizer_run = true;
}

ByteDataNativeFunction()

static void dart::ByteDataNativeFunction ( Dart_NativeArguments  args )

static

Definition at line 2201 of file dart_api_impl_test.cc.

                                                              {
  Dart_EnterScope();
  Dart_Handle byte_data = Dart_NewTypedData(Dart_TypedData_kByteData, kLength);
  EXPECT_VALID(byte_data);
  EXPECT_EQ(Dart_TypedData_kByteData, Dart_GetTypeOfTypedData(byte_data));
  Dart_SetReturnValue(args, byte_data);
  Dart_ExitScope();
}

ByteDataNativeResolver()

static Dart_NativeFunction dart::ByteDataNativeResolver ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 2210 of file dart_api_impl_test.cc.

                                                                          {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  return &ByteDataNativeFunction;
}

ByteRegisterOf()

ByteRegister dart::ByteRegisterOf ( Register  reg )

inline

Definition at line 50 of file constants_ia32.h.

                                                 {
  // This only works for EAX, ECX, EDX, EBX.
  // Remaining Register values map to high byte of the above registers.
  RELEASE_ASSERT(reg == Register::EAX || reg == Register::ECX ||
                 reg == Register::EDX || reg == Register::EBX);
  return static_cast<ByteRegister>(reg);
}

CacheRange()

static void dart::CacheRange ( Range **  slot, const Range *  range, RangeBoundary::RangeSize  size  )

static

Definition at line 3018 of file range_analysis.cc.

                                                    {
  if (range != nullptr) {
    if (*slot == nullptr) {
      *slot = new Range();
    }
    **slot = *range;
 
    // Eliminate any symbolic dependencies from the range information.
    (*slot)->ClampToConstant(size);
  } else if (*slot != nullptr) {
    **slot = Range();  // Clear cached range information.
  }
}

CalculateTargetUnboxedFieldsBitmap()

static UnboxedFieldBitmap dart::CalculateTargetUnboxedFieldsBitmap ( Serializer *  s, intptr_t  class_id  )

static

Definition at line 952 of file app_snapshot.cc.

                       {
  const auto unboxed_fields_bitmap_host =
      s->isolate_group()->class_table()->GetUnboxedFieldsMapAt(class_id);
 
  UnboxedFieldBitmap unboxed_fields_bitmap;
  if (unboxed_fields_bitmap_host.IsEmpty() ||
      kWordSize == compiler::target::kWordSize) {
    unboxed_fields_bitmap = unboxed_fields_bitmap_host;
  } else {
    ASSERT(kWordSize == 8 && compiler::target::kWordSize == 4);
    // A new bitmap is built if the word sizes in the target and
    // host are different
    unboxed_fields_bitmap.Reset();
    intptr_t target_i = 0, host_i = 0;
 
    while (host_i < UnboxedFieldBitmap::Length()) {
      // Each unboxed field has constant length, therefore the number of
      // words used by it should double when compiling from 64-bit to 32-bit.
      if (unboxed_fields_bitmap_host.Get(host_i++)) {
        unboxed_fields_bitmap.Set(target_i++);
        unboxed_fields_bitmap.Set(target_i++);
      } else {
        // For object pointers, the field is always one word length
        target_i++;
      }
    }
  }
 
  return unboxed_fields_bitmap;
}

CallbackNativeTypePointerParam()

DART_EXPORT void dart::CallbackNativeTypePointerParam

(

void(*)(void *)

f

)

Definition at line 1172 of file ffi_test_functions.cc.

                                                                  {
  void* pointer = malloc(sizeof(int64_t));
  f(pointer);
  free(pointer);
}

CallbackNativeTypePointerReturn()

DART_EXPORT void dart::CallbackNativeTypePointerReturn

(

void *(*)()

f

)

Definition at line 1180 of file ffi_test_functions.cc.

                                                               {
  void* p = f();
  uint8_t* p2 = reinterpret_cast<uint8_t*>(p);
  p2[0] = 42;
}

CallbackWithStruct()

DART_EXPORT void dart::CallbackWithStruct

(

void(*)(Struct8BytesNestedIntCopy)

f

)

Definition at line 882 of file ffi_test_functions.cc.

                                                                          {
  std::cout << "CallbackWithStruct" << "(" << reinterpret_cast<void*>(f)
            << ")\n";
 
  Struct8BytesNestedIntCopy arg;
  arg.a0.a0 = 10;
  arg.a0.a1 = 11;
  arg.a1.a0 = 12;
  arg.a1.a1 = 13;
 
  f(arg);
}

CalleeParameterTypeMightBeMoreSpecific()

static bool dart::CalleeParameterTypeMightBeMoreSpecific ( BitVector *  is_generic_covariant_impl, const FunctionType &  interface_target_signature, const FunctionType &  callee_signature, intptr_t  first_arg_index, intptr_t  arg_index  )

static

Definition at line 786 of file inliner.cc.

                        {
  if (arg_index > first_arg_index && is_generic_covariant_impl != nullptr &&
      is_generic_covariant_impl->Contains(arg_index - first_arg_index)) {
    const intptr_t param_index = arg_index - first_arg_index;
    const intptr_t num_named_params =
        callee_signature.NumOptionalNamedParameters();
    const intptr_t num_params = callee_signature.NumParameters();
    if (num_named_params == 0 &&
        param_index >= interface_target_signature.NumParameters()) {
      // An optional positional parameter which was added in the callee but
      // not present in the interface target.
      return false;
    }
 
    // Check if this argument corresponds to a named parameter. In this case
    // we need to find correct index based on the name.
    intptr_t interface_target_param_index = param_index;
    if (num_named_params > 0 &&
        (num_params - num_named_params) <= param_index) {
      // This is a named parameter.
      const String& name =
          String::Handle(callee_signature.ParameterNameAt(param_index));
      interface_target_param_index = -1;
      for (intptr_t i = interface_target_signature.NumParameters() -
                        interface_target_signature.NumOptionalNamedParameters(),
                    n = interface_target_signature.NumParameters();
           i < n; i++) {
        if (interface_target_signature.ParameterNameAt(i) == name.ptr()) {
          interface_target_param_index = i;
          break;
        }
      }
 
      // This is a named parameter which was added in the callee.
      if (interface_target_param_index == -1) {
        return false;
      }
    }
    const AbstractType& callee_parameter_type =
        AbstractType::Handle(callee_signature.ParameterTypeAt(param_index));
    const AbstractType& interface_target_parameter_type =
        AbstractType::Handle(interface_target_signature.ParameterTypeAt(
            interface_target_param_index));
    if (interface_target_parameter_type.ptr() != callee_parameter_type.ptr()) {
      // This a conservative approximation.
      return true;
    }
  }
  return false;
}

CallFunctionOnNewThreadBlocking()

DART_EXPORT void dart::CallFunctionOnNewThreadBlocking	(	int64_t	response_id,
		void(*)(int64_t, int32_t)	fn
	)

Definition at line 1294 of file ffi_test_functions.cc.

                                                                               {
  std::thread thread(fn, response_id, 123);
  thread.join();
}

CallFunctionOnNewThreadNonBlocking()

DART_EXPORT void dart::CallFunctionOnNewThreadNonBlocking	(	int64_t	response_id,
		void(*)(int64_t, int32_t)	fn
	)

Definition at line 1300 of file ffi_test_functions.cc.

                                                                         {
  std::thread thread(fn, response_id, 123);
  thread.detach();
}

CallFunctionOnSameThread()

DART_EXPORT void dart::CallFunctionOnSameThread	(	int64_t	response_id,
		void(*)(int64_t, int32_t)	fn
	)

Definition at line 1289 of file ffi_test_functions.cc.

                                                                        {
  fn(response_id, 123);
}

Calloc()

DART_EXPORT void * dart::Calloc	(	size_t	count,
		size_t	size
	)

Definition at line 620 of file ffi_test_functions_vmspecific.cc.

                                                    {
  return calloc(count, size);
}

calloc()

void * dart::calloc	(	size_t	n,
		size_t	size
	)

Definition at line 11 of file allocation.cc.

                                    {
  void* result = ::calloc(n, size);
  if (result == nullptr) {
    OUT_OF_MEMORY();
  }
  return result;
}

CallStatic1Arg()

static ObjectPtr dart::CallStatic1Arg ( Zone *  zone, const String &  name, const Instance &  arg0  )

static

Definition at line 296 of file dart_api_impl.cc.

                                                      {
  const intptr_t kNumArgs = 1;
  const Function& function =
      Function::Handle(zone, FindCoreLibPrivateFunction(zone, name));
  const Array& args = Array::Handle(zone, Array::New(kNumArgs));
  args.SetAt(0, arg0);
  return DartEntry::InvokeFunction(function, args);
}

CallStatic2Args()

static ObjectPtr dart::CallStatic2Args ( Zone *  zone, const String &  name, const Instance &  arg0, const Instance &  arg1  )

static

Definition at line 307 of file dart_api_impl.cc.

                                                       {
  const intptr_t kNumArgs = 2;
  const Function& function =
      Function::Handle(zone, FindCoreLibPrivateFunction(zone, name));
  const Array& args = Array::Handle(zone, Array::New(kNumArgs));
  args.SetAt(0, arg0);
  args.SetAt(1, arg1);
  return DartEntry::InvokeFunction(function, args);
}

CallStatic3Args()

static ObjectPtr dart::CallStatic3Args ( Zone *  zone, const String &  name, const Instance &  arg0, const Instance &  arg1, const Instance &  arg2  )

static

Definition at line 320 of file dart_api_impl.cc.

                                                       {
  const intptr_t kNumArgs = 3;
  const Function& function =
      Function::Handle(zone, FindCoreLibPrivateFunction(zone, name));
  const Array& args = Array::Handle(Array::New(kNumArgs));
  args.SetAt(0, arg0);
  args.SetAt(1, arg1);
  args.SetAt(2, arg2);
  return DartEntry::InvokeFunction(function, args);
}

CallTwoIntFunction()

DART_EXPORT int32_t dart::CallTwoIntFunction	(	int32_t(*)(int32_t, int32_t)	fn,
		int32_t	a,
		int32_t	b
	)

Definition at line 1310 of file ffi_test_functions.cc.

                                                  {
  return fn(a, b);
}

CallTwoIntPointerFunction()

DART_EXPORT void * dart::CallTwoIntPointerFunction	(	void *(*)(int32_t, int32_t)	fn,
		int32_t	a,
		int32_t	b
	)

Definition at line 1322 of file ffi_test_functions.cc.

                                                       {
  return fn(a, b);
}

CallTwoIntVoidFunction()

DART_EXPORT void dart::CallTwoIntVoidFunction	(	void(*)(int32_t, int32_t)	fn,
		int32_t	a,
		int32_t	b
	)

Definition at line 1316 of file ffi_test_functions.cc.

                                                   {
  fn(a, b);
}

CallTwoPointerIntFunction()

DART_EXPORT int32_t dart::CallTwoPointerIntFunction	(	int32_t(*)(void *, void *)	fn,
		void *	a,
		void *	b
	)

Definition at line 1328 of file ffi_test_functions.cc.

                                                       {
  return fn(a, b);
}

CanBeMadeExclusive()

static bool dart::CanBeMadeExclusive ( LoopInfo *  loop, InductionVar *  x, Instruction *  branch, bool  is_lower  )

static

Definition at line 137 of file loops.cc.

                                              {
  InductionVar* min = nullptr;
  InductionVar* max = nullptr;
  if (x->CanComputeBounds(loop, branch, &min, &max)) {
    int64_t end = 0;
    if (is_lower) {
      if (InductionVar::IsConstant(min, &end)) {
        return kMinInt64 < end;
      }
    } else if (InductionVar::IsConstant(max, &end)) {
      return end < kMaxInt64;
    } else if (InductionVar::IsInvariant(max) && max->mult() == 1 &&
               Definition::IsArrayLength(max->def())) {
      return max->offset() < 0;  // a.length - C, C > 0
    }
  }
  return false;
}

CanConvertInt64ToDouble() [1/2]

static bool dart::CanConvertInt64ToDouble ( )

static

Definition at line 1940 of file flow_graph.cc.

                                      {
  return FlowGraphCompiler::CanConvertInt64ToDouble();
}

CanConvertInt64ToDouble() [2/2]

static bool dart::CanConvertInt64ToDouble ( )

static

Definition at line 37 of file call_specializer.cc.

                                      {
  return FlowGraphCompiler::CanConvertInt64ToDouble();
}

CanonicalFunction()

const char * dart::CanonicalFunction

(

const char *

func

)

Definition at line 108 of file dart_api_impl.cc.

                                                {
  if (strncmp(func, "dart::", 6) == 0) {
    return func + 6;
  } else {
    return func;
  }
}

CanonicalizeBoundary()

static RangeBoundary dart::CanonicalizeBoundary ( const RangeBoundary &  a, const RangeBoundary &  overflow  )

static

Definition at line 1844 of file range_analysis.cc.

                                                                         {
  if (a.IsConstant()) {
    return a;
  }
 
  int64_t offset = a.offset();
  Definition* symbol = a.symbol();
 
  bool changed;
  do {
    changed = false;
    if (symbol->IsConstraint()) {
      symbol = symbol->AsConstraint()->value()->definition();
      changed = true;
    } else if (symbol->IsBinarySmiOp()) {
      BinarySmiOpInstr* op = symbol->AsBinarySmiOp();
      Definition* left = op->left()->definition();
      Definition* right = op->right()->definition();
      switch (op->op_kind()) {
        case Token::kADD:
          if (right->IsConstant()) {
            int64_t rhs = Smi::Cast(right->AsConstant()->value()).Value();
            if (Utils::WillAddOverflow(offset, rhs)) {
              return overflow;
            }
            offset += rhs;
            symbol = left;
            changed = true;
          } else if (left->IsConstant()) {
            int64_t rhs = Smi::Cast(left->AsConstant()->value()).Value();
            if (Utils::WillAddOverflow(offset, rhs)) {
              return overflow;
            }
            offset += rhs;
            symbol = right;
            changed = true;
          }
          break;
 
        case Token::kSUB:
          if (right->IsConstant()) {
            int64_t rhs = Smi::Cast(right->AsConstant()->value()).Value();
            if (Utils::WillSubOverflow(offset, rhs)) {
              return overflow;
            }
            offset -= rhs;
            symbol = left;
            changed = true;
          }
          break;
 
        default:
          break;
      }
    }
  } while (changed);
 
  if (!RangeBoundary::IsValidOffsetForSymbolicRangeBoundary(offset)) {
    return overflow;
  }
 
  return RangeBoundary::FromDefinition(symbol, offset);
}

CanonicalizeCommutativeDoubleArithmetic()

static Definition * dart::CanonicalizeCommutativeDoubleArithmetic ( Token::Kind  op, Value *  left, Value *  right  )

static

Definition at line 2145 of file il.cc.

                                                                         {
  int64_t left_value;
  if (!Evaluator::ToIntegerConstant(left, &left_value)) {
    return nullptr;
  }
 
  // Can't apply 0.0 * x -> 0.0 equivalence to double operation because
  // 0.0 * NaN is NaN not 0.0.
  // Can't apply 0.0 + x -> x to double because 0.0 + (-0.0) is 0.0 not -0.0.
  switch (op) {
    case Token::kMUL:
      if (left_value == 1) {
        if (right->definition()->representation() != kUnboxedDouble) {
          // Can't yet apply the equivalence because representation selection
          // did not run yet. We need it to guarantee that right value is
          // correctly coerced to double. The second canonicalization pass
          // will apply this equivalence.
          return nullptr;
        } else {
          return right->definition();
        }
      }
      break;
    default:
      break;
  }
 
  return nullptr;
}

CanonicalizeForComparison()

static bool dart::CanonicalizeForComparison ( RangeBoundary *  a, RangeBoundary *  b, BoundaryOp  op, const RangeBoundary &  overflow  )

static

Definition at line 1961 of file range_analysis.cc.

                                                                     {
  if (!a->IsSymbol() || !b->IsSymbol()) {
    return false;
  }
 
  RangeBoundary canonical_a = *a;
  RangeBoundary canonical_b = *b;
 
  do {
    if (DependOnSameSymbol(canonical_a, canonical_b)) {
      *a = canonical_a;
      *b = canonical_b;
      return true;
    }
  } while (op(&canonical_a) || op(&canonical_b));
 
  return false;
}

CanonicalizeMaxBoundary()

static bool dart::CanonicalizeMaxBoundary ( RangeBoundary *  a )

static

Definition at line 1909 of file range_analysis.cc.

                                                      {
  if (!a->IsSymbol()) return false;
 
  Range* range = a->symbol()->range();
  if ((range == nullptr) || !range->max().IsSymbol()) return false;
 
  if (Utils::WillAddOverflow(range->max().offset(), a->offset())) {
    *a = RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64);
    return true;
  }
 
  const int64_t offset = range->max().offset() + a->offset();
 
  if (!RangeBoundary::IsValidOffsetForSymbolicRangeBoundary(offset)) {
    *a = RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64);
    return true;
  }
 
  *a = CanonicalizeBoundary(
      RangeBoundary::FromDefinition(range->max().symbol(), offset),
      RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64));
 
  return true;
}

CanonicalizeMinBoundary()

static bool dart::CanonicalizeMinBoundary ( RangeBoundary *  a )

static

Definition at line 1934 of file range_analysis.cc.

                                                      {
  if (!a->IsSymbol()) return false;
 
  Range* range = a->symbol()->range();
  if ((range == nullptr) || !range->min().IsSymbol()) return false;
 
  if (Utils::WillAddOverflow(range->min().offset(), a->offset())) {
    *a = RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64);
    return true;
  }
 
  const int64_t offset = range->min().offset() + a->offset();
 
  if (!RangeBoundary::IsValidOffsetForSymbolicRangeBoundary(offset)) {
    *a = RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64);
    return true;
  }
 
  *a = CanonicalizeBoundary(
      RangeBoundary::FromDefinition(range->min().symbol(), offset),
      RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64));
 
  return true;
}

CanonicalizeStrictCompare()

static Definition * dart::CanonicalizeStrictCompare ( StrictCompareInstr *  compare, bool *  negated, bool  is_branch  )

static

Definition at line 3553 of file il.cc.

                                                             {
  // Use propagated cid and type information to eliminate number checks.
  // If one of the inputs is not a boxable number (Mint, Double), or
  // is not a subtype of num, no need for number checks.
  if (compare->needs_number_check()) {
    if (!MayBeBoxableNumber(compare->left()->Type()->ToCid()) ||
        !MayBeBoxableNumber(compare->right()->Type()->ToCid())) {
      compare->set_needs_number_check(false);
    } else if (!MayBeNumber(compare->left()->Type()) ||
               !MayBeNumber(compare->right()->Type())) {
      compare->set_needs_number_check(false);
    }
  }
  *negated = false;
  ConstantInstr* constant_defn = nullptr;
  Value* other = nullptr;
 
  if (!compare->IsComparisonWithConstant(&other, &constant_defn)) {
    return compare;
  }
 
  const Object& constant = constant_defn->value();
  const bool can_merge = is_branch || (other->Type()->ToCid() == kBoolCid);
  Definition* other_defn = other->definition();
  Token::Kind kind = compare->kind();
 
  if (!constant.IsBool() || !can_merge) {
    return compare;
  }
 
  const bool constant_value = Bool::Cast(constant).value();
 
  // Handle `e === true` and `e !== false`: these cases don't require
  // negation and allow direct merge.
  if ((kind == Token::kEQ_STRICT) == constant_value) {
    return other_defn;
  }
 
  // We now have `e !== true` or `e === false`: these cases require
  // negation.
  if (auto comp = other_defn->AsComparison()) {
    if (other_defn->HasOnlyUse(other) && !IsFpCompare(comp)) {
      *negated = true;
      return other_defn;
    }
  }
 
  return compare;
}

CanonicalizeStringInterpolate()

static Definition * dart::CanonicalizeStringInterpolate ( StaticCallInstr *  call, FlowGraph *  flow_graph  )

static

Definition at line 5711 of file il.cc.

                                                                        {
  auto arg0 = call->ArgumentValueAt(0)->definition();
  auto create_array = arg0->AsCreateArray();
  if (create_array == nullptr) {
    // Do not try to fold interpolate if array is an OSR argument.
    ASSERT(flow_graph->IsCompiledForOsr());
    ASSERT(arg0->IsPhi() || arg0->IsParameter());
    return call;
  }
  // Check if the string interpolation has only constant inputs.
  Value* num_elements = create_array->num_elements();
  if (!num_elements->BindsToConstant() ||
      !num_elements->BoundConstant().IsSmi()) {
    return call;
  }
  const intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  GrowableHandlePtrArray<const String> pieces(zone, length);
  for (intptr_t i = 0; i < length; i++) {
    pieces.Add(Object::null_string());
  }
 
  for (Value::Iterator it(create_array->input_use_list()); !it.Done();
       it.Advance()) {
    auto current = it.Current()->instruction();
    if (current == call) {
      continue;
    }
    auto store = current->AsStoreIndexed();
    if (store == nullptr || !store->index()->BindsToConstant() ||
        !store->index()->BoundConstant().IsSmi()) {
      return call;
    }
    intptr_t store_index = Smi::Cast(store->index()->BoundConstant()).Value();
    ASSERT(store_index < length);
    const String& piece =
        EvaluateToString(flow_graph->zone(), store->value()->definition());
    if (!piece.IsNull()) {
      pieces.SetAt(store_index, piece);
    } else {
      return call;
    }
  }
 
  const String& concatenated =
      String::ZoneHandle(zone, Symbols::FromConcatAll(thread, pieces));
  return flow_graph->GetConstant(concatenated);
}

CanonicalizeStringInterpolateSingle()

static Definition * dart::CanonicalizeStringInterpolateSingle ( StaticCallInstr *  call, FlowGraph *  flow_graph  )

static

Definition at line 5762 of file il.cc.

                                                                              {
  auto arg0 = call->ArgumentValueAt(0)->definition();
  const auto& result = EvaluateToString(flow_graph->zone(), arg0);
  if (!result.IsNull()) {
    return flow_graph->GetConstant(String::ZoneHandle(
        flow_graph->zone(), Symbols::New(flow_graph->thread(), result)));
  }
  return call;
}

CanonicalizeTAV()

static void dart::CanonicalizeTAV ( TypeArguments *  tav )

static

Definition at line 195 of file type_testing_stubs_test.cc.

                                                {
  *tav = tav->Canonicalize(Thread::Current());
}

CanonicalizeUri()

static const char * dart::CanonicalizeUri ( Thread *  thread, const Library &  library, const String &  uri, char **  error  )

static

Definition at line 921 of file isolate.cc.

                                                 {
  const char* result = nullptr;
  Zone* zone = thread->zone();
  auto isolate_group = thread->isolate_group();
  if (isolate_group->HasTagHandler()) {
    const Object& obj = Object::Handle(
        isolate_group->CallTagHandler(Dart_kCanonicalizeUrl, library, uri));
    if (obj.IsString()) {
      result = String2UTF8(String::Cast(obj));
    } else if (obj.IsError()) {
      Error& error_obj = Error::Handle();
      error_obj ^= obj.ptr();
      *error = zone->PrintToString("Unable to canonicalize uri '%s': %s",
                                   uri.ToCString(), error_obj.ToErrorCString());
    } else {
      *error = zone->PrintToString(
          "Unable to canonicalize uri '%s': "
          "library tag handler returned wrong type",
          uri.ToCString());
    }
  } else {
    *error = zone->PrintToString(
        "Unable to canonicalize uri '%s': no library tag handler found.",
        uri.ToCString());
  }
  return result;
}

CanPotentiallyBeSmi()

static bool dart::CanPotentiallyBeSmi ( const AbstractType &  type, bool  recurse  )

static

Definition at line 946 of file type_propagator.cc.

                                                                        {
  if (type.IsInstantiated()) {
    return CompileType::Smi().IsAssignableTo(type);
  } else if (type.IsTypeParameter()) {
    // For type parameters look at their bounds (if recurse allows us).
    const auto& param = TypeParameter::Cast(type);
    return !recurse || CanPotentiallyBeSmi(AbstractType::Handle(param.bound()),
                                           /*recurse=*/false);
  } else if (type.HasTypeClass()) {
    // If this is an uninstantiated type then it can only potentially be a super
    // type of a Smi if it is either FutureOr<...> or Comparable<...>.
    // In which case we need to look at the type argument to determine whether
    // this location can contain a smi.
    //
    // Note: we are making a simplification here. This approach will yield
    // true for Comparable<T> where T extends int - while in reality Smi is
    // *not* assignable to it (because int implements Comparable<num> and not
    // Comparable<int>).
    if (type.IsFutureOrType() ||
        type.type_class() == CompilerState::Current().ComparableClass().ptr()) {
      const auto& args = TypeArguments::Handle(type.arguments());
      const auto& arg0 = AbstractType::Handle(args.TypeAt(0));
      return !recurse || CanPotentiallyBeSmi(arg0, /*recurse=*/true);
    }
    return false;
  }
  return false;
}

CanRewindFrame()

static bool dart::CanRewindFrame ( intptr_t  frame_index, const char **  error  )

static

Definition at line 3192 of file debugger.cc.

                                                                     {
  // check rewind pc is found
  DebuggerStackTrace* stack = Isolate::Current()->debugger()->StackTrace();
  intptr_t num_frames = stack->Length();
  if (frame_index < 1 || frame_index >= num_frames) {
    if (error != nullptr) {
      *error = Thread::Current()->zone()->PrintToString(
          "Frame must be in bounds [1..%" Pd
          "]: "
          "saw %" Pd "",
          num_frames - 1, frame_index);
    }
    return false;
  }
  ActivationFrame* frame = stack->FrameAt(frame_index);
  if (!frame->IsRewindable()) {
    intptr_t next_index = FindNextRewindFrameIndex(stack, frame_index);
    if (next_index > 0) {
      *error = Thread::Current()->zone()->PrintToString(
          "Cannot rewind to frame %" Pd
          " due to conflicting compiler "
          "optimizations. "
          "Run the vm with --no-prune-dead-locals to disallow these "
          "optimizations. "
          "Next valid rewind frame is %" Pd ".",
          frame_index, next_index);
    } else {
      *error = Thread::Current()->zone()->PrintToString(
          "Cannot rewind to frame %" Pd
          " due to conflicting compiler "
          "optimizations. "
          "Run the vm with --no-prune-dead-locals to disallow these "
          "optimizations.",
          frame_index);
    }
    return false;
  }
  return true;
}

CanShareObject()

static DART_FORCE_INLINE bool dart::CanShareObject ( ObjectPtr  obj, uword  tags  )

static

Definition at line 149 of file object_graph_copy.cc.

                                                      {
  if ((tags & UntaggedObject::CanonicalBit::mask_in_place()) != 0) {
    return true;
  }
  const auto cid = UntaggedObject::ClassIdTag::decode(tags);
  if ((tags & UntaggedObject::ImmutableBit::mask_in_place()) != 0) {
    if (IsUnmodifiableTypedDataViewClassId(cid)) {
      // Unmodifiable typed data views may have mutable backing stores.
      return TypedDataView::RawCast(obj)
          ->untag()
          ->typed_data()
          ->untag()
          ->IsImmutable();
    }
 
    // All other objects that have immutability bit set are deeply immutable.
    return true;
  }
 
  // TODO(https://dartbug.com/55136): Mark Closures as shallowly imutable.
  // And move this into the if above.
  if (cid == kClosureCid) {
    // We can share a closure iff it doesn't close over any state.
    return Closure::RawCast(obj)->untag()->context() == Object::null();
  }
 
  return false;
}

CanShareObjectAcrossIsolates()

bool dart::CanShareObjectAcrossIsolates

(

ObjectPtr

obj

)

Definition at line 178 of file object_graph_copy.cc.

                                                 {
  if (!obj->IsHeapObject()) return true;
  const uword tags = TagsFromUntaggedObject(obj.untag());
  return CanShareObject(obj, tags);
}

CanTypeContainNull()

static bool dart::CanTypeContainNull ( const Type &  type )

static

Definition at line 3088 of file dart_api_impl.cc.

                                                 {
  return (type.nullability() == Nullability::kLegacy) ||
         (type.nullability() == Nullability::kNullable);
}

CanUnboxDouble() [1/2]

static bool dart::CanUnboxDouble ( )

static

Definition at line 1936 of file flow_graph.cc.

                             {
  return FlowGraphCompiler::SupportsUnboxedDoubles();
}

CanUnboxDouble() [2/2]

static bool dart::CanUnboxDouble ( )

static

Definition at line 33 of file call_specializer.cc.

                             {
  return FlowGraphCompiler::SupportsUnboxedDoubles();
}

CanUseCache()

static bool dart::CanUseCache ( uword  flags )

static

Definition at line 56 of file page.cc.

                                     {
  return (flags & (Page::kExecutable | Page::kImage | Page::kLarge |
                   Page::kVMIsolate)) == 0;
}

CaseInsensitiveCompareUCS2()

uword dart::CaseInsensitiveCompareUCS2	(	uword	str_raw,
		uword	lhs_index_raw,
		uword	rhs_index_raw,
		uword	length_raw
	)

Definition at line 25 of file regexp_assembler.cc.

                                                                 {
  const String& str = String::Handle(static_cast<StringPtr>(str_raw));
  const Smi& lhs_index = Smi::Handle(static_cast<SmiPtr>(lhs_index_raw));
  const Smi& rhs_index = Smi::Handle(static_cast<SmiPtr>(rhs_index_raw));
  const Smi& length = Smi::Handle(static_cast<SmiPtr>(length_raw));
 
  // TODO(zerny): Optimize as single instance. V8 has this as an
  // isolate member.
  unibrow::Mapping<unibrow::Ecma262Canonicalize> canonicalize;
 
  for (intptr_t i = 0; i < length.Value(); i++) {
    int32_t c1 = str.CharAt(lhs_index.Value() + i);
    int32_t c2 = str.CharAt(rhs_index.Value() + i);
    if (c1 != c2) {
      int32_t s1[1] = {c1};
      canonicalize.get(c1, '\0', s1);
      if (s1[0] != c2) {
        int32_t s2[1] = {c2};
        canonicalize.get(c2, '\0', s2);
        if (s1[0] != s2[0]) {
          return static_cast<uword>(Bool::False().ptr());
        }
      }
    }
  }
  return static_cast<uword>(Bool::True().ptr());
}

CaseInsensitiveCompareUTF16()

uword dart::CaseInsensitiveCompareUTF16	(	uword	str_raw,
		uword	lhs_index_raw,
		uword	rhs_index_raw,
		uword	length_raw
	)

Definition at line 56 of file regexp_assembler.cc.

                                                                  {
  const String& str = String::Handle(static_cast<StringPtr>(str_raw));
  const Smi& lhs_index = Smi::Handle(static_cast<SmiPtr>(lhs_index_raw));
  const Smi& rhs_index = Smi::Handle(static_cast<SmiPtr>(rhs_index_raw));
  const Smi& length = Smi::Handle(static_cast<SmiPtr>(length_raw));
 
  for (intptr_t i = 0; i < length.Value(); i++) {
    int32_t c1 = str.CharAt(lhs_index.Value() + i);
    int32_t c2 = str.CharAt(rhs_index.Value() + i);
    if (Utf16::IsLeadSurrogate(c1)) {
      // Non-BMP characters do not have case-equivalents in the BMP.
      // Both have to be non-BMP for them to be able to match.
      if (!Utf16::IsLeadSurrogate(c2))
        return static_cast<uword>(Bool::False().ptr());
      if (i + 1 < length.Value()) {
        uint16_t c1t = str.CharAt(lhs_index.Value() + i + 1);
        uint16_t c2t = str.CharAt(rhs_index.Value() + i + 1);
        if (Utf16::IsTrailSurrogate(c1t) && Utf16::IsTrailSurrogate(c2t)) {
          c1 = Utf16::Decode(c1, c1t);
          c2 = Utf16::Decode(c2, c2t);
          i++;
        }
      }
    }
    c1 = u_foldCase(c1, U_FOLD_CASE_DEFAULT);
    c2 = u_foldCase(c2, U_FOLD_CASE_DEFAULT);
    if (c1 != c2) return static_cast<uword>(Bool::False().ptr());
  }
  return static_cast<uword>(Bool::True().ptr());
}

CharacterLimit()

static uint16_t dart::CharacterLimit ( const String &  string, intptr_t  start, intptr_t  end  )

static

Definition at line 104 of file string.cc.

                                             {
  ASSERT(string.IsTwoByteString());
  // Maybe do loop unrolling, and handle two uint16_t in a single uint32_t
  // operation.
  NoSafepointScope no_safepoint;
  uint16_t result = 0;
  for (intptr_t i = start; i < end; i++) {
    result |= TwoByteString::CharAt(string, i);
  }
  return result;
}

CheckConcatAll()

static void dart::CheckConcatAll ( const String *  data[], intptr_t  n  )

static

Definition at line 7293 of file object_test.cc.

            {
  constValue().contains(null);
}
)";
  HashSetNonConstEqualsConst(kScript);
}
 
static void CheckConcatAll(const String* data[], intptr_t n) {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();

CheckDebuggerDisabled()

static bool dart::CheckDebuggerDisabled ( Thread *  thread, JSONStream *  js  )

static

Definition at line 512 of file service.cc.

                                                                  {
#if defined(DART_PRECOMPILED_RUNTIME)
  js->PrintError(kFeatureDisabled, "Debugger is disabled in AOT mode.");
  return true;
#else
  if (thread->isolate()->debugger() == nullptr) {
    js->PrintError(kFeatureDisabled, "Debugger is disabled.");
    return true;
  }
  return false;
#endif
}

CheckEncodeDecodeMessage()

static void dart::CheckEncodeDecodeMessage ( Zone *  zone, Dart_CObject *  root  )

static

Definition at line 108 of file snapshot_test.cc.

                                                                     {
  // Encode and decode the message.
  std::unique_ptr<Message> message =
      WriteApiMessage(zone, root, ILLEGAL_PORT, Message::kNormalPriority);
 
  Dart_CObject* new_root = ReadApiMessage(zone, message.get());
 
  // Check that the two messages are the same.
  CompareDartCObjects(root, new_root);
}

CheckFloat32x4Data()

static void dart::CheckFloat32x4Data ( Dart_Handle  obj )

static

Definition at line 3232 of file dart_api_impl_test.cc.

                                                {
  void* raw_data = nullptr;
  intptr_t len;
  Dart_TypedData_Type type;
  EXPECT_VALID(Dart_TypedDataAcquireData(obj, &type, &raw_data, &len));
  EXPECT_EQ(Dart_TypedData_kFloat32x4, type);
  EXPECT_EQ(len, 10);
  float* float_data = reinterpret_cast<float*>(raw_data);
  for (int i = 0; i < len * 4; i++) {
    EXPECT_EQ(0.0, float_data[i]);
  }
  EXPECT_VALID(Dart_TypedDataReleaseData(obj));
}

CheckInteger()

static bool dart::CheckInteger ( const Integer &  i )

static

Definition at line 24 of file integers.cc.

                                           {
  if (i.IsMint()) {
    const Mint& mint = Mint::Cast(i);
    return !Smi::IsValid(mint.value());
  }
  return true;
}

CheckIsAtLeastMinRequiredMacOSVersion()

char * dart::CheckIsAtLeastMinRequiredMacOSVersion

(

)

CheckIsolate()

static bool dart::CheckIsolate ( Isolate *  isolate )

static

Definition at line 1257 of file profiler.cc.

                                           {
  if ((isolate == nullptr) || (Dart::vm_isolate() == nullptr)) {
    // No isolate.
    return false;
  }
  return isolate != Dart::vm_isolate();
}

CheckMask()

static bool dart::CheckMask ( Definition *  definition, intptr_t *  mask_ptr  )

static

Definition at line 2329 of file call_specializer.cc.

                                                                  {
  if (!definition->IsConstant()) return false;
  ConstantInstr* constant_instruction = definition->AsConstant();
  const Object& constant_mask = constant_instruction->value();
  if (!constant_mask.IsSmi()) return false;
  const intptr_t mask = Smi::Cast(constant_mask).Value();
  if ((mask < 0) || (mask > 255)) {
    return false;  // Not a valid mask.
  }
  *mask_ptr = mask;
  return true;
}

CheckMemory()

static bool dart::CheckMemory ( Expect  expect, const uint8_t *  input, const uint8_t *  output, intptr_t  dest_start, intptr_t  src_start, intptr_t  length, intptr_t  elem_size  )

static

Definition at line 58 of file memory_copy_test.cc.

                                            {
  ASSERT(Utils::IsPowerOfTwo(kMemoryTestLength));
  expect.LessThan<intptr_t>(0, elem_size);
  if (!Utils::IsPowerOfTwo(elem_size)) {
    expect.Fail("Expected %" Pd " to be a power of two", elem_size);
  }
  expect.LessEqual<intptr_t>(0, length);
  expect.LessEqual<intptr_t>(0, dest_start);
  expect.LessEqual<intptr_t>(dest_start + length,
                             kMemoryTestLength / elem_size);
  expect.LessEqual<intptr_t>(0, src_start);
  expect.LessEqual<intptr_t>(src_start + length, kMemoryTestLength / elem_size);
  const bool use_same_buffer = input == output;
  const intptr_t dest_start_in_bytes = dest_start * elem_size;
  const intptr_t dest_end_in_bytes = dest_start_in_bytes + length * elem_size;
  const intptr_t index_diff = dest_start_in_bytes - src_start * elem_size;
  for (intptr_t i = 0; i < kMemoryTestLength; i++) {
    if (!use_same_buffer) {
      const intptr_t expected = ExpectedValue(i);
      const intptr_t got = input[i];
      if (expected != got) {
        expect.Fail("Unexpected change to input buffer at index %" Pd
                    ", expected %" Pd ", got %" Pd "",
                    i, expected, got);
      }
    }
    const intptr_t unchanged =
        use_same_buffer ? ExpectedValue(i) : kUnInitialized;
    const intptr_t got = output[i];
    if (dest_start_in_bytes <= i && i < dest_end_in_bytes) {
      // Copied.
      const intptr_t expected = ExpectedValue(i - index_diff);
      if (expected != got) {
        if (got == unchanged) {
          expect.Fail("No change to output buffer at index %" Pd
                      ", expected %" Pd ", got %" Pd "",
                      i, expected, got);
        } else {
          expect.Fail("Incorrect change to output buffer at index %" Pd
                      ", expected %" Pd ", got %" Pd "",
                      i, expected, got);
        }
      }
    } else {
      // Untouched.
      if (got != unchanged) {
        expect.Fail("Unexpected change to input buffer at index %" Pd
                    ", expected %" Pd ", got %" Pd "",
                    i, unchanged, got);
      }
    }
  }
  return expect.failed();
}

CheckMint()

void dart::CheckMint

(

int64_t

value

)

Definition at line 213 of file snapshot_test.cc.

                              {
  ApiNativeScope scope;
  StackZone zone(Thread::Current());
 
  Mint& mint = Mint::Handle();
  mint ^= Integer::New(value);
  Dart_CObject* mint_cobject =
      SerializeAndDeserializeMint(zone.GetZone(), mint);
// On 64-bit platforms mints always require 64-bits as the smi range
// here covers most of the 64-bit range. On 32-bit platforms the smi
// range covers most of the 32-bit range and values outside that
// range are also represented as mints.
#if defined(ARCH_IS_64_BIT) && !defined(DART_COMPRESSED_POINTERS)
  EXPECT_EQ(Dart_CObject_kInt64, mint_cobject->type);
  EXPECT_EQ(value, mint_cobject->value.as_int64);
#else
  if (kMinInt32 < value && value < kMaxInt32) {
    EXPECT_EQ(Dart_CObject_kInt32, mint_cobject->type);
    EXPECT_EQ(value, mint_cobject->value.as_int32);
  } else {
    EXPECT_EQ(Dart_CObject_kInt64, mint_cobject->type);
    EXPECT_EQ(value, mint_cobject->value.as_int64);
  }
#endif
}

CheckProfilerDisabled()

static bool dart::CheckProfilerDisabled ( Thread *  thread, JSONStream *  js  )

static

Definition at line 525 of file service.cc.

                                                                  {
  if (!FLAG_profiler) {
    js->PrintError(kFeatureDisabled, "Profiler is disabled.");
    return true;
  }
  return false;
}

CheckSlicesOneByte()

static bool dart::CheckSlicesOneByte ( const String &  base, const Array &  matches, const int  len  )

static

Definition at line 121 of file string.cc.

                                              {
  Instance& object = Instance::Handle();
  // Check each slice for one-bytedness.
  for (intptr_t i = 0; i < len; i++) {
    object ^= matches.At(i);
    if (object.IsSmi()) {
      intptr_t slice_start = Smi::Cast(object).Value();
      intptr_t slice_end;
      if (slice_start < 0) {
        intptr_t bits = -slice_start;
        slice_start = bits >> kLengthSize;
        slice_end = slice_start + (bits & kLengthMask);
      } else {
        i++;
        if (i >= len) {
          // Bad format, handled later.
          return false;
        }
        object ^= matches.At(i);
        if (!object.IsSmi()) {
          // Bad format, handled later.
          return false;
        }
        slice_end = Smi::Cast(object).Value();
      }
      uint16_t char_limit = CharacterLimit(base, slice_start, slice_end);
      if (char_limit > 0xff) {
        return false;
      }
    }
  }
  return true;
}

CheckString()

static void dart::CheckString ( Dart_Handle  dart_string, const char *  expected  )

static

Definition at line 812 of file snapshot_test.cc.

                                                                       {
  StackZone zone(Thread::Current());
  String& str = String::Handle();
  str ^= Api::UnwrapHandle(dart_string);
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, str, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(zone.GetZone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kString, root->type);
  EXPECT_STREQ(expected, root->value.as_string);
  CheckEncodeDecodeMessage(zone.GetZone(), root);
}

CheckStringInvalid()

static void dart::CheckStringInvalid ( Dart_Handle  dart_string )

static

Definition at line 828 of file snapshot_test.cc.

                                                        {
  StackZone zone(Thread::Current());
  String& str = String::Handle();
  str ^= Api::UnwrapHandle(dart_string);
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, str, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(zone.GetZone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kUnsupported, root->type);
}

CheckSubtypeRelation()

static void dart::CheckSubtypeRelation ( const Expect &  expect, const AbstractType &  sub, const AbstractType &  super, bool  is_subtype  )

static

Definition at line 7403 of file object_test.cc.

                                                        {
  *type ^= ClassFinalizer::FinalizeType(*type);
  ASSERT(type->IsCanonical());
}
 
static void CheckSubtypeRelation(const Expect& expect,
                                 const AbstractType& sub,

CheckTypedData()

static void dart::CheckTypedData ( Dart_CObject *  object, Dart_TypedData_Type  typed_data_type, int  len  )

static

Definition at line 1686 of file snapshot_test.cc.

                                    {
  EXPECT_EQ(Dart_CObject_kTypedData, object->type);
  EXPECT_EQ(typed_data_type, object->value.as_typed_data.type);
  EXPECT_EQ(len, object->value.as_typed_data.length);
}

CidTestResultsContains()

static bool dart::CidTestResultsContains ( const ZoneGrowableArray< intptr_t > &  results, intptr_t  test_cid  )

static

Definition at line 1362 of file call_specializer.cc.

                                                      {
  for (intptr_t i = 0; i < results.length(); i += 2) {
    if (results[i] == test_cid) return true;
  }
  return false;
}

CleanupIsolateGroup()

static void dart::CleanupIsolateGroup ( void *  callback_data )

static

Definition at line 278 of file run_vm_tests.cc.

                                                     {
  bin::IsolateGroupData* isolate_data =
      reinterpret_cast<bin::IsolateGroupData*>(callback_data);
  delete isolate_data;
}

ClearCpuSamples()

static void dart::ClearCpuSamples ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4504 of file service.cc.

                                                            {
  ProfilerService::ClearSamples();
  PrintSuccess(js);
}

ClearLazyDeopts()

static void dart::ClearLazyDeopts ( Thread *  thread, uword  frame_pointer  )

static

Definition at line 580 of file exceptions.cc.

                                                                 {
  if (thread->pending_deopts().HasPendingDeopts()) {
    // We may be jumping over frames scheduled for lazy deopt. Remove these
    // frames from the pending deopt table, but only after unmarking them so
    // any stack walk that happens before the stack is unwound will still work.
    {
      DartFrameIterator frames(thread,
                               StackFrameIterator::kNoCrossThreadIteration);
      for (StackFrame* frame = frames.NextFrame(); frame != nullptr;
           frame = frames.NextFrame()) {
        if (frame->fp() >= frame_pointer) {
          break;
        }
        if (frame->IsMarkedForLazyDeopt()) {
          frame->UnmarkForLazyDeopt();
        }
      }
    }
 
#if defined(DEBUG)
    ValidateFrames();
#endif
 
    thread->pending_deopts().ClearPendingDeoptsBelow(
        frame_pointer, PendingDeopts::kClearDueToThrow);
 
#if defined(DEBUG)
    ValidateFrames();
#endif
  }
}

ClearParsedUri()

static void dart::ClearParsedUri ( ParsedUri *  parsed_uri )

static

Definition at line 148 of file uri.cc.

                                                  {
  parsed_uri->scheme = nullptr;
  parsed_uri->userinfo = nullptr;
  parsed_uri->host = nullptr;
  parsed_uri->port = nullptr;
  parsed_uri->path = nullptr;
  parsed_uri->query = nullptr;
  parsed_uri->fragment = nullptr;
}

ClearVMTimeline()

static void dart::ClearVMTimeline ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4290 of file service.cc.

                                                            {
  Isolate* isolate = thread->isolate();
  ASSERT(isolate != nullptr);
  StackZone zone(thread);
 
  Timeline::Clear();
 
  PrintSuccess(js);
}

ClobberAndCall()

void dart::ClobberAndCall

(

void(*)()

fn

)

ClosureCallbackThroughHandle()

DART_EXPORT void dart::ClosureCallbackThroughHandle	(	void(*)(Dart_Handle)	callback,
		Dart_Handle	closureHandle
	)

Definition at line 984 of file ffi_test_functions_vmspecific.cc.

                                                                         {
  printf("ClosureCallbackThroughHandle %p %p\n", callback, closureHandle);
  callback(closureHandle);
}

ClosureEqualsHelper()

static bool dart::ClosureEqualsHelper ( Zone *  zone, const Closure &  receiver, const Object &  other  )

static

Definition at line 33 of file function.cc.

                                                     {
  if (receiver.ptr() == other.ptr()) {
    return true;
  }
  if (!other.IsClosure()) {
    return false;
  }
  const auto& other_closure = Closure::Cast(other);
  const auto& func_a = Function::Handle(zone, receiver.function());
  const auto& func_b = Function::Handle(zone, other_closure.function());
  // Check that functions match.
  if (func_a.ptr() != func_b.ptr()) {
    // Non-implicit closures taken from different functions are not equal.
    if (!func_a.IsImplicitClosureFunction() ||
        !func_b.IsImplicitClosureFunction()) {
      return false;
    }
    // If the closure functions are not the same, check the function's name and
    // owner, as multiple function objects could exist for the same function due
    // to hot reload.
    if ((func_a.name() != func_b.name() || func_a.Owner() != func_b.Owner() ||
         func_a.is_static() != func_b.is_static())) {
      return false;
    }
  }
  // Check that the delayed type argument vectors match.
  if (receiver.delayed_type_arguments() !=
      other_closure.delayed_type_arguments()) {
    // Mismatches should only happen when a generic function is involved.
    ASSERT(func_a.IsGeneric() || func_b.IsGeneric());
    const auto& type_args_a =
        TypeArguments::Handle(zone, receiver.delayed_type_arguments());
    const auto& type_args_b =
        TypeArguments::Handle(zone, other_closure.delayed_type_arguments());
    if (type_args_a.IsNull() || type_args_b.IsNull() ||
        (type_args_a.Length() != type_args_b.Length()) ||
        !type_args_a.IsEquivalent(type_args_b, TypeEquality::kSyntactical)) {
      return false;
    }
  }
  if (func_a.IsImplicitClosureFunction()) {
    ASSERT(func_b.IsImplicitClosureFunction());
    if (!func_a.is_static()) {
      ASSERT(!func_b.is_static());
      // Check that the both receiver instances are the same.
      const Instance& receiver_a =
          Instance::Handle(zone, receiver.GetImplicitClosureReceiver());
      const Instance& receiver_b =
          Instance::Handle(zone, other_closure.GetImplicitClosureReceiver());
      return receiver_a.ptr() == receiver_b.ptr();
    }
  } else {
    ASSERT(!func_b.IsImplicitClosureFunction());
    if (func_a.IsGeneric()) {
      // Additional constraints for closures of generic functions:
      // (1) Different instantiations of the same generic closure
      //     with the same type arguments should be equal.
      //     This means that instantiated generic closures are not unique
      //     and equality of instantiated generic closures should not be
      //     based on identity.
      // (2) Instantiations of non-equal generic closures should be non-equal.
      //     This means that equality of non-instantiated generic closures
      //     should not be based on identity too as it won't match equality
      //     after instantiation.
      if ((receiver.GetContext() != other_closure.GetContext()) ||
          (receiver.instantiator_type_arguments() !=
           other_closure.instantiator_type_arguments()) ||
          (receiver.function_type_arguments() !=
           other_closure.function_type_arguments())) {
        return false;
      }
    } else {
      // Closures of non-generic functions are unique.
      return false;
    }
  }
  return true;
}

CollectAllGarbage()

static void dart::CollectAllGarbage ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4559 of file service.cc.

                                                              {
  auto heap = thread->isolate_group()->heap();
  heap->CollectAllGarbage(GCReason::kDebugging);
  PrintSuccess(js);
}

CollectDartFrame()

static ActivationFrame * dart::CollectDartFrame ( uword  pc, StackFrame *  frame, const Code &  code, const Array &  deopt_frame, intptr_t  deopt_frame_offset  )

static

Definition at line 1631 of file debugger.cc.

                                                                      {
  ASSERT(code.ContainsInstructionAt(pc));
  ActivationFrame* activation = new ActivationFrame(
      pc, frame->fp(), frame->sp(), code, deopt_frame, deopt_frame_offset);
  if (FLAG_trace_debugger_stacktrace) {
    const Context& ctx = activation->GetSavedCurrentContext();
    OS::PrintErr("\tUsing saved context: %s\n", ctx.ToCString());
    OS::PrintErr("\tLine number: %" Pd "\n", activation->LineNumber());
  }
  return activation;
}

CollectFinalizedSuperClasses()

static void dart::CollectFinalizedSuperClasses ( const Class &  cls_, GrowableArray< intptr_t > *  finalized_super_classes  )

static

Definition at line 94 of file class_finalizer.cc.

                                                      {
  Class& cls = Class::Handle(cls_.ptr());
  AbstractType& super_type = Type::Handle();
  super_type = cls.super_type();
  if (!super_type.IsNull()) {
    if (super_type.HasTypeClass()) {
      cls = super_type.type_class();
      if (cls.is_finalized()) {
        AddSuperType(super_type, finalized_super_classes);
      }
    }
  }
}

CollectImmediateSuperInterfaces()

static void dart::CollectImmediateSuperInterfaces ( const Class &  cls, GrowableArray< intptr_t > *  cids  )

static

Definition at line 163 of file class_finalizer.cc.

                                                                           {
  const Array& interfaces = Array::Handle(cls.interfaces());
  Class& ifc = Class::Handle();
  AbstractType& type = AbstractType::Handle();
  for (intptr_t i = 0; i < interfaces.Length(); ++i) {
    type ^= interfaces.At(i);
    if (!type.HasTypeClass()) continue;
    ifc = type.type_class();
    for (intptr_t j = 0; j < cids->length(); ++j) {
      if ((*cids)[j] == ifc.id()) {
        // Already added.
        return;
      }
    }
    cids->Add(ifc.id());
  }
}

CollectOnNthAllocation()

DART_EXPORT void dart::CollectOnNthAllocation

(

intptr_t

num_allocations

)

Definition at line 94 of file ffi_test_functions_vmspecific.cc.

                                                                  {
  Dart_ExecuteInternalCommand("gc-on-nth-allocation",
                              reinterpret_cast<void*>(num_allocations));
}

CollectSample()

static void dart::CollectSample ( Isolate *  isolate, bool  exited_dart_code, bool  in_dart_code, Sample *  sample, ProfilerNativeStackWalker *  native_stack_walker, ProfilerDartStackWalker *  dart_stack_walker, uword  pc, uword  fp, uword  sp, ProfilerCounters *  counters  )

static

Definition at line 1169 of file profiler.cc.

                                                      {
  ASSERT(counters != nullptr);
#if defined(DART_HOST_OS_WINDOWS)
  // Use structured exception handling to trap guard page access on Windows.
  __try {
#endif
 
    if (in_dart_code) {
      // We can only trust the stack pointer if we are executing Dart code.
      // See http://dartbug.com/20421 for details.
      CopyStackBuffer(sample, sp);
    }
 
    if (FLAG_profile_vm) {
      // Always walk the native stack collecting both native and Dart frames.
      counters->stack_walker_native.fetch_add(1);
      native_stack_walker->walk();
    } else if (StubCode::HasBeenInitialized() && exited_dart_code) {
      counters->stack_walker_dart_exit.fetch_add(1);
      // We have a valid exit frame info, use the Dart stack walker.
      dart_stack_walker->walk();
    } else if (StubCode::HasBeenInitialized() && in_dart_code) {
      counters->stack_walker_dart.fetch_add(1);
      // We are executing Dart code. We have frame pointers.
      dart_stack_walker->walk();
    } else {
      counters->stack_walker_none.fetch_add(1);
      sample->SetAt(0, pc);
    }
 
#if defined(DART_HOST_OS_WINDOWS)
    // Use structured exception handling to trap guard page access.
  } __except (GuardPageExceptionFilter(GetExceptionInformation())) {  // NOLINT
    // Sample collection triggered a guard page fault:
    // 1) discard entire sample.
    sample->set_ignore_sample(true);
 
    // 2) Reenable guard bit on page that triggered the fault.
    // https://goo.gl/5mCsXW
    DWORD new_protect = PAGE_READWRITE | PAGE_GUARD;
    DWORD old_protect = 0;
    BOOL success =
        VirtualProtect(reinterpret_cast<void*>(fault_address),
                       sizeof(fault_address), new_protect, &old_protect);
    USE(success);
    ASSERT(success);
    ASSERT(old_protect == PAGE_READWRITE);
  }
#endif
}

CollectStringifiedType()

static void dart::CollectStringifiedType ( Thread *  thread, Zone *  zone, const AbstractType &  type, const GrowableObjectArray &  output  )

static

Definition at line 2889 of file service.cc.

                                                                      {
  Instance& instance = Instance::Handle(zone);
  if (type.IsFunctionType()) {
    // The closure class
    // (IsolateGroup::Current()->object_store()->closure_class())
    // is statically typed weird (the call method redirects to itself)
    // and the type is therefore not useful for the CFE. We use null instead.
    output.Add(instance);
    return;
  }
  if (type.IsRecordType()) {
    // _Record class is not useful for the CFE. We use null instead.
    output.Add(instance);
    return;
  }
  if (type.IsDynamicType()) {
    // Dynamic is weird in that it seems to have a class with no name and a
    // library called something like '7189777121420'. We use null instead.
    output.Add(instance);
    return;
  }
  if (type.IsTypeParameter()) {
    // Calling type_class on a type parameter will crash the VM.
    // We use null instead.
    output.Add(instance);
    return;
  }
  ASSERT(type.IsType());
 
  const Class& cls = Class::Handle(type.type_class());
  const Library& lib = Library::Handle(zone, cls.library());
 
  instance ^= lib.url();
  output.Add(instance);
 
  instance ^= cls.ScrubbedName();
  output.Add(instance);
 
  instance ^= Smi::New((intptr_t)type.nullability());
  output.Add(instance);
 
  const TypeArguments& type_arguments =
      TypeArguments::Handle(Type::Cast(type).arguments());
  if (!type_arguments.IsNull()) {
    instance ^= Smi::New(type_arguments.Length());
    output.Add(instance);
    AbstractType& src_type = AbstractType::Handle();
    for (intptr_t i = 0; i < type_arguments.Length(); i++) {
      src_type = type_arguments.TypeAt(i);
      CollectStringifiedType(thread, zone, src_type, output);
    }
  } else {
    const intptr_t num_type_parameters = cls.NumTypeParameters(thread);
    instance ^= Smi::New(num_type_parameters);
    output.Add(instance);
    const AbstractType& dynamic_type =
        AbstractType::Handle(Type::DynamicType());
    for (intptr_t i = 0; i < num_type_parameters; i++) {
      CollectStringifiedType(thread, zone, dynamic_type, output);
    }
  }
}

CollisionHash1()

static uint32_t dart::CollisionHash1 ( uint32_t  key )

static

Definition at line 68 of file hashmap_test.cc.

                                             {
  return key & 0x3;
}

CollisionHash2()

static uint32_t dart::CollisionHash2 ( uint32_t  key )

static

Definition at line 71 of file hashmap_test.cc.

                                             {
  return kInitialSize - 1;
}

CollisionHash3()

static uint32_t dart::CollisionHash3 ( uint32_t  key )

static

Definition at line 74 of file hashmap_test.cc.

                                             {
  return kInitialSize - 2;
}

CollisionHash4()

static uint32_t dart::CollisionHash4 ( uint32_t  key )

static

Definition at line 77 of file hashmap_test.cc.

                                             {
  return kInitialSize - 2;
}

Combine()

ContainedInLattice dart::Combine ( ContainedInLattice  a, ContainedInLattice  b  )

inline

Definition at line 1087 of file regexp.h.

                                                                              {
  return static_cast<ContainedInLattice>(a | b);
}

CombineHashes()

uint32_t dart::CombineHashes ( uint32_t  hash, uint32_t  other_hash  )

inline

Definition at line 12 of file hash.h.

                                                                  {
  // Keep in sync with AssemblerBase::CombineHashes.
  hash += other_hash;
  hash += hash << 10;
  hash ^= hash >> 6;  // Logical shift, unsigned hash.
  return hash;
}

CommentCheckedClasses()

static void dart::CommentCheckedClasses ( compiler::Assembler *  assembler, const CidRangeVector &  ranges  )

static

Definition at line 414 of file type_testing_stubs.cc.

                                                                {
  if (!assembler->EmittingComments()) return;
  Thread* const thread = Thread::Current();
  ClassTable* const class_table = thread->isolate_group()->class_table();
  Zone* const zone = thread->zone();
  if (ranges.is_empty()) {
    __ Comment("No valid cids to check");
    return;
  }
  if ((ranges.length() == 1) && ranges[0].IsSingleCid()) {
    const auto& cls = Class::Handle(zone, class_table->At(ranges[0].cid_start));
    __ Comment("Checking for cid %" Pd " (%s)", cls.id(),
               cls.ScrubbedNameCString());
    return;
  }
  __ Comment("Checking for concrete finalized classes:");
  auto& cls = Class::Handle(zone);
  for (const auto& range : ranges) {
    ASSERT(!range.IsIllegalRange());
    for (classid_t cid = range.cid_start; cid <= range.cid_end; cid++) {
      // Invalid entries can be included to keep range count low.
      if (!class_table->HasValidClassAt(cid)) continue;
      cls = class_table->At(cid);
      if (cls.is_abstract()) continue;  // Only output concrete classes.
      __ Comment(" * %" Pd32 " (%s)", cid, cls.ScrubbedNameCString());
    }
  }
}

CommentSkippedClasses()

static void dart::CommentSkippedClasses ( compiler::Assembler *  assembler, const Type &  type, const Class &  type_class, const CidRangeVector &  ranges  )

static

Definition at line 535 of file type_testing_stubs.cc.

                                                                {
  if (!assembler->EmittingComments() || ranges.is_empty()) return;
  if (ranges.is_empty()) return;
  ASSERT(type_class.is_implemented());
  __ Comment("Not checking the following concrete implementors of %s:",
             type_class.ScrubbedNameCString());
  Thread* const thread = Thread::Current();
  auto* const class_table = thread->isolate_group()->class_table();
  Zone* const zone = thread->zone();
  auto& cls = Class::Handle(zone);
  auto& calculated_type = Type::Handle(zone);
  for (const auto& range : ranges) {
    ASSERT(!range.IsIllegalRange());
    for (classid_t cid = range.cid_start; cid <= range.cid_end; cid++) {
      // Invalid entries can be included to keep range count low.
      if (!class_table->HasValidClassAt(cid)) continue;
      cls = class_table->At(cid);
      if (cls.is_abstract()) continue;  // Only output concrete classes.
      ASSERT(cls.is_type_finalized());
      TextBuffer buffer(128);
      buffer.Printf(" * %" Pd32 "(%s): ", cid, cls.ScrubbedNameCString());
      switch (SubtypeChecksForClass(zone, type, type_class, cls)) {
        case CheckType::kCannotBeChecked:
          calculated_type = cls.GetInstantiationOf(zone, type_class);
          buffer.AddString("cannot check that ");
          calculated_type.PrintName(Object::kScrubbedName, &buffer);
          buffer.AddString(" is a subtype of ");
          type.PrintName(Object::kScrubbedName, &buffer);
          break;
        case CheckType::kNotSubtype:
          calculated_type = cls.GetInstantiationOf(zone, type_class);
          calculated_type.PrintName(Object::kScrubbedName, &buffer);
          buffer.AddString(" is not a subtype of ");
          type.PrintName(Object::kScrubbedName, &buffer);
          break;
        case CheckType::kNeedsFinalization:
          buffer.AddString("is not finalized");
          break;
        case CheckType::kInstanceTypeArgumentsAreSubtypes:
          buffer.AddString("was not finalized during class splitting");
          break;
        default:
          // Either the CheckType was kCidCheckOnly, which should never happen
          // since it only requires type finalization, or a new CheckType has
          // been added.
          UNREACHABLE();
          break;
      }
      __ Comment("%s", buffer.buffer());
    }
  }
}

CommonSuffixLength()

static intptr_t dart::CommonSuffixLength ( const char *  a, const char *  b  )

static

Definition at line 623 of file isolate_reload.cc.

                                                                 {
  const intptr_t a_length = strlen(a);
  const intptr_t b_length = strlen(b);
  intptr_t a_cursor = a_length;
  intptr_t b_cursor = b_length;
 
  while ((a_cursor >= 0) && (b_cursor >= 0)) {
    if (a[a_cursor] != b[b_cursor]) {
      break;
    }
    a_cursor--;
    b_cursor--;
  }
 
  ASSERT((a_length - a_cursor) == (b_length - b_cursor));
  return (a_length - a_cursor);
}

CompareClusters()

static int dart::CompareClusters ( SerializationCluster *const *  a, SerializationCluster *const *  b  )

static

Definition at line 8506 of file app_snapshot.cc.

                                                           {
  if ((*a)->size() > (*b)->size()) {
    return -1;
  } else if ((*a)->size() < (*b)->size()) {
    return 1;
  } else {
    return 0;
  }
}

CompareDartCObjects()

static void dart::CompareDartCObjects ( Dart_CObject *  first, Dart_CObject *  second  )

static

Definition at line 58 of file snapshot_test.cc.

                                                                           {
  // Return immediately if entering a cycle.
  if (second->type == Dart_CObject_kNumberOfTypes) return;
 
  EXPECT_EQ(first->type, second->type);
  switch (first->type) {
    case Dart_CObject_kNull:
      // Nothing more to compare.
      break;
    case Dart_CObject_kBool:
      EXPECT_EQ(first->value.as_bool, second->value.as_bool);
      break;
    case Dart_CObject_kInt32:
      EXPECT_EQ(first->value.as_int32, second->value.as_int32);
      break;
    case Dart_CObject_kInt64:
      EXPECT_EQ(first->value.as_int64, second->value.as_int64);
      break;
    case Dart_CObject_kDouble:
      EXPECT_EQ(first->value.as_double, second->value.as_double);
      break;
    case Dart_CObject_kString:
      EXPECT_STREQ(first->value.as_string, second->value.as_string);
      break;
    case Dart_CObject_kTypedData:
      EXPECT_EQ(first->value.as_typed_data.length,
                second->value.as_typed_data.length);
      for (int i = 0; i < first->value.as_typed_data.length; i++) {
        EXPECT_EQ(first->value.as_typed_data.values[i],
                  second->value.as_typed_data.values[i]);
      }
      break;
    case Dart_CObject_kArray:
      // Use invalid type as a visited marker to avoid infinite
      // recursion on graphs with cycles.
      second->type = Dart_CObject_kNumberOfTypes;
      EXPECT_EQ(first->value.as_array.length, second->value.as_array.length);
      for (int i = 0; i < first->value.as_array.length; i++) {
        CompareDartCObjects(first->value.as_array.values[i],
                            second->value.as_array.values[i]);
      }
      break;
    case Dart_CObject_kCapability:
      EXPECT_EQ(first->value.as_capability.id, second->value.as_capability.id);
      break;
    default:
      EXPECT(false);
  }
}

CompareIntegers()

static bool dart::CompareIntegers ( Token::Kind  kind, const Integer &  left, const Integer &  right  )

static

Definition at line 648 of file constant_propagator.cc.

                                                  {
  const int result = left.CompareWith(right);
  switch (kind) {
    case Token::kEQ:
      return (result == 0);
    case Token::kNE:
      return (result != 0);
    case Token::kLT:
      return (result < 0);
    case Token::kGT:
      return (result > 0);
    case Token::kLTE:
      return (result <= 0);
    case Token::kGTE:
      return (result >= 0);
    default:
      UNREACHABLE();
      return false;
  }
}

CompareInverseRanges()

static bool dart::CompareInverseRanges ( ZoneGrowableArray< CharacterRange > *  ranges, const int32_t *  special_class, intptr_t  length  )

static

Definition at line 3813 of file regexp.cc.

                                                  {
  length--;  // Remove final kRangeEndMarker.
  ASSERT(special_class[length] == kRangeEndMarker);
  ASSERT(ranges->length() != 0);
  ASSERT(length != 0);
  ASSERT(special_class[0] != 0);
  if (ranges->length() != (length >> 1) + 1) {
    return false;
  }
  CharacterRange range = ranges->At(0);
  if (range.from() != 0) {
    return false;
  }
  for (intptr_t i = 0; i < length; i += 2) {
    if (special_class[i] != (range.to() + 1)) {
      return false;
    }
    range = ranges->At((i >> 1) + 1);
    if (special_class[i + 1] != range.from()) {
      return false;
    }
  }
  if (range.to() != Utf::kMaxCodePoint) {
    return false;
  }
  return true;
}

CompareRanges()

static bool dart::CompareRanges ( ZoneGrowableArray< CharacterRange > *  ranges, const int32_t *  special_class, intptr_t  length  )

static

Definition at line 3843 of file regexp.cc.

                                           {
  length--;  // Remove final kRangeEndMarker.
  ASSERT(special_class[length] == kRangeEndMarker);
  if (ranges->length() * 2 != length) {
    return false;
  }
  for (intptr_t i = 0; i < length; i += 2) {
    CharacterRange range = ranges->At(i >> 1);
    if (range.from() != special_class[i] ||
        range.to() != special_class[i + 1] - 1) {
      return false;
    }
  }
  return true;
}

COMPILE_ASSERT() [1/36]

dart::COMPILE_ASSERT

(

BoyerMoorePositionInfo::kMapSize

= =RegExpMacroAssembler::kTableSize

)

COMPILE_ASSERT() [2/36]

dart::COMPILE_ASSERT

(

kAbiPreservedCpuRegCount

= =7

)

COMPILE_ASSERT() [3/36]

dart::COMPILE_ASSERT

(

kAbiPreservedFpuRegCount

= =4

)

COMPILE_ASSERT() [4/36]

dart::COMPILE_ASSERT

(

kByteBufferCid+

1 = =kNullCid

)

COMPILE_ASSERT() [5/36]

dart::COMPILE_ASSERT

(

kFfiStructCid+

1 = =kFirstTypedDataCid

)

COMPILE_ASSERT() [6/36]

dart::COMPILE_ASSERT

(

kFirstErrorCid

= =kErrorCid &&kApiErrorCid==kFirstErrorCid+1 &&kLanguageErrorCid==kFirstErrorCid+2 &&kUnhandledExceptionCid==kFirstErrorCid+3 &&kUnwindErrorCid==kFirstErrorCid+4 &&kLastErrorCid==kUnwindErrorCid &&kLastInternalOnlyCid==kLastErrorCid

)

COMPILE_ASSERT() [7/36]

dart::COMPILE_ASSERT

(

kFirstInternalOnlyCid

= =kObjectCid+1

)

COMPILE_ASSERT() [8/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+1 *

kNumTypedDataCidRemainders = =kTypedDataUint8ArrayCid

)

COMPILE_ASSERT() [9/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+10 *

kNumTypedDataCidRemainders = =kTypedDataFloat64ArrayCid

)

COMPILE_ASSERT() [10/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+11 *

kNumTypedDataCidRemainders = =kTypedDataFloat32x4ArrayCid

)

COMPILE_ASSERT() [11/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+12 *

kNumTypedDataCidRemainders = =kTypedDataInt32x4ArrayCid

)

COMPILE_ASSERT() [12/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+13 *kNumTypedDataCidRemainders+

kTypedDataCidRemainderUnmodifiable = =kLastTypedDataCid

)

COMPILE_ASSERT() [13/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+13 *

kNumTypedDataCidRemainders = =kTypedDataFloat64x2ArrayCid

)

COMPILE_ASSERT() [14/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+2 *

kNumTypedDataCidRemainders = =kTypedDataUint8ClampedArrayCid

)

COMPILE_ASSERT() [15/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+3 *

kNumTypedDataCidRemainders = =kTypedDataInt16ArrayCid

)

COMPILE_ASSERT() [16/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+4 *

kNumTypedDataCidRemainders = =kTypedDataUint16ArrayCid

)

COMPILE_ASSERT() [17/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+5 *

kNumTypedDataCidRemainders = =kTypedDataInt32ArrayCid

)

COMPILE_ASSERT() [18/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+6 *

kNumTypedDataCidRemainders = =kTypedDataUint32ArrayCid

)

COMPILE_ASSERT() [19/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+7 *

kNumTypedDataCidRemainders = =kTypedDataInt64ArrayCid

)

COMPILE_ASSERT() [20/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+8 *

kNumTypedDataCidRemainders = =kTypedDataUint64ArrayCid

)

COMPILE_ASSERT() [21/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid+9 *

kNumTypedDataCidRemainders = =kTypedDataFloat32ArrayCid

)

COMPILE_ASSERT() [22/36]

dart::COMPILE_ASSERT

(

kFirstTypedDataCid

= =kTypedDataInt8ArrayCid

)

COMPILE_ASSERT() [23/36]

dart::COMPILE_ASSERT

(

kInstanceCid

= =kLastInternalOnlyCid+1

)

COMPILE_ASSERT() [24/36]

dart::COMPILE_ASSERT

(

kLastTypedDataCid+

1 = =kByteDataViewCid

)

COMPILE_ASSERT() [25/36]

dart::COMPILE_ASSERT

(

kObjectStartAlignment >=2 *

kBoolValueMask

)

COMPILE_ASSERT() [26/36]

dart::COMPILE_ASSERT

(

kObjectStartAlignment >=

kObjectAlignment

)

COMPILE_ASSERT() [27/36]

dart::COMPILE_ASSERT

(

kOneByteStringCid

= =kStringCid+1 &&kTwoByteStringCid==kStringCid+2

)

COMPILE_ASSERT() [28/36]

dart::COMPILE_ASSERT

(

kTypedDataCidRemainderInternal

= =0

)

COMPILE_ASSERT() [29/36]

dart::COMPILE_ASSERT

(

kTypedDataInt8ArrayCid+

kTypedDataCidRemainderView = =kTypedDataInt8ArrayViewCid

)

COMPILE_ASSERT() [30/36]

dart::COMPILE_ASSERT

(

kUnreachableReference

= =WeakTable::kNoValue

)

COMPILE_ASSERT() [31/36]

dart::COMPILE_ASSERT

(

sizeof(UntaggedDouble)

= =16

)

COMPILE_ASSERT() [32/36]

dart::COMPILE_ASSERT

(

sizeof(UntaggedFloat32x4)

= =24

)

COMPILE_ASSERT() [33/36]

dart::COMPILE_ASSERT

(

sizeof(UntaggedFloat64x2)

= =24

)

COMPILE_ASSERT() [34/36]

dart::COMPILE_ASSERT

(

sizeof(UntaggedInt32x4)

= =24

)

COMPILE_ASSERT() [35/36]

dart::COMPILE_ASSERT

(

sizeof(UntaggedMint)

= =16

)

COMPILE_ASSERT() [36/36]

dart::COMPILE_ASSERT

(

static_cast< uword >

kForwarded = =static_cast< uword >(kHeapObjectTag)

)

CompileExpression()

static void dart::CompileExpression ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3216 of file service.cc.

                                                              {
#if defined(DART_PRECOMPILED_RUNTIME)
  js->PrintError(kFeatureDisabled, "Debugger is disabled in AOT mode.");
#else
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  if (!KernelIsolate::IsRunning() && !KernelIsolate::Start()) {
    js->PrintError(
        kExpressionCompilationError,
        "%s: No compilation service available; cannot evaluate from source.",
        js->method());
    return;
  }
 
  const char* klass = js->LookupParam("klass");
  bool is_static =
      BoolParameter::Parse(js->LookupParam("isStatic"), (klass == nullptr));
  int64_t token_pos = Int64Parameter::Parse(js->LookupParam("tokenPos"));
 
  const GrowableObjectArray& params =
      GrowableObjectArray::Handle(thread->zone(), GrowableObjectArray::New());
  if (!ParseCSVList(js->LookupParam("definitions"), params)) {
    PrintInvalidParamError(js, "definitions");
    return;
  }
  const GrowableObjectArray& param_types =
      GrowableObjectArray::Handle(thread->zone(), GrowableObjectArray::New());
  if (!ParseCSVList(js->LookupParam("definitionTypes"), param_types)) {
    PrintInvalidParamError(js, "definitionTypes");
    return;
  }
 
  const GrowableObjectArray& type_params =
      GrowableObjectArray::Handle(thread->zone(), GrowableObjectArray::New());
  if (!ParseCSVList(js->LookupParam("typeDefinitions"), type_params)) {
    PrintInvalidParamError(js, "typedDefinitions");
    return;
  }
  const GrowableObjectArray& type_bounds =
      GrowableObjectArray::Handle(thread->zone(), GrowableObjectArray::New());
  if (!ParseCSVList(js->LookupParam("typeBounds"), type_bounds)) {
    PrintInvalidParamError(js, "typeBounds");
    return;
  }
  const GrowableObjectArray& type_defaults =
      GrowableObjectArray::Handle(thread->zone(), GrowableObjectArray::New());
  if (!ParseCSVList(js->LookupParam("typeDefaults"), type_defaults)) {
    PrintInvalidParamError(js, "typeDefaults");
    return;
  }
 
  const uint8_t* kernel_buffer = Service::dart_library_kernel();
  const intptr_t kernel_buffer_len = Service::dart_library_kernel_length();
 
  Dart_KernelCompilationResult compilation_result =
      KernelIsolate::CompileExpressionToKernel(
          kernel_buffer, kernel_buffer_len, js->LookupParam("expression"),
          Array::Handle(Array::MakeFixedLength(params)),
          Array::Handle(Array::MakeFixedLength(param_types)),
          Array::Handle(Array::MakeFixedLength(type_params)),
          Array::Handle(Array::MakeFixedLength(type_bounds)),
          Array::Handle(Array::MakeFixedLength(type_defaults)),
          js->LookupParam("libraryUri"), js->LookupParam("klass"),
          js->LookupParam("method"), TokenPosition::Deserialize(token_pos),
          js->LookupParam("scriptUri"), is_static);
 
  if (compilation_result.status != Dart_KernelCompilationStatus_Ok) {
    js->PrintError(kExpressionCompilationError, "%s", compilation_result.error);
    free(compilation_result.error);
    return;
  }
 
  const uint8_t* kernel_bytes = compilation_result.kernel;
  intptr_t kernel_length = compilation_result.kernel_size;
  ASSERT(kernel_bytes != nullptr);
 
  JSONObject report(js);
  report.AddPropertyBase64("kernelBytes", kernel_bytes, kernel_length);
#endif
}

CompileFunctionHelper()

static ObjectPtr dart::CompileFunctionHelper ( CompilationPipeline *  pipeline, const Function &  function, volatile bool  optimized, intptr_t  osr_id  )

static

Definition at line 683 of file compiler.cc.

                                                        {
  Thread* const thread = Thread::Current();
  NoActiveIsolateScope no_active_isolate(thread);
 
  ASSERT(!FLAG_precompiled_mode);
  ASSERT(!optimized || function.WasCompiled() || function.ForceOptimize());
  if (function.ForceOptimize()) optimized = true;
  LongJumpScope jump;
  if (setjmp(*jump.Set()) == 0) {
    StackZone stack_zone(thread);
    Zone* const zone = stack_zone.GetZone();
    const bool trace_compiler =
        FLAG_trace_compiler || (FLAG_trace_optimizing_compiler && optimized);
    Timer per_compile_timer;
    per_compile_timer.Start();
 
    ParsedFunction* parsed_function = new (zone)
        ParsedFunction(thread, Function::ZoneHandle(zone, function.ptr()));
    if (trace_compiler) {
      const intptr_t token_size = function.SourceSize();
      THR_Print("Compiling %s%sfunction %s: '%s' @ token %s, size %" Pd "\n",
                (osr_id == Compiler::kNoOSRDeoptId ? "" : "osr "),
                (optimized ? "optimized " : ""),
                (Compiler::IsBackgroundCompilation() ? "(background)" : ""),
                function.ToFullyQualifiedCString(),
                function.token_pos().ToCString(), token_size);
    }
    // Makes sure no classes are loaded during parsing in background.
    {
      HANDLESCOPE(thread);
      pipeline->ParseFunction(parsed_function);
    }
 
    CompileParsedFunctionHelper helper(parsed_function, optimized, osr_id);
 
    const Code& result = Code::Handle(helper.Compile(pipeline));
 
    if (result.IsNull()) {
      const Error& error = Error::Handle(thread->StealStickyError());
 
      if (Compiler::IsBackgroundCompilation()) {
        // Try again later, background compilation may abort because of
        // state change during compilation.
        if (FLAG_trace_compiler) {
          THR_Print("Aborted background compilation: %s\n",
                    function.ToFullyQualifiedCString());
        }
 
        // We got an error during compilation.
        // If it was a bailout, then disable optimization.
        if (error.ptr() == Object::background_compilation_error().ptr()) {
          if (FLAG_trace_compiler) {
            THR_Print(
                "--> discarding background compilation for '%s' (will "
                "try to re-compile again later)\n",
                function.ToFullyQualifiedCString());
          }
 
          // Trigger another optimization pass soon.
          function.SetUsageCounter(
              thread->isolate_group()->optimization_counter_threshold() - 100);
          return Error::null();
        } else if (error.IsLanguageError() &&
                   LanguageError::Cast(error).kind() == Report::kBailout) {
          if (FLAG_trace_compiler) {
            THR_Print("--> disabling optimizations for '%s'\n",
                      function.ToFullyQualifiedCString());
          }
          function.SetIsOptimizable(false);
          return Error::null();
        } else {
          // The background compiler does not execute Dart code or handle
          // isolate messages.
          ASSERT(!error.IsUnwindError());
          return error.ptr();
        }
      }
      if (optimized) {
        if (error.IsLanguageError() &&
            LanguageError::Cast(error).kind() == Report::kBailout) {
          // Functions which cannot deoptimize should never bail out.
          ASSERT(!function.ForceOptimize());
          // Optimizer bailed out. Disable optimizations and never try again.
          if (trace_compiler) {
            THR_Print("--> disabling optimizations for '%s'\n",
                      function.ToFullyQualifiedCString());
          } else if (FLAG_trace_failed_optimization_attempts) {
            THR_Print("Cannot optimize: %s\n",
                      function.ToFullyQualifiedCString());
          }
          function.SetIsOptimizable(false);
          return Error::null();
        }
        return error.ptr();
      } else {
        ASSERT(!optimized);
        // The non-optimizing compiler can get an unhandled exception
        // due to OOM or Stack overflow errors, it should not however
        // bail out.
        ASSERT(error.IsUnhandledException() || error.IsUnwindError() ||
               (error.IsLanguageError() &&
                LanguageError::Cast(error).kind() != Report::kBailout));
        return error.ptr();
      }
      UNREACHABLE();
    }
 
    per_compile_timer.Stop();
 
    if (trace_compiler) {
      const auto& code = Code::Handle(function.CurrentCode());
      THR_Print("--> '%s' entry: %#" Px " size: %" Pd " time: %" Pd64 " us\n",
                function.ToFullyQualifiedCString(), code.PayloadStart(),
                code.Size(), per_compile_timer.TotalElapsedTime());
    }
 
    return result.ptr();
  } else {
    Thread* const thread = Thread::Current();
    StackZone stack_zone(thread);
    // We got an error during compilation or it is a bailout from background
    // compilation (e.g., during parsing with EnsureIsFinalized).
    const Error& error = Error::Handle(thread->StealStickyError());
    if (error.ptr() == Object::background_compilation_error().ptr()) {
      // Exit compilation, retry it later.
      if (FLAG_trace_bailout) {
        THR_Print("Aborted background compilation: %s\n",
                  function.ToFullyQualifiedCString());
      }
      return Object::null();
    }
    // Do not attempt to optimize functions that can cause errors.
    function.set_is_optimizable(false);
    return error.ptr();
  }
  UNREACHABLE();
  return Object::null();
}

COMPILER_PASS() [1/36]

dart::COMPILER_PASS	(	AllocateRegisters	,
		{ flow_graph->InsertMoveArguments();flow_graph->GetLoopHierarchy();FlowGraphAllocator allocator(*flow_graph);allocator.AllocateRegisters();}
	)

COMPILER_PASS() [2/36]

dart::COMPILER_PASS	(	AllocateRegistersForGraphIntrinsic	,
		{ flow_graph->set_max_argument_slot_count(0);flow_graph->GetLoopHierarchy();FlowGraphAllocator allocator(*flow_graph, true);allocator.AllocateRegisters();}
	)

COMPILER_PASS() [3/36]

dart::COMPILER_PASS	(	AllocationSinking_DetachMaterializations	,
		{ if(state->sinking !=nullptr) { state->sinking->DetachMaterializations();} }
	)

COMPILER_PASS() [4/36]

dart::COMPILER_PASS	(	AllocationSinking_Sink	,
		{ if(flow_graph->graph_entry() ->catch_entries().is_empty()) { state->sinking=new AllocationSinking(flow_graph);state->sinking->Optimize();} }
	)

COMPILER_PASS() [5/36]

dart::COMPILER_PASS	(	ApplyClassIds	,
		{ state->call_specializer->ApplyClassIds();}
	)

COMPILER_PASS() [6/36]

dart::COMPILER_PASS	(	ApplyICData	,
		{ state->call_specializer->ApplyICData();}
	)

COMPILER_PASS() [7/36]

dart::COMPILER_PASS	(	BranchSimplify	,
		{ BranchSimplifier::Simplify(flow_graph);}
	)

COMPILER_PASS() [8/36]

dart::COMPILER_PASS	(	Canonicalize	,
		{ if(flow_graph->Canonicalize()) { flow_graph->Canonicalize();} }
	)

COMPILER_PASS() [9/36]

dart::COMPILER_PASS	(	ComputeSSA	,
		{ flow_graph->ComputeSSA(nullptr);}
	)

COMPILER_PASS() [10/36]

dart::COMPILER_PASS	(	DCE	,
		{ DeadCodeElimination::EliminateDeadCode(flow_graph);}
	)

COMPILER_PASS() [11/36]

dart::COMPILER_PASS	(	DelayAllocations	,
		{ DelayAllocations::Optimize(flow_graph);}
	)

COMPILER_PASS() [12/36]

dart::COMPILER_PASS	(	DSE	,
		{ DeadStoreElimination::Optimize(flow_graph);}
	)

COMPILER_PASS() [13/36]

dart::COMPILER_PASS	(	EliminateDeadPhis	,
		{ DeadCodeElimination::EliminateDeadPhis(flow_graph);}
	)

COMPILER_PASS() [14/36]

dart::COMPILER_PASS	(	EliminateEnvironments	,
		{ flow_graph->EliminateEnvironments();}
	)

COMPILER_PASS() [15/36]

dart::COMPILER_PASS	(	EliminateStackOverflowChecks	,
		{ if(!flow_graph->IsCompiledForOsr()) { CheckStackOverflowElimination::EliminateStackOverflow(flow_graph);} }
	)

COMPILER_PASS() [16/36]

dart::COMPILER_PASS	(	EliminateWriteBarriers	,
		{ EliminateWriteBarriers(flow_graph);}
	)

COMPILER_PASS() [17/36]

dart::COMPILER_PASS	(	FinalizeGraph	,
		{ intptr_t instruction_count=0;intptr_t call_site_count=0;FlowGraphInliner::CollectGraphInfo(flow_graph, 0, true, &instruction_count, &call_site_count);flow_graph->function().set_inlining_depth(state->inlining_depth);flow_graph->RemoveRedefinitions();}
	)

COMPILER_PASS() [18/36]

dart::COMPILER_PASS	(	GenerateCode	,
		{ state->graph_compiler->CompileGraph();}
	)

COMPILER_PASS() [19/36]

dart::COMPILER_PASS	(	IfConvert	,
		{ IfConverter::Simplify(flow_graph);}
	)

COMPILER_PASS() [20/36]

dart::COMPILER_PASS	(	Inlining	,
		{ FlowGraphInliner inliner(flow_graph, &state->inline_id_to_function, &state->inline_id_to_token_pos, &state->caller_inline_id, state->speculative_policy, state->precompiler);state->inlining_depth=inliner.Inline();}
	)

COMPILER_PASS() [21/36]

dart::COMPILER_PASS	(	LICM	,
		{ flow_graph->RenameUsesDominatedByRedefinitions();DEBUG_ASSERT(flow_graph->VerifyRedefinitions());LICM licm(flow_graph);licm.Optimize();flow_graph->RemoveRedefinitions(true);}
	)

COMPILER_PASS() [22/36]

dart::COMPILER_PASS	(	LoweringAfterCodeMotionDisabled	,
		{ flow_graph->ExtractNonInternalTypedDataPayloads();}
	)

COMPILER_PASS() [23/36]

dart::COMPILER_PASS	(	OptimisticallySpecializeSmiPhis	,
		{ LICM licm(flow_graph);licm.OptimisticallySpecializeSmiPhis();}
	)

COMPILER_PASS() [24/36]

dart::COMPILER_PASS	(	OptimizeBranches	,
		{ ConstantPropagator::OptimizeBranches(flow_graph);}
	)

COMPILER_PASS() [25/36]

dart::COMPILER_PASS	(	OptimizeTypedDataAccesses	,
		{ TypedDataSpecializer::Optimize(flow_graph);}
	)

COMPILER_PASS() [26/36]

dart::COMPILER_PASS	(	RangeAnalysis	,
		{ RangeAnalysis range_analysis(flow_graph);range_analysis.Analyze();}
	)

COMPILER_PASS() [27/36]

dart::COMPILER_PASS	(	ReorderBlocks	,
		{ BlockScheduler::ReorderBlocks(flow_graph);}
	)

COMPILER_PASS() [28/36]

dart::COMPILER_PASS	(	SelectRepresentations	,
		{ flow_graph->SelectRepresentations();}
	)

COMPILER_PASS() [29/36]

dart::COMPILER_PASS	(	SelectRepresentations_Final	,
		{ flow_graph->SelectRepresentations();flow_graph->disallow_unmatched_representations();}
	)

COMPILER_PASS() [30/36]

dart::COMPILER_PASS	(	SetOuterInliningId	,
		{ FlowGraphInliner::SetInliningId(flow_graph, 0);}
	)

COMPILER_PASS() [31/36]

dart::COMPILER_PASS	(	TestILSerialization	,
		{ if(FLAG_test_il_serialization &&CompilerState::Current().is_aot()) { Zone *zone=flow_graph->zone();auto *detached_defs=new(zone) ZoneGrowableArray< Definition * >(zone, 0);flow_graph->CompactSSA(detached_defs);ZoneWriteStream write_stream(flow_graph->zone(), 1024);FlowGraphSerializer serializer(&write_stream);serializer.WriteFlowGraph(*flow_graph, *detached_defs);ReadStream read_stream(write_stream.buffer(), write_stream.bytes_written());FlowGraphDeserializer deserializer(flow_graph->parsed_function(), &read_stream);state->set_flow_graph(deserializer.ReadFlowGraph());} }
	)

COMPILER_PASS() [32/36]

dart::COMPILER_PASS	(	TryCatchOptimization	,
		{ OptimizeCatchEntryStates(flow_graph, CompilerState::Current().is_aot());}
	)

COMPILER_PASS() [33/36]

dart::COMPILER_PASS	(	TryOptimizePatterns	,
		{ flow_graph->TryOptimizePatterns();}
	)

COMPILER_PASS() [34/36]

dart::COMPILER_PASS	(	TypePropagation	,
		{ FlowGraphTypePropagator::Propagate(flow_graph);}
	)

COMPILER_PASS() [35/36]

dart::COMPILER_PASS	(	UseTableDispatch	,
		{ state->call_specializer->ReplaceInstanceCallsWithDispatchTableCalls();}
	)

COMPILER_PASS() [36/36]

dart::COMPILER_PASS	(	WidenSmiToInt32	,
		{ flow_graph->WidenSmiToInt32();}
	)

COMPILER_PASS_REPEAT() [1/2]

dart::COMPILER_PASS_REPEAT	(	ConstantPropagation	,
		{ ConstantPropagator::Optimize(flow_graph);return true;}
	)

COMPILER_PASS_REPEAT() [2/2]

dart::COMPILER_PASS_REPEAT	(	CSE	,
		{ return DominatorBasedCSE::Optimize(flow_graph);}
	)

ComponentContext()

sys::ComponentContext * dart::ComponentContext

(

)

ComputeArrayElementType()

static CompileType dart::ComputeArrayElementType ( Value *  array )

static

Definition at line 1864 of file type_propagator.cc.

                                                         {
  // 1. Try to extract element type from array value.
  auto& elem_type = AbstractType::Handle(GetElementTypeFromArray(array));
  if (!elem_type.IsDynamicType()) {
    return CompileType::FromAbstractType(elem_type, CompileType::kCanBeNull,
                                         CompileType::kCannotBeSentinel);
  }
 
  // 2. Array value may be loaded from GrowableObjectArray.data.
  // Unwrap and try again.
  if (auto* load_field = array->definition()->AsLoadField()) {
    if (load_field->slot().IsIdentical(Slot::GrowableObjectArray_data())) {
      array = load_field->instance();
      elem_type = GetElementTypeFromArray(array);
      if (!elem_type.IsDynamicType()) {
        return CompileType::FromAbstractType(elem_type, CompileType::kCanBeNull,
                                             CompileType::kCannotBeSentinel);
      }
    }
  }
 
  // 3. If array was loaded from a Dart field, use field's static type.
  // Unlike propagated type (which could be cid), static type may contain
  // type arguments which can be used to figure out element type.
  if (auto* load_field = array->definition()->AsLoadField()) {
    if (load_field->slot().IsDartField()) {
      elem_type = load_field->slot().field().type();
      elem_type = ExtractElementTypeFromArrayType(elem_type);
    }
  }
 
  return CompileType::FromAbstractType(elem_type, CompileType::kCanBeNull,
                                       CompileType::kCannotBeSentinel);
}

ComputeExtraLoopInfo()

static ExtraLoopInfo * dart::ComputeExtraLoopInfo ( Zone *  zone, LoopInfo *  loop_info  )

static

Definition at line 68 of file linearscan.cc.

                                                                            {
  intptr_t start = loop_info->header()->start_pos();
  intptr_t end = start;
  for (auto back_edge : loop_info->back_edges()) {
    intptr_t end_pos = back_edge->end_pos();
    if (end_pos > end) {
      end = end_pos;
    }
  }
  return new (zone) ExtraLoopInfo(start, end);
}

ComputeInduction()

static const char * dart::ComputeInduction ( Thread *  thread, const char *  script_chars  )

static

Definition at line 65 of file loops_test.cc.

                                                                              {
  // Load the script and exercise the code once.
  const auto& root_library = Library::Handle(LoadTestScript(script_chars));
  Invoke(root_library, "main");
 
  std::initializer_list<CompilerPass::Id> passes = {
      CompilerPass::kComputeSSA,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyICData,
      CompilerPass::kTypePropagation,
      CompilerPass::kSelectRepresentations,
      CompilerPass::kTypePropagation,
      CompilerPass::kCanonicalize,
  };
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses(passes);
 
  // Build loop hierarchy and find induction.
  const LoopHierarchy& hierarchy = flow_graph->GetLoopHierarchy();
  hierarchy.ComputeInduction();
  flow_graph->RemoveRedefinitions();  // don't query later
 
  // Construct and return a debug string for testing.
  char buffer[1024];
  BufferFormatter f(buffer, sizeof(buffer));
  TestString(&f, hierarchy.top(), flow_graph->preorder());
  return Thread::Current()->zone()->MakeCopyOfString(buffer);
}

ComputeKernelServicePath()

static char * dart::ComputeKernelServicePath ( const char *  arg )

static

Definition at line 66 of file benchmark_test.cc.

                                                       {
  char buffer[2048];
  char* kernel_service_path =
      Utils::StrDup(File::GetCanonicalPath(nullptr, arg));
  EXPECT(kernel_service_path != nullptr);
  const char* compiler_path = "%s%sgen%skernel_service.dill";
  const char* path_separator = File::PathSeparator();
  ASSERT(path_separator != nullptr && strlen(path_separator) == 1);
  char* ptr = strrchr(kernel_service_path, *path_separator);
  while (ptr != nullptr) {
    *ptr = '\0';
    Utils::SNPrint(buffer, ARRAY_SIZE(buffer), compiler_path,
                   kernel_service_path, path_separator, path_separator);
    if (File::Exists(nullptr, buffer)) {
      break;
    }
    ptr = strrchr(kernel_service_path, *path_separator);
  }
  free(kernel_service_path);
  if (ptr == nullptr) {
    return nullptr;
  }
  return Utils::StrDup(buffer);
}

ComputeListFactoryType()

static CompileType dart::ComputeListFactoryType ( CompileType *  inferred_type, Value *  type_args_value  )

static

Definition at line 1547 of file type_propagator.cc.

                                                                  {
  ASSERT(inferred_type != nullptr);
  const intptr_t cid = inferred_type->ToNullableCid();
  ASSERT(cid != kDynamicCid);
  if ((cid == kGrowableObjectArrayCid || cid == kArrayCid ||
       cid == kImmutableArrayCid) &&
      type_args_value->BindsToConstant()) {
    Thread* thread = Thread::Current();
    Zone* zone = thread->zone();
    const Class& cls =
        Class::Handle(zone, thread->isolate_group()->class_table()->At(cid));
    auto& type_args = TypeArguments::Handle(zone);
    if (!type_args_value->BoundConstant().IsNull()) {
      type_args ^= type_args_value->BoundConstant().ptr();
      ASSERT(type_args.Length() >= cls.NumTypeArguments());
      type_args = type_args.FromInstanceTypeArguments(thread, cls);
    }
    Type& type = Type::ZoneHandle(
        zone, Type::New(cls, type_args, Nullability::kNonNullable));
    ASSERT(type.IsInstantiated());
    type.SetIsFinalized();
    return CompileType(CompileType::kCannotBeNull,
                       CompileType::kCannotBeSentinel, cid, &type);
  }
  return *inferred_type;
}

ComputePhiMoves()

static PhiPlaceMoves * dart::ComputePhiMoves ( PointerSet< Place > *  map, ZoneGrowableArray< Place * > *  places, bool  print_traces  )

static

Definition at line 1315 of file redundancy_elimination.cc.

                                                         {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  PhiPlaceMoves* phi_moves = new (zone) PhiPlaceMoves();
 
  for (intptr_t i = 0; i < places->length(); i++) {
    Place* place = (*places)[i];
 
    if (IsPhiDependentPlace(place)) {
      PhiInstr* phi = place->instance()->AsPhi();
      BlockEntryInstr* block = phi->GetBlock();
 
      if (FLAG_trace_optimization && print_traces) {
        THR_Print("phi dependent place %s\n", place->ToCString());
      }
 
      Place input_place(*place);
      for (intptr_t j = 0; j < phi->InputCount(); j++) {
        input_place.set_instance(phi->InputAt(j)->definition());
 
        Place* result = map->LookupValue(&input_place);
        if (result == nullptr) {
          result = Place::Wrap(zone, input_place, places->length());
          map->Insert(result);
          places->Add(result);
          if (FLAG_trace_optimization && print_traces) {
            THR_Print("  adding place %s as %" Pd "\n", result->ToCString(),
                      result->id());
          }
        }
        phi_moves->CreateOutgoingMove(zone, block->PredecessorAt(j),
                                      result->id(), place->id());
      }
    }
  }
 
  return phi_moves;
}

ComputeTimeout()

static int64_t dart::ComputeTimeout ( int64_t  idle_start )

static

Definition at line 18 of file thread_pool.cc.

                                                  {
  int64_t worker_timeout_micros =
      FLAG_worker_timeout_millis * kMicrosecondsPerMillisecond;
  if (worker_timeout_micros <= 0) {
    // No timeout.
    return 0;
  } else {
    int64_t waited = OS::GetCurrentMonotonicMicros() - idle_start;
    if (waited >= worker_timeout_micros) {
      // We must have gotten a spurious wakeup just before we timed
      // out.  Give the worker one last desperate chance to live.  We
      // are merciful.
      return 1;
    } else {
      return worker_timeout_micros - waited;
    }
  }
}

ComputeTypeCheckTarget()

static FunctionPtr dart::ComputeTypeCheckTarget ( const Instance &  receiver, const AbstractType &  type, const ArgumentsDescriptor &  desc  )

static

Definition at line 1720 of file runtime_entry.cc.

                                                                           {
  const bool result = receiver.IsInstanceOf(type, Object::null_type_arguments(),
                                            Object::null_type_arguments());
  const ObjectStore* store = IsolateGroup::Current()->object_store();
  const Function& target =
      Function::Handle(result ? store->simple_instance_of_true_function()
                              : store->simple_instance_of_false_function());
  ASSERT(!target.IsNull());
  return target.ptr();
}

Concat()

static const char * dart::Concat ( const char *  a, const char *  b  )

static

Definition at line 86 of file file_test.cc.

                                                        {
  const intptr_t len = strlen(a) + strlen(b);
  char* c = bin::DartUtils::ScopedCString(len + 1);
  EXPECT_NOTNULL(c);
  snprintf(c, len + 1, "%s%s", a, b);
  return c;
}

ConcreteRegister() [1/2]

Register dart::ConcreteRegister ( LinkRegister  )

inline

Definition at line 1332 of file constants_arm.h.

                                               {
  return LR;
}

ConcreteRegister() [2/2]

static Register dart::ConcreteRegister ( Register  r )

inlinestatic

Definition at line 636 of file constants_arm64.h.

                                                    {
  return ((r == ZR) || (r == CSP)) ? R31 : r;
}

ConstructFunctionFullyQualifiedCString()

static intptr_t dart::ConstructFunctionFullyQualifiedCString ( const Function &  function, char **  chars, intptr_t  reserve_len, bool  with_lib, QualifiedFunctionLibKind  lib_kind  )

static

Definition at line 9759 of file object.cc.

                                       {
  Zone* zone = Thread::Current()->zone();
  const char* name = String::Handle(zone, function.name()).ToCString();
  const char* function_format = (reserve_len == 0) ? "%s" : "%s_";
  reserve_len += Utils::SNPrint(nullptr, 0, function_format, name);
  const Function& parent = Function::Handle(zone, function.parent_function());
  intptr_t written = 0;
  if (parent.IsNull()) {
    const Class& function_class = Class::Handle(zone, function.Owner());
    ASSERT(!function_class.IsNull());
    const char* class_name =
        String::Handle(zone, function_class.Name()).ToCString();
    ASSERT(class_name != nullptr);
    const char* library_name = nullptr;
    const char* lib_class_format = nullptr;
    if (with_lib) {
      const Library& library = Library::Handle(zone, function_class.library());
      ASSERT(!library.IsNull());
      switch (lib_kind) {
        case kQualifiedFunctionLibKindLibUrl:
          library_name = String::Handle(zone, library.url()).ToCString();
          break;
        case kQualifiedFunctionLibKindLibName:
          library_name = String::Handle(zone, library.name()).ToCString();
          break;
        default:
          UNREACHABLE();
      }
      ASSERT(library_name != nullptr);
      lib_class_format = (library_name[0] == '\0') ? "%s%s_" : "%s_%s_";
    } else {
      library_name = "";
      lib_class_format = "%s%s.";
    }
    reserve_len +=
        Utils::SNPrint(nullptr, 0, lib_class_format, library_name, class_name);
    ASSERT(chars != nullptr);
    *chars = zone->Alloc<char>(reserve_len + 1);
    written = Utils::SNPrint(*chars, reserve_len + 1, lib_class_format,
                             library_name, class_name);
  } else {
    written = ConstructFunctionFullyQualifiedCString(parent, chars, reserve_len,
                                                     with_lib, lib_kind);
  }
  ASSERT(*chars != nullptr);
  char* next = *chars + written;
  written += Utils::SNPrint(next, reserve_len + 1, function_format, name);
  // Replace ":" with "_".
  while (true) {
    next = strchr(next, ':');
    if (next == nullptr) break;
    *next = '_';
  }
  return written;
}

ConstructImmutableMap()

static MapPtr dart::ConstructImmutableMap ( const Array &  input_data, intptr_t  used_data, const TypeArguments &  type_arguments  )

static

Definition at line 6749 of file object_test.cc.

                                                   {
      const uint32_t index_val = index2.GetUint32(i * kElementSize);
      THR_Print("LinkedHashBaseEqual index2[%" Pd "] %" Px32 "\n", i,
                index_val);
    }
  }
  return index_equal;
}
 
// Copies elements from data.
static MapPtr ConstructImmutableMap(const Array& input_data,
                                    intptr_t used_data,
                                    const TypeArguments& type_arguments) {
  auto& map = Map::Handle(ConstMap::NewUninitialized());
 
  const auto& data = Array::Handle(Array::New(used_data));
  for (intptr_t i = 0; i < used_data; i++) {

ConstructImmutableSet()

static SetPtr dart::ConstructImmutableSet ( const Array &  input_data, intptr_t  used_data, const TypeArguments &  type_arguments  )

static

Definition at line 7138 of file object_test.cc.

                                                                         {
  auto& set = Set::Handle(ConstSet::NewUninitialized());
 
  const auto& data = Array::Handle(Array::New(used_data));
  for (intptr_t i = 0; i < used_data; i++) {

ContainsNonInstance()

static bool dart::ContainsNonInstance ( const Object &  obj )

static

Definition at line 1790 of file service.cc.

                                                   {
  if (obj.IsArray()) {
    const Array& array = Array::Cast(obj);
    Object& element = Object::Handle();
    for (intptr_t i = 0; i < array.Length(); ++i) {
      element = array.At(i);
      if (!(element.IsInstance() || element.IsNull())) {
        return true;
      }
    }
    return false;
  } else if (obj.IsGrowableObjectArray()) {
    const GrowableObjectArray& array = GrowableObjectArray::Cast(obj);
    Object& element = Object::Handle();
    for (intptr_t i = 0; i < array.Length(); ++i) {
      element = array.At(i);
      if (!(element.IsInstance() || element.IsNull())) {
        return true;
      }
    }
    return false;
  } else {
    return !(obj.IsInstance() || obj.IsNull());
  }
}

ContainsScriptUri()

static bool dart::ContainsScriptUri ( const GrowableArray< const char * > &  seen_uris, const char *  uri  )

static

Definition at line 1450 of file isolate_reload.cc.

                                               {
  for (intptr_t i = 0; i < seen_uris.length(); i++) {
    const char* seen_uri = seen_uris.At(i);
    size_t seen_len = strlen(seen_uri);
    if (seen_len != strlen(uri)) {
      continue;
    } else if (strncmp(seen_uri, uri, seen_len) == 0) {
      return true;
    }
  }
  return false;
}

ContentsFinalizer()

static void dart::ContentsFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 322 of file vmservice.cc.

                                                                       {
  uint8_t* data = reinterpret_cast<uint8_t*>(peer);
  delete[] data;
}

ConvertNonLatin1ToLatin1()

static uint16_t dart::ConvertNonLatin1ToLatin1 ( uint16_t  c )

static

Definition at line 1962 of file regexp.cc.

                                                     {
  ASSERT(c > Symbols::kMaxOneCharCodeSymbol);
  switch (c) {
    // This are equivalent characters in unicode.
    case 0x39c:
    case 0x3bc:
      return 0xb5;
    // This is an uppercase of a Latin-1 character
    // outside of Latin-1.
    case 0x178:
      return 0xff;
  }
  return 0;
}

ConvertRangeToSigned()

static void dart::ConvertRangeToSigned ( uint64_t  a, uint64_t  b, int64_t *  sa, int64_t *  sb  )

static

Definition at line 2266 of file range_analysis.cc.

                                              {
  ASSERT(a <= b);
  if ((a <= static_cast<uint64_t>(kMaxInt64)) &&
      (b >= static_cast<uint64_t>(kMinInt64))) {
    // Range contains kMinInt64 and kMaxInt64 and wraps-around as signed.
    *sa = kMinInt64;
    *sb = kMaxInt64;
  } else {
    // Range is fully in the negative or non-negative part
    // and doesn't wrap-around if interpreted as signed.
    *sa = static_cast<int64_t>(a);
    *sb = static_cast<int64_t>(b);
  }
}

ConvertRangeToUnsigned()

static void dart::ConvertRangeToUnsigned ( int64_t  a, int64_t  b, uint64_t *  ua, uint64_t *  ub  )

static

Definition at line 2249 of file range_analysis.cc.

                                                 {
  ASSERT(a <= b);
  if ((a < 0) && (b >= 0)) {
    // Range contains -1 and 0 and wraps-around as unsigned.
    *ua = 0;
    *ub = kMaxUint64;
  } else {
    // Range is fully in the negative or non-negative part
    // and doesn't wrap-around if interpreted as unsigned.
    *ua = static_cast<uint64_t>(a);
    *ub = static_cast<uint64_t>(b);
  }
}

CoordinateElemAt1()

DART_EXPORT Coord * dart::CoordinateElemAt1

(

Coord *

coord

)

Definition at line 564 of file ffi_test_functions.cc.

                                                   {
  std::cout << "CoordinateElemAt1(" << coord << ")\n";
  std::cout << "sizeof(Coord): " << sizeof(Coord) << "\n";
  std::cout << "coord[0] = {" << coord[0].x << ", " << coord[0].y << ", "
            << coord[0].next << "}\n";
  std::cout << "coord[1] = {" << coord[1].x << ", " << coord[1].y << ", "
            << coord[1].next << "}\n";
  Coord* retval = coord + 1;
  std::cout << "returning " << retval << "\n";
  return retval;
}

CoordinateUnOpTrice()

DART_EXPORT Coord * dart::CoordinateUnOpTrice	(	CoordUnOp	unop,
		Coord *	coord
	)

Definition at line 581 of file ffi_test_functions.cc.

                                                                     {
  std::cout << "CoordinateUnOpTrice(" << &unop << ", " << coord << ")\n";
  Coord* retval = unop(unop(unop(coord)));
  std::cout << "returning " << retval << "\n";
  return retval;
}

CopyMutableObjectGraph()

ObjectPtr dart::CopyMutableObjectGraph

(

const Object &

object

)

Definition at line 2722 of file object_graph_copy.cc.

                                                       {
  auto thread = Thread::Current();
  TIMELINE_DURATION(thread, Isolate, "CopyMutableObjectGraph");
  ObjectGraphCopier copier(thread);
  ObjectPtr result = copier.CopyObjectGraph(object);
#if defined(SUPPORT_TIMELINE)
  if (tbes.enabled()) {
    tbes.SetNumArguments(2);
    tbes.FormatArgument(0, "CopiedObjects", "%" Pd, copier.copied_objects());
    tbes.FormatArgument(1, "AllocatedBytes", "%" Pd, copier.allocated_bytes());
  }
#endif
  return result;
}

CopySavedRegisters()

static void dart::CopySavedRegisters ( uword  saved_registers_address, fpu_register_t **  fpu_registers, intptr_t **  cpu_registers  )

static

Definition at line 3515 of file runtime_entry.cc.

                                                         {
  // Tell MemorySanitizer this region is initialized by generated code. This
  // region isn't already (fully) unpoisoned by FrameSetIterator::Unpoison
  // because it is in an exit frame and stack frame iteration doesn't have
  // access to true SP for exit frames.
  MSAN_UNPOISON(reinterpret_cast<void*>(saved_registers_address),
                kNumberOfSavedFpuRegisters * kFpuRegisterSize +
                    kNumberOfSavedCpuRegisters * kWordSize);
 
  ASSERT(sizeof(fpu_register_t) == kFpuRegisterSize);
  fpu_register_t* fpu_registers_copy =
      new fpu_register_t[kNumberOfSavedFpuRegisters];
  ASSERT(fpu_registers_copy != nullptr);
  for (intptr_t i = 0; i < kNumberOfSavedFpuRegisters; i++) {
    fpu_registers_copy[i] =
        *reinterpret_cast<fpu_register_t*>(saved_registers_address);
    saved_registers_address += kFpuRegisterSize;
  }
  *fpu_registers = fpu_registers_copy;
 
  ASSERT(sizeof(intptr_t) == kWordSize);
  intptr_t* cpu_registers_copy = new intptr_t[kNumberOfSavedCpuRegisters];
  ASSERT(cpu_registers_copy != nullptr);
  for (intptr_t i = 0; i < kNumberOfSavedCpuRegisters; i++) {
    cpu_registers_copy[i] =
        *reinterpret_cast<intptr_t*>(saved_registers_address);
    saved_registers_address += kWordSize;
  }
  *cpu_registers = cpu_registers_copy;
}

CopyStackBuffer()

static void dart::CopyStackBuffer ( Sample *  sample, uword  sp_addr  )

static

Definition at line 1137 of file profiler.cc.

                                                           {
  ASSERT(sample != nullptr);
  uword* sp = reinterpret_cast<uword*>(sp_addr);
  uword* buffer = sample->GetStackBuffer();
  if (sp != nullptr) {
    for (intptr_t i = 0; i < Sample::kStackBufferSizeInWords; i++) {
      MSAN_UNPOISON(sp, kWordSize);
      ASAN_UNPOISON(sp, kWordSize);
      buffer[i] = *sp;
      sp++;
    }
  }
}

CopyTypedDataBaseWithSafepointChecks()

template<typename T >

void dart::CopyTypedDataBaseWithSafepointChecks	(	Thread *	thread,
		const T &	from,
		const T &	to,
		intptr_t	length
	)

Definition at line 316 of file object_graph_copy.cc.

                                                           {
  constexpr intptr_t kChunkSize = 100 * 1024;
 
  const intptr_t chunks = length / kChunkSize;
  const intptr_t remainder = length % kChunkSize;
 
  // Notice we re-load the data pointer, since T may be TypedData in which case
  // the interior pointer may change after checking into safepoints.
  for (intptr_t i = 0; i < chunks; ++i) {
    memmove(to.ptr().untag()->data_ + i * kChunkSize,
            from.ptr().untag()->data_ + i * kChunkSize, kChunkSize);
 
    thread->CheckForSafepoint();
  }
  if (remainder > 0) {
    memmove(to.ptr().untag()->data_ + chunks * kChunkSize,
            from.ptr().untag()->data_ + chunks * kChunkSize, remainder);
  }
}

CountBoundChecks()

static intptr_t dart::CountBoundChecks ( FlowGraph *  flow_graph )

static

Definition at line 20 of file bce_test.cc.

                                                        {
  intptr_t count = 0;
  for (BlockIterator block_it = flow_graph->reverse_postorder_iterator();
       !block_it.Done(); block_it.Advance()) {
    for (ForwardInstructionIterator it(block_it.Current()); !it.Done();
         it.Advance()) {
      if (it.Current()->IsCheckBoundBase()) {
        count++;
      }
    }
  }
  return count;
}

CountFinalizedSubclasses()

static intptr_t dart::CountFinalizedSubclasses ( Thread *  thread, const Class &  cls  )

static

Definition at line 177 of file cha.cc.

                                                                           {
  intptr_t count = 0;
  const GrowableObjectArray& cls_direct_subclasses =
      GrowableObjectArray::Handle(thread->zone(), cls.direct_subclasses());
  if (cls_direct_subclasses.IsNull()) return count;
  Class& direct_subclass = Class::Handle(thread->zone());
  for (intptr_t i = 0; i < cls_direct_subclasses.Length(); i++) {
    direct_subclass ^= cls_direct_subclasses.At(i);
    // Unfinalized classes are treated as nonexistent for CHA purposes,
    // as that means that no instance of that class exists at runtime.
    if (!direct_subclass.is_finalized()) {
      continue;
    }
 
    count += 1 + CountFinalizedSubclasses(thread, direct_subclass);
  }
  return count;
}

CountLoadsStores()

static void dart::CountLoadsStores ( FlowGraph *  flow_graph, intptr_t *  loads, intptr_t *  stores  )

static

Definition at line 861 of file redundancy_elimination_test.cc.

                                               {
  for (BlockIterator block_it = flow_graph->reverse_postorder_iterator();
       !block_it.Done(); block_it.Advance()) {
    for (ForwardInstructionIterator it(block_it.Current()); !it.Done();
         it.Advance()) {
      if (it.Current()->IsLoadField()) {
        (*loads)++;
      } else if (it.Current()->IsStoreField()) {
        (*stores)++;
      }
    }
  }
}

CreateAndSetupServiceIsolate()

static Dart_Isolate dart::CreateAndSetupServiceIsolate ( const char *  script_uri, const char *  packages_config, Dart_IsolateFlags *  flags, char **  error  )

static

Definition at line 104 of file run_vm_tests.cc.

                                                               {
  // We only enable the vm-service for this particular test.
  // The vm-service seems to have some shutdown race which would cause other
  // vm/cc tests to randomly time out due to inability to shut service-isolate
  // down.
  // Issue(https://dartbug.com/37741):
  if ((strcmp(run_filter, "DartAPI_InvokeVMServiceMethod") != 0) &&
      (strcmp(run_filter, "DartAPI_InvokeVMServiceMethod_Loop") != 0)) {
    return nullptr;
  }
 
  ASSERT(script_uri != nullptr);
  Dart_Isolate isolate = nullptr;
  auto isolate_group_data = new bin::IsolateGroupData(
      script_uri, packages_config, /*app_snapshot=*/nullptr,
      /*isolate_run_app_snapshot=*/false);
 
  const uint8_t* kernel_buffer = nullptr;
  intptr_t kernel_buffer_size = 0;
 
  bin::dfe.Init();
  bin::dfe.LoadPlatform(&kernel_buffer, &kernel_buffer_size);
  RELEASE_ASSERT(kernel_buffer != nullptr);
 
  flags->load_vmservice_library = true;
  flags->is_service_isolate = true;
  isolate_group_data->SetKernelBufferUnowned(
      const_cast<uint8_t*>(kernel_buffer), kernel_buffer_size);
  isolate = Dart_CreateIsolateGroupFromKernel(
      script_uri, DART_VM_SERVICE_ISOLATE_NAME, kernel_buffer,
      kernel_buffer_size, flags, isolate_group_data, /*isolate_data=*/nullptr,
      error);
  if (isolate == nullptr) {
    delete isolate_group_data;
    return nullptr;
  }
 
  Dart_EnterScope();
 
  Dart_Handle result =
      Dart_SetLibraryTagHandler(bin::Loader::LibraryTagHandler);
  CHECK_RESULT(result);
 
  // Load embedder specific bits and return.
  if (!bin::VmService::Setup("127.0.0.1", 0,
                             /*dev_mode=*/false, /*auth_disabled=*/true,
                             /*write_service_info_filename=*/"",
                             /*trace_loading=*/false, /*deterministic=*/true,
                             /*enable_service_port_fallback=*/false,
                             /*wait_for_dds_to_advertise_service=*/false,
                             /*serve_devtools=*/false,
                             /*serve_observatory=*/true,
                             /*print_dtd=*/false)) {
    *error = Utils::StrDup(bin::VmService::GetErrorMessage());
    return nullptr;
  }
  result = Dart_SetEnvironmentCallback(bin::DartUtils::EnvironmentCallback);
  CHECK_RESULT(result);
  Dart_ExitScope();
  Dart_ExitIsolate();
  return isolate;
}

CreateCallableArgumentsFromStatic()

static ArrayPtr dart::CreateCallableArgumentsFromStatic ( Zone *  zone, const Instance &  receiver, const Array &  static_args, const Array &  arg_names, const ArgumentsDescriptor &  static_args_descriptor  )

static

Definition at line 4707 of file object.cc.

                                                       {
  const intptr_t num_static_type_args = static_args_descriptor.TypeArgsLen();
  const intptr_t num_static_args = static_args_descriptor.Count();
  // Double check that the static args descriptor expects boxed arguments
  // and the static args descriptor is consistent with the static arguments.
  ASSERT_EQUAL(static_args_descriptor.Size(), num_static_args);
  ASSERT_EQUAL(static_args.Length(),
               num_static_args + (num_static_type_args > 0 ? 1 : 0));
  // Add an additional slot to store the callable as the receiver.
  const auto& callable_args =
      Array::Handle(zone, Array::New(static_args.Length() + 1));
  const intptr_t first_arg_index = static_args_descriptor.FirstArgIndex();
  auto& temp = Object::Handle(zone);
  // Copy the static args into the corresponding slots of the callable args.
  if (num_static_type_args > 0) {
    temp = static_args.At(0);
    callable_args.SetAt(0, temp);
  }
  for (intptr_t i = first_arg_index; i < static_args.Length(); i++) {
    temp = static_args.At(i);
    callable_args.SetAt(i + 1, temp);
  }
  // Set the receiver slot in the callable args.
  callable_args.SetAt(first_arg_index, receiver);
  return callable_args.ptr();
}

CreateClassMirror()

static InstancePtr dart::CreateClassMirror ( const Class &  cls, const AbstractType &  type, const Bool &  is_declaration, const Instance &  owner_mirror  )

static

Definition at line 305 of file mirrors.cc.

                                                                   {
  ASSERT(!cls.IsDynamicClass());
  ASSERT(!cls.IsVoidClass());
  ASSERT(!cls.IsNeverClass());
  ASSERT(!type.IsNull());
  ASSERT(type.IsFinalized());
  ASSERT(type.IsCanonical());
  const Array& args = Array::Handle(Array::New(9));
  args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
  args.SetAt(1, type);
  args.SetAt(2, String::Handle(cls.Name()));
  args.SetAt(3, owner_mirror);
  args.SetAt(4, Bool::Get(cls.is_abstract()));
  args.SetAt(5, Bool::Get(cls.IsGeneric()));
  args.SetAt(6, Bool::Get(cls.is_transformed_mixin_application()));
  args.SetAt(7, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
  args.SetAt(8, Bool::Get(cls.is_enum_class()));
  return CreateMirror(Symbols::_ClassMirror(), args);
}

CreateCombinatorMirror()

static InstancePtr dart::CreateCombinatorMirror ( const Object &  identifiers, bool  is_show  )

static

Definition at line 362 of file mirrors.cc.

                                                        {
  const Array& args = Array::Handle(Array::New(2));
  args.SetAt(0, identifiers);
  args.SetAt(1, Bool::Get(is_show));
  return CreateMirror(Symbols::_CombinatorMirror(), args);
}

CreateDummyClass()

static ClassPtr dart::CreateDummyClass ( const String &  class_name, const Script &  script  )

static

Definition at line 44 of file object_test.cc.

                                                       {
  const Class& cls = Class::Handle(Class::New(
      Library::Handle(), class_name, script, TokenPosition::kNoSource));
  cls.set_is_synthesized_class_unsafe();  // Dummy class for testing.
  cls.set_is_declaration_loaded_unsafe();
  return cls.ptr();
}

CreateDummyLibrary()

static LibraryPtr dart::CreateDummyLibrary ( const String &  library_name )

static

Definition at line 2637 of file object_test.cc.

                                                                 {
  return Library::New(library_name);
}

CreateFunction() [1/2]

static FunctionPtr dart::CreateFunction ( const char *  name )

static

Definition at line 2641 of file object_test.cc.

                                                    {
  Thread* thread = Thread::Current();
  const String& class_name = String::Handle(Symbols::New(thread, "ownerClass"));
  const String& lib_name = String::Handle(Symbols::New(thread, "ownerLibrary"));
  const Script& script = Script::Handle();
  const Class& owner_class =
      Class::Handle(CreateDummyClass(class_name, script));
  const Library& owner_library = Library::Handle(CreateDummyLibrary(lib_name));
  owner_class.set_library(owner_library);
  const String& function_name = String::ZoneHandle(Symbols::New(thread, name));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  return Function::New(signature, function_name,
                       UntaggedFunction::kRegularFunction, true, false, false,
                       false, false, owner_class, TokenPosition::kMinSource);
}

CreateFunction() [2/2]

static Function * dart::CreateFunction ( const char *  name )

static

Definition at line 447 of file thread_test.cc.

                                                  {
  const String& class_name =
      String::Handle(Symbols::New(Thread::Current(), "ownerClass"));
  const Script& script = Script::Handle();
  const Library& lib = Library::Handle(Library::New(class_name));
  const Class& owner_class = Class::Handle(
      Class::New(lib, class_name, script, TokenPosition::kNoSource));
  const String& function_name =
      String::ZoneHandle(Symbols::New(Thread::Current(), name));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  Function& function = Function::ZoneHandle(Function::New(
      signature, function_name, UntaggedFunction::kRegularFunction, true, false,
      false, false, false, owner_class, TokenPosition::kNoSource));
  return &function;
}

CreateFunctionTypeMirror()

static InstancePtr dart::CreateFunctionTypeMirror ( const AbstractType &  type )

static

Definition at line 228 of file mirrors.cc.

                                                                      {
  ASSERT(type.IsFunctionType());
  const Class& closure_class =
      Class::Handle(IsolateGroup::Current()->object_store()->closure_class());
  const FunctionType& sig = FunctionType::Cast(type);
  const Array& args = Array::Handle(Array::New(3));
  args.SetAt(0, MirrorReference::Handle(MirrorReference::New(closure_class)));
  args.SetAt(1, MirrorReference::Handle(MirrorReference::New(sig)));
  args.SetAt(2, type);
  return CreateMirror(Symbols::_FunctionTypeMirror(), args);
}

CreateFutureOrType()

static TypePtr dart::CreateFutureOrType ( const AbstractType &  param, Nullability  nullability  )

static

Definition at line 7619 of file object_test.cc.

CreateFutureType()

static TypePtr dart::CreateFutureType ( const AbstractType &  param, Nullability  nullability  )

static

Definition at line 7632 of file object_test.cc.

CreateInvokeInstantiateTypeArgumentsStub()

static CodePtr dart::CreateInvokeInstantiateTypeArgumentsStub ( Thread *  thread )

static

Definition at line 7976 of file object_test.cc.

                                                                        {
  Zone* const zone = thread->zone();
  const auto& klass = Class::Handle(
      zone, thread->isolate_group()->class_table()->At(kInstanceCid));
  const auto& symbol = String::Handle(
      zone, Symbols::New(thread, OS::SCreate(zone, "InstantiateTAVTest")));
  const auto& signature = FunctionType::Handle(zone, FunctionType::New());
  const auto& function = Function::Handle(
      zone, Function::New(signature, symbol, UntaggedFunction::kRegularFunction,
                          false, false, false, false, false, klass,
                          TokenPosition::kNoSource));
 
  compiler::ObjectPoolBuilder pool_builder;
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  compiler::Assembler assembler(&pool_builder);
  GenerateInvokeInstantiateTAVStub(&assembler);
  const Code& invoke_instantiate_tav = Code::Handle(
      Code::FinalizeCodeAndNotify("InstantiateTAV", nullptr, &assembler,
                                  Code::PoolAttachment::kNotAttachPool,
                                  /*optimized=*/false));
 
  const auto& pool =
      ObjectPool::Handle(zone, ObjectPool::NewFromBuilder(pool_builder));

CreateIsolate()

static Dart_Isolate dart::CreateIsolate ( IsolateGroup *  group, bool  is_new_group, const char *  name, void *  isolate_data, char **  error  )

static

Definition at line 1229 of file dart_api_impl.cc.

                                                {
  CHECK_NO_ISOLATE(Isolate::Current());
 
  auto source = group->source();
  Isolate* I = Dart::CreateIsolate(name, source->flags, group);
  if (I == nullptr) {
    if (error != nullptr) {
      *error = Utils::StrDup("Isolate creation failed");
    }
    return static_cast<Dart_Isolate>(nullptr);
  }
 
  Thread* T = Thread::Current();
  bool success = false;
  {
    StackZone zone(T);
    HandleScope handle_scope(T);
 
#if defined(SUPPORT_TIMELINE)
    TimelineBeginEndScope tbes(T, Timeline::GetIsolateStream(),
                               "InitializeIsolate");
    tbes.SetNumArguments(1);
    tbes.CopyArgument(0, "isolateName", I->name());
#endif
 
    // We enter an API scope here as InitializeIsolate could compile some
    // bootstrap library files which call out to a tag handler that may create
    // Api Handles when an error is encountered.
    T->EnterApiScope();
    auto& error_obj = Error::Handle(Z);
    if (is_new_group) {
      error_obj = Dart::InitializeIsolateGroup(
          T, source->snapshot_data, source->snapshot_instructions,
          source->kernel_buffer, source->kernel_buffer_size);
    }
    if (error_obj.IsNull()) {
      error_obj = Dart::InitializeIsolate(T, is_new_group, isolate_data);
    }
    if (error_obj.IsNull()) {
#if defined(DEBUG) && !defined(DART_PRECOMPILED_RUNTIME)
      if (FLAG_check_function_fingerprints && !FLAG_precompiled_mode) {
        Library::CheckFunctionFingerprints();
      }
#endif  // defined(DEBUG) && !defined(DART_PRECOMPILED_RUNTIME).
      success = true;
    } else if (error != nullptr) {
      *error = Utils::StrDup(error_obj.ToErrorCString());
    }
    // We exit the API scope entered above.
    T->ExitApiScope();
  }
 
  if (success) {
    // A Thread structure has been associated to the thread, we do the
    // safepoint transition explicitly here instead of using the
    // TransitionXXX scope objects as the reverse transition happens
    // outside this scope in Dart_ShutdownIsolate/Dart_ExitIsolate.
    T->set_execution_state(Thread::kThreadInNative);
    T->EnterSafepoint();
    if (error != nullptr) {
      *error = nullptr;
    }
    return Api::CastIsolate(I);
  }
 
  Dart::ShutdownIsolate(T);
  return static_cast<Dart_Isolate>(nullptr);
}

CreateIsolateAndSetup()

static Dart_Isolate dart::CreateIsolateAndSetup ( const char *  script_uri, const char *  main, const char *  package_root, const char *  packages_config, Dart_IsolateFlags *  flags, void *  data, char **  error  )

static

Definition at line 170 of file run_vm_tests.cc.

                                                        {
  ASSERT(script_uri != nullptr);
  ASSERT(package_root == nullptr);
  if (strcmp(script_uri, DART_VM_SERVICE_ISOLATE_NAME) == 0) {
    return CreateAndSetupServiceIsolate(script_uri, packages_config, flags,
                                        error);
  }
  const bool is_kernel_isolate =
      strcmp(script_uri, DART_KERNEL_ISOLATE_NAME) == 0;
  if (!is_kernel_isolate) {
    *error = Utils::StrDup(
        "Spawning of only Kernel isolate is supported in run_vm_tests.");
    return nullptr;
  }
  Dart_Isolate isolate = nullptr;
  bin::IsolateGroupData* isolate_group_data = nullptr;
  const uint8_t* kernel_service_buffer = nullptr;
  intptr_t kernel_service_buffer_size = 0;
 
  // Kernel isolate uses an app snapshot or the kernel service dill file.
  if (kernel_snapshot != nullptr &&
      (bin::DartUtils::SniffForMagicNumber(kernel_snapshot) ==
       bin::DartUtils::kAppJITMagicNumber)) {
    script_uri = kernel_snapshot;
    bin::AppSnapshot* app_snapshot =
        bin::Snapshot::TryReadAppSnapshot(script_uri);
    ASSERT(app_snapshot != nullptr);
    const uint8_t* ignore_vm_snapshot_data;
    const uint8_t* ignore_vm_snapshot_instructions;
    const uint8_t* isolate_snapshot_data;
    const uint8_t* isolate_snapshot_instructions;
    app_snapshot->SetBuffers(
        &ignore_vm_snapshot_data, &ignore_vm_snapshot_instructions,
        &isolate_snapshot_data, &isolate_snapshot_instructions);
    isolate_group_data = new bin::IsolateGroupData(
        script_uri, packages_config, app_snapshot, app_snapshot != nullptr);
    isolate = Dart_CreateIsolateGroup(
        DART_KERNEL_ISOLATE_NAME, DART_KERNEL_ISOLATE_NAME,
        isolate_snapshot_data, isolate_snapshot_instructions, flags,
        isolate_group_data, /*isolate_data=*/nullptr, error);
    if (*error != nullptr) {
      OS::PrintErr("Error creating isolate group: %s\n", *error);
      free(*error);
      *error = nullptr;
    }
    // If a test does not actually require the kernel isolate the main thead can
    // start calling Dart::Cleanup() while the kernel isolate is booting up.
    // This can cause the isolate to be killed early which will return `nullptr`
    // here.
    if (isolate == nullptr) {
      delete isolate_group_data;
      return nullptr;
    }
  }
  if (isolate == nullptr) {
    delete isolate_group_data;
    isolate_group_data = nullptr;
 
    bin::dfe.Init();
    bin::dfe.LoadKernelService(&kernel_service_buffer,
                               &kernel_service_buffer_size);
    ASSERT(kernel_service_buffer != nullptr);
    isolate_group_data =
        new bin::IsolateGroupData(script_uri, packages_config, nullptr, false);
    isolate_group_data->SetKernelBufferUnowned(
        const_cast<uint8_t*>(kernel_service_buffer),
        kernel_service_buffer_size);
    isolate = Dart_CreateIsolateGroupFromKernel(
        script_uri, main, kernel_service_buffer, kernel_service_buffer_size,
        flags, isolate_group_data, /*isolate_data=*/nullptr, error);
  }
  if (isolate == nullptr) {
    delete isolate_group_data;
    return nullptr;
  }
 
  Dart_EnterScope();
 
  bin::DartUtils::SetOriginalWorkingDirectory();
  Dart_Handle result = bin::DartUtils::PrepareForScriptLoading(
      /*is_service_isolate=*/false, /*trace_loading=*/false);
  CHECK_RESULT(result);
 
  // Setup kernel service as the main script for this isolate.
  if (kernel_service_buffer != nullptr) {
    result = Dart_LoadScriptFromKernel(kernel_service_buffer,
                                       kernel_service_buffer_size);
    CHECK_RESULT(result);
  }
 
  Dart_ExitScope();
  Dart_ExitIsolate();
  *error = Dart_IsolateMakeRunnable(isolate);
  if (*error != nullptr) {
    Dart_EnterIsolate(isolate);
    Dart_ShutdownIsolate();
    return nullptr;
  }
 
  return isolate;
}

CreateIsolateMirror()

static InstancePtr dart::CreateIsolateMirror ( )

static

Definition at line 569 of file mirrors.cc.

                                         {
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  const String& debug_name = String::Handle(String::New(isolate->name()));
  const Library& root_library = Library::Handle(
      thread->zone(), isolate->group()->object_store()->root_library());
  const Instance& root_library_mirror =
      Instance::Handle(CreateLibraryMirror(thread, root_library));
 
  const Array& args = Array::Handle(Array::New(2));
  args.SetAt(0, debug_name);
  args.SetAt(1, root_library_mirror);
  return CreateMirror(Symbols::_IsolateMirror(), args);
}

CreateLibraryDependencyMirror() [1/2]

static InstancePtr dart::CreateLibraryDependencyMirror ( Thread *  thread, const Instance &  importer, const Library &  importee, const Array &  show_names, const Array &  hide_names, const Object &  metadata, const LibraryPrefix &  prefix, const String &  prefix_name, const bool  is_import, const bool  is_deferred  )

static

Definition at line 370 of file mirrors.cc.

                                                                         {
  const Instance& importee_mirror =
      Instance::Handle(CreateLibraryMirror(thread, importee));
  if (importee_mirror.IsNull()) {
    // Imported library is censored: censor the import.
    return Instance::null();
  }
 
  intptr_t n = show_names.IsNull() ? 0 : show_names.Length();
  intptr_t m = hide_names.IsNull() ? 0 : hide_names.Length();
  const Array& combinators = Array::Handle(Array::New(n + m));
  Object& t = Object::Handle();
  intptr_t i = 0;
  for (intptr_t j = 0; j < n; j++) {
    t = show_names.At(j);
    t = CreateCombinatorMirror(t, true);
    combinators.SetAt(i++, t);
  }
  for (intptr_t j = 0; j < m; j++) {
    t = hide_names.At(j);
    t = CreateCombinatorMirror(t, false);
    combinators.SetAt(i++, t);
  }
 
  const Array& args = Array::Handle(Array::New(7));
  args.SetAt(0, importer);
  if (importee.Loaded() || prefix.IsNull()) {
    // A native extension is never "loaded" by the embedder. Use the fact that
    // it doesn't have an prefix where asa  deferred import does to distinguish
    // it from a deferred import. It will appear like an empty library.
    args.SetAt(1, importee_mirror);
  } else {
    args.SetAt(1, prefix);
  }
  args.SetAt(2, combinators);
  args.SetAt(3, prefix_name);
  args.SetAt(4, Bool::Get(is_import));
  args.SetAt(5, Bool::Get(is_deferred));
  args.SetAt(6, metadata);
  return CreateMirror(Symbols::_LibraryDependencyMirror(), args);
}

CreateLibraryDependencyMirror() [2/2]

static InstancePtr dart::CreateLibraryDependencyMirror ( Thread *  thread, const Instance &  importer, const Namespace &  ns, const LibraryPrefix &  prefix, const bool  is_import, const bool  is_deferred  )

static

Definition at line 421 of file mirrors.cc.

                                                                         {
  const Library& importee = Library::Handle(ns.target());
  const Array& show_names = Array::Handle(ns.show_names());
  const Array& hide_names = Array::Handle(ns.hide_names());
 
  const Library& owner = Library::Handle(ns.owner());
  Object& metadata = Object::Handle(owner.GetMetadata(ns));
  if (metadata.IsError()) {
    Exceptions::PropagateError(Error::Cast(metadata));
    UNREACHABLE();
  }
 
  auto& prefix_name = String::Handle();
  if (!prefix.IsNull()) {
    prefix_name = prefix.name();
  }
 
  return CreateLibraryDependencyMirror(thread, importer, importee, show_names,
                                       hide_names, metadata, prefix,
                                       prefix_name, is_import, is_deferred);
}

CreateLibraryMirror()

static InstancePtr dart::CreateLibraryMirror ( Thread *  thread, const Library &  lib  )

static

Definition at line 345 of file mirrors.cc.

                                                                           {
  Zone* zone = thread->zone();
  ASSERT(!lib.IsNull());
  const Array& args = Array::Handle(zone, Array::New(3));
  args.SetAt(0, MirrorReference::Handle(zone, MirrorReference::New(lib)));
  String& str = String::Handle(zone);
  str = lib.name();
  args.SetAt(1, str);
  str = lib.url();
  if (IsCensoredLibrary(str)) {
    // Censored library (grumble).
    return Instance::null();
  }
  args.SetAt(2, str);
  return CreateMirror(Symbols::_LibraryMirror(), args);
}

CreateLineStartsData()

const dart::TypedData & dart::CreateLineStartsData

(

)

Definition at line 15 of file kernel_test.cc.

                                            {
  const intptr_t raw_line_starts_data[] = {
      0, 8, 12, 17, 18, 20, 23, 30, 31, 33,
  };
  const intptr_t length = std::extent<decltype(raw_line_starts_data)>::value;
  ASSERT(length > 0);
  const TypedData& line_starts_data = TypedData::Handle(
      TypedData::New(kTypedDataUint16ArrayCid, length, Heap::kOld));
  for (intptr_t i = 0; i < length; ++i) {
    line_starts_data.SetUint16(i << 1,
                               static_cast<int16_t>(raw_line_starts_data[i]));
  }
  return line_starts_data;
}

CreateMethodMirror()

static InstancePtr dart::CreateMethodMirror ( const Function &  func, const Instance &  owner_mirror, const AbstractType &  instantiator  )

static

Definition at line 240 of file mirrors.cc.

                                                                        {
  const Array& args = Array::Handle(Array::New(6));
  args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
 
  String& name = String::Handle(func.name());
  name = String::ScrubNameRetainPrivate(
      name, func.is_extension_member() || func.is_extension_type_member());
  args.SetAt(1, name);
  args.SetAt(2, owner_mirror);
  args.SetAt(3, instantiator);
  args.SetAt(4, Bool::Get(func.is_static()));
 
  intptr_t kind_flags = 0;
  kind_flags |=
      (static_cast<intptr_t>(func.is_abstract()) << Mirrors::kAbstract);
  kind_flags |=
      (static_cast<intptr_t>(func.IsGetterFunction()) << Mirrors::kGetter);
  kind_flags |=
      (static_cast<intptr_t>(func.IsSetterFunction()) << Mirrors::kSetter);
  bool is_ctor = (func.kind() == UntaggedFunction::kConstructor);
  kind_flags |= (static_cast<intptr_t>(is_ctor) << Mirrors::kConstructor);
  kind_flags |= (static_cast<intptr_t>(is_ctor && func.is_const())
                 << Mirrors::kConstCtor);
  kind_flags |=
      (static_cast<intptr_t>(is_ctor && func.IsGenerativeConstructor())
       << Mirrors::kGenerativeCtor);
  kind_flags |= (static_cast<intptr_t>(false) << Mirrors::kRedirectingCtor);
  kind_flags |= (static_cast<intptr_t>(is_ctor && func.IsFactory())
                 << Mirrors::kFactoryCtor);
  kind_flags |=
      (static_cast<intptr_t>(func.is_external()) << Mirrors::kExternal);
  bool is_synthetic = func.is_synthetic();
  kind_flags |= (static_cast<intptr_t>(is_synthetic) << Mirrors::kSynthetic);
  kind_flags |= (static_cast<intptr_t>(func.is_extension_member())
                 << Mirrors::kExtensionMember);
  kind_flags |= (static_cast<intptr_t>(func.is_extension_type_member())
                 << Mirrors::kExtensionTypeMember);
  args.SetAt(5, Smi::Handle(Smi::New(kind_flags)));
 
  return CreateMirror(Symbols::_MethodMirror(), args);
}

CreateMirror()

static InstancePtr dart::CreateMirror ( const String &  mirror_class_name, const Array &  constructor_arguments  )

static

Definition at line 31 of file mirrors.cc.

                                                                    {
  const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary());
  const String& constructor_name = Symbols::DotUnder();
 
  const Object& result = Object::Handle(DartLibraryCalls::InstanceCreate(
      mirrors_lib, mirror_class_name, constructor_name, constructor_arguments));
  if (result.IsError()) {
    Exceptions::PropagateError(Error::Cast(result));
  }
  return Instance::Cast(result).ptr();
}

CreateNativePorts()

static void dart::CreateNativePorts ( uword  param )

static

Definition at line 9948 of file dart_api_impl_test.cc.

            :isolate';
@pragma("vm:external-name", "Test_nativeFunc")
external void notifyLowMemory();
void main() {
  var v;
  for (var i = 0; i < 100; i++) {
    var t = [];
    for (var j = 0; j < 10000; j++) {
      t.add(List.filled(100, null));
    }
    v = t;
    notifyLowMemory();
  }
})";

CreateParallelMoveAfter()

static ParallelMoveInstr * dart::CreateParallelMoveAfter ( Instruction *  instr, intptr_t  pos  )

static

Definition at line 1677 of file linearscan.cc.

                                                                {
  Instruction* next = instr->next();
  if (next->IsParallelMove() &&
      (FlowGraphAllocator::GetLifetimePosition(next) == pos)) {
    return next->AsParallelMove();
  }
  return CreateParallelMoveBefore(next, pos);
}

CreateParallelMoveBefore()

static ParallelMoveInstr * dart::CreateParallelMoveBefore ( Instruction *  instr, intptr_t  pos  )

static

Definition at line 1662 of file linearscan.cc.

                                                                 {
  ASSERT(pos > 0);
  Instruction* prev = instr->previous();
  ParallelMoveInstr* move = prev->AsParallelMove();
  if ((move == nullptr) ||
      (FlowGraphAllocator::GetLifetimePosition(move) != pos)) {
    move = new ParallelMoveInstr();
    prev->LinkTo(move);
    move->LinkTo(instr);
    FlowGraphAllocator::SetLifetimePosition(move, pos);
  }
  return move;
}

CreateParameterMirrorList()

static InstancePtr dart::CreateParameterMirrorList ( const Function &  func, const FunctionType &  signature, const Instance &  owner_mirror  )

static

Definition at line 96 of file mirrors.cc.

                                                                           {
  Thread* const T = Thread::Current();
  Zone* const Z = T->zone();
  HANDLESCOPE(T);
  const intptr_t implicit_param_count = signature.num_implicit_parameters();
  const intptr_t non_implicit_param_count =
      signature.NumParameters() - implicit_param_count;
  const intptr_t index_of_first_optional_param =
      non_implicit_param_count - signature.NumOptionalParameters();
  const intptr_t index_of_first_named_param =
      non_implicit_param_count - signature.NumOptionalNamedParameters();
  const Array& results = Array::Handle(Z, Array::New(non_implicit_param_count));
  const Array& args = Array::Handle(Z, Array::New(9));
 
  Smi& pos = Smi::Handle(Z);
  String& name = String::Handle(Z);
  Instance& param = Instance::Handle(Z);
  Bool& is_final = Bool::Handle(Z);
  Object& default_value = Object::Handle(Z);
  Object& metadata = Object::Handle(Z);
 
  // We force compilation of constructors to ensure the types of initializing
  // formals have been corrected. We do not force the compilation of all types
  // of functions because some have no body, e.g. signature functions.
  if (!func.IsNull()) {
    EnsureConstructorsAreCompiled(func);
  }
 
  bool has_extra_parameter_info = true;
  if (non_implicit_param_count == 0) {
    has_extra_parameter_info = false;
  }
  if (func.IsNull() || func.IsImplicitConstructor()) {
    // This covers the default constructor and forwarding constructors.
    has_extra_parameter_info = false;
  }
  Array& param_descriptor = Array::Handle();
  if (has_extra_parameter_info) {
    // Reparse the function for the following information:
    // * The default value of a parameter.
    // * Whether a parameters has been declared as final.
    // * Any metadata associated with the parameter.
    Object& result = Object::Handle(kernel::BuildParameterDescriptor(func));
    if (result.IsError()) {
      Exceptions::PropagateError(Error::Cast(result));
      UNREACHABLE();
    }
    param_descriptor ^= result.ptr();
    ASSERT(param_descriptor.Length() ==
           (Parser::kParameterEntrySize * non_implicit_param_count));
  }
 
  args.SetAt(0, MirrorReference::Handle(MirrorReference::New(signature)));
  args.SetAt(2, owner_mirror);
 
  if (!has_extra_parameter_info) {
    is_final = Bool::True().ptr();
    default_value = Object::null();
    metadata = Object::null();
  }
 
  for (intptr_t i = 0; i < non_implicit_param_count; i++) {
    pos = Smi::New(i);
    if (i >= index_of_first_named_param) {
      // Named parameters are stored in the signature.
      name = signature.ParameterNameAt(implicit_param_count + i);
    } else if (!func.IsNull()) {
      // Positional parameters are stored in the function.
      name = func.ParameterNameAt(implicit_param_count + i);
    } else {
      // We were not given a function, only the type, so create placeholder
      // names for the positional parameters.
      const char* const placeholder = OS::SCreate(Z, ":param%" Pd "", i);
      name = String::New(placeholder);
    }
    if (has_extra_parameter_info) {
      is_final ^= param_descriptor.At(i * Parser::kParameterEntrySize +
                                      Parser::kParameterIsFinalOffset);
      default_value = param_descriptor.At(i * Parser::kParameterEntrySize +
                                          Parser::kParameterDefaultValueOffset);
      metadata = param_descriptor.At(i * Parser::kParameterEntrySize +
                                     Parser::kParameterMetadataOffset);
    }
    ASSERT(default_value.IsNull() || default_value.IsInstance());
 
    // Arguments 0 (referent) and 2 (owner) are the same for all parameters. See
    // above.
    args.SetAt(1, name);
    args.SetAt(3, pos);
    args.SetAt(4, Bool::Get(i >= index_of_first_optional_param));
    args.SetAt(5, Bool::Get(i >= index_of_first_named_param));
    args.SetAt(6, is_final);
    args.SetAt(7, default_value);
    args.SetAt(8, metadata);
    param = CreateMirror(Symbols::_ParameterMirror(), args);
    results.SetAt(i, param);
  }
  results.MakeImmutable();
  return results.ptr();
}

CreatePreallocatedStackTrace()

static StackTracePtr dart::CreatePreallocatedStackTrace ( Zone *  zone )

static

Definition at line 58 of file object_store.cc.

                                                              {
  const Array& code_array = Array::Handle(
      zone, Array::New(StackTrace::kPreallocatedStackdepth, Heap::kOld));
  const TypedData& pc_offset_array = TypedData::Handle(
      zone, TypedData::New(kUintPtrCid, StackTrace::kPreallocatedStackdepth,
                           Heap::kOld));
  const StackTrace& stack_trace =
      StackTrace::Handle(zone, StackTrace::New(code_array, pc_offset_array));
  // Expansion of inlined functions requires additional memory at run time,
  // avoid it.
  stack_trace.set_expand_inlined(false);
  return stack_trace.ptr();
}

CreateSourceLocation()

static InstancePtr dart::CreateSourceLocation ( const String &  uri, intptr_t  line, intptr_t  column  )

static

Definition at line 1558 of file mirrors.cc.

                                                         {
  const Array& args = Array::Handle(Array::New(3));
  args.SetAt(0, uri);
  args.SetAt(1, Smi::Handle(Smi::New(line)));
  args.SetAt(2, Smi::Handle(Smi::New(column)));
  return CreateMirror(Symbols::_SourceLocation(), args);
}

CreateSpecializedFunction()

void dart::CreateSpecializedFunction	(	Thread *	thread,
		Zone *	zone,
		const RegExp &	regexp,
		intptr_t	specialization_cid,
		bool	sticky,
		const Object &	owner
	)

Definition at line 5523 of file regexp.cc.

                                                    {
  const intptr_t kParamCount = RegExpMacroAssembler::kParamCount;
 
  const FunctionType& signature =
      FunctionType::Handle(zone, FunctionType::New());
  const String& pattern = String::Handle(zone, regexp.pattern());
  Function& fn =
      Function::Handle(zone, Function::New(signature, pattern,
                                           UntaggedFunction::kIrregexpFunction,
                                           true,   // Static.
                                           false,  // Not const.
                                           false,  // Not abstract.
                                           false,  // Not external.
                                           false,  // Not native.
                                           owner, TokenPosition::kMinSource));
 
  // TODO(zerny): Share these arrays between all irregexp functions.
  // TODO(regis): Better, share a common signature.
  signature.set_num_fixed_parameters(kParamCount);
  signature.set_parameter_types(
      Array::Handle(zone, Array::New(kParamCount, Heap::kOld)));
  fn.CreateNameArray();
  signature.SetParameterTypeAt(RegExpMacroAssembler::kParamRegExpIndex,
                               Object::dynamic_type());
  fn.SetParameterNameAt(RegExpMacroAssembler::kParamRegExpIndex,
                        Symbols::This());
  signature.SetParameterTypeAt(RegExpMacroAssembler::kParamStringIndex,
                               Object::dynamic_type());
  fn.SetParameterNameAt(RegExpMacroAssembler::kParamStringIndex,
                        Symbols::string_param());
  signature.SetParameterTypeAt(RegExpMacroAssembler::kParamStartOffsetIndex,
                               Object::dynamic_type());
  fn.SetParameterNameAt(RegExpMacroAssembler::kParamStartOffsetIndex,
                        Symbols::start_index_param());
  signature.set_result_type(Type::Handle(zone, Type::ArrayType()));
 
  // Cache the result.
  regexp.set_function(specialization_cid, sticky, fn);
 
  fn.SetRegExpData(regexp, specialization_cid, sticky);
  fn.set_is_debuggable(false);
 
  // The function is compiled lazily during the first call.
}

CreateStackTraceObject()

static StackTracePtr dart::CreateStackTraceObject ( Zone *  zone, const GrowableObjectArray &  code_list, const GrowableArray< uword > &  pc_offset_list  )

static

Definition at line 21 of file stacktrace.cc.

                                                {
  const auto& code_array =
      Array::Handle(zone, Array::MakeFixedLength(code_list));
  const auto& pc_offset_array = TypedData::Handle(
      zone, TypedData::New(kUintPtrCid, pc_offset_list.length()));
  {
    NoSafepointScope no_safepoint;
    memmove(pc_offset_array.DataAddr(0), pc_offset_list.data(),
            pc_offset_list.length() * kWordSize);
  }
  return StackTrace::New(code_array, pc_offset_array);
}

CreateTestClass() [1/2]

static ClassPtr dart::CreateTestClass ( const char *  name )

static

Definition at line 12 of file class_finalizer_test.cc.

                                                  {
  Thread* thread = Thread::Current();
  const String& class_name = String::Handle(Symbols::New(thread, name));
  const Script& script = Script::Handle();
  const Class& cls = Class::Handle(Class::New(
      Library::Handle(), class_name, script, TokenPosition::kNoSource));
  cls.set_interfaces(Object::empty_array());
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  cls.set_is_declaration_loaded();
  cls.SetFunctions(Object::empty_array());
  cls.SetFields(Object::empty_array());
  return cls.ptr();
}

CreateTestClass() [2/2]

static ClassPtr dart::CreateTestClass ( const char *  name )

static

Definition at line 2966 of file object_test.cc.

                                                  {
  const String& class_name =
      String::Handle(Symbols::New(Thread::Current(), name));
  const Class& cls =
      Class::Handle(CreateDummyClass(class_name, Script::Handle()));
  return cls.ptr();
}

CreateTestField()

static FieldPtr dart::CreateTestField ( const char *  name )

static

Definition at line 2974 of file object_test.cc.

                                                  {
  auto thread = Thread::Current();
  const Class& cls = Class::Handle(CreateTestClass("global:"));
  const String& field_name = String::Handle(Symbols::New(thread, name));
  const Field& field = Field::Handle(Field::New(
      field_name, true, false, false, true, false, cls, Object::dynamic_type(),
      TokenPosition::kMinSource, TokenPosition::kMinSource));
  {
    SafepointWriteRwLocker locker(thread,
                                  thread->isolate_group()->program_lock());
    thread->isolate_group()->RegisterStaticField(field, Object::sentinel());
  }
  return field.ptr();
}

CreateTestFunction()

FunctionPtr dart::CreateTestFunction

(

FfiCallbackKind

kind

)

Definition at line 25 of file ffi_callback_metadata_test.cc.

                                                     {
  const auto& ffi_lib = Library::Handle(Library::FfiLibrary());
  const auto& ffi_void = Class::Handle(ffi_lib.LookupClass(Symbols::FfiVoid()));
  const auto& ffi_void_type =
      Type::Handle(Type::NewNonParameterizedType(ffi_void));
 
  auto* thread = Thread::Current();
  const char* kScriptChars =
      R"(
      void testFunction() {
      }
      )";
  Dart_Handle library;
  {
    TransitionVMToNative transition(thread);
    library = TestCase::LoadTestScript(kScriptChars, nullptr);
    EXPECT_VALID(library);
  }
 
  const auto& lib =
      Library::Handle(Library::RawCast(Api::UnwrapHandle(library)));
  EXPECT(ClassFinalizer::ProcessPendingClasses());
  const auto& cls = Class::Handle(lib.toplevel_class());
  EXPECT(!cls.IsNull());
  const auto& error = cls.EnsureIsFinalized(thread);
  EXPECT(error == Error::null());
 
  auto& function_name = String::Handle(String::New("testFunction"));
  const auto& func = Function::Handle(cls.LookupStaticFunction(function_name));
  EXPECT(!func.IsNull());
 
  FunctionType& signature = FunctionType::Handle(FunctionType::New());
  signature.set_result_type(ffi_void_type);
  signature.SetIsFinalized();
  signature ^= signature.Canonicalize(thread);
 
  const auto& callback = Function::Handle(compiler::ffi::NativeCallbackFunction(
      signature, func, Instance::Handle(Instance::null()), kind));
 
  const auto& result = Object::Handle(
      thread->zone(), Compiler::CompileFunction(thread, callback));
  EXPECT(!result.IsError());

CreateTimelineEvents()

static void dart::CreateTimelineEvents ( uword  param )

static

Definition at line 10061 of file dart_api_impl_test.cc.

                    {
                  "jsonrpc": 2.0,
                  "id": "foo",
                  "method": "getVM",
                  "params": { }
                 })");
  uint8_t* response_json = nullptr;
  intptr_t response_json_length = 0;
  char* error = nullptr;

CreateTypeMirror()

static InstancePtr dart::CreateTypeMirror ( const AbstractType &  type )

static

Definition at line 518 of file mirrors.cc.

                                                              {
  ASSERT(type.IsFinalized());
  ASSERT(type.IsCanonical());
 
  if (type.IsFunctionType()) {
    return CreateFunctionTypeMirror(type);
  }
  if (type.IsRecordType()) {
    const Class& cls =
        Class::Handle(IsolateGroup::Current()->object_store()->record_class());
    return CreateClassMirror(cls, AbstractType::Handle(cls.DeclarationType()),
                             Bool::False(), Object::null_instance());
  }
  if (type.HasTypeClass()) {
    const Class& cls = Class::Handle(type.type_class());
    // Handle void and dynamic types.
    if (cls.IsVoidClass()) {
      Array& args = Array::Handle(Array::New(1));
      args.SetAt(0, Symbols::Void());
      return CreateMirror(Symbols::_SpecialTypeMirror(), args);
    } else if (cls.IsDynamicClass()) {
      Array& args = Array::Handle(Array::New(1));
      args.SetAt(0, Symbols::Dynamic());
      return CreateMirror(Symbols::_SpecialTypeMirror(), args);
    } else if (cls.IsNeverClass()) {
      Array& args = Array::Handle(Array::New(1));
      args.SetAt(0, Symbols::Never());
      return CreateMirror(Symbols::_SpecialTypeMirror(), args);
    }
    // TODO(regis): Until mirrors reflect nullability, force kLegacy, except for
    // Null type, which should remain nullable.
    if (!type.IsNullType()) {
      Type& legacy_type = Type::Handle(
          Type::Cast(type).ToNullability(Nullability::kLegacy, Heap::kOld));
      legacy_type ^= legacy_type.Canonicalize(Thread::Current());
      return CreateClassMirror(cls, legacy_type, Bool::False(),
                               Object::null_instance());
    }
    return CreateClassMirror(cls, type, Bool::False(), Object::null_instance());
  } else if (type.IsTypeParameter()) {
    // TODO(regis): Until mirrors reflect nullability, force kLegacy.
    TypeParameter& legacy_type =
        TypeParameter::Handle(TypeParameter::Cast(type).ToNullability(
            Nullability::kLegacy, Heap::kOld));
    legacy_type ^= legacy_type.Canonicalize(Thread::Current());
    return CreateTypeVariableMirror(legacy_type, Object::null_instance());
  }
  UNREACHABLE();
  return Instance::null();
}

CreateTypeVariableList()

static InstancePtr dart::CreateTypeVariableList ( const Class &  cls )

static

Definition at line 210 of file mirrors.cc.

                                                            {
  const intptr_t num_type_params = cls.NumTypeParameters();
  if (num_type_params == 0) {
    return Object::empty_array().ptr();
  }
  const Array& result = Array::Handle(Array::New(num_type_params * 2));
  TypeParameter& type = TypeParameter::Handle();
  String& name = String::Handle();
  for (intptr_t i = 0; i < num_type_params; i++) {
    type = cls.TypeParameterAt(i, Nullability::kLegacy);
    ASSERT(type.IsFinalized());
    name = type.UserVisibleName();
    result.SetAt(2 * i, name);
    result.SetAt(2 * i + 1, type);
  }
  return result.ptr();
}

CreateTypeVariableMirror()

static InstancePtr dart::CreateTypeVariableMirror ( const TypeParameter &  param, const Instance &  owner_mirror  )

static

Definition at line 199 of file mirrors.cc.

                                                                          {
  const Array& args = Array::Handle(Array::New(3));
  args.SetAt(0, param);
  args.SetAt(1, String::Handle(param.UserVisibleName()));
  args.SetAt(2, owner_mirror);
  return CreateMirror(Symbols::_TypeVariableMirror(), args);
}

CreateVariableMirror()

static InstancePtr dart::CreateVariableMirror ( const Field &  field, const Instance &  owner_mirror  )

static

Definition at line 284 of file mirrors.cc.

                                                                      {
  const MirrorReference& field_ref =
      MirrorReference::Handle(MirrorReference::New(field));
 
  const String& name = String::Handle(field.name());
 
  const Array& args = Array::Handle(Array::New(9));
  args.SetAt(0, field_ref);
  args.SetAt(1, name);
  args.SetAt(2, owner_mirror);
  args.SetAt(3, Object::null_instance());  // Null for type.
  args.SetAt(4, Bool::Get(field.is_static()));
  args.SetAt(5, Bool::Get(field.is_final()));
  args.SetAt(6, Bool::Get(field.is_const()));
  args.SetAt(7, Bool::Get(field.is_extension_member()));
  args.SetAt(8, Bool::Get(field.is_extension_type_member()));
 
  return CreateMirror(Symbols::_VariableMirror(), args);
}

CreateWithinExistingIsolateGroup()

Isolate * dart::CreateWithinExistingIsolateGroup	(	IsolateGroup *	group,
		const char *	name,
		char **	error
	)

Definition at line 1302 of file dart_api_impl.cc.

                                                        {
  API_TIMELINE_DURATION(Thread::Current());
  CHECK_NO_ISOLATE(Isolate::Current());
 
  auto spawning_group = group;
 
  Isolate* isolate = reinterpret_cast<Isolate*>(
      CreateIsolate(spawning_group, /*is_new_group=*/false, name,
                    /*isolate_data=*/nullptr, error));
  if (isolate == nullptr) return nullptr;
 
  auto source = spawning_group->source();
  ASSERT(isolate->source() == source);
 
  return isolate;
}

CStringToDouble()

bool dart::CStringToDouble	(	const char *	str,
		intptr_t	length,
		double *	result
	)

Definition at line 155 of file double_conversion.cc.

                                                                       {
  if (length == 0) {
    return false;
  }
 
  double_conversion::StringToDoubleConverter converter(
      double_conversion::StringToDoubleConverter::NO_FLAGS, 0.0, 0.0,
      kInfinitySymbol, kNaNSymbol);
 
  int parsed_count = 0;
  *result =
      converter.StringToDouble(str, static_cast<int>(length), &parsed_count);
  return (parsed_count == length);
}

CurrentStackTrace()

static StackTracePtr dart::CurrentStackTrace ( Thread *  thread, intptr_t  skip_frames = 1  )

static

Definition at line 38 of file stacktrace.cc.

                                                                 {
  Zone* zone = thread->zone();
 
  const auto& code_array = GrowableObjectArray::ZoneHandle(
      zone, GrowableObjectArray::New(kDefaultStackAllocation));
  GrowableArray<uword> pc_offset_array(kDefaultStackAllocation);
 
  // Collect the frames.
  StackTraceUtils::CollectFrames(thread, skip_frames,
                                 [&](const StackTraceUtils::Frame& frame) {
                                   code_array.Add(frame.code);
                                   pc_offset_array.Add(frame.pc_offset);
                                 });
 
  return CreateStackTraceObject(zone, code_array, pc_offset_array);
}

CurrentStackTraceNative()

void dart::CurrentStackTraceNative

(

Dart_NativeArguments

args

)

Definition at line 494 of file dart_api_impl_test.cc.

                                                        {
  Dart_EnterScope();
 
  Dart_StackTrace stacktrace;
  Dart_Handle result = Dart_GetStackTrace(&stacktrace);
  EXPECT_VALID(result);
 
  intptr_t frame_count = 0;
  result = Dart_StackTraceLength(stacktrace, &frame_count);
  EXPECT_VALID(result);
  EXPECT_EQ(102, frame_count);
  // Test something bigger than the preallocated size to verify nothing was
  // truncated.
  EXPECT(102 > StackTrace::kPreallocatedStackdepth);
 
  Dart_Handle function_name;
  Dart_Handle script_url;
  intptr_t line_number = 0;
  intptr_t column_number = 0;
  const char* cstr = "";
  const char* test_lib = "file:///test-lib";
 
  // Top frame is inspectStack().
  Dart_ActivationFrame frame;
  result = Dart_GetActivationFrame(stacktrace, 0, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("inspectStack", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_STREQ(test_lib, cstr);
  EXPECT_EQ(3, line_number);
  EXPECT_EQ(24, column_number);
 
  // Second frame is foo() positioned at call to inspectStack().
  result = Dart_GetActivationFrame(stacktrace, 1, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("foo", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_STREQ(test_lib, cstr);
  EXPECT_EQ(4, line_number);
  EXPECT_EQ(20, column_number);
 
  // Middle frames positioned at the recursive call.
  for (intptr_t frame_index = 2; frame_index < (frame_count - 1);
       frame_index++) {
    result = Dart_GetActivationFrame(stacktrace, frame_index, &frame);
    EXPECT_VALID(result);
    result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                      &line_number, &column_number);
    EXPECT_VALID(result);
    Dart_StringToCString(function_name, &cstr);
    EXPECT_STREQ("foo", cstr);
    Dart_StringToCString(script_url, &cstr);
    EXPECT_STREQ(test_lib, cstr);
    EXPECT_EQ(4, line_number);
    EXPECT_EQ(37, column_number);
  }
 
  // Bottom frame positioned at testMain().
  result = Dart_GetActivationFrame(stacktrace, frame_count - 1, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("testMain", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_STREQ(test_lib, cstr);
  EXPECT_EQ(5, line_number);
  EXPECT_EQ(15, column_number);
 
  // Out-of-bounds frames.
  result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
  EXPECT(Dart_IsError(result));
  result = Dart_GetActivationFrame(stacktrace, -1, &frame);
  EXPECT(Dart_IsError(result));
 
  Dart_SetReturnValue(args, Dart_NewInteger(42));
  Dart_ExitScope();
}

CurrentStackTraceNativeLookup()

static Dart_NativeFunction dart::CurrentStackTraceNativeLookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 582 of file dart_api_impl_test.cc.

                            {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  return CurrentStackTraceNative;
}

CustomIsolateImpl_start()

static void dart::CustomIsolateImpl_start ( Dart_NativeArguments  args )

static

Definition at line 256 of file custom_isolate_test.cc.

                                                               {
  OS::PrintErr("-- Enter: CustomIsolateImpl_start --\n");
 
  // We would probably want to pass in the this pointer too, so we
  // could associate the CustomIsolateImpl instance with the
  // Dart_Isolate by storing it in a native field.
  EXPECT_EQ(1, Dart_GetNativeArgumentCount(args));
  Dart_Handle param = Dart_GetNativeArgument(args, 0);
  EXPECT_VALID(param);
  EXPECT(Dart_IsString(param));
  const char* isolate_main = nullptr;
  EXPECT_VALID(Dart_StringToCString(param, &isolate_main));
  isolate_main = Utils::StrDup(isolate_main);
 
  // Save current isolate.
  Dart_Isolate saved_isolate = Dart_CurrentIsolate();
  Dart_ExitIsolate();
 
  // Create a new Dart_Isolate.
  Dart_Isolate new_isolate = TestCase::CreateTestIsolate();
  EXPECT(new_isolate != nullptr);
  Dart_SetMessageNotifyCallback(&NotifyMessage);
  Dart_EnterScope();
  // Reload all the test classes here.
  //
  // TODO(turnidge): Use the create isolate callback instead?
  Dart_Handle lib =
      TestCase::LoadTestScript(kCustomIsolateScriptChars, NativeLookup);
  EXPECT_VALID(lib);
 
  Dart_Handle main_send_port = Dart_GetField(lib, NewString("mainSendPort"));
  EXPECT_VALID(main_send_port);
  Dart_Port main_port_id;
  Dart_Handle err = Dart_SendPortGetId(main_send_port, &main_port_id);
  EXPECT_VALID(err);
 
  OS::PrintErr("-- Adding StartEvent to queue --\n");
  event_queue->Add(new StartEvent(new_isolate, isolate_main));
 
  // Restore the original isolate.
  Dart_ExitScope();
  Dart_ExitIsolate();
  Dart_EnterIsolate(saved_isolate);
  Dart_EnterScope();
 
  Dart_Handle send_port = Dart_NewSendPort(main_port_id);
  EXPECT_VALID(send_port);
  Dart_SetReturnValue(args, send_port);
 
  OS::PrintErr("-- Exit: CustomIsolateImpl_start --\n");
  Dart_ExitScope();
}

CutOutRange()

static void dart::CutOutRange ( RegExpMacroAssembler *  masm, ZoneGrowableArray< uint16_t > *  ranges, intptr_t  start_index, intptr_t  end_index, intptr_t  cut_index, BlockLabel *  even_label, BlockLabel *  odd_label  )

static

Definition at line 1121 of file regexp.cc.

                                               {
  bool odd = (((cut_index - start_index) & 1) == 1);
  BlockLabel* in_range_label = odd ? odd_label : even_label;
  BlockLabel dummy;
  EmitDoubleBoundaryTest(masm, ranges->At(cut_index),
                         ranges->At(cut_index + 1) - 1, &dummy, in_range_label,
                         &dummy);
  ASSERT(!dummy.is_linked());
  // Cut out the single range by rewriting the array.  This creates a new
  // range that is a merger of the two ranges on either side of the one we
  // are cutting out.  The oddity of the labels is preserved.
  for (intptr_t j = cut_index; j > start_index; j--) {
    (*ranges)[j] = ranges->At(j - 1);
  }
  for (intptr_t j = cut_index + 1; j < end_index; j++) {
    (*ranges)[j] = ranges->At(j + 1);
  }
}

Dart_ActivationFrameInfo()

Dart_Handle dart::Dart_ActivationFrameInfo	(	Dart_ActivationFrame	activation_frame,
		Dart_Handle *	function_name,
		Dart_Handle *	script_url,
		intptr_t *	line_number,
		intptr_t *	column_number
	)

Returns information about the given activation frame. \function_name receives a string handle with the qualified function name. \script_url receives a string handle with the url of the source script that contains the frame's function. \line_number receives the line number in the script. \col_number receives the column number in the script, or -1 if column information is not available

Any or all of the out parameters above may be nullptr.

Requires there to be a current isolate.

Returns

A valid handle if no error occurs during the operation.

Definition at line 118 of file debugger_api_impl_test.cc.

                                                              {
  DARTSCOPE(Thread::Current());
  CHECK_AND_CAST(ActivationFrame, frame, activation_frame);
  if (function_name != nullptr) {
    *function_name = Api::NewHandle(T, frame->QualifiedFunctionName());
  }
  if (script_url != nullptr) {
    *script_url = Api::NewHandle(T, frame->SourceUrl());
  }
  if (line_number != nullptr) {
    *line_number = frame->LineNumber();
  }
  if (column_number != nullptr) {
    *column_number = frame->ColumnNumber();
  }
  return Api::Success();
}

Dart_AddSymbols()

DART_EXPORT void dart::Dart_AddSymbols	(	const char *	dso_name,
		void *	buffer,
		intptr_t	buffer_size
	)

Definition at line 1593 of file dart_api_impl.cc.

                                                       {
  NativeSymbolResolver::AddSymbols(dso_name, buffer, buffer_size);
}

Dart_Allocate()

DART_EXPORT Dart_Handle dart::Dart_Allocate

(

Dart_Handle

type

)

Definition at line 4377 of file dart_api_impl.cc.

                                                        {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
 
  const Type& type_obj = Api::UnwrapTypeHandle(Z, type);
  // Get the class to instantiate.
  if (type_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, type, Type);
  }
 
  if (!type_obj.IsFinalized()) {
    return Api::NewError(
        "%s expects argument 'type' to be a fully resolved type.",
        CURRENT_FUNC);
  }
 
  const Class& cls = Class::Handle(Z, type_obj.type_class());
  const TypeArguments& type_arguments =
      TypeArguments::Handle(Z, type_obj.GetInstanceTypeArguments(T));
 
  CHECK_ERROR_HANDLE(cls.VerifyEntryPoint());
#if defined(DEBUG)
  if (!cls.is_allocated() && (Dart::vm_snapshot_kind() == Snapshot::kFullAOT)) {
    return Api::NewError("Precompilation dropped '%s'", cls.ToCString());
  }
#endif
  CHECK_ERROR_HANDLE(cls.EnsureIsAllocateFinalized(T));
  const Instance& new_obj = Instance::Handle(Z, AllocateObject(T, cls));
  if (!type_arguments.IsNull()) {
    new_obj.SetTypeArguments(type_arguments);
  }
  return Api::NewHandle(T, new_obj.ptr());
}

Dart_AllocateWithNativeFields()

DART_EXPORT Dart_Handle dart::Dart_AllocateWithNativeFields	(	Dart_Handle	type,
		intptr_t	num_native_fields,
		const intptr_t *	native_fields
	)

Definition at line 4412 of file dart_api_impl.cc.

                                                             {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
 
  const Type& type_obj = Api::UnwrapTypeHandle(Z, type);
  // Get the class to instantiate.
  if (type_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, type, Type);
  }
  if (native_fields == nullptr) {
    RETURN_NULL_ERROR(native_fields);
  }
  const Class& cls = Class::Handle(Z, type_obj.type_class());
  CHECK_ERROR_HANDLE(cls.VerifyEntryPoint());
#if defined(DEBUG)
  if (!cls.is_allocated() && (Dart::vm_snapshot_kind() == Snapshot::kFullAOT)) {
    return Api::NewError("Precompilation dropped '%s'", cls.ToCString());
  }
#endif
  CHECK_ERROR_HANDLE(cls.EnsureIsAllocateFinalized(T));
  if (num_native_fields != cls.num_native_fields()) {
    return Api::NewError(
        "%s: invalid number of native fields %" Pd " passed in, expected %d",
        CURRENT_FUNC, num_native_fields, cls.num_native_fields());
  }
  const Instance& instance = Instance::Handle(Z, AllocateObject(T, cls));
  instance.SetNativeFields(num_native_fields, native_fields);
  return Api::NewHandle(T, instance.ptr());
}

Dart_BooleanValue()

DART_EXPORT Dart_Handle dart::Dart_BooleanValue	(	Dart_Handle	boolean_obj,
		bool *	value
	)

Definition at line 2803 of file dart_api_impl.cc.

                                                       {
  DARTSCOPE(Thread::Current());
  const Bool& obj = Api::UnwrapBoolHandle(Z, boolean_obj);
  if (obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, boolean_obj, Bool);
  }
  *value = obj.value();
  return Api::Success();
}

Dart_ClassLibrary()

DART_EXPORT Dart_Handle dart::Dart_ClassLibrary

(

Dart_Handle

cls_type

)

Definition at line 2554 of file dart_api_impl.cc.

                                                                {
  DARTSCOPE(Thread::Current());
  const Type& type_obj = Api::UnwrapTypeHandle(Z, cls_type);
  const Class& klass = Class::Handle(Z, type_obj.type_class());
  if (klass.IsNull()) {
    return Api::NewError(
        "cls_type must be a Type object which represents a Class.");
  }
  const Library& library = Library::Handle(klass.library());
  if (library.IsNull()) {
    return Dart_Null();
  }
  return Api::NewHandle(Thread::Current(), library.ptr());
}

Dart_ClassName()

DART_EXPORT Dart_Handle dart::Dart_ClassName

(

Dart_Handle

cls_type

)

Definition at line 2485 of file dart_api_impl.cc.

                                                             {
  DARTSCOPE(Thread::Current());
  const Type& type_obj = Api::UnwrapTypeHandle(Z, cls_type);
  if (type_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, cls_type, Type);
  }
  const Class& klass = Class::Handle(Z, type_obj.type_class());
  if (klass.IsNull()) {
    return Api::NewError(
        "cls_type must be a Type object which represents a Class.");
  }
  return Api::NewHandle(T, klass.UserVisibleName());
}

Dart_Cleanup()

DART_EXPORT char * dart::Dart_Cleanup

(

void

)

Definition at line 1181 of file dart_api_impl.cc.

                                 {
  CHECK_NO_ISOLATE(Isolate::Current());
  return Dart::Cleanup();
}

Dart_CloseNativePort()

DART_EXPORT bool dart::Dart_CloseNativePort

(

Dart_Port

native_port_id

)

Definition at line 104 of file native_api_impl.cc.

                                                                {
  // Close the native port without a current isolate.
  IsolateLeaveScope saver(Isolate::Current());
 
  MessageHandler* handler = nullptr;
  const bool was_closed = PortMap::ClosePort(native_port_id, &handler);
  if (was_closed) {
    handler->RequestDeletion();
  }
  return was_closed;
}

Dart_ClosureFunction()

DART_EXPORT Dart_Handle dart::Dart_ClosureFunction

(

Dart_Handle

closure

)

Definition at line 2541 of file dart_api_impl.cc.

                                                                  {
  DARTSCOPE(Thread::Current());
  const Instance& closure_obj = Api::UnwrapInstanceHandle(Z, closure);
  if (closure_obj.IsNull() || !closure_obj.IsClosure()) {
    RETURN_TYPE_ERROR(Z, closure, Instance);
  }
 
  ASSERT(ClassFinalizer::AllClassesFinalized());
 
  FunctionPtr rf = Closure::Cast(closure_obj).function();
  return Api::NewHandle(T, rf);
}

Dart_CompileAll()

DART_EXPORT Dart_Handle dart::Dart_CompileAll

(

void

)

Definition at line 221 of file native_api_impl.cc.

                                          {
#if defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  Dart_Handle result = Api::CheckAndFinalizePendingClasses(T);
  if (Api::IsError(result)) {
    return result;
  }
  CHECK_CALLBACK_STATE(T);
  const Error& error = Error::Handle(T->zone(), Library::CompileAll());
  if (!error.IsNull()) {
    return Api::NewHandle(T, error.ptr());
  }
  return Api::Success();
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

Dart_CompileToKernel()

DART_EXPORT Dart_KernelCompilationResult dart::Dart_CompileToKernel	(	const char *	script_uri,
		const uint8_t *	platform_kernel,
		intptr_t	platform_kernel_size,
		bool	incremental_compile,
		bool	for_snapshot,
		bool	embed_sources,
		const char *	package_config,
		Dart_KernelCompilationVerbosityLevel	verbosity
	)

Definition at line 6049 of file dart_api_impl.cc.

                                                                     {
  API_TIMELINE_DURATION(Thread::Current());
 
  Dart_KernelCompilationResult result = {};
#if defined(DART_PRECOMPILED_RUNTIME)
  result.status = Dart_KernelCompilationStatus_Unknown;
  result.error = Utils::StrDup("Dart_CompileToKernel is unsupported.");
#else
  result = KernelIsolate::CompileToKernel(
      script_uri, platform_kernel, platform_kernel_size, 0, nullptr,
      incremental_compile, for_snapshot, embed_sources, package_config, nullptr,
      nullptr, verbosity);
  if (incremental_compile) {
    Dart_KernelCompilationResult ack_result =
        result.status == Dart_KernelCompilationStatus_Ok
            ? KernelIsolate::AcceptCompilation()
            : KernelIsolate::RejectCompilation();
    if (ack_result.status != Dart_KernelCompilationStatus_Ok) {
      FATAL(
          "An error occurred in the CFE while acking the most recent"
          " compilation results: %s",
          ack_result.error);
    }
  }
#endif
  return result;
}

Dart_CopyUTF8EncodingOfString()

DART_EXPORT Dart_Handle dart::Dart_CopyUTF8EncodingOfString	(	Dart_Handle	str,
		uint8_t *	utf8_array,
		intptr_t	length
	)

Definition at line 2941 of file dart_api_impl.cc.

                                                                       {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  if (utf8_array == nullptr) {
    RETURN_NULL_ERROR(utf8_array);
  }
  const String& str_obj = Api::UnwrapStringHandle(Z, str);
  if (str_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, str, String);
  }
  intptr_t str_len = Utf8::Length(str_obj);
  if (length < str_len) {
    return Api::NewError(
        "Provided buffer is not large enough to hold "
        "the UTF-8 representation of the string");
  }
  str_obj.ToUTF8(utf8_array, str_len);
  return Api::Success();
}

Dart_CreateAppAOTSnapshotAsAssemblies()

DART_EXPORT Dart_Handle dart::Dart_CreateAppAOTSnapshotAsAssemblies	(	Dart_CreateLoadingUnitCallback	next_callback,
		void *	next_callback_data,
		bool	strip,
		Dart_StreamingWriteCallback	write_callback,
		Dart_StreamingCloseCallback	close_callback
	)

Definition at line 6586 of file dart_api_impl.cc.

                                                {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("AOT compilation is not supported on IA32.");
#elif defined(DART_TARGET_OS_WINDOWS)
  return Api::NewError("Assembly generation is not implemented for Windows.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError(
      "This VM was built without support for AOT compilation.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_NULL(next_callback);
  CHECK_NULL(write_callback);
  CHECK_NULL(close_callback);
 
  Split(next_callback, next_callback_data, strip, /*as_elf*/ false,
        write_callback, close_callback);
 
  return Api::Success();
#endif
}

Dart_CreateAppAOTSnapshotAsAssembly()

DART_EXPORT Dart_Handle dart::Dart_CreateAppAOTSnapshotAsAssembly	(	Dart_StreamingWriteCallback	callback,
		void *	callback_data,
		bool	strip,
		void *	debug_callback_data
	)

Definition at line 6560 of file dart_api_impl.cc.

                                                               {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("AOT compilation is not supported on IA32.");
#elif defined(DART_TARGET_OS_WINDOWS)
  return Api::NewError("Assembly generation is not implemented for Windows.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError(
      "This VM was built without support for AOT compilation.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_NULL(callback);
 
  // Mark as not split.
  T->isolate_group()->object_store()->set_loading_units(Object::null_array());
 
  CreateAppAOTSnapshot(callback, callback_data, strip, /*as_elf*/ false,
                       debug_callback_data, nullptr, nullptr, 0);
 
  return Api::Success();
#endif
}

Dart_CreateAppAOTSnapshotAsElf()

DART_EXPORT Dart_Handle dart::Dart_CreateAppAOTSnapshotAsElf	(	Dart_StreamingWriteCallback	callback,
		void *	callback_data,
		bool	strip,
		void *	debug_callback_data
	)

Definition at line 6643 of file dart_api_impl.cc.

                                                          {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("AOT compilation is not supported on IA32.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError(
      "This VM was built without support for AOT compilation.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_NULL(callback);
 
  // Mark as not split.
  T->isolate_group()->object_store()->set_loading_units(Object::null_array());
 
  CreateAppAOTSnapshot(callback, callback_data, strip, /*as_elf*/ true,
                       debug_callback_data, nullptr, nullptr, 0);
 
  return Api::Success();
#endif
}

Dart_CreateAppAOTSnapshotAsElfs()

DART_EXPORT Dart_Handle dart::Dart_CreateAppAOTSnapshotAsElfs	(	Dart_CreateLoadingUnitCallback	next_callback,
		void *	next_callback_data,
		bool	strip,
		Dart_StreamingWriteCallback	write_callback,
		Dart_StreamingCloseCallback	close_callback
	)

Definition at line 6668 of file dart_api_impl.cc.

                                                                            {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("AOT compilation is not supported on IA32.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError(
      "This VM was built without support for AOT compilation.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_NULL(next_callback);
  CHECK_NULL(write_callback);
  CHECK_NULL(close_callback);
 
  Split(next_callback, next_callback_data, strip, /*as_elf*/ true,
        write_callback, close_callback);
 
  return Api::Success();
#endif
}

Dart_CreateAppJITSnapshotAsBlobs()

DART_EXPORT Dart_Handle dart::Dart_CreateAppJITSnapshotAsBlobs	(	uint8_t **	isolate_snapshot_data_buffer,
		intptr_t *	isolate_snapshot_data_size,
		uint8_t **	isolate_snapshot_instructions_buffer,
		intptr_t *	isolate_snapshot_instructions_size
	)

Definition at line 6784 of file dart_api_impl.cc.

                                                                               {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("Snapshots with code are not supported on IA32.");
#elif defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("JIT app snapshots cannot be taken from an AOT runtime");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  auto I = T->isolate();
  auto IG = T->isolate_group();
  CHECK_NULL(isolate_snapshot_data_buffer);
  CHECK_NULL(isolate_snapshot_data_size);
  CHECK_NULL(isolate_snapshot_instructions_buffer);
  CHECK_NULL(isolate_snapshot_instructions_size);
 
  // Finalize all classes if needed.
  Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
  if (Api::IsError(state)) {
    return state;
  }
 
  // Kill off any auxiliary isolates before starting with deduping.
  KillNonMainIsolatesSlow(T, I);
 
  NoBackgroundCompilerScope no_bg_compiler(T);
  DropRegExpMatchCode(Z);
 
  ProgramVisitor::Dedup(T);
 
  if (FLAG_dump_tables) {
    Symbols::DumpTable(IG);
    DumpTypeTable(I);
    DumpTypeParameterTable(I);
    DumpTypeArgumentsTable(I);
  }
 
  TIMELINE_DURATION(T, Isolate, "WriteAppJITSnapshot");
  ZoneWriteStream isolate_snapshot_data(Api::TopScope(T)->zone(),
                                        FullSnapshotWriter::kInitialSize);
  ZoneWriteStream isolate_snapshot_instructions(
      Api::TopScope(T)->zone(), FullSnapshotWriter::kInitialSize);
  BlobImageWriter image_writer(T, /*vm_instructions=*/nullptr,
                               &isolate_snapshot_instructions);
  FullSnapshotWriter writer(Snapshot::kFullJIT, nullptr, &isolate_snapshot_data,
                            nullptr, &image_writer);
  writer.WriteFullSnapshot();
 
  *isolate_snapshot_data_buffer = isolate_snapshot_data.buffer();
  *isolate_snapshot_data_size = isolate_snapshot_data.bytes_written();
  *isolate_snapshot_instructions_buffer =
      isolate_snapshot_instructions.buffer();
  *isolate_snapshot_instructions_size =
      isolate_snapshot_instructions.bytes_written();
 
  return Api::Success();
#endif
}

Dart_CreateIsolateGroup()

DART_EXPORT Dart_Isolate dart::Dart_CreateIsolateGroup	(	const char *	script_uri,
		const char *	name,
		const uint8_t *	snapshot_data,
		const uint8_t *	snapshot_instructions,
		Dart_IsolateFlags *	flags,
		void *	isolate_group_data,
		void *	isolate_data,
		char **	error
	)

Definition at line 1326 of file dart_api_impl.cc.

                                      {
  API_TIMELINE_DURATION(Thread::Current());
 
  Dart_IsolateFlags api_flags;
  if (flags == nullptr) {
    Isolate::FlagsInitialize(&api_flags);
    flags = &api_flags;
  }
 
  const char* non_null_name = name == nullptr ? "isolate" : name;
  std::unique_ptr<IsolateGroupSource> source(
      new IsolateGroupSource(script_uri, non_null_name, snapshot_data,
                             snapshot_instructions, nullptr, -1, *flags));
  auto group = new IsolateGroup(std::move(source), isolate_group_data, *flags,
                                /*is_vm_isolate=*/false);
  group->CreateHeap(
      /*is_vm_isolate=*/false,
      flags->is_service_isolate || flags->is_kernel_isolate);
  IsolateGroup::RegisterIsolateGroup(group);
  Dart_Isolate isolate = CreateIsolate(group, /*is_new_group=*/true,
                                       non_null_name, isolate_data, error);
  if (isolate != nullptr) {
    group->set_initial_spawn_successful();
  }
  return isolate;
}

Dart_CreateIsolateGroupFromKernel()

DART_EXPORT Dart_Isolate dart::Dart_CreateIsolateGroupFromKernel	(	const char *	script_uri,
		const char *	name,
		const uint8_t *	kernel_buffer,
		intptr_t	kernel_buffer_size,
		Dart_IsolateFlags *	flags,
		void *	isolate_group_data,
		void *	isolate_data,
		char **	error
	)

Definition at line 1361 of file dart_api_impl.cc.

                                                {
  API_TIMELINE_DURATION(Thread::Current());
 
  Dart_IsolateFlags api_flags;
  if (flags == nullptr) {
    Isolate::FlagsInitialize(&api_flags);
    flags = &api_flags;
  }
 
  const char* non_null_name = name == nullptr ? "isolate" : name;
  std::shared_ptr<IsolateGroupSource> source(
      new IsolateGroupSource(script_uri, non_null_name, nullptr, nullptr,
                             kernel_buffer, kernel_buffer_size, *flags));
  auto group = new IsolateGroup(source, isolate_group_data, *flags,
                                /*is_vm_isolate=*/false);
  IsolateGroup::RegisterIsolateGroup(group);
  group->CreateHeap(
      /*is_vm_isolate=*/false,
      flags->is_service_isolate || flags->is_kernel_isolate);
  Dart_Isolate isolate = CreateIsolate(group, /*is_new_group=*/true,
                                       non_null_name, isolate_data, error);
  if (isolate != nullptr) {
    group->set_initial_spawn_successful();
  }
  return isolate;
}

Dart_CreateIsolateInGroup()

DART_EXPORT Dart_Isolate dart::Dart_CreateIsolateInGroup	(	Dart_Isolate	group_member,
		const char *	name,
		Dart_IsolateShutdownCallback	shutdown_callback,
		Dart_IsolateCleanupCallback	cleanup_callback,
		void *	child_isolate_data,
		char **	error
	)

Definition at line 1396 of file dart_api_impl.cc.

                                        {
  CHECK_NO_ISOLATE(Isolate::Current());
  auto member = reinterpret_cast<Isolate*>(group_member);
  if (member->IsScheduled()) {
    FATAL("The given member isolate (%s) must not have been entered.",
          member->name());
  }
 
  *error = nullptr;
 
  Isolate* isolate;
  isolate = CreateWithinExistingIsolateGroup(member->group(), name, error);
  if (isolate != nullptr) {
    isolate->set_origin_id(member->origin_id());
    isolate->set_init_callback_data(child_isolate_data);
    isolate->set_on_shutdown_callback(shutdown_callback);
    isolate->set_on_cleanup_callback(cleanup_callback);
  }
 
  return Api::CastIsolate(isolate);
}

Dart_CreateSnapshot()

DART_EXPORT Dart_Handle dart::Dart_CreateSnapshot	(	uint8_t **	vm_snapshot_data_buffer,
		intptr_t *	vm_snapshot_data_size,
		uint8_t **	isolate_snapshot_data_buffer,
		intptr_t *	isolate_snapshot_data_size,
		bool	is_core
	)

Definition at line 1878 of file dart_api_impl.cc.

                                  {
#if defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("Cannot create snapshots on an AOT runtime.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  if (vm_snapshot_data_buffer != nullptr) {
    CHECK_NULL(vm_snapshot_data_size);
  }
  CHECK_NULL(isolate_snapshot_data_buffer);
  CHECK_NULL(isolate_snapshot_data_size);
  // Finalize all classes if needed.
  Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
  if (Api::IsError(state)) {
    return state;
  }
  NoBackgroundCompilerScope no_bg_compiler(T);
 
#if defined(DEBUG)
  T->isolate_group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  {
    HeapIterationScope iteration(T);
    CheckFunctionTypesVisitor check_canonical(T);
    iteration.IterateObjects(&check_canonical);
  }
#endif  // #if defined(DEBUG)
 
  ZoneWriteStream vm_snapshot_data(Api::TopScope(T)->zone(),
                                   FullSnapshotWriter::kInitialSize);
  ZoneWriteStream isolate_snapshot_data(Api::TopScope(T)->zone(),
                                        FullSnapshotWriter::kInitialSize);
  const Snapshot::Kind snapshot_kind =
      is_core ? Snapshot::kFullCore : Snapshot::kFull;
  FullSnapshotWriter writer(
      snapshot_kind, &vm_snapshot_data, &isolate_snapshot_data,
      nullptr /* vm_image_writer */, nullptr /* isolate_image_writer */);
  writer.WriteFullSnapshot();
  if (vm_snapshot_data_buffer != nullptr) {
    *vm_snapshot_data_buffer = vm_snapshot_data.buffer();
    *vm_snapshot_data_size = writer.VmIsolateSnapshotSize();
  }
  *isolate_snapshot_data_buffer = isolate_snapshot_data.buffer();
  *isolate_snapshot_data_size = writer.IsolateSnapshotSize();
  return Api::Success();
#endif
}

Dart_CreateVMAOTSnapshotAsAssembly()

DART_EXPORT Dart_Handle dart::Dart_CreateVMAOTSnapshotAsAssembly	(	Dart_StreamingWriteCallback	callback,
		void *	callback_data
	)

Definition at line 6614 of file dart_api_impl.cc.

                                                        {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("AOT compilation is not supported on IA32.");
#elif defined(DART_TARGET_OS_WINDOWS)
  return Api::NewError("Assembly generation is not implemented for Windows.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError(
      "This VM was built without support for AOT compilation.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_NULL(callback);
 
  TIMELINE_DURATION(T, Isolate, "WriteVMAOTSnapshot");
  StreamingWriteStream assembly_stream(kAssemblyInitialSize, callback,
                                       callback_data);
  AssemblyImageWriter image_writer(T, &assembly_stream);
  ZoneWriteStream vm_snapshot_data(T->zone(), FullSnapshotWriter::kInitialSize);
  FullSnapshotWriter writer(Snapshot::kFullAOT, &vm_snapshot_data, nullptr,
                            &image_writer, nullptr);
 
  writer.WriteFullSnapshot();
 
  return Api::Success();
#endif
}

Dart_CurrentIsolate()

DART_EXPORT Dart_Isolate dart::Dart_CurrentIsolate

(

void

)

Definition at line 1455 of file dart_api_impl.cc.

                                               {
  return Api::CastIsolate(Isolate::Current());
}

Dart_CurrentIsolateData()

DART_EXPORT void * dart::Dart_CurrentIsolateData

(

void

)

Definition at line 1459 of file dart_api_impl.cc.

                                            {
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->init_callback_data();
}

Dart_CurrentIsolateGroup()

DART_EXPORT Dart_IsolateGroup dart::Dart_CurrentIsolateGroup

(

void

)

Definition at line 1474 of file dart_api_impl.cc.

                                                         {
  return Api::CastIsolateGroup(IsolateGroup::Current());
}

Dart_CurrentIsolateGroupData()

DART_EXPORT void * dart::Dart_CurrentIsolateGroupData

(

void

)

Definition at line 1478 of file dart_api_impl.cc.

                                                 {
  IsolateGroup* isolate_group = IsolateGroup::Current();
  CHECK_ISOLATE_GROUP(isolate_group);
  NoSafepointScope no_safepoint_scope;
  return isolate_group->embedder_data();
}

Dart_CurrentIsolateGroupId()

DART_EXPORT Dart_IsolateGroupId dart::Dart_CurrentIsolateGroupId

(

void

)

Definition at line 1485 of file dart_api_impl.cc.

                                                             {
  IsolateGroup* isolate_group = IsolateGroup::Current();
  CHECK_ISOLATE_GROUP(isolate_group);
  return isolate_group->id();
}

Dart_DebugName()

DART_EXPORT Dart_Handle dart::Dart_DebugName

(

void

)

Definition at line 1499 of file dart_api_impl.cc.

                                         {
  DARTSCOPE(Thread::Current());
  Isolate* I = T->isolate();
  return Api::NewHandle(
      T, String::NewFormatted("(%" Pd64 ") '%s'",
                              static_cast<int64_t>(I->main_port()), I->name()));
}

Dart_DebugNameToCString()

DART_EXPORT const char * dart::Dart_DebugNameToCString

(

void

)

Definition at line 1507 of file dart_api_impl.cc.

                                                  {
  Thread* thread = Thread::Current();
  if (thread == nullptr) {
    return nullptr;
  }
  Isolate* I = thread->isolate();
  if (I == nullptr) {
    return nullptr;
  }
  int64_t main_port = static_cast<int64_t>(I->main_port());
  const char* fmt = "%s (%" Pd64 ")";
  int length = snprintf(nullptr, 0, fmt, I->name(), main_port) + 1;
  char* res = Api::TopScope(thread)->zone()->Alloc<char>(length);
  snprintf(res, length, fmt, I->name(), main_port);
  return res;
}

Dart_DefaultCanonicalizeUrl()

DART_EXPORT Dart_Handle dart::Dart_DefaultCanonicalizeUrl	(	Dart_Handle	base_url,
		Dart_Handle	url
	)

Definition at line 5393 of file dart_api_impl.cc.

                                                                     {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_CALLBACK_STATE(T);
 
  const String& base_uri = Api::UnwrapStringHandle(Z, base_url);
  if (base_uri.IsNull()) {
    RETURN_TYPE_ERROR(Z, base_url, String);
  }
  const String& uri = Api::UnwrapStringHandle(Z, url);
  if (uri.IsNull()) {
    RETURN_TYPE_ERROR(Z, url, String);
  }
 
  const char* resolved_uri;
  if (!ResolveUri(uri.ToCString(), base_uri.ToCString(), &resolved_uri)) {
    return Api::NewError("%s: Unable to canonicalize uri '%s'.", CURRENT_FUNC,
                         uri.ToCString());
  }
  return Api::NewHandle(T, String::New(resolved_uri));
}

Dart_DeferredLoadComplete()

DART_EXPORT Dart_Handle dart::Dart_DeferredLoadComplete	(	intptr_t	loading_unit_id,
		const uint8_t *	snapshot_data,
		const uint8_t *	snapshot_instructions
	)

Definition at line 5904 of file dart_api_impl.cc.

                                                                {
  return DeferredLoadComplete(loading_unit_id, false, snapshot_data,
                              snapshot_instructions, nullptr, false);
}

Dart_DeferredLoadCompleteError()

DART_EXPORT Dart_Handle dart::Dart_DeferredLoadCompleteError	(	intptr_t	loading_unit_id,
		const char *	error_message,
		bool	transient
	)

Definition at line 5912 of file dart_api_impl.cc.

                                               {
  return DeferredLoadComplete(loading_unit_id, true, nullptr, nullptr,
                              error_message, transient);
}

Dart_DeleteFinalizableHandle()

DART_EXPORT void dart::Dart_DeleteFinalizableHandle	(	Dart_FinalizableHandle	object,
		Dart_Handle	strong_ref_to_object
	)

Definition at line 1143 of file dart_api_impl.cc.

                                      {
  if (!::Dart_IdentityEquals(strong_ref_to_object,
                             HandleFromFinalizable(object))) {
    FATAL(
        "%s expects arguments 'object' and 'strong_ref_to_object' to point to "
        "the same object.",
        CURRENT_FUNC);
  }
 
  auto wph_object = reinterpret_cast<Dart_WeakPersistentHandle>(object);
 
  ::Dart_DeleteWeakPersistentHandle(wph_object);
}

Dart_DeletePersistentHandle()

DART_EXPORT void dart::Dart_DeletePersistentHandle

(

Dart_PersistentHandle

object

)

Definition at line 1114 of file dart_api_impl.cc.

                                                                           {
  Thread* T = Thread::Current();
  IsolateGroup* isolate_group = T->isolate_group();
  CHECK_ISOLATE_GROUP(isolate_group);
  TransitionToVM transition(T);
  ApiState* state = isolate_group->api_state();
  ASSERT(state != nullptr);
  ASSERT(state->IsActivePersistentHandle(object));
  ASSERT(!Api::IsProtectedHandle(object));
  if (!Api::IsProtectedHandle(object)) {
    PersistentHandle* ref = PersistentHandle::Cast(object);
    state->FreePersistentHandle(ref);
  }
}

Dart_DeleteWeakPersistentHandle()

DART_EXPORT void dart::Dart_DeleteWeakPersistentHandle

(

Dart_WeakPersistentHandle

object

)

Definition at line 1129 of file dart_api_impl.cc.

                                      {
  Thread* T = Thread::Current();
  IsolateGroup* isolate_group = T->isolate_group();
  CHECK_ISOLATE_GROUP(isolate_group);
  TransitionToVM transition(T);
  ApiState* state = isolate_group->api_state();
  ASSERT(state != nullptr);
  ASSERT(state->IsActiveWeakPersistentHandle(object));
  auto weak_ref = FinalizablePersistentHandle::Cast(object);
  weak_ref->EnsureFreedExternal(isolate_group);
  state->FreeWeakPersistentHandle(weak_ref);
}

Dart_DetectNullSafety()

DART_EXPORT bool dart::Dart_DetectNullSafety	(	const char *	script_uri,
		const char *	package_config,
		const char *	original_working_directory,
		const uint8_t *	snapshot_data,
		const uint8_t *	snapshot_instructions,
		const uint8_t *	kernel_buffer,
		intptr_t	kernel_buffer_size
	)

Definition at line 6104 of file dart_api_impl.cc.

                                                                    {
  return true;
}

Dart_DisableHeapSampling()

DART_EXPORT void dart::Dart_DisableHeapSampling

(

void

)

Definition at line 1804 of file dart_api_impl.cc.

                                            {
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  HeapProfileSampler::Enable(false);
#endif
}

Dart_DoubleValue()

DART_EXPORT Dart_Handle dart::Dart_DoubleValue	(	Dart_Handle	double_obj,
		double *	value
	)

Definition at line 2722 of file dart_api_impl.cc.

                                                        {
  DARTSCOPE(Thread::Current());
  const Double& obj = Api::UnwrapDoubleHandle(Z, double_obj);
  if (obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, double_obj, Double);
  }
  *value = obj.value();
  return Api::Success();
}

Dart_DumpNativeStackTrace()

DART_EXPORT void dart::Dart_DumpNativeStackTrace

(

void *

context

)

Definition at line 40 of file unit_test_custom_zone.cc.

                                                          {
  fprintf(stderr, "Dart_DumpNativeStackTrace() not implemented!\n");
  exit(1);
}

Dart_EmptyString()

DART_EXPORT Dart_Handle dart::Dart_EmptyString

(

void

)

Definition at line 2225 of file dart_api_impl.cc.

                                           {
  ASSERT(Isolate::Current() != nullptr);
  return Api::EmptyString();
}

Dart_EnableHeapSampling()

DART_EXPORT void dart::Dart_EnableHeapSampling

(

void

)

Definition at line 1798 of file dart_api_impl.cc.

                                           {
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  HeapProfileSampler::Enable(true);
#endif
}

Dart_EnterIsolate()

DART_EXPORT void dart::Dart_EnterIsolate

(

Dart_Isolate

isolate

)

Definition at line 1534 of file dart_api_impl.cc.

                                                         {
  CHECK_NO_ISOLATE(Isolate::Current());
  // TODO(http://dartbug.com/16615): Validate isolate parameter.
  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
  if (iso->IsScheduled()) {
    FATAL(
        "Isolate %s is already scheduled on mutator thread %p, "
        "failed to schedule from os thread 0x%" Px "\n",
        iso->name(), iso->scheduled_mutator_thread(),
        OSThread::ThreadIdToIntPtr(OSThread::GetCurrentThreadId()));
  }
  Thread::EnterIsolate(iso);
  // A Thread structure has been associated to the thread, we do the
  // safepoint transition explicitly here instead of using the
  // TransitionXXX scope objects as the reverse transition happens
  // outside this scope in Dart_ExitIsolate/Dart_ShutdownIsolate.
  Thread* T = Thread::Current();
  T->set_execution_state(Thread::kThreadInNative);
  T->EnterSafepoint();
}

Dart_EnterScope()

DART_EXPORT void dart::Dart_EnterScope

(

void

)

Definition at line 2184 of file dart_api_impl.cc.

                                   {
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  TransitionNativeToVM transition(thread);
  thread->EnterApiScope();
}

Dart_ErrorGetException()

DART_EXPORT Dart_Handle dart::Dart_ErrorGetException

(

Dart_Handle

handle

)

Definition at line 801 of file dart_api_impl.cc.

                                                                   {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
  if (obj.IsUnhandledException()) {
    const UnhandledException& error = UnhandledException::Cast(obj);
    return Api::NewHandle(T, error.exception());
  } else if (obj.IsError()) {
    return Api::NewError("This error is not an unhandled exception error.");
  } else {
    return Api::NewError("Can only get exceptions from error handles.");
  }
}

Dart_ErrorGetStackTrace()

DART_EXPORT Dart_Handle dart::Dart_ErrorGetStackTrace

(

Dart_Handle

handle

)

Definition at line 814 of file dart_api_impl.cc.

                                                                    {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
  if (obj.IsUnhandledException()) {
    const UnhandledException& error = UnhandledException::Cast(obj);
    return Api::NewHandle(T, error.stacktrace());
  } else if (obj.IsError()) {
    return Api::NewError("This error is not an unhandled exception error.");
  } else {
    return Api::NewError("Can only get stacktraces from error handles.");
  }
}

Dart_ErrorHasException()

DART_EXPORT bool dart::Dart_ErrorHasException

(

Dart_Handle

handle

)

Definition at line 795 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
  return obj.IsUnhandledException();
}

Dart_EvaluateStaticExpr()

Dart_Handle dart::Dart_EvaluateStaticExpr	(	Dart_Handle	lib_handle,
		Dart_Handle	expr
	)

Execute the expression given in string \expr in the context of \lib_handle library, as if it were a top-level function in it.

Requires there to be a current isolate.

Returns

A handle to the computed value, or an error object if the compilation of the expression fails, or if the evaluation throws an error.

Definition at line 169 of file debugger_api_impl_test.cc.

                                                         {
  DARTSCOPE(Thread::Current());
  CHECK_DEBUGGER(T->isolate());
 
  const Object& target = Object::Handle(Z, Api::UnwrapHandle(lib_handle));
  if (target.IsError()) return lib_handle;
  if (target.IsNull()) {
    return Api::NewError("%s expects argument 'target' to be non-null",
                         CURRENT_FUNC);
  }
  const Library& lib = Library::Cast(target);
  UNWRAP_AND_CHECK_PARAM(String, expr, expr_in);
 
  if (!KernelIsolate::IsRunning()) {
    UNREACHABLE();
  } else {
    Dart_KernelCompilationResult compilation_result =
        KernelIsolate::CompileExpressionToKernel(
            /* platform_kernel= */ nullptr, /* platform_kernel_size= */ 0,
            expr.ToCString(),
            /* definitions= */ Array::empty_array(),
            /* definition_types= */ Array::empty_array(),
            /* type_definitions= */ Array::empty_array(),
            /* type_bounds= */ Array::empty_array(),
            /* type_defaults= */ Array::empty_array(),
            String::Handle(lib.url()).ToCString(),
            /* klass= */ nullptr,
            /* method= */ nullptr,
            /* token_pos= */ TokenPosition::kNoSource,
            /* script_uri= */ String::Handle(lib.url()).ToCString(),
            /* is_static= */ true);
    if (compilation_result.status != Dart_KernelCompilationStatus_Ok) {
      return Api::NewError("Failed to compile expression.");
    }
 
    const ExternalTypedData& kernel_buffer =
        ExternalTypedData::Handle(ExternalTypedData::NewFinalizeWithFree(
            const_cast<uint8_t*>(compilation_result.kernel),
            compilation_result.kernel_size));
 
    Dart_Handle result = Api::NewHandle(
        T,
        lib.EvaluateCompiledExpression(kernel_buffer,
                                       /* type_definitions= */
                                       Array::empty_array(),
                                       /* param_values= */
                                       Array::empty_array(),
                                       /* type_param_values= */
                                       TypeArguments::null_type_arguments()));
    return result;
  }
}

Dart_ExecuteInternalCommand()

DART_EXPORT void * dart::Dart_ExecuteInternalCommand	(	const char *	command,
		void *	arg
	)

Definition at line 265 of file native_api_impl.cc.

                                                                              {
  if (strcmp(command, "gc-on-nth-allocation") == 0) {
    Thread* const thread = Thread::Current();
    Isolate* isolate = (thread == nullptr) ? nullptr : thread->isolate();
    CHECK_ISOLATE(isolate);
    TransitionNativeToVM _(thread);
    intptr_t argument = reinterpret_cast<intptr_t>(arg);
    ASSERT(argument > 0);
    IsolateGroup::Current()->heap()->CollectOnNthAllocation(argument);
    return nullptr;
 
  } else if (strcmp(command, "gc-now") == 0) {
    ASSERT(arg == nullptr);  // Don't pass an argument to this command.
    Thread* const thread = Thread::Current();
    Isolate* isolate = (thread == nullptr) ? nullptr : thread->isolate();
    CHECK_ISOLATE(isolate);
    TransitionNativeToVM _(thread);
    IsolateGroup::Current()->heap()->CollectAllGarbage(GCReason::kDebugging);
    return nullptr;
 
  } else if (strcmp(command, "is-thread-in-generated") == 0) {
    if (Thread::Current()->execution_state() == Thread::kThreadInGenerated) {
      return reinterpret_cast<void*>(1);
    }
    return nullptr;
 
  } else if (strcmp(command, "is-mutator-in-native") == 0) {
    Isolate* const isolate = reinterpret_cast<Isolate*>(arg);
    CHECK_ISOLATE(isolate);
    if (isolate->mutator_thread()->execution_state_cross_thread_for_testing() ==
        Thread::kThreadInNative) {
      return arg;
    } else {
      return nullptr;
    }
 
  } else if (strcmp(command, "run-in-safepoint-and-rw-code") == 0) {
    const RunInSafepointAndRWCodeArgs* const args =
        reinterpret_cast<RunInSafepointAndRWCodeArgs*>(arg);
    Isolate* const isolate = args->isolate;
    CHECK_ISOLATE(isolate);
    auto isolate_group = isolate->group();
    const bool kBypassSafepoint = false;
    Thread::EnterIsolateGroupAsHelper(isolate_group, Thread::kUnknownTask,
                                      kBypassSafepoint);
    Thread* const thread = Thread::Current();
    {
      GcSafepointOperationScope scope(thread);
      isolate_group->heap()->WriteProtectCode(/*read_only=*/false);
      (*args->callback)();
      isolate_group->heap()->WriteProtectCode(/*read_only=*/true);
    }
    Thread::ExitIsolateGroupAsHelper(kBypassSafepoint);
    return nullptr;
 
  } else {
    UNREACHABLE();
  }
}

Dart_ExitIsolate()

DART_EXPORT void dart::Dart_ExitIsolate

(

void

)

Definition at line 1864 of file dart_api_impl.cc.

                                    {
  Thread* T = Thread::Current();
  CHECK_ISOLATE(T->isolate());
  // The Thread structure is disassociated from the isolate, we do the
  // safepoint transition explicitly here instead of using the TransitionXXX
  // scope objects as the original transition happened outside this scope in
  // Dart_EnterIsolate/Dart_CreateIsolateGroup.
  ASSERT(T->execution_state() == Thread::kThreadInNative);
  T->ExitSafepoint();
  T->set_execution_state(Thread::kThreadInVM);
  Thread::ExitIsolate();
}

Dart_ExitScope()

DART_EXPORT void dart::Dart_ExitScope

(

void

)

Definition at line 2192 of file dart_api_impl.cc.

                                  {
  Thread* thread = Thread::Current();
  CHECK_API_SCOPE(thread);
  TransitionNativeToVM transition(thread);
  thread->ExitApiScope();
}

Dart_False()

DART_EXPORT Dart_Handle dart::Dart_False

(

void

)

Definition at line 2792 of file dart_api_impl.cc.

                                     {
  ASSERT(Isolate::Current() != nullptr);
  return Api::False();
}

Dart_FinalizeAllClasses()

DART_EXPORT Dart_Handle dart::Dart_FinalizeAllClasses

(

void

)

Definition at line 240 of file native_api_impl.cc.

                                                  {
#if defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("%s: All classes are already finalized in AOT runtime.",
                       CURRENT_FUNC);
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  Dart_Handle result = Api::CheckAndFinalizePendingClasses(T);
  if (Api::IsError(result)) {
    return result;
  }
  CHECK_CALLBACK_STATE(T);
  const Error& error = Error::Handle(T->zone(), Library::FinalizeAllClasses());
  if (!error.IsNull()) {
    return Api::NewHandle(T, error.ptr());
  }
  return Api::Success();
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

Dart_FinalizeLoading()

DART_EXPORT Dart_Handle dart::Dart_FinalizeLoading

(

bool

complete_futures

)

Definition at line 5804 of file dart_api_impl.cc.

                                                                    {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  Isolate* I = T->isolate();
  CHECK_CALLBACK_STATE(T);
 
  // Finalize all classes if needed.
  Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
  if (Api::IsError(state)) {
    return state;
  }
 
#if !defined(PRODUCT)
  // Now that the newly loaded classes are finalized, notify the debugger
  // that new code has been loaded. If there are latent breakpoints in
  // the new code, the debugger convert them to unresolved source breakpoints.
  // The code that completes the futures (invoked below) may call into the
  // newly loaded code and trigger one of these breakpoints.
  I->debugger()->NotifyDoneLoading();
#endif
 
  // After having loaded all the code, we can let the GC set reasonable limits
  // for the heap growth.
  // If this is an auxiliary isolate inside a larger isolate group, we will not
  // re-initialize the growth policy.
  if (I->group()->ContainsOnlyOneIsolate()) {
    I->group()->heap()->old_space()->EvaluateAfterLoading();
  }
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  if (FLAG_enable_mirrors) {
    // Notify mirrors that MirrorSystem.libraries needs to be recomputed.
    const Library& libmirrors = Library::Handle(Z, Library::MirrorsLibrary());
    const Field& dirty_bit =
        Field::Handle(Z, libmirrors.LookupFieldAllowPrivate(
                             String::Handle(String::New("_dirty"))));
    ASSERT(!dirty_bit.IsNull() && dirty_bit.is_static());
    dirty_bit.SetStaticValue(Bool::True());
  }
#endif
 
  return Api::Success();
}

Dart_FunctionIsStatic()

DART_EXPORT Dart_Handle dart::Dart_FunctionIsStatic	(	Dart_Handle	function,
		bool *	is_static
	)

Definition at line 2527 of file dart_api_impl.cc.

                                                               {
  DARTSCOPE(Thread::Current());
  if (is_static == nullptr) {
    RETURN_NULL_ERROR(is_static);
  }
  const Function& func = Api::UnwrapFunctionHandle(Z, function);
  if (func.IsNull()) {
    RETURN_TYPE_ERROR(Z, function, Function);
  }
  *is_static = func.is_static();
  return Api::Success();
}

Dart_FunctionName()

DART_EXPORT Dart_Handle dart::Dart_FunctionName

(

Dart_Handle

function

)

Definition at line 2476 of file dart_api_impl.cc.

                                                                {
  DARTSCOPE(Thread::Current());
  const Function& func = Api::UnwrapFunctionHandle(Z, function);
  if (func.IsNull()) {
    RETURN_TYPE_ERROR(Z, function, Function);
  }
  return Api::NewHandle(T, func.UserVisibleName());
}

Dart_FunctionOwner()

DART_EXPORT Dart_Handle dart::Dart_FunctionOwner

(

Dart_Handle

function

)

Definition at line 2499 of file dart_api_impl.cc.

                                                                 {
  DARTSCOPE(Thread::Current());
  const Function& func = Api::UnwrapFunctionHandle(Z, function);
  if (func.IsNull()) {
    RETURN_TYPE_ERROR(Z, function, Function);
  }
  if (func.IsNonImplicitClosureFunction()) {
    FunctionPtr parent_function = func.parent_function();
    return Api::NewHandle(T, parent_function);
  }
  const Class& owner = Class::Handle(Z, func.Owner());
  ASSERT(!owner.IsNull());
  if (owner.IsTopLevel()) {
// Top-level functions are implemented as members of a hidden class. We hide
// that class here and instead answer the library.
#if defined(DEBUG)
    const Library& lib = Library::Handle(Z, owner.library());
    if (lib.IsNull()) {
      ASSERT(owner.IsDynamicClass() || owner.IsVoidClass() ||
             owner.IsNeverClass());
    }
#endif
    return Api::NewHandle(T, owner.library());
  } else {
    return Api::NewHandle(T, owner.RareType());
  }
}

Dart_GetActivationFrame()

Dart_Handle dart::Dart_GetActivationFrame	(	Dart_StackTrace	trace,
		int	frame_index,
		Dart_ActivationFrame *	frame
	)

Returns in \frame the activation frame with index \frame_index. The activation frame at the top of stack has index 0.

Requires there to be a current isolate.

Returns

A handle to the True object if no error occurs.

Definition at line 70 of file debugger_api_impl_test.cc.

                                                                 {
  DARTSCOPE(Thread::Current());
  CHECK_NOT_NULL(frame);
  CHECK_AND_CAST(DebuggerStackTrace, stack_trace, trace);
  if ((frame_index < 0) || (frame_index >= stack_trace->Length())) {
    return Api::NewError("argument 'frame_index' is out of range for %s",
                         CURRENT_FUNC);
  }
  *frame =
      reinterpret_cast<Dart_ActivationFrame>(stack_trace->FrameAt(frame_index));
  return Api::Success();
}

Dart_GetClass()

DART_EXPORT Dart_Handle dart::Dart_GetClass	(	Dart_Handle	library,
		Dart_Handle	class_name
	)

Definition at line 5500 of file dart_api_impl.cc.

                                                              {
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  const String& cls_name = Api::UnwrapStringHandle(Z, class_name);
  if (cls_name.IsNull()) {
    RETURN_TYPE_ERROR(Z, class_name, String);
  }
  const Class& cls = Class::Handle(Z, lib.LookupClassAllowPrivate(cls_name));
  if (cls.IsNull()) {
    // TODO(turnidge): Return null or error in this case?
    const String& lib_name = String::Handle(Z, lib.name());
    return Api::NewError("Class '%s' not found in library '%s'.",
                         cls_name.ToCString(), lib_name.ToCString());
  }
  cls.EnsureDeclarationLoaded();
  CHECK_ERROR_HANDLE(cls.VerifyEntryPoint());
  return Api::NewHandle(T, cls.RareType());
}

Dart_GetCurrentUserTag()

DART_EXPORT Dart_Handle dart::Dart_GetCurrentUserTag

(

)

Definition at line 6904 of file dart_api_impl.cc.

                                                 {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  DARTSCOPE(thread);
  Isolate* isolate = thread->isolate();
  return Api::NewHandle(thread, isolate->current_tag());
}

Dart_GetDataFromByteBuffer()

DART_EXPORT Dart_Handle dart::Dart_GetDataFromByteBuffer

(

Dart_Handle

object

)

Definition at line 4156 of file dart_api_impl.cc.

                                                                       {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  TransitionNativeToVM transition(thread);
  intptr_t class_id = Api::ClassId(object);
  if (class_id != kByteBufferCid) {
    RETURN_TYPE_ERROR(zone, object, 'ByteBuffer');
  }
  const Instance& instance = Api::UnwrapInstanceHandle(zone, object);
  ASSERT(!instance.IsNull());
  return Api::NewHandle(thread, ByteBuffer::Data(instance));
}

Dart_GetDefaultUserTag()

DART_EXPORT Dart_Handle dart::Dart_GetDefaultUserTag

(

)

Definition at line 6912 of file dart_api_impl.cc.

                                                 {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  DARTSCOPE(thread);
  Isolate* isolate = thread->isolate();
  return Api::NewHandle(thread, isolate->default_tag());
}

Dart_GetError()

DART_EXPORT const char * dart::Dart_GetError

(

Dart_Handle

handle

)

Definition at line 788 of file dart_api_impl.cc.

                                                          {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
  return GetErrorString(T, obj);
}

Dart_GetField()

DART_EXPORT Dart_Handle dart::Dart_GetField	(	Dart_Handle	container,
		Dart_Handle	name
	)

Definition at line 4678 of file dart_api_impl.cc.

                                                                               {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_CALLBACK_STATE(T);
 
  String& field_name =
      String::Handle(Z, Api::UnwrapStringHandle(Z, name).ptr());
  if (field_name.IsNull()) {
    RETURN_TYPE_ERROR(Z, name, String);
  }
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(container));
  const bool throw_nsm_if_absent = true;
  const bool respect_reflectable = false;
  const bool check_is_entrypoint = FLAG_verify_entry_points;
 
  if (obj.IsType()) {
    if (!Type::Cast(obj).IsFinalized()) {
      return Api::NewError(
          "%s expects argument 'container' to be a fully resolved type.",
          CURRENT_FUNC);
    }
    Class& cls = Class::Handle(Z, Type::Cast(obj).type_class());
    if (Library::IsPrivate(field_name)) {
      const Library& lib = Library::Handle(Z, cls.library());
      field_name = lib.PrivateName(field_name);
    }
    return Api::NewHandle(
        T, cls.InvokeGetter(field_name, throw_nsm_if_absent,
                            respect_reflectable, check_is_entrypoint));
  } else if (obj.IsNull() || obj.IsInstance()) {
    Instance& instance = Instance::Handle(Z);
    instance ^= obj.ptr();
    if (Library::IsPrivate(field_name)) {
      const Class& cls = Class::Handle(Z, instance.clazz());
      const Library& lib = Library::Handle(Z, cls.library());
      field_name = lib.PrivateName(field_name);
    }
    return Api::NewHandle(T,
                          instance.InvokeGetter(field_name, respect_reflectable,
                                                check_is_entrypoint));
  } else if (obj.IsLibrary()) {
    const Library& lib = Library::Cast(obj);
    // Check that the library is loaded.
    if (!lib.Loaded()) {
      return Api::NewError(
          "%s expects library argument 'container' to be loaded.",
          CURRENT_FUNC);
    }
    if (Library::IsPrivate(field_name)) {
      field_name = lib.PrivateName(field_name);
    }
    return Api::NewHandle(
        T, lib.InvokeGetter(field_name, throw_nsm_if_absent,
                            respect_reflectable, check_is_entrypoint));
  } else if (obj.IsError()) {
    return container;
  } else {
    return Api::NewError(
        "%s expects argument 'container' to be an object, type, or library.",
        CURRENT_FUNC);
  }
}

Dart_GetLibraryDebuggable()

Dart_Handle dart::Dart_GetLibraryDebuggable	(	intptr_t	library_id,
		bool *	is_debuggable
	)

Returns true if the debugger can step into code of the given library.

Requires there to be a current isolate.

Returns

A handle to the True object if no error occurs.

Definition at line 236 of file debugger_api_impl_test.cc.

                                                           {
  DARTSCOPE(Thread::Current());
  CHECK_NOT_NULL(is_debuggable);
  const Library& lib = Library::Handle(Library::GetLibrary(library_id));
  if (lib.IsNull()) {
    return Api::NewError("%s: %" Pd " is not a valid library id", CURRENT_FUNC,
                         library_id);
  }
  *is_debuggable = lib.IsDebuggable();
  return Api::Success();
}

Dart_GetLoadedLibraries()

DART_EXPORT Dart_Handle dart::Dart_GetLoadedLibraries

(

void

)

Definition at line 5697 of file dart_api_impl.cc.

                                                  {
  DARTSCOPE(Thread::Current());
  auto IG = T->isolate_group();
 
  const GrowableObjectArray& libs =
      GrowableObjectArray::Handle(Z, IG->object_store()->libraries());
  int num_libs = libs.Length();
 
  // Create new list and populate with the loaded libraries.
  Library& lib = Library::Handle();
  const Array& library_list = Array::Handle(Z, Array::New(num_libs));
  for (int i = 0; i < num_libs; i++) {
    lib ^= libs.At(i);
    ASSERT(!lib.IsNull());
    library_list.SetAt(i, lib);
  }
  return Api::NewHandle(T, library_list.ptr());
}

Dart_GetMainPortId()

DART_EXPORT Dart_Port dart::Dart_GetMainPortId

(

void

)

Definition at line 2176 of file dart_api_impl.cc.

                                           {
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  return isolate->main_port();
}

Dart_GetMessageNotifyCallback()

DART_EXPORT Dart_MessageNotifyCallback dart::Dart_GetMessageNotifyCallback

(

void

)

Definition at line 1976 of file dart_api_impl.cc.

                                                                       {
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->message_notify_callback();
}

Dart_GetNativeArgument()

DART_EXPORT Dart_Handle dart::Dart_GetNativeArgument	(	Dart_NativeArguments	args,
		int	index
	)

Definition at line 5101 of file dart_api_impl.cc.

                                                          {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  if ((index < 0) || (index >= arguments->NativeArgCount())) {
    return Api::NewError(
        "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
        CURRENT_FUNC, arguments->NativeArgCount() - 1, index);
  }
  TransitionNativeToVM transition(arguments->thread());
  return Api::NewHandle(arguments->thread(), arguments->NativeArgAt(index));
}

Dart_GetNativeArgumentCount()

DART_EXPORT int dart::Dart_GetNativeArgumentCount

(

Dart_NativeArguments

args

)

Definition at line 5113 of file dart_api_impl.cc.

                                                                       {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  return arguments->NativeArgCount();
}

Dart_GetNativeArguments()

DART_EXPORT Dart_Handle dart::Dart_GetNativeArguments	(	Dart_NativeArguments	args,
		int	num_arguments,
		const Dart_NativeArgument_Descriptor *	argument_descriptors,
		Dart_NativeArgument_Value *	arg_values
	)

Definition at line 4967 of file dart_api_impl.cc.

                                           {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
  ASSERT(arguments->thread()->isolate() == Isolate::Current());
  if (arg_values == nullptr) {
    RETURN_NULL_ERROR(arg_values);
  }
  for (int i = 0; i < num_arguments; i++) {
    Dart_NativeArgument_Descriptor desc = argument_descriptors[i];
    Dart_NativeArgument_Type arg_type =
        static_cast<Dart_NativeArgument_Type>(desc.type);
    int arg_index = desc.index;
    ASSERT(arg_index >= 0 && arg_index < arguments->NativeArgCount());
    Dart_NativeArgument_Value* native_value = &(arg_values[i]);
    switch (arg_type) {
      case Dart_NativeArgument_kBool:
        if (!Api::GetNativeBooleanArgument(arguments, arg_index,
                                           &(native_value->as_bool))) {
          return Api::NewArgumentError(
              "%s: expects argument at index %d to be of"
              " type Boolean.",
              CURRENT_FUNC, i);
        }
        break;
 
      case Dart_NativeArgument_kInt32: {
        int64_t value = 0;
        if (!GetNativeIntegerArgument(arguments, arg_index, &value)) {
          return Api::NewArgumentError(
              "%s: expects argument at index %d to be of"
              " type Integer.",
              CURRENT_FUNC, i);
        }
        if (value < INT32_MIN || value > INT32_MAX) {
          return Api::NewArgumentError(
              "%s: argument value at index %d is out of range", CURRENT_FUNC,
              i);
        }
        native_value->as_int32 = static_cast<int32_t>(value);
        break;
      }
 
      case Dart_NativeArgument_kUint32: {
        int64_t value = 0;
        if (!GetNativeIntegerArgument(arguments, arg_index, &value)) {
          return Api::NewArgumentError(
              "%s: expects argument at index %d to be of"
              " type Integer.",
              CURRENT_FUNC, i);
        }
        if (value < 0 || value > UINT32_MAX) {
          return Api::NewArgumentError(
              "%s: argument value at index %d is out of range", CURRENT_FUNC,
              i);
        }
        native_value->as_uint32 = static_cast<uint32_t>(value);
        break;
      }
 
      case Dart_NativeArgument_kInt64: {
        int64_t value = 0;
        if (!GetNativeIntegerArgument(arguments, arg_index, &value)) {
          return Api::NewArgumentError(
              "%s: expects argument at index %d to be of"
              " type Integer.",
              CURRENT_FUNC, i);
        }
        native_value->as_int64 = value;
        break;
      }
 
      case Dart_NativeArgument_kUint64: {
        uint64_t value = 0;
        if (!GetNativeUnsignedIntegerArgument(arguments, arg_index, &value)) {
          return Api::NewArgumentError(
              "%s: expects argument at index %d to be of"
              " type Integer.",
              CURRENT_FUNC, i);
        }
        native_value->as_uint64 = value;
        break;
      }
 
      case Dart_NativeArgument_kDouble:
        if (!GetNativeDoubleArgument(arguments, arg_index,
                                     &(native_value->as_double))) {
          return Api::NewArgumentError(
              "%s: expects argument at index %d to be of"
              " type Double.",
              CURRENT_FUNC, i);
        }
        break;
 
      case Dart_NativeArgument_kString:
        if (!GetNativeStringArgument(arguments, arg_index,
                                     &(native_value->as_string.dart_str),
                                     &(native_value->as_string.peer))) {
          return Api::NewArgumentError(
              "%s: expects argument at index %d to be of"
              " type String.",
              CURRENT_FUNC, i);
        }
        break;
 
      case Dart_NativeArgument_kNativeFields: {
        Dart_Handle result = GetNativeFieldsOfArgument(
            arguments, arg_index, native_value->as_native_fields.num_fields,
            native_value->as_native_fields.values, CURRENT_FUNC);
        if (result != Api::Success()) {
          return result;
        }
        break;
      }
 
      case Dart_NativeArgument_kInstance: {
        ASSERT(arguments->thread() == Thread::Current());
        ASSERT(arguments->thread()->api_top_scope() != nullptr);
        native_value->as_instance = Api::NewHandle(
            arguments->thread(), arguments->NativeArgAt(arg_index));
        break;
      }
 
      default:
        return Api::NewArgumentError("%s: invalid argument type %d.",
                                     CURRENT_FUNC, arg_type);
    }
  }
  return Api::Success();
}

Dart_GetNativeBooleanArgument()

DART_EXPORT Dart_Handle dart::Dart_GetNativeBooleanArgument	(	Dart_NativeArguments	args,
		int	index,
		bool *	value
	)

Definition at line 5186 of file dart_api_impl.cc.

                                                                   {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  if ((index < 0) || (index >= arguments->NativeArgCount())) {
    return Api::NewError(
        "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
        CURRENT_FUNC, arguments->NativeArgCount() - 1, index);
  }
  if (!Api::GetNativeBooleanArgument(arguments, index, value)) {
    return Api::NewArgumentError(
        "%s: expects argument at %d to be of type Boolean.", CURRENT_FUNC,
        index);
  }
  return Api::Success();
}

Dart_GetNativeDoubleArgument()

DART_EXPORT Dart_Handle dart::Dart_GetNativeDoubleArgument	(	Dart_NativeArguments	args,
		int	index,
		double *	value
	)

Definition at line 5203 of file dart_api_impl.cc.

                                                                    {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  if ((index < 0) || (index >= arguments->NativeArgCount())) {
    return Api::NewError(
        "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
        CURRENT_FUNC, arguments->NativeArgCount() - 1, index);
  }
  if (!GetNativeDoubleArgument(arguments, index, value)) {
    return Api::NewArgumentError(
        "%s: expects argument at %d to be of"
        " type Double.",
        CURRENT_FUNC, index);
  }
  return Api::Success();
}

Dart_GetNativeFieldsOfArgument()

DART_EXPORT Dart_Handle dart::Dart_GetNativeFieldsOfArgument	(	Dart_NativeArguments	args,
		int	arg_index,
		int	num_fields,
		intptr_t *	field_values
	)

Definition at line 5119 of file dart_api_impl.cc.

                                                       {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  if ((arg_index < 0) || (arg_index >= arguments->NativeArgCount())) {
    return Api::NewError(
        "%s: argument 'arg_index' out of range. Expected 0..%d but saw %d.",
        CURRENT_FUNC, arguments->NativeArgCount() - 1, arg_index);
  }
  if (field_values == nullptr) {
    RETURN_NULL_ERROR(field_values);
  }
  return GetNativeFieldsOfArgument(arguments, arg_index, num_fields,
                                   field_values, CURRENT_FUNC);
}

Dart_GetNativeInstanceField()

DART_EXPORT Dart_Handle dart::Dart_GetNativeInstanceField	(	Dart_Handle	obj,
		int	index,
		intptr_t *	value
	)

Definition at line 4915 of file dart_api_impl.cc.

                                                                     {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  bool is_null = false;
  {
    ReusableObjectHandleScope reused_obj_handle(thread);
    const Instance& instance =
        Api::UnwrapInstanceHandle(reused_obj_handle, obj);
    if (!instance.IsNull()) {
      if (instance.IsValidNativeIndex(index)) {
        *value = instance.GetNativeField(index);
        return Api::Success();
      }
    } else {
      is_null = true;
    }
  }
  if (is_null) {
    RETURN_TYPE_ERROR(thread->zone(), obj, Instance);
  }
  return Api::NewError(
      "%s: invalid index %d passed into access native instance field",
      CURRENT_FUNC, index);
}

Dart_GetNativeInstanceFieldCount()

DART_EXPORT Dart_Handle dart::Dart_GetNativeInstanceFieldCount	(	Dart_Handle	obj,
		int *	count
	)

Definition at line 4898 of file dart_api_impl.cc.

                                                                     {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  {
    ReusableObjectHandleScope reused_obj_handle(thread);
    const Instance& instance =
        Api::UnwrapInstanceHandle(reused_obj_handle, obj);
    if (!instance.IsNull()) {
      *count = instance.NumNativeFields();
      return Api::Success();
    }
  }
  RETURN_TYPE_ERROR(thread->zone(), obj, Instance);
}

Dart_GetNativeIntegerArgument()

DART_EXPORT Dart_Handle dart::Dart_GetNativeIntegerArgument	(	Dart_NativeArguments	args,
		int	index,
		int64_t *	value
	)

Definition at line 5168 of file dart_api_impl.cc.

                                                                      {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  if ((index < 0) || (index >= arguments->NativeArgCount())) {
    return Api::NewError(
        "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
        CURRENT_FUNC, arguments->NativeArgCount() - 1, index);
  }
  if (!GetNativeIntegerArgument(arguments, index, value)) {
    return Api::NewArgumentError(
        "%s: expects argument at %d to be of"
        " type Integer.",
        CURRENT_FUNC, index);
  }
  return Api::Success();
}

Dart_GetNativeIsolateGroupData()

DART_EXPORT void * dart::Dart_GetNativeIsolateGroupData

(

Dart_NativeArguments

args

)

Definition at line 4960 of file dart_api_impl.cc.

                                                                            {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  Isolate* isolate = arguments->thread()->isolate();
  ASSERT(isolate == Isolate::Current());
  return isolate->init_callback_data();
}

Dart_GetNativeReceiver()

DART_EXPORT Dart_Handle dart::Dart_GetNativeReceiver	(	Dart_NativeArguments	args,
		intptr_t *	value
	)

Definition at line 5136 of file dart_api_impl.cc.

                                                                {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
  ASSERT(arguments->thread()->isolate() == Isolate::Current());
  if (value == nullptr) {
    RETURN_NULL_ERROR(value);
  }
  if (Api::GetNativeReceiver(arguments, value)) {
    return Api::Success();
  }
  return Api::NewError(
      "%s expects receiver argument to be non-null and of"
      " type Instance.",
      CURRENT_FUNC);
}

Dart_GetNativeResolver()

DART_EXPORT Dart_Handle dart::Dart_GetNativeResolver	(	Dart_Handle	library,
		Dart_NativeEntryResolver *	resolver
	)

Definition at line 5934 of file dart_api_impl.cc.

                                                           {
  if (resolver == nullptr) {
    RETURN_NULL_ERROR(resolver);
  }
  *resolver = nullptr;
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  *resolver = lib.native_entry_resolver();
  return Api::Success();
}

Dart_GetNativeStringArgument()

DART_EXPORT Dart_Handle dart::Dart_GetNativeStringArgument	(	Dart_NativeArguments	args,
		int	arg_index,
		void **	peer
	)

Definition at line 5153 of file dart_api_impl.cc.

                                                                  {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
  Dart_Handle result = Api::Null();
  if (!GetNativeStringArgument(arguments, arg_index, &result, peer)) {
    return Api::NewArgumentError(
        "%s expects argument at %d to be of"
        " type String.",
        CURRENT_FUNC, arg_index);
  }
  return result;
}

Dart_GetNativeSymbol()

DART_EXPORT Dart_Handle dart::Dart_GetNativeSymbol	(	Dart_Handle	library,
		Dart_NativeEntrySymbol *	resolver
	)

Definition at line 5949 of file dart_api_impl.cc.

                                                                               {
  if (resolver == nullptr) {
    RETURN_NULL_ERROR(resolver);
  }
  *resolver = nullptr;
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  *resolver = lib.native_entry_symbol_resolver();
  return Api::Success();
}

Dart_GetNonNullableType()

DART_EXPORT Dart_Handle dart::Dart_GetNonNullableType	(	Dart_Handle	library,
		Dart_Handle	class_name,
		intptr_t	number_of_type_arguments,
		Dart_Handle *	type_arguments
	)

Definition at line 5618 of file dart_api_impl.cc.

                                                     {
  return GetTypeCommon(library, class_name, number_of_type_arguments,
                       type_arguments, Nullability::kNonNullable);
}

Dart_GetNullableType()

DART_EXPORT Dart_Handle dart::Dart_GetNullableType	(	Dart_Handle	library,
		Dart_Handle	class_name,
		intptr_t	number_of_type_arguments,
		Dart_Handle *	type_arguments
	)

Definition at line 5609 of file dart_api_impl.cc.

                                                                          {
  return GetTypeCommon(library, class_name, number_of_type_arguments,
                       type_arguments, Nullability::kNullable);
}

Dart_GetObfuscationMap()

DART_EXPORT Dart_Handle dart::Dart_GetObfuscationMap	(	uint8_t **	buffer,
		intptr_t *	buffer_length
	)

Definition at line 6845 of file dart_api_impl.cc.

                                                                        {
#if defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("No obfuscation map to save on an AOT runtime.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError("Obfuscation is only supported for AOT compiler.");
#else
  Thread* thread = Thread::Current();
  DARTSCOPE(thread);
  auto isolate_group = thread->isolate_group();
 
  if (buffer == nullptr) {
    RETURN_NULL_ERROR(buffer);
  }
  if (buffer_length == nullptr) {
    RETURN_NULL_ERROR(buffer_length);
  }
 
  // Note: can't use JSONStream in PRODUCT builds.
  const intptr_t kInitialBufferSize = 1 * MB;
  ZoneTextBuffer text_buffer(Api::TopScope(T)->zone(), kInitialBufferSize);
 
  text_buffer.AddChar('[');
  if (isolate_group->obfuscation_map() != nullptr) {
    for (intptr_t i = 0; isolate_group->obfuscation_map()[i] != nullptr; i++) {
      if (i > 0) {
        text_buffer.AddChar(',');
      }
      text_buffer.AddChar('"');
      text_buffer.AddEscapedString(isolate_group->obfuscation_map()[i]);
      text_buffer.AddChar('"');
    }
  }
  text_buffer.AddChar(']');
 
  *buffer_length = text_buffer.length();
  *reinterpret_cast<char**>(buffer) = text_buffer.buffer();
  return Api::Success();
#endif
}

Dart_GetPeer()

DART_EXPORT Dart_Handle dart::Dart_GetPeer	(	Dart_Handle	object,
		void **	peer
	)

Definition at line 5978 of file dart_api_impl.cc.

                                                                      {
  if (peer == nullptr) {
    RETURN_NULL_ERROR(peer);
  }
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  REUSABLE_OBJECT_HANDLESCOPE(thread);
  Object& obj = thread->ObjectHandle();
  obj = Api::UnwrapHandle(object);
  if (obj.IsNull() || obj.IsNumber() || obj.IsBool()) {
    const char* msg =
        "%s: argument 'object' cannot be a subtype of Null, num, or bool";
    return Api::NewError(msg, CURRENT_FUNC);
  }
  {
    NoSafepointScope no_safepoint;
    ObjectPtr raw_obj = obj.ptr();
    *peer = thread->heap()->GetPeer(raw_obj);
  }
  return Api::Success();
}

Dart_GetStackTrace()

Dart_Handle dart::Dart_GetStackTrace

(

Dart_StackTrace *

trace

)

Returns in \trace the current stack trace, or nullptr if the VM is not paused.

Requires there to be a current isolate.

Returns

A valid handle if no error occurs during the operation.

Definition at line 85 of file debugger_api_impl_test.cc.

                                                       {
  DARTSCOPE(Thread::Current());
  Isolate* I = T->isolate();
  CHECK_DEBUGGER(I);
  CHECK_NOT_NULL(trace);
  *trace = reinterpret_cast<Dart_StackTrace>(DebuggerStackTrace::Collect());
  return Api::Success();
}

Dart_GetStackTraceFromError()

Dart_Handle dart::Dart_GetStackTraceFromError	(	Dart_Handle	error,
		Dart_StackTrace *	trace
	)

Returns in \trace the stack trace associated with the error given in \handle.

Requires there to be a current isolate.

Returns

A valid handle if no error occurs during the operation.

Definition at line 94 of file debugger_api_impl_test.cc.

                                                                {
  DARTSCOPE(Thread::Current());
  CHECK_DEBUGGER(T->isolate());
  CHECK_NOT_NULL(trace);
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
  if (obj.IsUnhandledException()) {
    const UnhandledException& error = UnhandledException::Cast(obj);
    StackTrace& dart_stacktrace = StackTrace::Handle(Z);
    dart_stacktrace ^= error.stacktrace();
    if (dart_stacktrace.IsNull()) {
      *trace = nullptr;
    } else {
      *trace = reinterpret_cast<Dart_StackTrace>(
          DebuggerStackTrace::From(dart_stacktrace));
    }
    return Api::Success();
  } else {
    return Api::NewError(
        "Can only get stacktraces from error handles or "
        "instances of Error.");
  }
}

Dart_GetStaticMethodClosure()

DART_EXPORT Dart_Handle dart::Dart_GetStaticMethodClosure	(	Dart_Handle	library,
		Dart_Handle	cls_type,
		Dart_Handle	function_name
	)

Definition at line 2733 of file dart_api_impl.cc.

                                                                               {
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
 
  const Type& type_obj = Api::UnwrapTypeHandle(Z, cls_type);
  if (type_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, cls_type, Type);
  }
 
  const Class& klass = Class::Handle(Z, type_obj.type_class());
  if (klass.IsNull()) {
    return Api::NewError(
        "cls_type must be a Type object which represents a Class");
  }
 
  const auto& error = klass.EnsureIsFinalized(Thread::Current());
  if (error != Error::null()) {
    return Api::NewHandle(T, error);
  }
 
  const String& func_name = Api::UnwrapStringHandle(Z, function_name);
  if (func_name.IsNull()) {
    RETURN_TYPE_ERROR(Z, function_name, String);
  }
 
  Function& func =
      Function::Handle(Z, klass.LookupStaticFunctionAllowPrivate(func_name));
  if (func.IsNull()) {
    return Dart_Null();
  }
 
  if (!func.is_static()) {
    return Api::NewError("function_name must refer to a static method.");
  }
 
  if (func.kind() != UntaggedFunction::kRegularFunction) {
    return Api::NewError(
        "function_name must be the name of a regular function.");
  }
  func = func.ImplicitClosureFunction();
  if (func.IsNull()) {
    return Dart_Null();
  }
 
  return Api::NewHandle(T, func.ImplicitStaticClosure());
}

Dart_GetStickyError()

DART_EXPORT Dart_Handle dart::Dart_GetStickyError

(

void

)

Definition at line 1768 of file dart_api_impl.cc.

                                              {
  Thread* T = Thread::Current();
  Isolate* I = T->isolate();
  CHECK_ISOLATE(I);
  {
    NoSafepointScope no_safepoint_scope;
    if (I->sticky_error() == Error::null()) {
      return Api::Null();
    }
  }
  TransitionNativeToVM transition(T);
  return Api::NewHandle(T, I->sticky_error());
}

Dart_GetType()

DART_EXPORT Dart_Handle dart::Dart_GetType	(	Dart_Handle	library,
		Dart_Handle	class_name,
		intptr_t	number_of_type_arguments,
		Dart_Handle *	type_arguments
	)

Definition at line 5600 of file dart_api_impl.cc.

                                                                  {
  return Api::NewError(
      "Cannot use legacy types with --sound-null-safety enabled. "
      "Use Dart_GetNullableType or Dart_GetNonNullableType instead.");
}

Dart_GetTypeOfExternalTypedData()

DART_EXPORT Dart_TypedData_Type dart::Dart_GetTypeOfExternalTypedData

(

Dart_Handle

object

)

Definition at line 3710 of file dart_api_impl.cc.

                                                    {
  Thread* thread = Thread::Current();
  API_TIMELINE_DURATION(thread);
  TransitionNativeToVM transition(thread);
  intptr_t class_id = Api::ClassId(object);
  if (IsExternalTypedDataClassId(class_id)) {
    return GetType(class_id);
  }
  if (IsTypedDataViewClassId(class_id) ||
      IsUnmodifiableTypedDataViewClassId(class_id)) {
    // Check if data object of the view is external.
    Zone* zone = thread->zone();
    const auto& view_obj = Api::UnwrapTypedDataViewHandle(zone, object);
    ASSERT(!view_obj.IsNull());
    const auto& data_obj = Instance::Handle(zone, view_obj.typed_data());
    if (ExternalTypedData::IsExternalTypedData(data_obj)) {
      return GetType(class_id);
    }
  }
  return Dart_TypedData_kInvalid;
}

Dart_GetTypeOfTypedData()

DART_EXPORT Dart_TypedData_Type dart::Dart_GetTypeOfTypedData

(

Dart_Handle

object

)

Definition at line 3697 of file dart_api_impl.cc.

                                                                            {
  Thread* thread = Thread::Current();
  API_TIMELINE_DURATION(thread);
  TransitionNativeToVM transition(thread);
  intptr_t class_id = Api::ClassId(object);
  if (IsTypedDataClassId(class_id) || IsTypedDataViewClassId(class_id) ||
      IsUnmodifiableTypedDataViewClassId(class_id)) {
    return GetType(class_id);
  }
  return Dart_TypedData_kInvalid;
}

Dart_GetUserTagLabel()

DART_EXPORT char * dart::Dart_GetUserTagLabel

(

Dart_Handle

user_tag

)

Definition at line 6943 of file dart_api_impl.cc.

                                                             {
  DARTSCOPE(Thread::Current());
  const UserTag& tag = Api::UnwrapUserTagHandle(Z, user_tag);
  if (tag.IsNull()) {
    return nullptr;
  }
  const String& label = String::Handle(Z, tag.label());
  return Utils::StrDup(label.ToCString());
}

Dart_HandleFromPersistent()

DART_EXPORT Dart_Handle dart::Dart_HandleFromPersistent

(

Dart_PersistentHandle

object

)

Definition at line 929 of file dart_api_impl.cc.

                                                        {
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  ApiState* state = isolate->group()->api_state();
  ASSERT(state != nullptr);
  TransitionNativeToVM transition(thread);
  NoSafepointScope no_safepoint_scope;
  PersistentHandle* ref = PersistentHandle::Cast(object);
  return Api::NewHandle(thread, ref->ptr());
}

Dart_HandleFromWeakPersistent()

DART_EXPORT Dart_Handle dart::Dart_HandleFromWeakPersistent

(

Dart_WeakPersistentHandle

object

)

Definition at line 942 of file dart_api_impl.cc.

                                                                {
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  ApiState* state = isolate->group()->api_state();
  ASSERT(state != nullptr);
  TransitionNativeToVM transition(thread);
  NoSafepointScope no_safepoint_scope;
  FinalizablePersistentHandle* weak_ref =
      FinalizablePersistentHandle::Cast(object);
  if (weak_ref->IsFinalizedNotFreed()) {
    return Dart_Null();
  }
  return Api::NewHandle(thread, weak_ref->ptr());
}

Dart_HandleMessage()

DART_EXPORT Dart_Handle dart::Dart_HandleMessage

(

void

)

Definition at line 2087 of file dart_api_impl.cc.

                                             {
  Thread* T = Thread::Current();
  Isolate* I = T->isolate();
  CHECK_API_SCOPE(T);
  CHECK_CALLBACK_STATE(T);
  API_TIMELINE_BEGIN_END(T);
  TransitionNativeToVM transition(T);
  if (I->message_handler()->HandleNextMessage() != MessageHandler::kOK) {
    return Api::NewHandle(T, T->StealStickyError());
  }
  return Api::Success();
}

Dart_HandleServiceMessages()

DART_EXPORT bool dart::Dart_HandleServiceMessages

(

void

)

Definition at line 2100 of file dart_api_impl.cc.

                                              {
#if defined(PRODUCT)
  return true;
#else
  Thread* T = Thread::Current();
  Isolate* I = T->isolate();
  CHECK_API_SCOPE(T);
  CHECK_CALLBACK_STATE(T);
  API_TIMELINE_DURATION(T);
  TransitionNativeToVM transition(T);
  ASSERT(I->GetAndClearResumeRequest() == false);
  MessageHandler::MessageStatus status =
      I->message_handler()->HandleOOBMessages();
  bool resume = I->GetAndClearResumeRequest();
  return (status != MessageHandler::kOK) || resume;
#endif
}

Dart_HasLivePorts()

DART_EXPORT bool dart::Dart_HasLivePorts

(

void

)

Definition at line 2129 of file dart_api_impl.cc.

                                     {
  Isolate* isolate = Isolate::Current();
  ASSERT(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->HasLivePorts();
}

Dart_HasServiceMessages()

DART_EXPORT bool dart::Dart_HasServiceMessages

(

void

)

Definition at line 2118 of file dart_api_impl.cc.

                                           {
#if defined(PRODUCT)
  return false;
#else
  Isolate* isolate = Isolate::Current();
  ASSERT(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->message_handler()->HasOOBMessages();
#endif
}

Dart_HasStickyError()

DART_EXPORT bool dart::Dart_HasStickyError

(

void

)

Definition at line 1760 of file dart_api_impl.cc.

                                       {
  Thread* T = Thread::Current();
  Isolate* isolate = T->isolate();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->sticky_error() != Error::null();
}

Dart_IdentityEquals()

DART_EXPORT bool dart::Dart_IdentityEquals	(	Dart_Handle	obj1,
		Dart_Handle	obj2
	)

Definition at line 912 of file dart_api_impl.cc.

                                                                         {
  DARTSCOPE(Thread::Current());
  {
    NoSafepointScope no_safepoint_scope;
    if (Api::UnwrapHandle(obj1) == Api::UnwrapHandle(obj2)) {
      return true;
    }
  }
  const Object& object1 = Object::Handle(Z, Api::UnwrapHandle(obj1));
  const Object& object2 = Object::Handle(Z, Api::UnwrapHandle(obj2));
  if (object1.IsInstance() && object2.IsInstance()) {
    return Instance::Cast(object1).IsIdenticalTo(Instance::Cast(object2));
  }
  return false;
}

Dart_Initialize()

DART_EXPORT char * dart::Dart_Initialize

(

Dart_InitializeParams *

params

)

Definition at line 1165 of file dart_api_impl.cc.

                                                                 {
  if (params == nullptr) {
    return Utils::StrDup(
        "Dart_Initialize: "
        "Dart_InitializeParams is null.");
  }
 
  if (params->version != DART_INITIALIZE_PARAMS_CURRENT_VERSION) {
    return Utils::StrDup(
        "Dart_Initialize: "
        "Invalid Dart_InitializeParams version.");
  }
 
  return Dart::Init(params);
}

Dart_InstanceGetType()

DART_EXPORT Dart_Handle dart::Dart_InstanceGetType

(

Dart_Handle

instance

)

Definition at line 2460 of file dart_api_impl.cc.

                                                                   {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  auto isolate_group = T->isolate_group();
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(instance));
  if (obj.IsNull()) {
    return Api::NewHandle(T, isolate_group->object_store()->null_type());
  }
  if (!obj.IsInstance()) {
    RETURN_TYPE_ERROR(Z, instance, Instance);
  }
  const AbstractType& type =
      AbstractType::Handle(Instance::Cast(obj).GetType(Heap::kNew));
  return Api::NewHandle(T, type.Canonicalize(T));
}

Dart_IntegerFitsIntoInt64()

DART_EXPORT Dart_Handle dart::Dart_IntegerFitsIntoInt64	(	Dart_Handle	integer,
		bool *	fits
	)

Definition at line 2571 of file dart_api_impl.cc.

                                                              {
  // Fast path for Smis and Mints.
  Thread* thread = Thread::Current();
  API_TIMELINE_DURATION(thread);
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  if (Api::IsSmi(integer)) {
    *fits = true;
    return Api::Success();
  }
  // Slow path for mints and type error.
  DARTSCOPE(thread);
  if (Api::ClassId(integer) == kMintCid) {
    *fits = true;
    return Api::Success();
  }
  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
  ASSERT(int_obj.IsNull());
  RETURN_TYPE_ERROR(Z, integer, Integer);
}

Dart_IntegerFitsIntoUint64()

DART_EXPORT Dart_Handle dart::Dart_IntegerFitsIntoUint64	(	Dart_Handle	integer,
		bool *	fits
	)

Definition at line 2593 of file dart_api_impl.cc.

                                                               {
  // Fast path for Smis.
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  API_TIMELINE_DURATION(thread);
  if (Api::IsSmi(integer)) {
    *fits = (Api::SmiValue(integer) >= 0);
    return Api::Success();
  }
  // Slow path for Mints.
  DARTSCOPE(thread);
  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
  if (int_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, integer, Integer);
  }
  ASSERT(int_obj.IsMint());
  *fits = !int_obj.IsNegative();
  return Api::Success();
}

Dart_IntegerToHexCString()

DART_EXPORT Dart_Handle dart::Dart_IntegerToHexCString	(	Dart_Handle	integer,
		const char **	value
	)

Definition at line 2703 of file dart_api_impl.cc.

                                                                     {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
  if (int_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, integer, Integer);
  }
  Zone* scope_zone = Api::TopScope(Thread::Current())->zone();
  *value = int_obj.ToHexCString(scope_zone);
  return Api::Success();
}

Dart_IntegerToInt64()

DART_EXPORT Dart_Handle dart::Dart_IntegerToInt64	(	Dart_Handle	integer,
		int64_t *	value
	)

Definition at line 2650 of file dart_api_impl.cc.

                                                            {
  // Fast path for Smis.
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  if (Api::IsSmi(integer)) {
    *value = Api::SmiValue(integer);
    return Api::Success();
  }
  // Slow path for Mints.
  DARTSCOPE(thread);
  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
  if (int_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, integer, Integer);
  }
  ASSERT(int_obj.IsMint());
  *value = int_obj.AsInt64Value();
  return Api::Success();
}

Dart_IntegerToUint64()

DART_EXPORT Dart_Handle dart::Dart_IntegerToUint64	(	Dart_Handle	integer,
		uint64_t *	value
	)

Definition at line 2671 of file dart_api_impl.cc.

                                                              {
  // Fast path for Smis.
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  if (Api::IsSmi(integer)) {
    intptr_t smi_value = Api::SmiValue(integer);
    if (smi_value >= 0) {
      *value = smi_value;
      return Api::Success();
    }
  }
  // Slow path for Mints.
  DARTSCOPE(thread);
  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
  if (int_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, integer, Integer);
  }
  if (int_obj.IsSmi()) {
    ASSERT(int_obj.IsNegative());
  } else {
    ASSERT(int_obj.IsMint());
    if (!int_obj.IsNegative()) {
      *value = int_obj.AsInt64Value();
      return Api::Success();
    }
  }
  return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
                       CURRENT_FUNC, int_obj.ToCString());
}

Dart_Invoke()

DART_EXPORT Dart_Handle dart::Dart_Invoke	(	Dart_Handle	target,
		Dart_Handle	name,
		int	number_of_arguments,
		Dart_Handle *	arguments
	)

Definition at line 4552 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_CALLBACK_STATE(T);
 
  String& function_name =
      String::Handle(Z, Api::UnwrapStringHandle(Z, name).ptr());
  if (function_name.IsNull()) {
    RETURN_TYPE_ERROR(Z, name, String);
  }
  if (number_of_arguments < 0) {
    return Api::NewError(
        "%s expects argument 'number_of_arguments' to be non-negative.",
        CURRENT_FUNC);
  }
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(target));
  if (obj.IsError()) {
    return target;
  }
  Dart_Handle result;
  Array& args = Array::Handle(Z);
  // This API does not provide a way to pass named parameters.
  const Array& arg_names = Object::empty_array();
  const bool respect_reflectable = false;
  const bool check_is_entrypoint = FLAG_verify_entry_points;
  if (obj.IsType()) {
    if (!Type::Cast(obj).IsFinalized()) {
      return Api::NewError(
          "%s expects argument 'target' to be a fully resolved type.",
          CURRENT_FUNC);
    }
 
    const Class& cls = Class::Handle(Z, Type::Cast(obj).type_class());
    if (Library::IsPrivate(function_name)) {
      const Library& lib = Library::Handle(Z, cls.library());
      function_name = lib.PrivateName(function_name);
    }
 
    // Setup args and check for malformed arguments in the arguments list.
    result = SetupArguments(T, number_of_arguments, arguments, 0, &args);
    if (Api::IsError(result)) {
      return result;
    }
    return Api::NewHandle(
        T, cls.Invoke(function_name, args, arg_names, respect_reflectable,
                      check_is_entrypoint));
  } else if (obj.IsNull() || obj.IsInstance()) {
    // Since we have allocated an object it would mean that the type of the
    // receiver is already resolved and finalized, hence it is not necessary
    // to check here.
    Instance& instance = Instance::Handle(Z);
    instance ^= obj.ptr();
 
    // Setup args and check for malformed arguments in the arguments list.
    result = SetupArguments(T, number_of_arguments, arguments, 1, &args);
    if (Api::IsError(result)) {
      return result;
    }
    args.SetAt(0, instance);
    return Api::NewHandle(
        T, instance.Invoke(function_name, args, arg_names, respect_reflectable,
                           check_is_entrypoint));
  } else if (obj.IsLibrary()) {
    // Check whether class finalization is needed.
    const Library& lib = Library::Cast(obj);
 
    // Check that the library is loaded.
    if (!lib.Loaded()) {
      return Api::NewError("%s expects library argument 'target' to be loaded.",
                           CURRENT_FUNC);
    }
 
    if (Library::IsPrivate(function_name)) {
      function_name = lib.PrivateName(function_name);
    }
 
    // Setup args and check for malformed arguments in the arguments list.
    result = SetupArguments(T, number_of_arguments, arguments, 0, &args);
    if (Api::IsError(result)) {
      return result;
    }
 
    return Api::NewHandle(
        T, lib.Invoke(function_name, args, arg_names, respect_reflectable,
                      check_is_entrypoint));
  } else {
    return Api::NewError(
        "%s expects argument 'target' to be an object, type, or library.",
        CURRENT_FUNC);
  }
}

Dart_InvokeClosure()

DART_EXPORT Dart_Handle dart::Dart_InvokeClosure	(	Dart_Handle	closure,
		int	number_of_arguments,
		Dart_Handle *	arguments
	)

Definition at line 4647 of file dart_api_impl.cc.

                                                                   {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_CALLBACK_STATE(T);
  const Instance& closure_obj = Api::UnwrapInstanceHandle(Z, closure);
  if (closure_obj.IsNull() || !closure_obj.IsCallable(nullptr)) {
    RETURN_TYPE_ERROR(Z, closure, Instance);
  }
  if (number_of_arguments < 0) {
    return Api::NewError(
        "%s expects argument 'number_of_arguments' to be non-negative.",
        CURRENT_FUNC);
  }
 
  // Set up arguments to include the closure as the first argument.
  const Array& args = Array::Handle(Z, Array::New(number_of_arguments + 1));
  Object& obj = Object::Handle(Z);
  args.SetAt(0, closure_obj);
  for (int i = 0; i < number_of_arguments; i++) {
    obj = Api::UnwrapHandle(arguments[i]);
    if (!obj.IsNull() && !obj.IsInstance()) {
      RETURN_TYPE_ERROR(Z, arguments[i], Instance);
    }
    args.SetAt(i + 1, obj);
  }
  // Now try to invoke the closure.
  return Api::NewHandle(T, DartEntry::InvokeClosure(T, args));
}

Dart_InvokeConstructor()

DART_EXPORT Dart_Handle dart::Dart_InvokeConstructor	(	Dart_Handle	object,
		Dart_Handle	name,
		int	number_of_arguments,
		Dart_Handle *	arguments
	)

Definition at line 4470 of file dart_api_impl.cc.

                                                                       {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_CALLBACK_STATE(T);
 
  if (number_of_arguments < 0) {
    return Api::NewError(
        "%s expects argument 'number_of_arguments' to be non-negative.",
        CURRENT_FUNC);
  }
  const Instance& instance = Api::UnwrapInstanceHandle(Z, object);
  if (instance.IsNull()) {
    RETURN_TYPE_ERROR(Z, object, Instance);
  }
 
  // Since we have allocated an object it would mean that the type
  // is finalized.
  // TODO(asiva): How do we ensure that a constructor is not called more than
  // once for the same object.
 
  // Construct name of the constructor to invoke.
  const String& constructor_name = Api::UnwrapStringHandle(Z, name);
  AbstractType& type_obj =
      AbstractType::Handle(Z, instance.GetType(Heap::kNew));
  const Class& cls = Class::Handle(Z, type_obj.type_class());
  const String& class_name = String::Handle(Z, cls.Name());
  const Array& strings = Array::Handle(Z, Array::New(3));
  strings.SetAt(0, class_name);
  strings.SetAt(1, Symbols::Dot());
  if (constructor_name.IsNull()) {
    strings.SetAt(2, Symbols::Empty());
  } else {
    strings.SetAt(2, constructor_name);
  }
  const String& dot_name = String::Handle(Z, String::ConcatAll(strings));
  TypeArguments& type_arguments = TypeArguments::Handle(Z);
  if (type_obj.IsType()) {
    type_arguments = Type::Cast(type_obj).GetInstanceTypeArguments(T);
  }
  const Function& constructor =
      Function::Handle(Z, cls.LookupFunctionAllowPrivate(dot_name));
  const int kTypeArgsLen = 0;
  const int extra_args = 1;
  if (!constructor.IsNull() && constructor.IsGenerativeConstructor() &&
      constructor.AreValidArgumentCounts(
          kTypeArgsLen, number_of_arguments + extra_args, 0, nullptr)) {
    CHECK_ERROR_HANDLE(constructor.VerifyCallEntryPoint());
    // Create the argument list.
    Dart_Handle result;
    Array& args = Array::Handle(Z);
    result =
        SetupArguments(T, number_of_arguments, arguments, extra_args, &args);
    if (!Api::IsError(result)) {
      args.SetAt(0, instance);
 
      const int kTypeArgsLen = 0;
      const Array& args_descriptor_array = Array::Handle(
          Z, ArgumentsDescriptor::NewBoxed(kTypeArgsLen, args.Length()));
      ArgumentsDescriptor args_descriptor(args_descriptor_array);
      ObjectPtr type_error = constructor.DoArgumentTypesMatch(
          args, args_descriptor, type_arguments);
      if (type_error != Error::null()) {
        return Api::NewHandle(T, type_error);
      }
 
      const Object& retval =
          Object::Handle(Z, DartEntry::InvokeFunction(constructor, args));
      if (retval.IsError()) {
        result = Api::NewHandle(T, retval.ptr());
      } else {
        result = Api::NewHandle(T, instance.ptr());
      }
    }
    return result;
  }
  return Api::NewError("%s expects argument 'name' to be a valid constructor.",
                       CURRENT_FUNC);
}

Dart_InvokeVMServiceMethod()

DART_EXPORT bool dart::Dart_InvokeVMServiceMethod	(	uint8_t *	request_json,
		intptr_t	request_json_length,
		uint8_t **	response_json,
		intptr_t *	response_json_length,
		char **	error
	)

Definition at line 116 of file native_api_impl.cc.

                                                          {
#if !defined(PRODUCT)
  Isolate* isolate = Isolate::Current();
  ASSERT(isolate == nullptr || !isolate->is_service_isolate());
  IsolateLeaveScope saver(isolate);
 
  if (!Dart::IsInitialized()) {
    *error = ::dart::Utils::StrDup("VM Service is not active.");
    return false;
  }
 
  // We only allow one isolate reload at a time.  If this turns out to be on the
  // critical path, we can change it to have a global datastructure which is
  // mapping the reply ports to receive buffers.
  static Monitor* vm_service_calls_monitor = new Monitor();
  MonitorLocker _(vm_service_calls_monitor);
 
  static Monitor* vm_service_call_monitor = new Monitor();
  static uint8_t* result_bytes = nullptr;
  static intptr_t result_length = 0;
 
  ASSERT(result_bytes == nullptr);
  ASSERT(result_length == 0);
 
  struct Utils {
    static void HandleResponse(Dart_Port dest_port_id, Dart_CObject* message) {
      MonitorLocker monitor(vm_service_call_monitor);
 
      RELEASE_ASSERT(message->type == Dart_CObject_kTypedData);
      RELEASE_ASSERT(message->value.as_typed_data.type ==
                     Dart_TypedData_kUint8);
      result_length = message->value.as_typed_data.length;
      result_bytes = reinterpret_cast<uint8_t*>(malloc(result_length));
      memmove(result_bytes, message->value.as_typed_data.values, result_length);
 
      monitor.Notify();
    }
  };
 
  auto port =
      ::Dart_NewNativePort("service-rpc", &Utils::HandleResponse, false);
  if (port == ILLEGAL_PORT) {
    if (error != nullptr) {
      *error = ::dart::Utils::StrDup("Was unable to create native port.");
    }
    return false;
  }
 
  // Before sending the message we'll lock the monitor, which the receiver
  // will later on notify once the answer has been received.
  MonitorLocker monitor(vm_service_call_monitor);
 
  if (ServiceIsolate::SendServiceRpc(request_json, request_json_length, port,
                                     error)) {
    // We posted successfully and expect the vm-service to send the reply, so
    // we will wait for it now. Since the service isolate could have shutdown
    // after we sent the message we make sure to wake up periodically and
    // check to see if the service isolate has shutdown.
    do {
      auto wait_result = monitor.Wait(1000); /* milliseconds */
      if (wait_result == Monitor::kNotified) {
        break;
      }
      if (!ServiceIsolate::IsRunning()) {
        // Service Isolate has shutdown while we were waiting for a reply,
        // We will not get a reply anymore, cleanup and return an error.
        Dart_CloseNativePort(port);
        return false;
      }
    } while (true);
 
    // The caller takes ownership of the data.
    *response_json = result_bytes;
    *response_json_length = result_length;
 
    // Reset global data, which can be used by the next call (after the mutex
    // has been released).
    result_bytes = nullptr;
    result_length = 0;
 
    // After the data has been received, we will not get any more messages on
    // this port and can safely close it now.
    Dart_CloseNativePort(port);
 
    return true;
  } else {
    // We couldn't post the message and will not receive any reply. Therefore we
    // clean up the port and return an error.
    Dart_CloseNativePort(port);
    return false;
  }
#else   // !defined(PRODUCT)
  if (error != nullptr) {
    *error = Utils::StrDup("VM Service is not supported in PRODUCT mode.");
  }
  return false;
#endif  // !defined(PRODUCT)
}

Dart_IsApiError()

DART_EXPORT bool dart::Dart_IsApiError

(

Dart_Handle

object

)

Definition at line 756 of file dart_api_impl.cc.

                                                     {
  Thread* thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  return Api::ClassId(object) == kApiErrorCid;
}

Dart_IsBoolean()

DART_EXPORT bool dart::Dart_IsBoolean

(

Dart_Handle

object

)

Definition at line 2340 of file dart_api_impl.cc.

                                                    {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return Api::ClassId(object) == kBoolCid;
}

Dart_IsByteBuffer()

DART_EXPORT bool dart::Dart_IsByteBuffer

(

Dart_Handle

handle

)

Definition at line 2440 of file dart_api_impl.cc.

                                                       {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return Api::ClassId(handle) == kByteBufferCid;
}

Dart_IsClosure()

DART_EXPORT bool dart::Dart_IsClosure

(

Dart_Handle

object

)

Definition at line 2412 of file dart_api_impl.cc.

                                                    {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return Api::ClassId(object) == kClosureCid;
}

Dart_IsCompilationError()

DART_EXPORT bool dart::Dart_IsCompilationError

(

Dart_Handle

object

)

Definition at line 768 of file dart_api_impl.cc.

                                                             {
  if (::Dart_IsUnhandledExceptionError(object)) {
    DARTSCOPE(Thread::Current());
    const UnhandledException& error =
        UnhandledException::Cast(Object::Handle(Z, Api::UnwrapHandle(object)));
    const Instance& exc = Instance::Handle(Z, error.exception());
    return IsCompiletimeErrorObject(Z, exc);
  }
 
  Thread* thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  return Api::ClassId(object) == kLanguageErrorCid;
}

Dart_IsDouble()

DART_EXPORT bool dart::Dart_IsDouble

(

Dart_Handle

object

)

Definition at line 2333 of file dart_api_impl.cc.

                                                   {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return Api::ClassId(object) == kDoubleCid;
}

Dart_IsError()

DART_EXPORT bool dart::Dart_IsError

(

Dart_Handle

handle

)

Definition at line 744 of file dart_api_impl.cc.

                                                  {
  Thread* thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  return Api::IsError(handle);
}

Dart_IsFatalError()

DART_EXPORT bool dart::Dart_IsFatalError

(

Dart_Handle

object

)

Definition at line 782 of file dart_api_impl.cc.

                                                       {
  Thread* thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  return Api::ClassId(object) == kUnwindErrorCid;
}

Dart_IsFunction()

DART_EXPORT bool dart::Dart_IsFunction

(

Dart_Handle

handle

)

Definition at line 2391 of file dart_api_impl.cc.

                                                     {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return Api::ClassId(handle) == kFunctionCid;
}

Dart_IsFuture()

DART_EXPORT bool dart::Dart_IsFuture

(

Dart_Handle

handle

)

Definition at line 2447 of file dart_api_impl.cc.

                                                   {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
  if (obj.IsInstance()) {
    const Class& obj_class = Class::Handle(Z, obj.clazz());
    return obj_class.is_future_subtype();
  }
  return false;
}

Dart_IsInstance()

DART_EXPORT bool dart::Dart_IsInstance

(

Dart_Handle

object

)

Definition at line 2309 of file dart_api_impl.cc.

                                                     {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  REUSABLE_OBJECT_HANDLESCOPE(thread);
  Object& ref = thread->ObjectHandle();
  ref = Api::UnwrapHandle(object);
  return ref.IsInstance();
}

Dart_IsInteger()

DART_EXPORT bool dart::Dart_IsInteger

(

Dart_Handle

object

)

Definition at line 2326 of file dart_api_impl.cc.

                                                    {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return IsIntegerClassId(Api::ClassId(object));
}

Dart_IsKernel()

DART_EXPORT bool dart::Dart_IsKernel	(	const uint8_t *	buffer,
		intptr_t	buffer_size
	)

Definition at line 1929 of file dart_api_impl.cc.

                                                                            {
  if (buffer_size < 4) {
    return false;
  }
  return (buffer[0] == 0x90) && (buffer[1] == 0xab) && (buffer[2] == 0xcd) &&
         (buffer[3] == 0xef);
}

Dart_IsKernelIsolate()

DART_EXPORT bool dart::Dart_IsKernelIsolate

(

Dart_Isolate

isolate

)

Definition at line 6023 of file dart_api_impl.cc.

                                                            {
#if defined(DART_PRECOMPILED_RUNTIME)
  return false;
#else
  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
  return iso->is_kernel_isolate();
#endif
}

Dart_IsLegacyType()

DART_EXPORT Dart_Handle dart::Dart_IsLegacyType	(	Dart_Handle	type,
		bool *	result
	)

Definition at line 5667 of file dart_api_impl.cc.

                                                                          {
  return IsOfTypeNullabilityHelper(type, Nullability::kLegacy, result);
}

Dart_IsLibrary()

DART_EXPORT bool dart::Dart_IsLibrary

(

Dart_Handle

object

)

Definition at line 2377 of file dart_api_impl.cc.

                                                    {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return Api::ClassId(object) == kLibraryCid;
}

Dart_IsList()

DART_EXPORT bool dart::Dart_IsList

(

Dart_Handle

object

)

Definition at line 2361 of file dart_api_impl.cc.

                                                 {
  DARTSCOPE(Thread::Current());
  if (IsBuiltinListClassId(Api::ClassId(object))) {
    return true;
  }
 
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(object));
  return GetListInstance(Z, obj) != Instance::null();
}

Dart_IsMap()

DART_EXPORT bool dart::Dart_IsMap

(

Dart_Handle

object

)

Definition at line 2371 of file dart_api_impl.cc.

                                                {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(object));
  return GetMapInstance(Z, obj) != Instance::null();
}

Dart_IsNonNullableType()

DART_EXPORT Dart_Handle dart::Dart_IsNonNullableType	(	Dart_Handle	type,
		bool *	result
	)

Definition at line 5663 of file dart_api_impl.cc.

                                                                               {
  return IsOfTypeNullabilityHelper(type, Nullability::kNonNullable, result);
}

Dart_IsNull()

DART_EXPORT bool dart::Dart_IsNull

(

Dart_Handle

object

)

Definition at line 2220 of file dart_api_impl.cc.

                                                 {
  TransitionNativeToVM transition(Thread::Current());
  return Api::UnwrapHandle(object) == Object::null();
}

Dart_IsNullableType()

DART_EXPORT Dart_Handle dart::Dart_IsNullableType	(	Dart_Handle	type,
		bool *	result
	)

Definition at line 5659 of file dart_api_impl.cc.

                                                                            {
  return IsOfTypeNullabilityHelper(type, Nullability::kNullable, result);
}

Dart_IsNumber()

DART_EXPORT bool dart::Dart_IsNumber

(

Dart_Handle

object

)

Definition at line 2319 of file dart_api_impl.cc.

                                                   {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return IsNumberClassId(Api::ClassId(object));
}

Dart_IsolateData()

DART_EXPORT void * dart::Dart_IsolateData

(

Dart_Isolate

isolate

)

Definition at line 1466 of file dart_api_impl.cc.

                                                         {
  if (isolate == nullptr) {
    FATAL("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC);
  }
  // TODO(http://dartbug.com/16615): Validate isolate parameter.
  return reinterpret_cast<Isolate*>(isolate)->init_callback_data();
}

Dart_IsolateFlagsInitialize()

DART_EXPORT void dart::Dart_IsolateFlagsInitialize

(

Dart_IsolateFlags *

flags

)

Definition at line 1321 of file dart_api_impl.cc.

                                                                       {
  Isolate::FlagsInitialize(flags);
}

Dart_IsolateGroupData()

DART_EXPORT void * dart::Dart_IsolateGroupData

(

Dart_Isolate

isolate

)

Definition at line 1491 of file dart_api_impl.cc.

                                                              {
  if (isolate == nullptr) {
    FATAL("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC);
  }
  // TODO(http://dartbug.com/16615): Validate isolate parameter.
  return reinterpret_cast<Isolate*>(isolate)->group()->embedder_data();
}

Dart_IsolateMakeRunnable()

DART_EXPORT char * dart::Dart_IsolateMakeRunnable

(

Dart_Isolate

isolate

)

Definition at line 1937 of file dart_api_impl.cc.

                                                                 {
  CHECK_NO_ISOLATE(Isolate::Current());
  API_TIMELINE_DURATION(Thread::Current());
  if (isolate == nullptr) {
    FATAL("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC);
  }
  // TODO(16615): Validate isolate parameter.
  const char* error = reinterpret_cast<Isolate*>(isolate)->MakeRunnable();
  if (error != nullptr) {
    return Utils::StrDup(error);
  }
  return nullptr;
}

Dart_IsolateServiceId()

DART_EXPORT const char * dart::Dart_IsolateServiceId

(

Dart_Isolate

isolate

)

Definition at line 1524 of file dart_api_impl.cc.

                                                                    {
  if (isolate == nullptr) {
    FATAL("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC);
  }
  // TODO(http://dartbug.com/16615): Validate isolate parameter.
  Isolate* I = reinterpret_cast<Isolate*>(isolate);
  int64_t main_port = static_cast<int64_t>(I->main_port());
  return OS::SCreate(nullptr, "isolates/%" Pd64, main_port);
}

Dart_IsPausedOnExit()

DART_EXPORT bool dart::Dart_IsPausedOnExit

(

void

)

Definition at line 1715 of file dart_api_impl.cc.

                                       {
#if defined(PRODUCT)
  return false;
#else
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->message_handler()->is_paused_on_exit();
#endif
}

Dart_IsPausedOnStart()

DART_EXPORT bool dart::Dart_IsPausedOnStart

(

void

)

Definition at line 1665 of file dart_api_impl.cc.

                                        {
#if defined(PRODUCT)
  return false;
#else
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->message_handler()->is_paused_on_start();
#endif
}

Dart_IsPrecompiledRuntime()

DART_EXPORT bool dart::Dart_IsPrecompiledRuntime

(

void

)

Definition at line 6886 of file dart_api_impl.cc.

                                             {
#if defined(DART_PRECOMPILED_RUNTIME)
  return true;
#else
  return false;
#endif
}

Dart_IsReloading()

DART_EXPORT bool dart::Dart_IsReloading

(

)

Definition at line 6244 of file dart_api_impl.cc.

                                    {
#if defined(PRODUCT) || defined(DART_PRECOMPILED_RUNTIME)
  return false;
#else
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  return isolate->group()->IsReloading();
#endif
}

Dart_IsServiceIsolate()

DART_EXPORT bool dart::Dart_IsServiceIsolate

(

Dart_Isolate

isolate

)

Definition at line 6116 of file dart_api_impl.cc.

                                                             {
  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
  return iso->is_service_isolate();
}

Dart_IsString()

DART_EXPORT bool dart::Dart_IsString

(

Dart_Handle

object

)

Definition at line 2347 of file dart_api_impl.cc.

                                                   {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return IsStringClassId(Api::ClassId(object));
}

Dart_IsStringLatin1()

DART_EXPORT bool dart::Dart_IsStringLatin1

(

Dart_Handle

object

)

Definition at line 2354 of file dart_api_impl.cc.

                                                         {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return IsOneByteStringClassId(Api::ClassId(object));
}

Dart_IsTearOff()

DART_EXPORT bool dart::Dart_IsTearOff

(

Dart_Handle

object

)

Definition at line 2419 of file dart_api_impl.cc.

                                                    {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(object));
  if (obj.IsClosure()) {
    const Closure& closure = Closure::Cast(obj);
    const Function& func = Function::Handle(Z, closure.function());
    return func.IsImplicitClosureFunction();
  }
  return false;
}

Dart_IsType()

DART_EXPORT bool dart::Dart_IsType

(

Dart_Handle

handle

)

Definition at line 2384 of file dart_api_impl.cc.

                                                 {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return IsTypeClassId(Api::ClassId(handle));
}

Dart_IsTypedData()

DART_EXPORT bool dart::Dart_IsTypedData

(

Dart_Handle

handle

)

Definition at line 2431 of file dart_api_impl.cc.

                                                      {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  intptr_t cid = Api::ClassId(handle);
  return IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid) ||
         IsTypedDataViewClassId(cid) || IsUnmodifiableTypedDataViewClassId(cid);
}

Dart_IsTypeVariable()

DART_EXPORT bool dart::Dart_IsTypeVariable

(

Dart_Handle

handle

)

Definition at line 2405 of file dart_api_impl.cc.

                                                         {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return Api::ClassId(handle) == kTypeParameterCid;
}

Dart_IsUnhandledExceptionError()

DART_EXPORT bool dart::Dart_IsUnhandledExceptionError

(

Dart_Handle

object

)

Definition at line 762 of file dart_api_impl.cc.

                                                                    {
  Thread* thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  return Api::ClassId(object) == kUnhandledExceptionCid;
}

Dart_IsVariable()

DART_EXPORT bool dart::Dart_IsVariable

(

Dart_Handle

handle

)

Definition at line 2398 of file dart_api_impl.cc.

                                                     {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  return Api::ClassId(handle) == kFieldCid;
}

Dart_IsVMFlagSet()

DART_EXPORT bool dart::Dart_IsVMFlagSet

(

const char *

flag_name

)

Definition at line 1190 of file dart_api_impl.cc.

                                                         {
  return Flags::IsSet(flag_name);
}

Dart_KernelIsolateIsRunning()

DART_EXPORT bool dart::Dart_KernelIsolateIsRunning

(

void

)

Definition at line 6032 of file dart_api_impl.cc.

                                               {
#if defined(DART_PRECOMPILED_RUNTIME)
  return false;
#else
  return KernelIsolate::IsRunning();
#endif
}

Dart_KernelListDependencies()

DART_EXPORT Dart_KernelCompilationResult dart::Dart_KernelListDependencies

(

void

)

Definition at line 6084 of file dart_api_impl.cc.

                                                                       {
  Dart_KernelCompilationResult result = {};
#if defined(DART_PRECOMPILED_RUNTIME)
  result.status = Dart_KernelCompilationStatus_Unknown;
  result.error = Utils::StrDup("Dart_KernelListDependencies is unsupported.");
#else
  result = KernelIsolate::ListDependencies();
#endif
  return result;
}

Dart_KernelPort()

DART_EXPORT Dart_Port dart::Dart_KernelPort

(

void

)

Definition at line 6040 of file dart_api_impl.cc.

                                        {
#if defined(DART_PRECOMPILED_RUNTIME)
  return false;
#else
  return KernelIsolate::KernelPort();
#endif
}

Dart_KillIsolate()

DART_EXPORT void dart::Dart_KillIsolate

(

Dart_Isolate

handle

)

Definition at line 750 of file dart_api_impl.cc.

                                                       {
  Isolate* isolate = reinterpret_cast<Isolate*>(handle);
  CHECK_ISOLATE(isolate);
  Isolate::KillIfExists(isolate, Isolate::kKillMsg);
}

Dart_LibraryHandleError()

DART_EXPORT Dart_Handle dart::Dart_LibraryHandleError	(	Dart_Handle	library_in,
		Dart_Handle	error_in
	)

Definition at line 5732 of file dart_api_impl.cc.

                                                                      {
  DARTSCOPE(Thread::Current());
 
  const Library& lib = Api::UnwrapLibraryHandle(Z, library_in);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library_in, Library);
  }
  const Instance& err = Api::UnwrapInstanceHandle(Z, error_in);
  if (err.IsNull()) {
    RETURN_TYPE_ERROR(Z, error_in, Instance);
  }
  CHECK_CALLBACK_STATE(T);
 
  return error_in;
}

Dart_LibraryId()

Dart_Handle dart::Dart_LibraryId	(	Dart_Handle	library,
		intptr_t *	library_id
	)

Returns in \library_id the library id of the given \library.

Returns

A valid handle if no error occurs during the operation.

Definition at line 223 of file debugger_api_impl_test.cc.

                                                                      {
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  if (library_id == nullptr) {
    RETURN_NULL_ERROR(library_id);
  }
  *library_id = lib.index();
  return Api::Success();
}

Dart_LibraryResolvedUrl()

DART_EXPORT Dart_Handle dart::Dart_LibraryResolvedUrl

(

Dart_Handle

library

)

Definition at line 5682 of file dart_api_impl.cc.

                                                                     {
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  const Class& toplevel = Class::Handle(lib.toplevel_class());
  ASSERT(!toplevel.IsNull());
  const Script& script = Script::Handle(toplevel.script());
  ASSERT(!script.IsNull());
  const String& url = String::Handle(script.resolved_url());
  ASSERT(!url.IsNull());
  return Api::NewHandle(T, url.ptr());
}

Dart_LibraryUrl()

DART_EXPORT Dart_Handle dart::Dart_LibraryUrl

(

Dart_Handle

library

)

Definition at line 5671 of file dart_api_impl.cc.

                                                             {
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  const String& url = String::Handle(Z, lib.url());
  ASSERT(!url.IsNull());
  return Api::NewHandle(T, url.ptr());
}

Dart_ListGetAsBytes()

DART_EXPORT Dart_Handle dart::Dart_ListGetAsBytes	(	Dart_Handle	list,
		intptr_t	offset,
		uint8_t *	native_array,
		intptr_t	length
	)

Definition at line 3412 of file dart_api_impl.cc.

                                                             {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(list));
  if (obj.IsTypedDataBase()) {
    const TypedDataBase& array = TypedDataBase::Cast(obj);
    if (array.ElementSizeInBytes() == 1) {
      if (Utils::RangeCheck(offset, length, array.Length())) {
        NoSafepointScope no_safepoint;
        memmove(native_array,
                reinterpret_cast<uint8_t*>(array.DataAddr(offset)), length);
        return Api::Success();
      }
      return Api::NewError("Invalid length passed into access list elements");
    }
  }
  if (obj.IsArray()) {
    GET_LIST_ELEMENT_AS_BYTES(Array, obj, native_array, offset, length);
  }
  if (obj.IsGrowableObjectArray()) {
    GET_LIST_ELEMENT_AS_BYTES(GrowableObjectArray, obj, native_array, offset,
                              length);
  }
  if (obj.IsError()) {
    return list;
  }
  CHECK_CALLBACK_STATE(T);
 
  // Check and handle a dart object that implements the List interface.
  const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
  if (!instance.IsNull()) {
    const int kNumArgs = 2;
    const Function& function = Function::Handle(
        Z, FindCoreLibPrivateFunction(Z, Symbols::_listGetAt()));
    Object& result = Object::Handle(Z);
    Integer& intobj = Integer::Handle(Z);
    const Array& args = Array::Handle(Z, Array::New(kNumArgs));
    args.SetAt(0, instance);  // Set up the receiver as the first argument.
    for (int i = 0; i < length; i++) {
      HANDLESCOPE(T);
      intobj = Integer::New(offset + i);
      args.SetAt(1, intobj);
      result = DartEntry::InvokeFunction(function, args);
      if (result.IsError()) {
        return Api::NewHandle(T, result.ptr());
      }
      if (!result.IsInteger()) {
        return Api::NewError(
            "%s expects the argument 'list' to be "
            "a List of int",
            CURRENT_FUNC);
      }
      const Integer& integer_result = Integer::Cast(result);
      ASSERT(integer_result.AsInt64Value() <= 0xff);
      // TODO(hpayer): value should always be smaller then 0xff. Add error
      // handling.
      native_array[i] =
          static_cast<uint8_t>(integer_result.AsInt64Value() & 0xff);
    }
    return Api::Success();
  }
  return Api::NewArgumentError(
      "Object does not implement the 'List' interface");
}

Dart_ListGetAt()

DART_EXPORT Dart_Handle dart::Dart_ListGetAt	(	Dart_Handle	list,
		intptr_t	index
	)

Definition at line 3207 of file dart_api_impl.cc.

                                                                         {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(list));
  if (obj.IsArray()) {
    GET_LIST_ELEMENT(T, Array, obj, index);
  } else if (obj.IsGrowableObjectArray()) {
    GET_LIST_ELEMENT(T, GrowableObjectArray, obj, index);
  } else if (obj.IsError()) {
    return list;
  } else {
    CHECK_CALLBACK_STATE(T);
    // Check and handle a dart object that implements the List interface.
    const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
    if (!instance.IsNull()) {
      return Api::NewHandle(
          T, CallStatic2Args(Z, Symbols::_listGetAt(), instance,
                             Instance::Handle(Z, Integer::New(index))));
    }
    return Api::NewArgumentError(
        "Object does not implement the 'List' interface");
  }
}

Dart_ListGetRange()

DART_EXPORT Dart_Handle dart::Dart_ListGetRange	(	Dart_Handle	list,
		intptr_t	offset,
		intptr_t	length,
		Dart_Handle *	result
	)

Definition at line 3240 of file dart_api_impl.cc.

                                                               {
  DARTSCOPE(Thread::Current());
  if (result == nullptr) {
    RETURN_NULL_ERROR(result);
  }
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(list));
  if (obj.IsArray()) {
    GET_LIST_RANGE(T, Array, obj, offset, length);
  } else if (obj.IsGrowableObjectArray()) {
    GET_LIST_RANGE(T, GrowableObjectArray, obj, offset, length);
  } else if (obj.IsError()) {
    return list;
  } else {
    CHECK_CALLBACK_STATE(T);
    // Check and handle a dart object that implements the List interface.
    const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
    if (!instance.IsNull()) {
      const intptr_t kNumArgs = 2;
      const Function& function = Function::Handle(
          Z, FindCoreLibPrivateFunction(Z, Symbols::_listGetAt()));
      const Array& args = Array::Handle(Z, Array::New(kNumArgs));
      args.SetAt(0, instance);
      Instance& index = Instance::Handle(Z);
      for (intptr_t i = 0; i < length; ++i) {
        index = Integer::New(i);
        args.SetAt(1, index);
        Dart_Handle value =
            Api::NewHandle(T, DartEntry::InvokeFunction(function, args));
        if (Api::IsError(value)) return value;
        result[i] = value;
      }
      return Api::Success();
    }
    return Api::NewArgumentError(
        "Object does not implement the 'List' interface");
  }
}

Dart_ListLength()

DART_EXPORT Dart_Handle dart::Dart_ListLength	(	Dart_Handle	list,
		intptr_t *	len
	)

Definition at line 3155 of file dart_api_impl.cc.

                                                                         {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(list));
  if (obj.IsError()) {
    // Pass through errors.
    return list;
  }
  if (obj.IsTypedDataBase()) {
    GET_LIST_LENGTH(Z, TypedDataBase, obj, len);
  }
  if (obj.IsArray()) {
    GET_LIST_LENGTH(Z, Array, obj, len);
  }
  if (obj.IsGrowableObjectArray()) {
    GET_LIST_LENGTH(Z, GrowableObjectArray, obj, len);
  }
  CHECK_CALLBACK_STATE(T);
 
  // Now check and handle a dart object that implements the List interface.
  const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
  if (instance.IsNull()) {
    return Api::NewArgumentError(
        "Object does not implement the List interface");
  }
  const Object& retval =
      Object::Handle(Z, CallStatic1Arg(Z, Symbols::_listLength(), instance));
  if (retval.IsSmi()) {
    *len = Smi::Cast(retval).Value();
    return Api::Success();
  } else if (retval.IsMint()) {
    int64_t mint_value = Mint::Cast(retval).value();
    if (mint_value >= kIntptrMin && mint_value <= kIntptrMax) {
      *len = static_cast<intptr_t>(mint_value);
      return Api::Success();
    }
    return Api::NewError(
        "Length of List object is greater than the "
        "maximum value that 'len' parameter can hold");
  } else if (retval.IsError()) {
    return Api::NewHandle(T, retval.ptr());
  } else {
    return Api::NewError("Length of List object is not an integer");
  }
}

Dart_ListSetAsBytes()

DART_EXPORT Dart_Handle dart::Dart_ListSetAsBytes	(	Dart_Handle	list,
		intptr_t	offset,
		const uint8_t *	native_array,
		intptr_t	length
	)

Definition at line 3491 of file dart_api_impl.cc.

                                                             {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(list));
  if (obj.IsTypedDataBase()) {
    const TypedDataBase& array = TypedDataBase::Cast(obj);
    if (array.ElementSizeInBytes() == 1) {
      if (Utils::RangeCheck(offset, length, array.Length())) {
        NoSafepointScope no_safepoint;
        memmove(reinterpret_cast<uint8_t*>(array.DataAddr(offset)),
                native_array, length);
        return Api::Success();
      }
      return Api::NewError("Invalid length passed into access list elements");
    }
  }
  if (obj.IsArray() && !Array::Cast(obj).IsImmutable()) {
    // If the list is immutable we call into Dart for the indexed setter to
    // get the unsupported operation exception as the result.
    SET_LIST_ELEMENT_AS_BYTES(Array, obj, native_array, offset, length);
  }
  if (obj.IsGrowableObjectArray()) {
    SET_LIST_ELEMENT_AS_BYTES(GrowableObjectArray, obj, native_array, offset,
                              length);
  }
  if (obj.IsError()) {
    return list;
  }
  CHECK_CALLBACK_STATE(T);
 
  // Check and handle a dart object that implements the List interface.
  const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
  if (!instance.IsNull()) {
    const int kNumArgs = 3;
    const Function& function = Function::Handle(
        Z, FindCoreLibPrivateFunction(Z, Symbols::_listSetAt()));
    Integer& indexobj = Integer::Handle(Z);
    Integer& valueobj = Integer::Handle(Z);
    const Array& args = Array::Handle(Z, Array::New(kNumArgs));
    args.SetAt(0, instance);  // Set up the receiver as the first argument.
    for (int i = 0; i < length; i++) {
      indexobj = Integer::New(offset + i);
      valueobj = Integer::New(native_array[i]);
      args.SetAt(1, indexobj);
      args.SetAt(2, valueobj);
      const Object& result =
          Object::Handle(Z, DartEntry::InvokeFunction(function, args));
      if (result.IsError()) {
        return Api::NewHandle(T, result.ptr());
      }
    }
    return Api::Success();
  }
  return Api::NewArgumentError(
      "Object does not implement the 'List' interface");
}

Dart_ListSetAt()

DART_EXPORT Dart_Handle dart::Dart_ListSetAt	(	Dart_Handle	list,
		intptr_t	index,
		Dart_Handle	value
	)

Definition at line 3293 of file dart_api_impl.cc.

                                                          {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(list));
  // If the list is immutable we call into Dart for the indexed setter to
  // get the unsupported operation exception as the result.
  if (obj.IsArray() && !Array::Cast(obj).IsImmutable()) {
    SET_LIST_ELEMENT(Array, obj, index, value);
  } else if (obj.IsGrowableObjectArray()) {
    SET_LIST_ELEMENT(GrowableObjectArray, obj, index, value);
  } else if (obj.IsError()) {
    return list;
  } else {
    CHECK_CALLBACK_STATE(T);
 
    // Check and handle a dart object that implements the List interface.
    const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
    if (!instance.IsNull()) {
      const Integer& index_obj = Integer::Handle(Z, Integer::New(index));
      const Object& value_obj = Object::Handle(Z, Api::UnwrapHandle(value));
      if (!value_obj.IsNull() && !value_obj.IsInstance()) {
        RETURN_TYPE_ERROR(Z, value, Instance);
      }
      return Api::NewHandle(
          T, CallStatic3Args(Z, Symbols::_listSetAt(), instance, index_obj,
                             Instance::Cast(value_obj)));
    }
    return Api::NewArgumentError(
        "Object does not implement the 'List' interface");
  }
}

Dart_LoadingUnitLibraryUris()

DART_EXPORT Dart_Handle dart::Dart_LoadingUnitLibraryUris

(

intptr_t

loading_unit_id

)

Definition at line 6692 of file dart_api_impl.cc.

                                                                              {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("AOT compilation is not supported on IA32.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError(
      "This VM was built without support for AOT compilation.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
 
  const Array& loading_units =
      Array::Handle(Z, T->isolate_group()->object_store()->loading_unit_uris());
  if (loading_unit_id >= 0 && loading_unit_id < loading_units.Length()) {
    return Api::NewHandle(T, loading_units.At(loading_unit_id));
  }
  return Api::NewError("Invalid loading_unit_id");
#endif
}

Dart_LoadLibrary()

DART_EXPORT Dart_Handle dart::Dart_LoadLibrary

(

Dart_Handle

kernel_buffer

)

Definition at line 5788 of file dart_api_impl.cc.

                                                                    {
#if defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
#else
  DARTSCOPE(Thread::Current());
  const ExternalTypedData& td =
      Api::UnwrapExternalTypedDataHandle(Z, kernel_buffer);
  if (td.IsNull()) {
    RETURN_TYPE_ERROR(Z, kernel_buffer, ExternalTypedData);
  }
  return LoadLibrary(T, td);
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

Dart_LoadLibraryFromKernel()

DART_EXPORT Dart_Handle dart::Dart_LoadLibraryFromKernel	(	const uint8_t *	buffer,
		intptr_t	buffer_size
	)

Definition at line 5768 of file dart_api_impl.cc.

                                                                         {
#if defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  StackZone zone(T);
 
  CHECK_CALLBACK_STATE(T);
 
  // NOTE: We do not attach a finalizer for this object, because the embedder
  // will/should free it once the isolate group has shutdown.
  const auto& td = ExternalTypedData::Handle(ExternalTypedData::New(
      kExternalTypedDataUint8ArrayCid, const_cast<uint8_t*>(buffer),
      buffer_size, Heap::kOld));
  return LoadLibrary(T, td);
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

Dart_LoadScriptFromKernel()

DART_EXPORT Dart_Handle dart::Dart_LoadScriptFromKernel	(	const uint8_t *	buffer,
		intptr_t	buffer_size
	)

Definition at line 5424 of file dart_api_impl.cc.

                                                                        {
#if defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  StackZone zone(T);
  IsolateGroup* IG = T->isolate_group();
 
  Library& library = Library::Handle(Z, IG->object_store()->root_library());
  if (!library.IsNull()) {
    const String& library_url = String::Handle(Z, library.url());
    return Api::NewError("%s: A script has already been loaded from '%s'.",
                         CURRENT_FUNC, library_url.ToCString());
  }
  CHECK_CALLBACK_STATE(T);
 
  // NOTE: We do not attach a finalizer for this object, because the embedder
  // will free it once the isolate group has shutdown.
  const auto& td = ExternalTypedData::Handle(ExternalTypedData::New(
      kExternalTypedDataUint8ArrayCid, const_cast<uint8_t*>(buffer),
      buffer_size, Heap::kOld));
 
  const char* error = nullptr;
  std::unique_ptr<kernel::Program> program =
      kernel::Program::ReadFromTypedData(td, &error);
  if (program == nullptr) {
    return Api::NewError("Can't load Kernel binary: %s.", error);
  }
  const Object& tmp = kernel::KernelLoader::LoadEntireProgram(program.get());
  program.reset();
 
  if (tmp.IsError()) {
    return Api::NewHandle(T, tmp.ptr());
  }
 
  IG->source()->script_kernel_size = buffer_size;
  IG->source()->script_kernel_buffer = buffer;
 
  // TODO(32618): Setting root library based on whether it has 'main' or not
  // is not correct because main can be in the exported namespace of a library
  // or it could be a getter.
  if (tmp.IsNull()) {
    return Api::NewError(
        "Invoked Dart programs must have a 'main' function defined:\n"
        "https://dart.dev/guides/language/"
        "language-tour#a-basic-dart-program");
  }
  library ^= tmp.ptr();
  IG->object_store()->set_root_library(library);
  return Api::NewHandle(T, library.ptr());
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

Dart_LookupLibrary()

DART_EXPORT Dart_Handle dart::Dart_LookupLibrary

(

Dart_Handle

url

)

Definition at line 5716 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  const String& url_str = Api::UnwrapStringHandle(Z, url);
  if (url_str.IsNull()) {
    RETURN_TYPE_ERROR(Z, url, String);
  }
  const Library& library =
      Library::Handle(Z, Library::LookupLibrary(T, url_str));
  if (library.IsNull()) {
    return Api::NewError("%s: library '%s' not found.", CURRENT_FUNC,
                         url_str.ToCString());
  } else {
    return Api::NewHandle(T, library.ptr());
  }
}

Dart_MapContainsKey()

DART_EXPORT Dart_Handle dart::Dart_MapContainsKey	(	Dart_Handle	map,
		Dart_Handle	key
	)

Definition at line 3568 of file dart_api_impl.cc.

                                                                              {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(map));
  const Instance& instance = Instance::Handle(Z, GetMapInstance(Z, obj));
  if (!instance.IsNull()) {
    const Object& key_obj = Object::Handle(Z, Api::UnwrapHandle(key));
    if (!(key_obj.IsInstance() || key_obj.IsNull())) {
      return Api::NewError("Key is not an instance");
    }
    return Api::NewHandle(
        T, CallStatic2Args(Z, Symbols::_mapContainsKey(), instance,
                           Instance::Cast(key_obj)));
  }
  return Api::NewArgumentError("Object does not implement the 'Map' interface");
}

Dart_MapGetAt()

DART_EXPORT Dart_Handle dart::Dart_MapGetAt	(	Dart_Handle	map,
		Dart_Handle	key
	)

Definition at line 3552 of file dart_api_impl.cc.

                                                                        {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(map));
  const Instance& instance = Instance::Handle(Z, GetMapInstance(Z, obj));
  if (!instance.IsNull()) {
    const Object& key_obj = Object::Handle(Api::UnwrapHandle(key));
    if (!(key_obj.IsInstance() || key_obj.IsNull())) {
      return Api::NewError("Key is not an instance");
    }
    return Api::NewHandle(T, CallStatic2Args(Z, Symbols::_mapGet(), instance,
                                             Instance::Cast(key_obj)));
  }
  return Api::NewArgumentError("Object does not implement the 'Map' interface");
}

Dart_MapKeys()

DART_EXPORT Dart_Handle dart::Dart_MapKeys

(

Dart_Handle

map

)

Definition at line 3585 of file dart_api_impl.cc.

                                                      {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  Object& obj = Object::Handle(Z, Api::UnwrapHandle(map));
  Instance& instance = Instance::Handle(Z, GetMapInstance(Z, obj));
  if (!instance.IsNull()) {
    return Api::NewHandle(T, CallStatic1Arg(Z, Symbols::_mapKeys(), instance));
  }
  return Api::NewArgumentError("Object does not implement the 'Map' interface");
}

Dart_New()

DART_EXPORT Dart_Handle dart::Dart_New	(	Dart_Handle	type,
		Dart_Handle	constructor_name,
		int	number_of_arguments,
		Dart_Handle *	arguments
	)

Definition at line 4219 of file dart_api_impl.cc.

                                                         {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  Object& result = Object::Handle(Z);
 
  if (number_of_arguments < 0) {
    return Api::NewError(
        "%s expects argument 'number_of_arguments' to be non-negative.",
        CURRENT_FUNC);
  }
 
  // Get the class to instantiate.
  Object& unchecked_type = Object::Handle(Api::UnwrapHandle(type));
  if (unchecked_type.IsNull() || !unchecked_type.IsType()) {
    RETURN_TYPE_ERROR(Z, type, Type);
  }
  Type& type_obj = Type::Handle();
  type_obj ^= unchecked_type.ptr();
  if (!type_obj.IsFinalized()) {
    return Api::NewError(
        "%s expects argument 'type' to be a fully resolved type.",
        CURRENT_FUNC);
  }
  Class& cls = Class::Handle(Z, type_obj.type_class());
  CHECK_ERROR_HANDLE(cls.EnsureIsAllocateFinalized(T));
 
  TypeArguments& type_arguments =
      TypeArguments::Handle(Z, type_obj.GetInstanceTypeArguments(T));
 
  const String& base_constructor_name = String::Handle(Z, cls.Name());
 
  // And get the name of the constructor to invoke.
  String& dot_name = String::Handle(Z);
  result = Api::UnwrapHandle(constructor_name);
  if (result.IsNull()) {
    dot_name = Symbols::Dot().ptr();
  } else if (result.IsString()) {
    dot_name = String::Concat(Symbols::Dot(), String::Cast(result));
  } else {
    RETURN_TYPE_ERROR(Z, constructor_name, String);
  }
 
  // Resolve the constructor.
  String& constr_name =
      String::Handle(String::Concat(base_constructor_name, dot_name));
  result = ResolveConstructor("Dart_New", cls, base_constructor_name,
                              constr_name, number_of_arguments);
  if (result.IsError()) {
    return Api::NewHandle(T, result.ptr());
  }
  ASSERT(result.IsFunction());
  Function& constructor = Function::Handle(Z);
  constructor ^= result.ptr();
 
  Instance& new_object = Instance::Handle(Z);
  if (constructor.IsGenerativeConstructor()) {
    CHECK_ERROR_HANDLE(cls.VerifyEntryPoint());
#if defined(DEBUG)
    if (!cls.is_allocated() &&
        (Dart::vm_snapshot_kind() == Snapshot::kFullAOT)) {
      return Api::NewError("Precompilation dropped '%s'", cls.ToCString());
    }
#endif
    // Create the new object.
    new_object = Instance::New(cls);
  }
 
  // Create the argument list.
  intptr_t arg_index = 0;
  int extra_args = 1;
  const Array& args =
      Array::Handle(Z, Array::New(number_of_arguments + extra_args));
  if (constructor.IsGenerativeConstructor()) {
    // Constructors get the uninitialized object.
    if (!type_arguments.IsNull()) {
      // The type arguments will be null if the class has no type parameters, in
      // which case the following call would fail because there is no slot
      // reserved in the object for the type vector.
      new_object.SetTypeArguments(type_arguments);
    }
    args.SetAt(arg_index++, new_object);
  } else {
    // Factories get type arguments.
    args.SetAt(arg_index++, type_arguments);
  }
  Object& argument = Object::Handle(Z);
  for (int i = 0; i < number_of_arguments; i++) {
    argument = Api::UnwrapHandle(arguments[i]);
    if (!argument.IsNull() && !argument.IsInstance()) {
      if (argument.IsError()) {
        return Api::NewHandle(T, argument.ptr());
      } else {
        return Api::NewError(
            "%s expects arguments[%d] to be an Instance handle.", CURRENT_FUNC,
            i);
      }
    }
    args.SetAt(arg_index++, argument);
  }
 
  const int kTypeArgsLen = 0;
  Array& args_descriptor_array = Array::Handle(
      Z, ArgumentsDescriptor::NewBoxed(kTypeArgsLen, args.Length()));
 
  ArgumentsDescriptor args_descriptor(args_descriptor_array);
  ObjectPtr type_error = constructor.DoArgumentTypesMatch(
      args, args_descriptor, type_arguments, Object::empty_type_arguments());
  if (type_error != Error::null()) {
    return Api::NewHandle(T, type_error);
  }
 
  // Invoke the constructor and return the new object.
  result = DartEntry::InvokeFunction(constructor, args);
  if (result.IsError()) {
    return Api::NewHandle(T, result.ptr());
  }
 
  if (constructor.IsGenerativeConstructor()) {
    ASSERT(result.IsNull());
  } else {
    ASSERT(result.IsNull() || result.IsInstance());
    new_object ^= result.ptr();
  }
  return Api::NewHandle(T, new_object.ptr());
}

Dart_NewApiError()

DART_EXPORT Dart_Handle dart::Dart_NewApiError

(

const char *

error

)

Definition at line 827 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
 
  const String& message = String::Handle(Z, String::New(error));
  return Api::NewHandle(T, ApiError::New(message));
}

Dart_NewBoolean()

DART_EXPORT Dart_Handle dart::Dart_NewBoolean

(

bool

value

)

Definition at line 2797 of file dart_api_impl.cc.

                                                    {
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  return value ? Api::True() : Api::False();
}

Dart_NewByteBuffer()

DART_EXPORT Dart_Handle dart::Dart_NewByteBuffer

(

Dart_Handle

typed_data

)

Definition at line 3970 of file dart_api_impl.cc.

                                                                   {
  DARTSCOPE(Thread::Current());
  intptr_t class_id = Api::ClassId(typed_data);
  if (!IsExternalTypedDataClassId(class_id) &&
      !IsTypedDataViewClassId(class_id) && !IsTypedDataClassId(class_id)) {
    RETURN_TYPE_ERROR(Z, typed_data, 'TypedData');
  }
  Object& result = Object::Handle(Z);
  result = GetByteBufferConstructor(T, Symbols::_ByteBuffer(),
                                    Symbols::_ByteBufferDot_New(), 1);
  ASSERT(!result.IsNull());
  ASSERT(result.IsFunction());
  const Function& factory = Function::Cast(result);
  ASSERT(!factory.IsGenerativeConstructor());
 
  // Create the argument list.
  const Array& args = Array::Handle(Z, Array::New(2));
  // Factories get type arguments.
  args.SetAt(0, Object::null_type_arguments());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(typed_data));
  args.SetAt(1, obj);
 
  // Invoke the factory constructor and return the new object.
  result = DartEntry::InvokeFunction(factory, args);
  ASSERT(result.IsInstance() || result.IsNull() || result.IsError());
  return Api::NewHandle(T, result.ptr());
}

Dart_NewCompilationError()

DART_EXPORT Dart_Handle dart::Dart_NewCompilationError

(

const char *

error

)

Definition at line 835 of file dart_api_impl.cc.

                                                                    {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
 
  const String& message = String::Handle(Z, String::New(error));
  return Api::NewHandle(T, LanguageError::New(message));
}

Dart_NewDouble()

DART_EXPORT Dart_Handle dart::Dart_NewDouble

(

double

value

)

Definition at line 2716 of file dart_api_impl.cc.

                                                     {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  return Api::NewHandle(T, Double::New(value));
}

Dart_NewExternalTypedData()

DART_EXPORT Dart_Handle dart::Dart_NewExternalTypedData	(	Dart_TypedData_Type	type,
		void *	data,
		intptr_t	length
	)

Definition at line 3926 of file dart_api_impl.cc.

                                                                   {
  return NewExternalTypedDataWithFinalizer(type, data, length, nullptr, 0,
                                           nullptr, false);
}

Dart_NewExternalTypedDataWithFinalizer()

DART_EXPORT Dart_Handle dart::Dart_NewExternalTypedDataWithFinalizer	(	Dart_TypedData_Type	type,
		void *	data,
		intptr_t	length,
		void *	peer,
		intptr_t	external_allocation_size,
		Dart_HandleFinalizer	callback
	)

Definition at line 3934 of file dart_api_impl.cc.

                                                                      {
  return NewExternalTypedDataWithFinalizer(
      type, data, length, peer, external_allocation_size, callback, false);
}

Dart_NewFinalizableHandle()

DART_EXPORT Dart_FinalizableHandle dart::Dart_NewFinalizableHandle	(	Dart_Handle	object,
		void *	peer,
		intptr_t	external_allocation_size,
		Dart_HandleFinalizer	callback
	)

Definition at line 1101 of file dart_api_impl.cc.

                                                         {
  DARTSCOPE(Thread::Current());
  if (callback == nullptr) {
    return nullptr;
  }
 
  return AllocateFinalizableHandle(T, object, peer, external_allocation_size,
                                   callback);
}

Dart_NewInteger()

DART_EXPORT Dart_Handle dart::Dart_NewInteger

(

int64_t

value

)

Definition at line 2615 of file dart_api_impl.cc.

                                                       {
  // Fast path for Smis.
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  API_TIMELINE_DURATION(thread);
  DARTSCOPE(thread);
  CHECK_CALLBACK_STATE(thread);
  return Api::NewHandle(thread, Integer::New(value));
}

Dart_NewIntegerFromHexCString()

DART_EXPORT Dart_Handle dart::Dart_NewIntegerFromHexCString

(

const char *

str

)

Definition at line 2637 of file dart_api_impl.cc.

                                                                       {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  API_TIMELINE_DURATION(T);
  const String& str_obj = String::Handle(Z, String::New(str));
  IntegerPtr integer = Integer::New(str_obj);
  if (integer == Integer::null()) {
    return Api::NewError("%s: Cannot create Dart integer from string %s",
                         CURRENT_FUNC, str);
  }
  return Api::NewHandle(T, integer);
}

Dart_NewIntegerFromUint64()

DART_EXPORT Dart_Handle dart::Dart_NewIntegerFromUint64

(

uint64_t

value

)

Definition at line 2626 of file dart_api_impl.cc.

                                                                  {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  API_TIMELINE_DURATION(T);
  if (Integer::IsValueInRange(value)) {
    return Api::NewHandle(T, Integer::NewFromUint64(value));
  }
  return Api::NewError("%s: Cannot create Dart integer from value %" Pu64,
                       CURRENT_FUNC, value);
}

Dart_NewList()

DART_EXPORT Dart_Handle dart::Dart_NewList

(

intptr_t

length

)

Definition at line 3050 of file dart_api_impl.cc.

                                                      {
  return Dart_NewListOf(Dart_CoreType_Dynamic, length);
}

Dart_NewListOf()

DART_EXPORT Dart_Handle dart::Dart_NewListOf	(	Dart_CoreType_Id	element_type_id,
		intptr_t	length
	)

Definition at line 3069 of file dart_api_impl.cc.

                                                        {
  DARTSCOPE(Thread::Current());
  if (element_type_id != Dart_CoreType_Dynamic) {
    return Api::NewError(
        "Cannot use legacy types with --sound-null-safety enabled. "
        "Use Dart_NewListOfType or Dart_NewListOfTypeFilled instead.");
  }
  CHECK_LENGTH(length, Array::kMaxElements);
  CHECK_CALLBACK_STATE(T);
  const Array& arr = Array::Handle(Z, Array::New(length));
  if (element_type_id != Dart_CoreType_Dynamic) {
    arr.SetTypeArguments(TypeArguments::Handle(
        Z, TypeArgumentsForElementType(T->isolate_group()->object_store(),
                                       element_type_id)));
  }
  return Api::NewHandle(T, arr.ptr());
}

Dart_NewListOfType()

DART_EXPORT Dart_Handle dart::Dart_NewListOfType	(	Dart_Handle	element_type,
		intptr_t	length
	)

Definition at line 3093 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  CHECK_LENGTH(length, Array::kMaxElements);
  CHECK_CALLBACK_STATE(T);
  const Type& type = Api::UnwrapTypeHandle(Z, element_type);
  if (type.IsNull()) {
    RETURN_TYPE_ERROR(Z, element_type, Type);
  }
  if (!type.IsFinalized()) {
    return Api::NewError(
        "%s expects argument 'type' to be a fully resolved type.",
        CURRENT_FUNC);
  }
  if ((length > 0) && !CanTypeContainNull(type)) {
    return Api::NewError("%s expects argument 'type' to be a nullable type.",
                         CURRENT_FUNC);
  }
  return Api::NewHandle(T, Array::New(length, type));
}

Dart_NewListOfTypeFilled()

DART_EXPORT Dart_Handle dart::Dart_NewListOfTypeFilled	(	Dart_Handle	element_type,
		Dart_Handle	fill_object,
		intptr_t	length
	)

Definition at line 3114 of file dart_api_impl.cc.

                                                                  {
  DARTSCOPE(Thread::Current());
  CHECK_LENGTH(length, Array::kMaxElements);
  CHECK_CALLBACK_STATE(T);
  const Type& type = Api::UnwrapTypeHandle(Z, element_type);
  if (type.IsNull()) {
    RETURN_TYPE_ERROR(Z, element_type, Type);
  }
  if (!type.IsFinalized()) {
    return Api::NewError(
        "%s expects argument 'type' to be a fully resolved type.",
        CURRENT_FUNC);
  }
  const Instance& instance = Api::UnwrapInstanceHandle(Z, fill_object);
  if (!instance.IsNull() && !InstanceIsType(T, instance, type)) {
    return Api::NewError(
        "%s expects argument 'fill_object' to have the same type as "
        "'element_type'.",
        CURRENT_FUNC);
  }
  if ((length > 0) && instance.IsNull() && !CanTypeContainNull(type)) {
    return Api::NewError(
        "%s expects argument 'fill_object' to be non-null for a non-nullable "
        "'element_type'.",
        CURRENT_FUNC);
  }
  Array& arr = Array::Handle(Z, Array::New(length, type));
  for (intptr_t i = 0; i < arr.Length(); ++i) {
    arr.SetAt(i, instance);
  }
  return Api::NewHandle(T, arr.ptr());
}

Dart_NewNativePort()

DART_EXPORT Dart_Port dart::Dart_NewNativePort	(	const char *	name,
		Dart_NativeMessageHandler	handler,
		bool	handle_concurrently
	)

Definition at line 74 of file native_api_impl.cc.

                                                                   {
  if (name == nullptr) {
    name = "<UnnamedNativePort>";
  }
  if (handler == nullptr) {
    OS::PrintErr("%s expects argument 'handler' to be non-null.\n",
                 CURRENT_FUNC);
    return ILLEGAL_PORT;
  }
  if (!Dart::SetActiveApiCall()) {
    return ILLEGAL_PORT;
  }
  // Start the native port without a current isolate.
  IsolateLeaveScope saver(Isolate::Current());
 
  NativeMessageHandler* nmh = new NativeMessageHandler(name, handler);
  Dart_Port port_id = PortMap::CreatePort(nmh);
  if (port_id != ILLEGAL_PORT) {
    if (!nmh->Run(Dart::thread_pool(), nullptr, nullptr, 0)) {
      PortMap::ClosePort(port_id);
      nmh->RequestDeletion();
      port_id = ILLEGAL_PORT;
    }
  }
  Dart::ResetActiveApiCall();
  return port_id;
}

Dart_NewPersistentHandle()

DART_EXPORT Dart_PersistentHandle dart::Dart_NewPersistentHandle

(

Dart_Handle

object

)

Definition at line 971 of file dart_api_impl.cc.

                                                                               {
  DARTSCOPE(Thread::Current());
  Isolate* I = T->isolate();
  ApiState* state = I->group()->api_state();
  ASSERT(state != nullptr);
  const Object& old_ref = Object::Handle(Z, Api::UnwrapHandle(object));
  PersistentHandle* new_ref = state->AllocatePersistentHandle();
  new_ref->set_ptr(old_ref);
  return new_ref->apiHandle();
}

Dart_NewSendPort()

DART_EXPORT Dart_Handle dart::Dart_NewSendPort

(

Dart_Port

port_id

)

Definition at line 2149 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  if (port_id == ILLEGAL_PORT) {
    return Api::NewError("%s: illegal port_id %" Pd64 ".", CURRENT_FUNC,
                         port_id);
  }
  int64_t origin_id = PortMap::GetOriginId(port_id);
  return Api::NewHandle(T, SendPort::New(port_id, origin_id));
}

Dart_NewStringFromCString()

DART_EXPORT Dart_Handle dart::Dart_NewStringFromCString

(

const char *

str

)

Definition at line 2844 of file dart_api_impl.cc.

                                                                   {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  if (str == nullptr) {
    RETURN_NULL_ERROR(str);
  }
  CHECK_CALLBACK_STATE(T);
  return Api::NewHandle(T, String::New(str));
}

Dart_NewStringFromUTF16()

DART_EXPORT Dart_Handle dart::Dart_NewStringFromUTF16	(	const uint16_t *	utf16_array,
		intptr_t	length
	)

Definition at line 2870 of file dart_api_impl.cc.

                                                                 {
  DARTSCOPE(Thread::Current());
  if (utf16_array == nullptr && length != 0) {
    RETURN_NULL_ERROR(utf16_array);
  }
  CHECK_LENGTH(length, String::kMaxElements);
  CHECK_CALLBACK_STATE(T);
  return Api::NewHandle(T, String::FromUTF16(utf16_array, length));
}

Dart_NewStringFromUTF32()

DART_EXPORT Dart_Handle dart::Dart_NewStringFromUTF32	(	const int32_t *	utf32_array,
		intptr_t	length
	)

Definition at line 2881 of file dart_api_impl.cc.

                                                                 {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  if (utf32_array == nullptr && length != 0) {
    RETURN_NULL_ERROR(utf32_array);
  }
  CHECK_LENGTH(length, String::kMaxElements);
  CHECK_CALLBACK_STATE(T);
  return Api::NewHandle(T, String::FromUTF32(utf32_array, length));
}

Dart_NewStringFromUTF8()

DART_EXPORT Dart_Handle dart::Dart_NewStringFromUTF8	(	const uint8_t *	utf8_array,
		intptr_t	length
	)

Definition at line 2854 of file dart_api_impl.cc.

                                                                {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  if (utf8_array == nullptr && length != 0) {
    RETURN_NULL_ERROR(utf8_array);
  }
  CHECK_LENGTH(length, String::kMaxElements);
  if (!Utf8::IsValid(utf8_array, length)) {
    return Api::NewError("%s expects argument 'str' to be valid UTF-8.",
                         CURRENT_FUNC);
  }
  CHECK_CALLBACK_STATE(T);
  return Api::NewHandle(T, String::FromUTF8(utf8_array, length));
}

Dart_NewTypedData()

DART_EXPORT Dart_Handle dart::Dart_NewTypedData	(	Dart_TypedData_Type	type,
		intptr_t	length
	)

Definition at line 3799 of file dart_api_impl.cc.

                                                           {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  switch (type) {
    case Dart_TypedData_kByteData:
      return NewByteData(T, length);
    case Dart_TypedData_kInt8:
      return NewTypedData(T, kTypedDataInt8ArrayCid, length);
    case Dart_TypedData_kUint8:
      return NewTypedData(T, kTypedDataUint8ArrayCid, length);
    case Dart_TypedData_kUint8Clamped:
      return NewTypedData(T, kTypedDataUint8ClampedArrayCid, length);
    case Dart_TypedData_kInt16:
      return NewTypedData(T, kTypedDataInt16ArrayCid, length);
    case Dart_TypedData_kUint16:
      return NewTypedData(T, kTypedDataUint16ArrayCid, length);
    case Dart_TypedData_kInt32:
      return NewTypedData(T, kTypedDataInt32ArrayCid, length);
    case Dart_TypedData_kUint32:
      return NewTypedData(T, kTypedDataUint32ArrayCid, length);
    case Dart_TypedData_kInt64:
      return NewTypedData(T, kTypedDataInt64ArrayCid, length);
    case Dart_TypedData_kUint64:
      return NewTypedData(T, kTypedDataUint64ArrayCid, length);
    case Dart_TypedData_kFloat32:
      return NewTypedData(T, kTypedDataFloat32ArrayCid, length);
    case Dart_TypedData_kFloat64:
      return NewTypedData(T, kTypedDataFloat64ArrayCid, length);
    case Dart_TypedData_kInt32x4:
      return NewTypedData(T, kTypedDataInt32x4ArrayCid, length);
    case Dart_TypedData_kFloat32x4:
      return NewTypedData(T, kTypedDataFloat32x4ArrayCid, length);
    case Dart_TypedData_kFloat64x2:
      return NewTypedData(T, kTypedDataFloat64x2ArrayCid, length);
    default:
      return Api::NewError("%s expects argument 'type' to be of 'TypedData'",
                           CURRENT_FUNC);
  }
  UNREACHABLE();
  return Api::Null();
}

Dart_NewUnhandledExceptionError()

DART_EXPORT Dart_Handle dart::Dart_NewUnhandledExceptionError

(

Dart_Handle

exception

)

Definition at line 843 of file dart_api_impl.cc.

                                                                               {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
 
  Instance& obj = Instance::Handle(Z);
  intptr_t class_id = Api::ClassId(exception);
  if ((class_id == kApiErrorCid) || (class_id == kLanguageErrorCid)) {
    const Object& excp = Object::Handle(Z, Api::UnwrapHandle(exception));
    obj = String::New(GetErrorString(T, excp));
  } else {
    obj = Api::UnwrapInstanceHandle(Z, exception).ptr();
    if (obj.IsNull()) {
      RETURN_TYPE_ERROR(Z, exception, Instance);
    }
  }
  const StackTrace& stacktrace = StackTrace::Handle(Z);
  return Api::NewHandle(T, UnhandledException::New(obj, stacktrace));
}

Dart_NewUnmodifiableExternalTypedDataWithFinalizer()

DART_EXPORT Dart_Handle dart::Dart_NewUnmodifiableExternalTypedDataWithFinalizer	(	Dart_TypedData_Type	type,
		const void *	data,
		intptr_t	length,
		void *	peer,
		intptr_t	external_allocation_size,
		Dart_HandleFinalizer	callback
	)

Definition at line 3944 of file dart_api_impl.cc.

                                   {
  return NewExternalTypedDataWithFinalizer(
      type, const_cast<void*>(data), length, peer, external_allocation_size,
      callback, true);
}

Dart_NewUserTag()

DART_EXPORT Dart_Handle dart::Dart_NewUserTag

(

const char *

label

)

Definition at line 6920 of file dart_api_impl.cc.

                                                           {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  DARTSCOPE(thread);
  if (label == nullptr) {
    return Api::NewError(
        "Dart_NewUserTag expects argument 'label' to be non-null");
  }
  const String& value = String::Handle(String::New(label));
  return Api::NewHandle(thread, UserTag::New(value));
}

Dart_NewWeakPersistentHandle()

DART_EXPORT Dart_WeakPersistentHandle dart::Dart_NewWeakPersistentHandle	(	Dart_Handle	object,
		void *	peer,
		intptr_t	external_allocation_size,
		Dart_HandleFinalizer	callback
	)

Definition at line 1087 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  if (callback == nullptr) {
    return nullptr;
  }
 
  return AllocateWeakPersistentHandle(T, object, peer, external_allocation_size,
                                      callback);
}

Dart_NotifyDestroyed()

DART_EXPORT void dart::Dart_NotifyDestroyed

(

void

)

Definition at line 1790 of file dart_api_impl.cc.

                                        {
  Thread* T = Thread::Current();
  CHECK_ISOLATE(T->isolate());
  API_TIMELINE_BEGIN_END(T);
  TransitionNativeToVM transition(T);
  T->heap()->NotifyDestroyed();
}

Dart_NotifyIdle()

DART_EXPORT void dart::Dart_NotifyIdle

(

int64_t

deadline

)

Definition at line 1782 of file dart_api_impl.cc.

                                                   {
  Thread* T = Thread::Current();
  CHECK_ISOLATE(T->isolate());
  API_TIMELINE_BEGIN_END(T);
  TransitionNativeToVM transition(T);
  T->isolate()->group()->idle_time_handler()->NotifyIdle(deadline);
}

Dart_NotifyLowMemory()

DART_EXPORT void dart::Dart_NotifyLowMemory

(

void

)

Definition at line 1842 of file dart_api_impl.cc.

                                        {
  API_TIMELINE_BEGIN_END(Thread::Current());
  Page::ClearCache();
  Zone::ClearCache();
 
  // For each isolate's global variables, we might also clear:
  //  - RegExp backtracking stack (both bytecode and compiled versions)
  //  - String -> RegExp cache
  //  - BigInt division/remainder cache
  //  - double.toString cache
  // But cache invalidation code might be larger than the expected size of some
  // caches.
}

Dart_Null()

DART_EXPORT Dart_Handle dart::Dart_Null

(

void

)

Definition at line 2215 of file dart_api_impl.cc.

                                    {
  ASSERT(Isolate::Current() != nullptr);
  return Api::Null();
}

Dart_ObjectEquals()

DART_EXPORT Dart_Handle dart::Dart_ObjectEquals	(	Dart_Handle	obj1,
		Dart_Handle	obj2,
		bool *	value
	)

Definition at line 2251 of file dart_api_impl.cc.

                                                       {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  const Instance& expected =
      Instance::CheckedHandle(Z, Api::UnwrapHandle(obj1));
  const Instance& actual = Instance::CheckedHandle(Z, Api::UnwrapHandle(obj2));
  const Object& result =
      Object::Handle(Z, DartLibraryCalls::Equals(expected, actual));
  if (result.IsBool()) {
    *value = Bool::Cast(result).value();
    return Api::Success();
  } else if (result.IsError()) {
    return Api::NewHandle(T, result.ptr());
  } else {
    return Api::NewError("Expected boolean result from ==");
  }
}

Dart_ObjectIsType()

DART_EXPORT Dart_Handle dart::Dart_ObjectIsType	(	Dart_Handle	object,
		Dart_Handle	type,
		bool *	value
	)

Definition at line 2281 of file dart_api_impl.cc.

                                                       {
  DARTSCOPE(Thread::Current());
 
  const Type& type_obj = Api::UnwrapTypeHandle(Z, type);
  if (type_obj.IsNull()) {
    *value = false;
    RETURN_TYPE_ERROR(Z, type, Type);
  }
  if (!type_obj.IsFinalized()) {
    return Api::NewError(
        "%s expects argument 'type' to be a fully resolved type.",
        CURRENT_FUNC);
  }
  if (object == Api::Null()) {
    *value = false;
    return Api::Success();
  }
  const Instance& instance = Api::UnwrapInstanceHandle(Z, object);
  if (instance.IsNull()) {
    *value = false;
    RETURN_TYPE_ERROR(Z, object, Instance);
  }
  *value = InstanceIsType(T, instance, type_obj);
  return Api::Success();
}

Dart_Post()

DART_EXPORT bool dart::Dart_Post	(	Dart_Port	port_id,
		Dart_Handle	handle
	)

Definition at line 2136 of file dart_api_impl.cc.

                                                                  {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  NoSafepointScope no_safepoint_scope;
  if (port_id == ILLEGAL_PORT) {
    return false;
  }
 
  const Object& object = Object::Handle(Z, Api::UnwrapHandle(handle));
  return PortMap::PostMessage(WriteMessage(/* same_group */ false, object,
                                           port_id, Message::kNormalPriority));
}

Dart_PostCObject()

DART_EXPORT bool dart::Dart_PostCObject	(	Dart_Port	port_id,
		Dart_CObject *	message
	)

Definition at line 59 of file native_api_impl.cc.

                                                                            {
  return PostCObjectHelper(port_id, message);
}

Dart_PostInteger()

DART_EXPORT bool dart::Dart_PostInteger	(	Dart_Port	port_id,
		int64_t	message
	)

Definition at line 63 of file native_api_impl.cc.

                                                                      {
  if (Smi::IsValid(message)) {
    return PortMap::PostMessage(
        Message::New(port_id, Smi::New(message), Message::kNormalPriority));
  }
  Dart_CObject cobj;
  cobj.type = Dart_CObject_kInt64;
  cobj.value.as_int64 = message;
  return PostCObjectHelper(port_id, &cobj);
}

Dart_Precompile()

DART_EXPORT Dart_Handle dart::Dart_Precompile

(

void

)

Definition at line 6397 of file dart_api_impl.cc.

                                          {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("AOT compilation is not supported on IA32.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError(
      "This VM was built without support for AOT compilation.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_BEGIN_END(T);
  if (!FLAG_precompiled_mode) {
    return Api::NewError("Flag --precompilation was not specified.");
  }
  Dart_Handle result = Api::CheckAndFinalizePendingClasses(T);
  if (Api::IsError(result)) {
    return result;
  }
  CHECK_CALLBACK_STATE(T);
  CompilerState state(Thread::Current(), /*is_aot=*/true,
                      /*is_optimizing=*/true);
  CHECK_ERROR_HANDLE(Precompiler::CompileAll());
  return Api::Success();
#endif
}

Dart_PrepareToAbort()

DART_EXPORT void dart::Dart_PrepareToAbort

(

void

)

Definition at line 35 of file unit_test_custom_zone.cc.

                                       {
  fprintf(stderr, "Dart_PrepareToAbort() not implemented!\n");
  exit(1);
}

Dart_PropagateError()

DART_EXPORT void dart::Dart_PropagateError

(

Dart_Handle

handle

)

Definition at line 862 of file dart_api_impl.cc.

                                                         {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  const Object& obj = Object::Handle(thread->zone(), Api::UnwrapHandle(handle));
  if (!obj.IsError()) {
    FATAL(
        "%s expects argument 'handle' to be an error handle.  "
        "Did you forget to check Dart_IsError first?",
        CURRENT_FUNC);
  }
  if (thread->top_exit_frame_info() == 0) {
    // There are no dart frames on the stack so it would be illegal to
    // propagate an error here.
    FATAL("No Dart frames on stack, cannot propagate error.");
  }
  // Unwind all the API scopes till the exit frame before propagating.
  const Error* error;
  {
    // We need to preserve the error object across the destruction of zones
    // when the ApiScopes are unwound.  By using NoSafepointScope, we can ensure
    // that GC won't touch the raw error object before creating a valid
    // handle for it in the surviving zone.
    NoSafepointScope no_safepoint;
    ErrorPtr raw_error = Api::UnwrapErrorHandle(thread->zone(), handle).ptr();
    thread->UnwindScopes(thread->top_exit_frame_info());
    // Note that thread's zone is different here than at the beginning of this
    // function.
    error = &Error::Handle(thread->zone(), raw_error);
  }
  Exceptions::PropagateError(*error);
  UNREACHABLE();
}

Dart_RecordTimelineEvent()

DART_EXPORT void dart::Dart_RecordTimelineEvent	(	const char *	label,
		int64_t	timestamp0,
		int64_t	timestamp1_or_id,
		intptr_t	flow_id_count,
		const int64_t *	flow_ids,
		Dart_Timeline_Event_Type	type,
		intptr_t	argument_count,
		const char **	argument_names,
		const char **	argument_values
	)

Definition at line 6281 of file dart_api_impl.cc.

                                                                        {
#if defined(SUPPORT_TIMELINE)
  if (type < Dart_Timeline_Event_Begin) {
    return;
  }
  if (type > Dart_Timeline_Event_Flow_End) {
    return;
  }
  if (!Dart::SetActiveApiCall()) {
    return;
  }
  TimelineStream* stream = Timeline::GetEmbedderStream();
  ASSERT(stream != nullptr);
  TimelineEvent* event = stream->StartEvent();
  if (event != nullptr) {
    switch (type) {
      case Dart_Timeline_Event_Begin:
        event->Begin(label, timestamp1_or_id, timestamp0);
        break;
      case Dart_Timeline_Event_End:
        event->End(label, timestamp1_or_id, timestamp0);
        break;
      case Dart_Timeline_Event_Instant:
        event->Instant(label, timestamp0);
        break;
      case Dart_Timeline_Event_Duration:
        event->Duration(label, timestamp0, timestamp1_or_id);
        break;
      case Dart_Timeline_Event_Async_Begin:
        event->AsyncBegin(label, timestamp1_or_id, timestamp0);
        break;
      case Dart_Timeline_Event_Async_End:
        event->AsyncEnd(label, timestamp1_or_id, timestamp0);
        break;
      case Dart_Timeline_Event_Async_Instant:
        event->AsyncInstant(label, timestamp1_or_id, timestamp0);
        break;
      case Dart_Timeline_Event_Counter:
        event->Counter(label, timestamp0);
        break;
      case Dart_Timeline_Event_Flow_Begin:
        event->FlowBegin(label, timestamp1_or_id, timestamp0);
        break;
      case Dart_Timeline_Event_Flow_Step:
        event->FlowStep(label, timestamp1_or_id, timestamp0);
        break;
      case Dart_Timeline_Event_Flow_End:
        event->FlowEnd(label, timestamp1_or_id, timestamp0);
        break;
      default:
        FATAL("Unknown Dart_Timeline_Event_Type");
    }
    if (flow_id_count > 0 && flow_ids != nullptr) {
      std::unique_ptr<const int64_t[]> flow_ids_copy;
      int64_t* flow_ids_internal = new int64_t[flow_id_count];
      for (intptr_t i = 0; i < flow_id_count; ++i) {
        flow_ids_internal[i] = flow_ids[i];
      }
      flow_ids_copy = std::unique_ptr<const int64_t[]>(flow_ids_internal);
      event->SetFlowIds(flow_id_count, flow_ids_copy);
    }
    event->SetNumArguments(argument_count);
    for (intptr_t i = 0; i < argument_count; i++) {
      event->CopyArgument(i, argument_names[i], argument_values[i]);
    }
    event->Complete();
  }
  Dart::ResetActiveApiCall();
#endif
}

Dart_RegisterHeapSamplingCallback()

DART_EXPORT void dart::Dart_RegisterHeapSamplingCallback	(	Dart_HeapSamplingCreateCallback	create_callback,
		Dart_HeapSamplingDeleteCallback	delete_callback
	)

Definition at line 1810 of file dart_api_impl.cc.

                                                     {
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  HeapProfileSampler::SetSamplingCallback(create_callback, delete_callback);
#endif
}

Dart_RegisterIsolateServiceRequestCallback()

DART_EXPORT void dart::Dart_RegisterIsolateServiceRequestCallback	(	const char *	name,
		Dart_ServiceRequestCallback	callback,
		void *	user_data
	)

Definition at line 6121 of file dart_api_impl.cc.

                     {
#if !defined(PRODUCT)
  Service::RegisterIsolateEmbedderCallback(name, callback, user_data);
#endif
}

Dart_RegisterRootServiceRequestCallback()

DART_EXPORT void dart::Dart_RegisterRootServiceRequestCallback	(	const char *	name,
		Dart_ServiceRequestCallback	callback,
		void *	user_data
	)

Definition at line 6130 of file dart_api_impl.cc.

                     {
#if !defined(PRODUCT)
  Service::RegisterRootEmbedderCallback(name, callback, user_data);
#endif
}

Dart_RemoveBreakpoint()

Dart_Handle dart::Dart_RemoveBreakpoint

(

Dart_Handle

breakpoint_id

)

Remove breakpoint with provided id.

Requires there to be a current isolate.

Definition at line 160 of file debugger_api_impl_test.cc.

                                                                {
  DARTSCOPE(Thread::Current());
  Isolate* I = T->isolate();
  CHECK_DEBUGGER(I);
  UNWRAP_AND_CHECK_PARAM(Integer, breakpoint_id, breakpoint_id_in);
  I->debugger()->RemoveBreakpoint(breakpoint_id.AsInt64Value());
  return Api::Success();
}

Dart_ReportSurvivingAllocations()

DART_EXPORT void dart::Dart_ReportSurvivingAllocations	(	Dart_HeapSamplingReportCallback	callback,
		void *	context,
		bool	force_gc
	)

Definition at line 1818 of file dart_api_impl.cc.

                   {
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  CHECK_NO_ISOLATE(Thread::Current());
  IsolateGroup::ForEach([&](IsolateGroup* group) {
    Thread::EnterIsolateGroupAsHelper(group, Thread::kUnknownTask,
                                      /*bypass_safepoint=*/false);
    if (force_gc) {
      group->heap()->CollectAllGarbage(GCReason::kDebugging);
    }
    group->heap()->ReportSurvivingAllocations(callback, context);
    Thread::ExitIsolateGroupAsHelper(/*bypass_safepoint=*/false);
  });
#endif
}

Dart_ReThrowException()

DART_EXPORT Dart_Handle dart::Dart_ReThrowException	(	Dart_Handle	exception,
		Dart_Handle	stacktrace
	)

Definition at line 4855 of file dart_api_impl.cc.

                                                                      {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  CHECK_CALLBACK_STATE(thread);
  TransitionNativeToVM transition(thread);
  {
    const Instance& excp = Api::UnwrapInstanceHandle(zone, exception);
    if (excp.IsNull()) {
      RETURN_TYPE_ERROR(zone, exception, Instance);
    }
    const Instance& stk = Api::UnwrapInstanceHandle(zone, stacktrace);
    if (stk.IsNull()) {
      RETURN_TYPE_ERROR(zone, stacktrace, Instance);
    }
  }
  if (thread->top_exit_frame_info() == 0) {
    // There are no dart frames on the stack so it would be illegal to
    // throw an exception here.
    return Api::NewError("No Dart frames on stack, cannot throw exception");
  }
  // Unwind all the API scopes till the exit frame before throwing an
  // exception.
  const Instance* saved_exception;
  const StackTrace* saved_stacktrace;
  {
    NoSafepointScope no_safepoint;
    InstancePtr raw_exception =
        Api::UnwrapInstanceHandle(zone, exception).ptr();
    StackTracePtr raw_stacktrace =
        Api::UnwrapStackTraceHandle(zone, stacktrace).ptr();
    thread->UnwindScopes(thread->top_exit_frame_info());
    saved_exception = &Instance::Handle(raw_exception);
    saved_stacktrace = &StackTrace::Handle(raw_stacktrace);
  }
  Exceptions::ReThrow(thread, *saved_exception, *saved_stacktrace);
  return Api::NewError("Exception was not re thrown, internal error");
}

Dart_RootLibrary()

DART_EXPORT Dart_Handle dart::Dart_RootLibrary

(

void

)

Definition at line 5479 of file dart_api_impl.cc.

                                           {
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  TransitionNativeToVM transition(thread);
  return Api::NewHandle(thread,
                        isolate->group()->object_store()->root_library());
}

Dart_RunLoop()

DART_EXPORT Dart_Handle dart::Dart_RunLoop

(

void

)

Definition at line 1996 of file dart_api_impl.cc.

                                       {
  Isolate* I;
  bool result;
  {
    Thread* T = Thread::Current();
    I = T->isolate();
    CHECK_API_SCOPE(T);
    CHECK_CALLBACK_STATE(T);
  }
  API_TIMELINE_BEGIN_END(Thread::Current());
  // The message handler run loop does not expect to have a current isolate
  // so we exit the isolate here and enter it again after the runloop is done.
  ::Dart_ExitIsolate();
  {
    Monitor monitor;
    MonitorLocker ml(&monitor);
    RunLoopData data;
    data.monitor = &monitor;
    data.done = false;
    result =
        I->message_handler()->Run(I->group()->thread_pool(), nullptr,
                                  RunLoopDone, reinterpret_cast<uword>(&data));
    if (result) {
      while (!data.done) {
        ml.Wait();
      }
    }
  }
  ::Dart_EnterIsolate(Api::CastIsolate(I));
  if (!result) {
    Thread* T = Thread::Current();
    TransitionNativeToVM transition(T);
    return Api::NewError("Run method in isolate message handler failed");
  } else if (I->sticky_error() != Object::null()) {
    Thread* T = Thread::Current();
    TransitionNativeToVM transition(T);
    return Api::NewHandle(T, I->StealStickyError());
  }
  if (FLAG_print_class_table) {
    HANDLESCOPE(Thread::Current());
    I->group()->class_table()->Print();
  }
  return Api::Success();
}

Dart_RunLoopAsync()

DART_EXPORT bool dart::Dart_RunLoopAsync	(	bool	errors_are_fatal,
		Dart_Port	on_error_port,
		Dart_Port	on_exit_port,
		char **	error
	)

Definition at line 2041 of file dart_api_impl.cc.

                                                 {
  auto thread = Thread::Current();
  auto isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  *error = nullptr;
 
  if (thread->api_top_scope() != nullptr) {
    *error = Utils::StrDup("There must not be an active api scope.");
    return false;
  }
 
  if (!isolate->is_runnable()) {
    const char* error_msg = isolate->MakeRunnable();
    if (error_msg != nullptr) {
      *error = Utils::StrDup(error_msg);
      return false;
    }
  }
 
  isolate->SetErrorsFatal(errors_are_fatal);
 
  if (on_error_port != ILLEGAL_PORT || on_exit_port != ILLEGAL_PORT) {
    auto thread = Thread::Current();
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
 
    if (on_error_port != ILLEGAL_PORT) {
      const auto& port =
          SendPort::Handle(thread->zone(), SendPort::New(on_error_port));
      isolate->AddErrorListener(port);
    }
    if (on_exit_port != ILLEGAL_PORT) {
      const auto& port =
          SendPort::Handle(thread->zone(), SendPort::New(on_exit_port));
      isolate->AddExitListener(port, Instance::null_instance());
    }
  }
 
  Dart_ExitIsolate();
  isolate->Run();
  return true;
}

Dart_ScopeAllocate()

DART_EXPORT uint8_t * dart::Dart_ScopeAllocate

(

intptr_t

size

)

Definition at line 2199 of file dart_api_impl.cc.

                                                       {
  Zone* zone;
  Thread* thread = Thread::Current();
  if (thread != nullptr) {
    ApiLocalScope* scope = thread->api_top_scope();
    zone = scope->zone();
  } else {
    ApiNativeScope* scope = ApiNativeScope::Current();
    if (scope == nullptr) return nullptr;
    zone = scope->zone();
  }
  return reinterpret_cast<uint8_t*>(zone->AllocUnsafe(size));
}

Dart_SendPortGetId()

DART_EXPORT Dart_Handle dart::Dart_SendPortGetId	(	Dart_Handle	port,
		Dart_Port *	port_id
	)

Definition at line 2160 of file dart_api_impl.cc.

                                                               {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  API_TIMELINE_DURATION(T);
  const SendPort& send_port = Api::UnwrapSendPortHandle(Z, port);
  if (send_port.IsNull()) {
    RETURN_TYPE_ERROR(Z, port, SendPort);
  }
  if (port_id == nullptr) {
    RETURN_NULL_ERROR(port_id);
  }
  *port_id = send_port.Id();
  return Api::Success();
}

Dart_ServiceSendDataEvent()

DART_EXPORT char * dart::Dart_ServiceSendDataEvent	(	const char *	stream_id,
		const char *	event_kind,
		const uint8_t *	bytes,
		intptr_t	bytes_length
	)

Definition at line 6185 of file dart_api_impl.cc.

                                                                   {
#if !defined(PRODUCT)
  if (stream_id == nullptr) {
    return Utils::StrDup(
        "Dart_ServiceSendDataEvent expects argument 'stream_id' to be "
        "non-null.");
  }
  if (event_kind == nullptr) {
    return Utils::StrDup(
        "Dart_ServiceSendDataEvent expects argument 'event_kind' to be "
        "non-null.");
  }
  if (bytes == nullptr) {
    return Utils::StrDup(
        "Dart_ServiceSendDataEvent expects argument 'bytes' to be non-null.");
  }
  if (bytes_length < 0) {
    return Utils::StrDup(
        "Dart_ServiceSendDataEvent expects argument 'bytes_length' to be >= "
        "0.");
  }
  Service::SendEmbedderEvent(Isolate::Current(),  // May be nullptr
                             stream_id, event_kind, bytes, bytes_length);
#endif
  return nullptr;
}

Dart_SetBooleanReturnValue()

DART_EXPORT void dart::Dart_SetBooleanReturnValue	(	Dart_NativeArguments	args,
		bool	retval
	)

Definition at line 5351 of file dart_api_impl.cc.

                                                         {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
  ASSERT(arguments->thread()->isolate() == Isolate::Current());
  ASSERT_CALLBACK_STATE(arguments->thread());
  arguments->SetReturn(Bool::Get(retval));
}

Dart_SetBreakpoint()

Dart_Handle dart::Dart_SetBreakpoint	(	Dart_Handle	script_url,
		intptr_t	line_number
	)

Sets a breakpoint at line \line_number in \script_url, or the closest following line (within the same function) where a breakpoint can be set.

Requires there to be a current isolate.

Returns

A handle containing the breakpoint id, which is an integer value, or an error object if a breakpoint could not be set.

Definition at line 140 of file debugger_api_impl_test.cc.

                                                     {
  Breakpoint* bpt;
  {
    DARTSCOPE(Thread::Current());
    Isolate* I = T->isolate();
    CHECK_DEBUGGER(I);
    UNWRAP_AND_CHECK_PARAM(String, script_url, script_url_in);
 
    Debugger* debugger = I->debugger();
    bpt = debugger->SetBreakpointAtLineCol(script_url, line_number, -1);
    if (bpt == nullptr) {
      return Api::NewError("%s: could not set breakpoint at line %" Pd
                           " in '%s'",
                           CURRENT_FUNC, line_number, script_url.ToCString());
    }
  }
  return Dart_NewInteger(bpt->id());
}

Dart_SetCurrentUserTag()

DART_EXPORT Dart_Handle dart::Dart_SetCurrentUserTag

(

Dart_Handle

user_tag

)

Definition at line 6932 of file dart_api_impl.cc.

                                                                     {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  DARTSCOPE(thread);
  const UserTag& tag = Api::UnwrapUserTagHandle(Z, user_tag);
  if (tag.IsNull()) {
    RETURN_TYPE_ERROR(Z, user_tag, UserTag);
  }
  return Api::NewHandle(thread, tag.MakeActive());
}

Dart_SetDartLibrarySourcesKernel()

DART_EXPORT void dart::Dart_SetDartLibrarySourcesKernel	(	const uint8_t *	platform_kernel,
		const intptr_t	platform_kernel_size
	)

Definition at line 6095 of file dart_api_impl.cc.

                                         {
#if !defined(PRODUCT)
  Service::SetDartLibraryKernelForSources(platform_kernel,
                                          platform_kernel_size);
#endif
}

Dart_SetDeferredLoadHandler()

DART_EXPORT Dart_Handle dart::Dart_SetDeferredLoadHandler

(

Dart_DeferredLoadHandler

handler

)

Definition at line 5417 of file dart_api_impl.cc.

                                                              {
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  isolate->group()->set_deferred_load_handler(handler);
  return Api::Success();
}

Dart_SetDoubleReturnValue()

DART_EXPORT void dart::Dart_SetDoubleReturnValue	(	Dart_NativeArguments	args,
		double	retval
	)

Definition at line 5374 of file dart_api_impl.cc.

                                                          {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  ASSERT(arguments->thread()->isolate() == Isolate::Current());
  ASSERT_CALLBACK_STATE(arguments->thread());
  TransitionNativeToVM transition(arguments->thread());
  Api::SetDoubleReturnValue(arguments, retval);
}

Dart_SetDwarfStackTraceFootnoteCallback()

DART_EXPORT void dart::Dart_SetDwarfStackTraceFootnoteCallback

(

Dart_DwarfStackTraceFootnoteCallback

callback

)

Definition at line 6215 of file dart_api_impl.cc.

                                                   {
  Dart::set_dwarf_stacktrace_footnote_callback(callback);
}

Dart_SetEmbedderInformationCallback()

DART_EXPORT void dart::Dart_SetEmbedderInformationCallback

(

Dart_EmbedderInformationCallback

callback

)

Definition at line 6139 of file dart_api_impl.cc.

                                               {
#if !defined(PRODUCT)
  Service::SetEmbedderInformationCallback(callback);
#endif
}

Dart_SetEnabledTimelineCategory()

DART_EXPORT bool dart::Dart_SetEnabledTimelineCategory

(

const char *

categories

)

Definition at line 6255 of file dart_api_impl.cc.

                                                                         {
#if defined(SUPPORT_TIMELINE)
  bool result = false;
  if (categories != nullptr) {
    char* carray = Utils::SCreate("[%s]", categories);
    result = Service::EnableTimelineStreams(carray);
    free(carray);
  }
  return result;
#else
  return false;
#endif
}

Dart_SetEnvironmentCallback()

DART_EXPORT Dart_Handle dart::Dart_SetEnvironmentCallback

(

Dart_EnvironmentCallback

callback

)

Definition at line 5343 of file dart_api_impl.cc.

                                                               {
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  isolate->set_environment_callback(callback);
  return Api::Success();
}

Dart_SetFfiNativeResolver()

DART_EXPORT Dart_Handle dart::Dart_SetFfiNativeResolver	(	Dart_Handle	library,
		Dart_FfiNativeResolver	resolver
	)

Definition at line 5965 of file dart_api_impl.cc.

                                                           {
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  lib.set_ffi_native_resolver(resolver);
  return Api::Success();
}

Dart_SetField()

DART_EXPORT Dart_Handle dart::Dart_SetField	(	Dart_Handle	container,
		Dart_Handle	name,
		Dart_Handle	value
	)

Definition at line 4741 of file dart_api_impl.cc.

                                                         {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_CALLBACK_STATE(T);
 
  String& field_name =
      String::Handle(Z, Api::UnwrapStringHandle(Z, name).ptr());
  if (field_name.IsNull()) {
    RETURN_TYPE_ERROR(Z, name, String);
  }
 
  // Since null is allowed for value, we don't use UnwrapInstanceHandle.
  const Object& value_obj = Object::Handle(Z, Api::UnwrapHandle(value));
  if (!value_obj.IsNull() && !value_obj.IsInstance()) {
    RETURN_TYPE_ERROR(Z, value, Instance);
  }
  Instance& value_instance = Instance::Handle(Z);
  value_instance ^= value_obj.ptr();
 
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(container));
  const bool respect_reflectable = false;
  const bool check_is_entrypoint = FLAG_verify_entry_points;
 
  if (obj.IsType()) {
    if (!Type::Cast(obj).IsFinalized()) {
      return Api::NewError(
          "%s expects argument 'container' to be a fully resolved type.",
          CURRENT_FUNC);
    }
 
    // To access a static field we may need to use the Field or the
    // setter Function.
    Class& cls = Class::Handle(Z, Type::Cast(obj).type_class());
    if (Library::IsPrivate(field_name)) {
      const Library& lib = Library::Handle(Z, cls.library());
      field_name = lib.PrivateName(field_name);
    }
    return Api::NewHandle(
        T, cls.InvokeSetter(field_name, value_instance, respect_reflectable,
                            check_is_entrypoint));
  } else if (obj.IsNull() || obj.IsInstance()) {
    Instance& instance = Instance::Handle(Z);
    instance ^= obj.ptr();
    if (Library::IsPrivate(field_name)) {
      const Class& cls = Class::Handle(Z, instance.clazz());
      const Library& lib = Library::Handle(Z, cls.library());
      field_name = lib.PrivateName(field_name);
    }
    return Api::NewHandle(
        T, instance.InvokeSetter(field_name, value_instance,
                                 respect_reflectable, check_is_entrypoint));
  } else if (obj.IsLibrary()) {
    // To access a top-level we may need to use the Field or the
    // setter Function.  The setter function may either be in the
    // library or in the field's owner class, depending.
    const Library& lib = Library::Cast(obj);
    // Check that the library is loaded.
    if (!lib.Loaded()) {
      return Api::NewError(
          "%s expects library argument 'container' to be loaded.",
          CURRENT_FUNC);
    }
 
    if (Library::IsPrivate(field_name)) {
      field_name = lib.PrivateName(field_name);
    }
    return Api::NewHandle(
        T, lib.InvokeSetter(field_name, value_instance, respect_reflectable,
                            check_is_entrypoint));
  } else if (obj.IsError()) {
    return container;
  }
  return Api::NewError(
      "%s expects argument 'container' to be an object, type, or library.",
      CURRENT_FUNC);
}

Dart_SetFileModifiedCallback()

DART_EXPORT char * dart::Dart_SetFileModifiedCallback

(

Dart_FileModifiedCallback

file_modified_callback

)

Definition at line 6220 of file dart_api_impl.cc.

                                                      {
#if !defined(PRODUCT)
#if !defined(DART_PRECOMPILED_RUNTIME)
  if (file_modified_callback != nullptr) {
    if (IsolateGroupReloadContext::file_modified_callback() != nullptr) {
      return Utils::StrDup(
          "Dart_SetFileModifiedCallback permits only one callback to be"
          " registered, please remove the existing callback and then add"
          " this callback");
    }
  } else {
    if (IsolateGroupReloadContext::file_modified_callback() == nullptr) {
      return Utils::StrDup(
          "Dart_SetFileModifiedCallback expects 'file_modified_callback' to"
          " be set before it is cleared.");
    }
  }
  IsolateGroupReloadContext::SetFileModifiedCallback(file_modified_callback);
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
#endif  // !defined(PRODUCT)
  return nullptr;
}

Dart_SetHeapSamplingPeriod()

DART_EXPORT void dart::Dart_SetHeapSamplingPeriod

(

intptr_t

bytes

)

Definition at line 1836 of file dart_api_impl.cc.

                                                            {
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  HeapProfileSampler::SetSamplingInterval(bytes);
#endif
}

Dart_SetIntegerReturnValue()

DART_EXPORT void dart::Dart_SetIntegerReturnValue	(	Dart_NativeArguments	args,
		int64_t	retval
	)

Definition at line 5360 of file dart_api_impl.cc.

                                                            {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
  ASSERT(arguments->thread()->isolate() == Isolate::Current());
  ASSERT_CALLBACK_STATE(arguments->thread());
  if (Smi::IsValid(retval)) {
    Api::SetSmiReturnValue(arguments, static_cast<intptr_t>(retval));
  } else {
    // Slow path for Mints.
    Api::SetIntegerReturnValue(arguments, retval);
  }
}

Dart_SetLibraryDebuggable()

Dart_Handle dart::Dart_SetLibraryDebuggable	(	intptr_t	library_id,
		bool	is_debuggable
	)

Requests that debugging be enabled for the given library.

Requires there to be a current isolate.

Returns

A handle to the True object if no error occurs.

Definition at line 249 of file debugger_api_impl_test.cc.

                                                                               {
  DARTSCOPE(Thread::Current());
  const Library& lib = Library::Handle(Z, Library::GetLibrary(library_id));
  if (lib.IsNull()) {
    return Api::NewError("%s: %" Pd " is not a valid library id", CURRENT_FUNC,
                         library_id);
  }
  lib.set_debuggable(is_debuggable);
  return Api::Success();
}

Dart_SetLibraryTagHandler()

DART_EXPORT Dart_Handle dart::Dart_SetLibraryTagHandler

(

Dart_LibraryTagHandler

handler

)

Definition at line 5386 of file dart_api_impl.cc.

                                                          {
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  isolate->group()->set_library_tag_handler(handler);
  return Api::Success();
}

Dart_SetMessageNotifyCallback()

DART_EXPORT void dart::Dart_SetMessageNotifyCallback

(

Dart_MessageNotifyCallback

message_notify_callback

)

Definition at line 1953 of file dart_api_impl.cc.

                                                        {
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
 
  {
    NoSafepointScope no_safepoint_scope;
    isolate->set_message_notify_callback(message_notify_callback);
  }
 
  if (message_notify_callback != nullptr && isolate->HasPendingMessages()) {
    ::Dart_ExitIsolate();
 
    // If a new handler gets installed and there are pending messages in the
    // queue (e.g. OOB messages for doing vm service work) we need to notify
    // the newly registered callback, otherwise the embedder might never get
    // notified about the pending messages.
    message_notify_callback(Api::CastIsolate(isolate));
 
    ::Dart_EnterIsolate(Api::CastIsolate(isolate));
  }
}

Dart_SetNativeInstanceField()

DART_EXPORT Dart_Handle dart::Dart_SetNativeInstanceField	(	Dart_Handle	obj,
		int	index,
		intptr_t	value
	)

Definition at line 4943 of file dart_api_impl.cc.

                                                                    {
  DARTSCOPE(Thread::Current());
  const Instance& instance = Api::UnwrapInstanceHandle(Z, obj);
  if (instance.IsNull()) {
    RETURN_TYPE_ERROR(Z, obj, Instance);
  }
  if (!instance.IsValidNativeIndex(index)) {
    return Api::NewError(
        "%s: invalid index %d passed into set native instance field",
        CURRENT_FUNC, index);
  }
  instance.SetNativeField(index, value);
  return Api::Success();
}

Dart_SetNativeResolver()

DART_EXPORT Dart_Handle dart::Dart_SetNativeResolver	(	Dart_Handle	library,
		Dart_NativeEntryResolver	resolver,
		Dart_NativeEntrySymbol	symbol
	)

Definition at line 5920 of file dart_api_impl.cc.

                                                      {
  DARTSCOPE(Thread::Current());
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  lib.set_native_entry_resolver(resolver);
  lib.set_native_entry_symbol_resolver(symbol);
  return Api::Success();
}

Dart_SetPausedOnExit()

DART_EXPORT void dart::Dart_SetPausedOnExit

(

bool

paused

)

Definition at line 1726 of file dart_api_impl.cc.

                                                   {
#if defined(PRODUCT)
  if (paused) {
    FATAL("%s(true) is not supported in a PRODUCT build", CURRENT_FUNC);
  }
#else
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  if (isolate->message_handler()->is_paused_on_exit() != paused) {
    isolate->message_handler()->PausedOnExit(paused);
  }
#endif
}

Dart_SetPausedOnStart()

DART_EXPORT void dart::Dart_SetPausedOnStart

(

bool

paused

)

Definition at line 1676 of file dart_api_impl.cc.

                                                    {
#if defined(PRODUCT)
  if (paused) {
    FATAL("%s(true) is not supported in a PRODUCT build", CURRENT_FUNC);
  }
#else
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  if (isolate->message_handler()->is_paused_on_start() != paused) {
    isolate->message_handler()->PausedOnStart(paused);
  }
#endif
}

Dart_SetPeer()

DART_EXPORT Dart_Handle dart::Dart_SetPeer	(	Dart_Handle	object,
		void *	peer
	)

Definition at line 6001 of file dart_api_impl.cc.

                                                                     {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  REUSABLE_OBJECT_HANDLESCOPE(thread);
  Object& obj = thread->ObjectHandle();
  obj = Api::UnwrapHandle(object);
  if (obj.IsNull() || obj.IsNumber() || obj.IsBool()) {
    const char* msg =
        "%s: argument 'object' cannot be a subtype of Null, num, or bool";
    return Api::NewError(msg, CURRENT_FUNC);
  }
  {
    NoSafepointScope no_safepoint;
    ObjectPtr raw_obj = obj.ptr();
    thread->heap()->SetPeer(raw_obj, peer);
  }
  return Api::Success();
}

Dart_SetPerformanceMode()

DART_EXPORT Dart_PerformanceMode dart::Dart_SetPerformanceMode

(

Dart_PerformanceMode

mode

)

Definition at line 1857 of file dart_api_impl.cc.

                                                   {
  Thread* T = Thread::Current();
  CHECK_ISOLATE(T->isolate());
  TransitionNativeToVM transition(T);
  return T->heap()->SetMode(mode);
}

Dart_SetPersistentHandle()

DART_EXPORT void dart::Dart_SetPersistentHandle	(	Dart_PersistentHandle	obj1,
		Dart_Handle	obj2
	)

Definition at line 982 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  Isolate* I = T->isolate();
  ApiState* state = I->group()->api_state();
  ASSERT(state != nullptr);
  ASSERT(state->IsValidPersistentHandle(obj1));
  const Object& obj2_ref = Object::Handle(Z, Api::UnwrapHandle(obj2));
  PersistentHandle* obj1_ref = PersistentHandle::Cast(obj1);
  obj1_ref->set_ptr(obj2_ref);
}

Dart_SetReturnValue()

DART_EXPORT void dart::Dart_SetReturnValue	(	Dart_NativeArguments	args,
		Dart_Handle	retval
	)

Definition at line 5221 of file dart_api_impl.cc.

                                                         {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  ASSERT(arguments->thread()->isolate() == Isolate::Current());
  ASSERT_CALLBACK_STATE(arguments->thread());
  TransitionNativeToVM transition(arguments->thread());
  if ((retval != Api::Null()) && !Api::IsInstance(retval) &&
      !Api::IsError(retval)) {
    // Print the current stack trace to make the problematic caller
    // easier to find.
    const StackTrace& stacktrace = GetCurrentStackTrace(0);
    OS::PrintErr("=== Current Trace:\n%s===\n", stacktrace.ToCString());
 
    const Object& ret_obj = Object::Handle(Api::UnwrapHandle(retval));
    FATAL(
        "Return value check failed: saw '%s' expected a dart Instance or "
        "an Error.",
        ret_obj.ToCString());
  }
  ASSERT(retval != nullptr);
  Api::SetReturnValue(arguments, retval);
}

Dart_SetRootLibrary()

DART_EXPORT Dart_Handle dart::Dart_SetRootLibrary

(

Dart_Handle

library

)

Definition at line 5488 of file dart_api_impl.cc.

                                                                 {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(library));
  if (obj.IsNull() || obj.IsLibrary()) {
    Library& lib = Library::Handle(Z);
    lib ^= obj.ptr();
    T->isolate_group()->object_store()->set_root_library(lib);
    return library;
  }
  RETURN_TYPE_ERROR(Z, library, Library);
}

Dart_SetServiceStreamCallbacks()

DART_EXPORT char * dart::Dart_SetServiceStreamCallbacks	(	Dart_ServiceStreamListenCallback	listen_callback,
		Dart_ServiceStreamCancelCallback	cancel_callback
	)

Definition at line 6146 of file dart_api_impl.cc.

                                                      {
#if defined(PRODUCT)
  return nullptr;
#else
  if (listen_callback != nullptr) {
    if (Service::stream_listen_callback() != nullptr) {
      return Utils::StrDup(
          "Dart_SetServiceStreamCallbacks "
          "permits only one listen callback to be registered, please "
          "remove the existing callback and then add this callback");
    }
  } else {
    if (Service::stream_listen_callback() == nullptr) {
      return Utils::StrDup(
          "Dart_SetServiceStreamCallbacks "
          "expects 'listen_callback' to be present in the callback set.");
    }
  }
  if (cancel_callback != nullptr) {
    if (Service::stream_cancel_callback() != nullptr) {
      return Utils::StrDup(
          "Dart_SetServiceStreamCallbacks "
          "permits only one cancel callback to be registered, please "
          "remove the existing callback and then add this callback");
    }
  } else {
    if (Service::stream_cancel_callback() == nullptr) {
      return Utils::StrDup(
          "Dart_SetServiceStreamCallbacks "
          "expects 'cancel_callback' to be present in the callback set.");
    }
  }
  Service::SetEmbedderStreamCallbacks(listen_callback, cancel_callback);
  return nullptr;
#endif
}

Dart_SetShouldPauseOnExit()

DART_EXPORT void dart::Dart_SetShouldPauseOnExit

(

bool

should_pause

)

Definition at line 1702 of file dart_api_impl.cc.

                                                              {
#if defined(PRODUCT)
  if (should_pause) {
    FATAL("%s(true) is not supported in a PRODUCT build", CURRENT_FUNC);
  }
#else
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  isolate->message_handler()->set_should_pause_on_exit(should_pause);
#endif
}

Dart_SetShouldPauseOnStart()

DART_EXPORT void dart::Dart_SetShouldPauseOnStart

(

bool

should_pause

)

Definition at line 1648 of file dart_api_impl.cc.

                                                               {
#if defined(PRODUCT)
  if (should_pause) {
    FATAL("%s(true) is not supported in a PRODUCT build", CURRENT_FUNC);
  }
#else
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  if (isolate->is_runnable()) {
    FATAL("%s expects the current isolate to not be runnable yet.",
          CURRENT_FUNC);
  }
  isolate->message_handler()->set_should_pause_on_start(should_pause);
#endif
}

Dart_SetStickyError()

DART_EXPORT void dart::Dart_SetStickyError

(

Dart_Handle

error

)

Definition at line 1741 of file dart_api_impl.cc.

                                                        {
  Thread* thread = Thread::Current();
  DARTSCOPE(thread);
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  const Error& error_handle = Api::UnwrapErrorHandle(Z, error);
  if ((isolate->sticky_error() != Error::null()) &&
      (error_handle.ptr() != Object::null())) {
    FATAL("%s expects there to be no sticky error.", CURRENT_FUNC);
  }
  if (!error_handle.IsUnhandledException() &&
      (error_handle.ptr() != Object::null())) {
    FATAL("%s expects the error to be an unhandled exception error or null.",
          CURRENT_FUNC);
  }
  isolate->SetStickyError(error_handle.ptr());
}

Dart_SetThreadName()

DART_EXPORT void dart::Dart_SetThreadName

(

const char *

name

)

Definition at line 6367 of file dart_api_impl.cc.

                                                      {
  OSThread* thread = OSThread::Current();
  if (thread == nullptr) {
    // VM is shutting down.
    return;
  }
  thread->SetName(name);
}

Dart_SetTimelineRecorderCallback()

DART_EXPORT void dart::Dart_SetTimelineRecorderCallback

(

Dart_TimelineRecorderCallback

callback

)

Definition at line 6360 of file dart_api_impl.cc.

                                            {
#if defined(SUPPORT_TIMELINE)
  Timeline::set_callback(callback);
#endif
}

Dart_SetVMFlags()

DART_EXPORT char * dart::Dart_SetVMFlags	(	int	argc,
		const char **	argv
	)

Definition at line 1186 of file dart_api_impl.cc.

                                                               {
  return Flags::ProcessCommandLineFlags(argc, argv);
}

Dart_SetWeakHandleReturnValue()

DART_EXPORT void dart::Dart_SetWeakHandleReturnValue	(	Dart_NativeArguments	args,
		Dart_WeakPersistentHandle	rval
	)

Definition at line 5244 of file dart_api_impl.cc.

                                                                               {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
#if defined(DEBUG)
  Isolate* isolate = arguments->thread()->isolate();
  ASSERT(isolate == Isolate::Current());
  ASSERT(isolate->group()->api_state() != nullptr &&
         (isolate->group()->api_state()->IsValidWeakPersistentHandle(rval)));
#endif
  Api::SetWeakHandleReturnValue(arguments, rval);
}

Dart_ShouldPauseOnExit()

DART_EXPORT bool dart::Dart_ShouldPauseOnExit

(

void

)

Definition at line 1691 of file dart_api_impl.cc.

                                          {
#if defined(PRODUCT)
  return false;
#else
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->message_handler()->should_pause_on_exit();
#endif
}

Dart_ShouldPauseOnStart()

DART_EXPORT bool dart::Dart_ShouldPauseOnStart

(

void

)

Definition at line 1637 of file dart_api_impl.cc.

                                           {
#if defined(PRODUCT)
  return false;
#else
  Isolate* isolate = Isolate::Current();
  CHECK_ISOLATE(isolate);
  NoSafepointScope no_safepoint_scope;
  return isolate->message_handler()->should_pause_on_start();
#endif
}

Dart_ShutdownIsolate()

DART_EXPORT void dart::Dart_ShutdownIsolate

(

void

)

Definition at line 1423 of file dart_api_impl.cc.

                                        {
  Thread* T = Thread::Current();
  auto I = T->isolate();
  CHECK_ISOLATE(I);
 
  // The Thread structure is disassociated from the isolate, we do the
  // safepoint transition explicitly here instead of using the TransitionXXX
  // scope objects as the original transition happened outside this scope in
  // Dart_EnterIsolate/Dart_CreateIsolateGroup.
  ASSERT(T->execution_state() == Thread::kThreadInNative);
  T->ExitSafepoint();
  T->set_execution_state(Thread::kThreadInVM);
 
  I->WaitForOutstandingSpawns();
 
  // Release any remaining API scopes.
  ApiLocalScope* scope = T->api_top_scope();
  while (scope != nullptr) {
    ApiLocalScope* previous = scope->previous();
    delete scope;
    scope = previous;
  }
  T->set_api_top_scope(nullptr);
 
  {
    StackZone zone(T);
    HandleScope handle_scope(T);
    Dart::RunShutdownCallback();
  }
  Dart::ShutdownIsolate(T);
}

Dart_SortClasses()

DART_EXPORT Dart_Handle dart::Dart_SortClasses

(

void

)

Definition at line 6376 of file dart_api_impl.cc.

                                           {
#if defined(DART_PRECOMPILED_RUNTIME)
  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
#else
  DARTSCOPE(Thread::Current());
 
  // Prevent background compiler from running while code is being cleared and
  // adding new code.
  NoBackgroundCompilerScope no_bg_compiler(T);
 
  // We don't have mechanisms to change class-ids that are embedded in code and
  // ICData.
  ClassFinalizer::ClearAllCode();
  // Make sure that ICData etc. that have been cleared are also removed from
  // the heap so that they are not found by the heap verifier.
  IsolateGroup::Current()->heap()->CollectAllGarbage();
  ClassFinalizer::SortClasses();
  return Api::Success();
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

Dart_StackTraceLength()

Dart_Handle dart::Dart_StackTraceLength	(	Dart_StackTrace	trace,
		intptr_t *	length
	)

Returns in \length the number of activation frames in the given stack trace.

Requires there to be a current isolate.

Returns

A handle to the True object if no error occurs.

Definition at line 62 of file debugger_api_impl_test.cc.

                                                                           {
  DARTSCOPE(Thread::Current());
  CHECK_NOT_NULL(length);
  CHECK_AND_CAST(DebuggerStackTrace, stack_trace, trace);
  *length = stack_trace->Length();
  return Api::Success();
}

Dart_StartProfiling()

DART_EXPORT void dart::Dart_StartProfiling

(

void

)

Definition at line 1555 of file dart_api_impl.cc.

                                       {
#if !defined(PRODUCT)
  if (!FLAG_profiler) {
    FLAG_profiler = true;
    Profiler::Init();
  }
#endif  // !defined(PRODUCT)
}

Dart_StopProfiling()

DART_EXPORT void dart::Dart_StopProfiling

(

void

)

Definition at line 1564 of file dart_api_impl.cc.

                                      {
#if !defined(PRODUCT)
  if (FLAG_profiler) {
    Profiler::Cleanup();
    FLAG_profiler = false;
  }
#endif  // !defined(PRODUCT)
}

Dart_StringGetProperties()

DART_EXPORT Dart_Handle dart::Dart_StringGetProperties	(	Dart_Handle	object,
		intptr_t *	char_size,
		intptr_t *	str_len,
		void **	peer
	)

Definition at line 3027 of file dart_api_impl.cc.

                                                              {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  {
    ReusableObjectHandleScope reused_obj_handle(thread);
    const String& str = Api::UnwrapStringHandle(reused_obj_handle, object);
    if (!str.IsNull()) {
      NoSafepointScope no_safepoint_scope;
      *peer = thread->heap()->GetPeer(str.ptr());
      *char_size = str.CharSize();
      *str_len = str.Length();
      return Api::Success();
    }
  }
  RETURN_TYPE_ERROR(thread->zone(), object, String);
}

Dart_StringLength()

DART_EXPORT Dart_Handle dart::Dart_StringLength	(	Dart_Handle	str,
		intptr_t *	len
	)

Definition at line 2816 of file dart_api_impl.cc.

                                                                          {
  Thread* thread = Thread::Current();
  DARTSCOPE(thread);
  {
    ReusableObjectHandleScope reused_obj_handle(thread);
    const String& str_obj = Api::UnwrapStringHandle(reused_obj_handle, str);
    if (!str_obj.IsNull()) {
      *len = str_obj.Length();
      return Api::Success();
    }
  }
  RETURN_TYPE_ERROR(thread->zone(), str, String);
}

Dart_StringStorageSize()

DART_EXPORT Dart_Handle dart::Dart_StringStorageSize	(	Dart_Handle	str,
		intptr_t *	size
	)

Definition at line 3008 of file dart_api_impl.cc.

                                                               {
  Thread* thread = Thread::Current();
  CHECK_ISOLATE(thread->isolate());
  TransitionNativeToVM transition(thread);
  if (size == nullptr) {
    RETURN_NULL_ERROR(size);
  }
  {
    ReusableObjectHandleScope reused_obj_handle(thread);
    const String& str_obj = Api::UnwrapStringHandle(reused_obj_handle, str);
    if (!str_obj.IsNull()) {
      *size = (str_obj.Length() * str_obj.CharSize());
      return Api::Success();
    }
  }
  RETURN_TYPE_ERROR(thread->zone(), str, String);
}

Dart_StringToCString()

DART_EXPORT Dart_Handle dart::Dart_StringToCString	(	Dart_Handle	object,
		const char **	cstr
	)

Definition at line 2893 of file dart_api_impl.cc.

                                                                {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  if (cstr == nullptr) {
    RETURN_NULL_ERROR(cstr);
  }
  const String& str_obj = Api::UnwrapStringHandle(Z, object);
  if (str_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, object, String);
  }
  intptr_t string_length = Utf8::Length(str_obj);
  char* res = Api::TopScope(T)->zone()->Alloc<char>(string_length + 1);
  if (res == nullptr) {
    return Api::NewError("Unable to allocate memory");
  }
  const char* string_value = str_obj.ToCString();
  memmove(res, string_value, string_length + 1);
  ASSERT(res[string_length] == '\0');
  *cstr = res;
  return Api::Success();
}

Dart_StringToLatin1()

DART_EXPORT Dart_Handle dart::Dart_StringToLatin1	(	Dart_Handle	str,
		uint8_t *	latin1_array,
		intptr_t *	length
	)

Definition at line 2963 of file dart_api_impl.cc.

                                                              {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  if (latin1_array == nullptr) {
    RETURN_NULL_ERROR(latin1_array);
  }
  if (length == nullptr) {
    RETURN_NULL_ERROR(length);
  }
  const String& str_obj = Api::UnwrapStringHandle(Z, str);
  if (str_obj.IsNull() || !str_obj.IsOneByteString()) {
    RETURN_TYPE_ERROR(Z, str, String);
  }
  intptr_t str_len = str_obj.Length();
  intptr_t copy_len = (str_len > *length) ? *length : str_len;
 
  // We have already asserted that the string object is a Latin-1 string
  // so we can copy the characters over using a simple loop.
  for (intptr_t i = 0; i < copy_len; i++) {
    latin1_array[i] = str_obj.CharAt(i);
  }
  *length = copy_len;
  return Api::Success();
}

Dart_StringToUTF16()

DART_EXPORT Dart_Handle dart::Dart_StringToUTF16	(	Dart_Handle	str,
		uint16_t *	utf16_array,
		intptr_t *	length
	)

Definition at line 2990 of file dart_api_impl.cc.

                                                             {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  const String& str_obj = Api::UnwrapStringHandle(Z, str);
  if (str_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, str, String);
  }
  intptr_t str_len = str_obj.Length();
  intptr_t copy_len = (str_len > *length) ? *length : str_len;
  for (intptr_t i = 0; i < copy_len; i++) {
    utf16_array[i] = str_obj.CharAt(i);
  }
  *length = copy_len;
  return Api::Success();
}

Dart_StringToUTF8()

DART_EXPORT Dart_Handle dart::Dart_StringToUTF8	(	Dart_Handle	str,
		uint8_t **	utf8_array,
		intptr_t *	length
	)

Definition at line 2916 of file dart_api_impl.cc.

                                                            {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  if (utf8_array == nullptr) {
    RETURN_NULL_ERROR(utf8_array);
  }
  if (length == nullptr) {
    RETURN_NULL_ERROR(length);
  }
  const String& str_obj = Api::UnwrapStringHandle(Z, str);
  if (str_obj.IsNull()) {
    RETURN_TYPE_ERROR(Z, str, String);
  }
  intptr_t str_len = Utf8::Length(str_obj);
  *utf8_array = Api::TopScope(T)->zone()->Alloc<uint8_t>(str_len);
  if (*utf8_array == nullptr) {
    return Api::NewError("Unable to allocate memory");
  }
  str_obj.ToUTF8(*utf8_array, str_len);
  *length = str_len;
  return Api::Success();
}

Dart_StringUTF8Length()

DART_EXPORT Dart_Handle dart::Dart_StringUTF8Length	(	Dart_Handle	str,
		intptr_t *	len
	)

Definition at line 2830 of file dart_api_impl.cc.

                                                                              {
  Thread* thread = Thread::Current();
  DARTSCOPE(thread);
  {
    ReusableObjectHandleScope reused_obj_handle(thread);
    const String& str_obj = Api::UnwrapStringHandle(reused_obj_handle, str);
    if (!str_obj.IsNull()) {
      *len = Utf8::Length(str_obj);
      return Api::Success();
    }
  }
  RETURN_TYPE_ERROR(thread->zone(), str, String);
}

Dart_ThreadDisableProfiling()

DART_EXPORT void dart::Dart_ThreadDisableProfiling

(

void

)

Definition at line 1573 of file dart_api_impl.cc.

                                               {
#if !defined(PRODUCT)
  OSThread* os_thread = OSThread::Current();
  if (os_thread == nullptr) {
    return;
  }
  os_thread->DisableThreadInterrupts();
#endif  // !defined(PRODUCT)
}

Dart_ThreadEnableProfiling()

DART_EXPORT void dart::Dart_ThreadEnableProfiling

(

void

)

Definition at line 1583 of file dart_api_impl.cc.

                                              {
#if !defined(PRODUCT)
  OSThread* os_thread = OSThread::Current();
  if (os_thread == nullptr) {
    return;
  }
  os_thread->EnableThreadInterrupts();
#endif  // !defined(PRODUCT)
}

Dart_ThrowException()

DART_EXPORT Dart_Handle dart::Dart_ThrowException

(

Dart_Handle

exception

)

Definition at line 4822 of file dart_api_impl.cc.

                                                                   {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  CHECK_CALLBACK_STATE(thread);
  if (::Dart_IsError(exception)) {
    ::Dart_PropagateError(exception);
  }
  TransitionNativeToVM transition(thread);
  const Instance& excp = Api::UnwrapInstanceHandle(zone, exception);
  if (excp.IsNull()) {
    RETURN_TYPE_ERROR(zone, exception, Instance);
  }
  if (thread->top_exit_frame_info() == 0) {
    // There are no dart frames on the stack so it would be illegal to
    // throw an exception here.
    return Api::NewError("No Dart frames on stack, cannot throw exception");
  }
  // Unwind all the API scopes till the exit frame before throwing an
  // exception.
  const Instance* saved_exception;
  {
    NoSafepointScope no_safepoint;
    InstancePtr raw_exception =
        Api::UnwrapInstanceHandle(zone, exception).ptr();
    thread->UnwindScopes(thread->top_exit_frame_info());
    saved_exception = &Instance::Handle(raw_exception);
  }
  Exceptions::Throw(thread, *saved_exception);
  return Api::NewError("Exception was not thrown, internal error");
}

Dart_TimelineGetMicros()

DART_EXPORT int64_t dart::Dart_TimelineGetMicros

(

)

Definition at line 6269 of file dart_api_impl.cc.

                                             {
  return OS::GetCurrentMonotonicMicros();
}

Dart_TimelineGetTicks()

DART_EXPORT int64_t dart::Dart_TimelineGetTicks

(

)

Definition at line 6273 of file dart_api_impl.cc.

                                            {
  return OS::GetCurrentMonotonicTicks();
}

Dart_TimelineGetTicksFrequency()

DART_EXPORT int64_t dart::Dart_TimelineGetTicksFrequency

(

)

Definition at line 6277 of file dart_api_impl.cc.

                                                     {
  return OS::GetCurrentMonotonicFrequency();
}

Dart_ToString()

DART_EXPORT Dart_Handle dart::Dart_ToString

(

Dart_Handle

object

)

Definition at line 896 of file dart_api_impl.cc.

                                                          {
  DARTSCOPE(Thread::Current());
  const Object& obj = Object::Handle(Z, Api::UnwrapHandle(object));
  if (obj.IsString()) {
    return Api::NewHandle(T, obj.ptr());
  } else if (obj.IsInstance()) {
    CHECK_CALLBACK_STATE(T);
    const Instance& receiver = Instance::Cast(obj);
    return Api::NewHandle(T, DartLibraryCalls::ToString(receiver));
  } else {
    CHECK_CALLBACK_STATE(T);
    // This is a VM internal object. Call the C++ method of printing.
    return Api::NewHandle(T, String::New(obj.ToCString()));
  }
}

Dart_True()

DART_EXPORT Dart_Handle dart::Dart_True

(

void

)

Definition at line 2787 of file dart_api_impl.cc.

                                    {
  ASSERT(Isolate::Current() != nullptr);
  return Api::True();
}

Dart_TypedDataAcquireData()

DART_EXPORT Dart_Handle dart::Dart_TypedDataAcquireData	(	Dart_Handle	object,
		Dart_TypedData_Type *	type,
		void **	data,
		intptr_t *	len
	)

Definition at line 4030 of file dart_api_impl.cc.

                                                                 {
  DARTSCOPE(Thread::Current());
  Isolate* I = T->isolate();
  intptr_t class_id = Api::ClassId(object);
  if (!IsExternalTypedDataClassId(class_id) &&
      !IsTypedDataViewClassId(class_id) && !IsTypedDataClassId(class_id) &&
      !IsUnmodifiableTypedDataViewClassId(class_id)) {
    RETURN_TYPE_ERROR(Z, object, 'TypedData');
  }
  if (type == nullptr) {
    RETURN_NULL_ERROR(type);
  }
  if (data == nullptr) {
    RETURN_NULL_ERROR(data);
  }
  if (len == nullptr) {
    RETURN_NULL_ERROR(len);
  }
  // Get the type of typed data object.
  *type = GetType(class_id);
  intptr_t length = 0;
  intptr_t size_in_bytes = 0;
  void* data_tmp = nullptr;
  bool external = false;
  T->IncrementNoSafepointScopeDepth();
  START_NO_CALLBACK_SCOPE(T);
  if (IsExternalTypedDataClassId(class_id)) {
    const ExternalTypedData& obj =
        Api::UnwrapExternalTypedDataHandle(Z, object);
    ASSERT(!obj.IsNull());
    length = obj.Length();
    size_in_bytes = length * ExternalTypedData::ElementSizeInBytes(class_id);
    data_tmp = obj.DataAddr(0);
    external = true;
  } else if (IsTypedDataClassId(class_id)) {
    const TypedData& obj = Api::UnwrapTypedDataHandle(Z, object);
    ASSERT(!obj.IsNull());
    length = obj.Length();
    size_in_bytes = length * TypedData::ElementSizeInBytes(class_id);
    data_tmp = obj.DataAddr(0);
  } else {
    ASSERT(IsTypedDataViewClassId(class_id) ||
           IsUnmodifiableTypedDataViewClassId(class_id));
    const auto& view_obj = Api::UnwrapTypedDataViewHandle(Z, object);
    ASSERT(!view_obj.IsNull());
    Smi& val = Smi::Handle();
    val = view_obj.length();
    length = val.Value();
    size_in_bytes = length * TypedDataView::ElementSizeInBytes(class_id);
    val = view_obj.offset_in_bytes();
    intptr_t offset_in_bytes = val.Value();
    const auto& obj = Instance::Handle(view_obj.typed_data());
    if (TypedData::IsTypedData(obj)) {
      const TypedData& data_obj = TypedData::Cast(obj);
      data_tmp = data_obj.DataAddr(offset_in_bytes);
    } else {
      ASSERT(ExternalTypedData::IsExternalTypedData(obj));
      const ExternalTypedData& data_obj = ExternalTypedData::Cast(obj);
      data_tmp = data_obj.DataAddr(offset_in_bytes);
      external = true;
    }
  }
  if (FLAG_verify_acquired_data) {
    {
      NoSafepointScope no_safepoint(T);
      bool sweep_in_progress;
      {
        PageSpace* old_space = T->heap()->old_space();
        MonitorLocker ml(old_space->tasks_lock());
        sweep_in_progress = (old_space->phase() == PageSpace::kSweepingLarge) ||
                            (old_space->phase() == PageSpace::kSweepingRegular);
      }
      if (!sweep_in_progress) {
        if (external) {
          ASSERT(!T->heap()->Contains(reinterpret_cast<uword>(data_tmp)));
        } else {
          ASSERT(T->heap()->Contains(reinterpret_cast<uword>(data_tmp)));
        }
      }
    }
    const Object& obj = Object::Handle(Z, Api::UnwrapHandle(object));
    WeakTable* table = I->group()->api_state()->acquired_table();
    intptr_t current = table->GetValue(obj.ptr());
    if (current != 0) {
      return Api::NewError("Data was already acquired for this object.");
    }
    // Do not make a copy if the data is external. Some callers expect external
    // data to remain in place, even though the API spec doesn't guarantee it.
    // TODO(koda/asiva): Make final decision and document it.
    AcquiredData* ad = new AcquiredData(data_tmp, size_in_bytes, !external);
    table->SetValue(obj.ptr(), reinterpret_cast<intptr_t>(ad));
    data_tmp = ad->GetData();
  }
  *data = data_tmp;
  *len = length;
  return Api::Success();
}

Dart_TypedDataReleaseData()

DART_EXPORT Dart_Handle dart::Dart_TypedDataReleaseData

(

Dart_Handle

object

)

Definition at line 4131 of file dart_api_impl.cc.

                                                                      {
  DARTSCOPE(Thread::Current());
  Isolate* I = T->isolate();
  intptr_t class_id = Api::ClassId(object);
  if (!IsExternalTypedDataClassId(class_id) &&
      !IsTypedDataViewClassId(class_id) && !IsTypedDataClassId(class_id) &&
      !IsUnmodifiableTypedDataViewClassId(class_id)) {
    RETURN_TYPE_ERROR(Z, object, 'TypedData');
  }
  if (FLAG_verify_acquired_data) {
    const Object& obj = Object::Handle(Z, Api::UnwrapHandle(object));
    WeakTable* table = I->group()->api_state()->acquired_table();
    intptr_t current = table->GetValue(obj.ptr());
    if (current == 0) {
      return Api::NewError("Data was not acquired for this object.");
    }
    AcquiredData* ad = reinterpret_cast<AcquiredData*>(current);
    table->SetValue(obj.ptr(), 0);  // Delete entry from table.
    delete ad;
  }
  T->DecrementNoSafepointScopeDepth();
  END_NO_CALLBACK_SCOPE(T);
  return Api::Success();
}

Dart_TypeDynamic()

DART_EXPORT Dart_Handle dart::Dart_TypeDynamic

(

void

)

Definition at line 2230 of file dart_api_impl.cc.

                                           {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  API_TIMELINE_DURATION(T);
  return Api::NewHandle(T, Type::DynamicType());
}

Dart_TypeNever()

DART_EXPORT Dart_Handle dart::Dart_TypeNever

(

void

)

Definition at line 2244 of file dart_api_impl.cc.

                                         {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  API_TIMELINE_DURATION(T);
  return Api::NewHandle(T, Type::NeverType());
}

Dart_TypeToNonNullableType()

DART_EXPORT Dart_Handle dart::Dart_TypeToNonNullableType

(

Dart_Handle

type

)

Definition at line 5642 of file dart_api_impl.cc.

                                                                     {
  return TypeToHelper(type, Nullability::kNonNullable);
}

Dart_TypeToNullableType()

DART_EXPORT Dart_Handle dart::Dart_TypeToNullableType

(

Dart_Handle

type

)

Definition at line 5638 of file dart_api_impl.cc.

                                                                  {
  return TypeToHelper(type, Nullability::kNullable);
}

Dart_TypeVoid()

DART_EXPORT Dart_Handle dart::Dart_TypeVoid

(

void

)

Definition at line 2237 of file dart_api_impl.cc.

                                        {
  DARTSCOPE(Thread::Current());
  CHECK_CALLBACK_STATE(T);
  API_TIMELINE_DURATION(T);
  return Api::NewHandle(T, Type::VoidType());
}

Dart_VersionString()

DART_EXPORT const char * dart::Dart_VersionString

(

void

)

Definition at line 1161 of file dart_api_impl.cc.

                                             {
  return Version::String();
}

Dart_WriteHeapSnapshot()

DART_EXPORT char * dart::Dart_WriteHeapSnapshot	(	Dart_HeapSnapshotWriteChunkCallback	write,
		void *	context
	)

Definition at line 6953 of file dart_api_impl.cc.

                   {
#if defined(DART_ENABLE_HEAP_SNAPSHOT_WRITER)
  DARTSCOPE(Thread::Current());
  CallbackHeapSnapshotWriter callback_writer(T, write, context);
  HeapSnapshotWriter writer(T, &callback_writer);
  writer.Write();
  return nullptr;
#else
  return Utils::StrDup("VM is built without the heap snapshot writer.");
#endif
}

Dart_WriteProfileToTimeline()

DART_EXPORT bool dart::Dart_WriteProfileToTimeline	(	Dart_Port	main_port,
		char **	error
	)

Definition at line 1599 of file dart_api_impl.cc.

                                                           {
#if defined(PRODUCT)
  return false;
#else
  if (!FLAG_profiler) {
    if (error != nullptr) {
      *error = Utils::StrDup("The profiler is not running.");
    }
    return false;
  }
 
  const intptr_t kBufferLength = 512;
  char method[kBufferLength];
 
  // clang-format off
  intptr_t method_length = snprintf(method, kBufferLength, "{"
      "\"jsonrpc\": \"2.0\","
      "\"method\": \"_writeCpuProfileTimeline\","
      "\"id\": \"\","
      "\"params\": {"
      "  \"isolateId\": \"isolates/%" Pd64 "\","
      "  \"tags\": \"None\""
      "}"
  "}", main_port);
  // clang-format on
  ASSERT(method_length <= kBufferLength);
 
  char* response = nullptr;
  intptr_t response_length;
  bool success = Dart_InvokeVMServiceMethod(
      reinterpret_cast<uint8_t*>(method), method_length,
      reinterpret_cast<uint8_t**>(&response), &response_length, error);
  free(response);
  return success;
#endif
}

DartModulo()

double dart::DartModulo	(	double	left,
		double	right
	)

Definition at line 3794 of file runtime_entry.cc.

                                             {
  double remainder = fmod_ieee(left, right);
  if (remainder == 0.0) {
    // We explicitly switch to the positive 0.0 (just in case it was negative).
    remainder = +0.0;
  } else if (remainder < 0.0) {
    if (right < 0) {
      remainder -= right;
    } else {
      remainder += right;
    }
  }
  return remainder;
}

DartNativeThrowArgumentException()

void dart::DartNativeThrowArgumentException

(

const Instance &

instance

)

Definition at line 31 of file native_entry.cc.

                                                                {
  const Array& __args__ = Array::Handle(Array::New(1));
  __args__.SetAt(0, instance);
  Exceptions::ThrowByType(Exceptions::kArgument, __args__);
}

DartNativeThrowTypeArgumentCountException()

void dart::DartNativeThrowTypeArgumentCountException	(	int	num_type_args,
		int	num_type_args_expected
	)

Definition at line 23 of file native_entry.cc.

                                                                           {
  const String& error = String::Handle(String::NewFormatted(
      "Wrong number of type arguments (%i), expected %i type arguments",
      num_type_args, num_type_args_expected));
  Exceptions::ThrowArgumentError(error);
}

DebuggerSetResumeIfStepping()

static void dart::DebuggerSetResumeIfStepping ( Isolate *  isolate )

static

Definition at line 690 of file dart_entry.cc.

                                                          {
#if !defined(PRODUCT)
  if (isolate->debugger()->IsStepping()) {
    // If the isolate is being debugged and the debugger was stepping
    // through code, enable single stepping so debugger will stop
    // at the first location the user is interested in.
    isolate->debugger()->SetResumeAction(Debugger::kStepInto);
  }
#endif
}

DECLARE_FLAG() [1/69]

dart::DECLARE_FLAG	(	bool	,
		check_reloaded
	)

DECLARE_FLAG() [2/69]

dart::DECLARE_FLAG	(	bool	,
		complete_timeline
	)

DECLARE_FLAG() [3/69]

dart::DECLARE_FLAG	(	bool	,
		enable_simd_inline
	)

DECLARE_FLAG() [4/69]

dart::DECLARE_FLAG	(	bool	,
		force_evacuation
	)

DECLARE_FLAG() [5/69]

dart::DECLARE_FLAG	(	bool	,
		gc_during_reload
	)

DECLARE_FLAG() [6/69]

dart::DECLARE_FLAG	(	bool	,
		inline_alloc
	)

DECLARE_FLAG() [7/69]

dart::DECLARE_FLAG	(	bool	,
		intrinsify
	)

DECLARE_FLAG() [8/69]

dart::DECLARE_FLAG	(	bool	,
		precompiled_mode
	)

DECLARE_FLAG() [9/69]

dart::DECLARE_FLAG	(	bool	,
		print_class_table
	)

DECLARE_FLAG() [10/69]

dart::DECLARE_FLAG	(	bool	,
		print_flags
	)

DECLARE_FLAG() [11/69]

dart::DECLARE_FLAG	(	bool	,
		print_flow_graph
	)

DECLARE_FLAG() [12/69]

dart::DECLARE_FLAG	(	bool	,
		print_flow_graph_optimized
	)

DECLARE_FLAG() [13/69]

dart::DECLARE_FLAG	(	bool	,
		print_instruction_stats
	)

DECLARE_FLAG() [14/69]

dart::DECLARE_FLAG	(	bool	,
		print_metrics
	)

DECLARE_FLAG() [15/69]

dart::DECLARE_FLAG	(	bool	,
		profile_vm
	)

DECLARE_FLAG() [16/69]

dart::DECLARE_FLAG	(	bool	,
		profile_vm_allocation
	)

DECLARE_FLAG() [17/69]

dart::DECLARE_FLAG	(	bool	,
		reload_every_back_off
	)

DECLARE_FLAG() [18/69]

dart::DECLARE_FLAG	(	bool	,
		reload_every_optimized
	)

DECLARE_FLAG() [19/69]

dart::DECLARE_FLAG	(	bool	,
		show_invisible_frames
	)

DECLARE_FLAG() [20/69]

dart::DECLARE_FLAG	(	bool	,
		trace_bailout
	)

DECLARE_FLAG() [21/69]

dart::DECLARE_FLAG	(	bool	,
		trace_compiler
	)

DECLARE_FLAG() [22/69]

dart::DECLARE_FLAG	(	bool	,
		trace_constant_propagation
	)

DECLARE_FLAG() [23/69]

dart::DECLARE_FLAG	(	bool	,
		trace_deoptimization
	)

DECLARE_FLAG() [24/69]

dart::DECLARE_FLAG	(	bool	,
		trace_deoptimization_verbose
	)

DECLARE_FLAG() [25/69]

dart::DECLARE_FLAG	(	bool	,
		trace_failed_optimization_attempts
	)

DECLARE_FLAG() [26/69]

dart::DECLARE_FLAG	(	bool	,
		trace_inlining_intervals
	)

DECLARE_FLAG() [27/69]

dart::DECLARE_FLAG	(	bool	,
		trace_optimizing_compiler
	)

DECLARE_FLAG() [28/69]

dart::DECLARE_FLAG	(	bool	,
		trace_reload
	)

DECLARE_FLAG() [29/69]

dart::DECLARE_FLAG	(	bool	,
		trace_reload_verbose
	)

DECLARE_FLAG() [30/69]

dart::DECLARE_FLAG	(	bool	,
		trace_service
	)

DECLARE_FLAG() [31/69]

dart::DECLARE_FLAG	(	bool	,
		trace_service_pause_events
	)

DECLARE_FLAG() [32/69]

dart::DECLARE_FLAG	(	bool	,
		trace_service_verbose
	)

DECLARE_FLAG() [33/69]

dart::DECLARE_FLAG	(	bool	,
		trace_shutdown
	)

DECLARE_FLAG() [34/69]

dart::DECLARE_FLAG	(	bool	,
		two_args_smi_icd
	)

DECLARE_FLAG() [35/69]

dart::DECLARE_FLAG	(	bool	,
		use_compressed_instructions
	)

DECLARE_FLAG() [36/69]

dart::DECLARE_FLAG	(	bool	,
		use_slow_path
	)

DECLARE_FLAG() [37/69]

dart::DECLARE_FLAG	(	bool	,
		use_sse41
	)

DECLARE_FLAG() [38/69]

dart::DECLARE_FLAG	(	bool	,
		verify_acquired_data
	)

DECLARE_FLAG() [39/69]

dart::DECLARE_FLAG	(	bool	,
		warn_on_pause_with_no_debugger
	)

DECLARE_FLAG() [40/69]

dart::DECLARE_FLAG	(	bool	,
		write_protect_code
	)

DECLARE_FLAG() [41/69]

dart::DECLARE_FLAG	(	charp	,
		deoptimize_filter
	)

DECLARE_FLAG() [42/69]

dart::DECLARE_FLAG	(	charp	,
		stacktrace_filter
	)

DECLARE_FLAG() [43/69]

dart::DECLARE_FLAG	(	charp	,
		trace_precompiler_to
	)

DECLARE_FLAG() [44/69]

dart::DECLARE_FLAG	(	charp	,
		write_v8_snapshot_profile_to
	)

DECLARE_FLAG() [45/69]

dart::DECLARE_FLAG	(	int	,
		code_heap_size
	)

DECLARE_FLAG() [46/69]

dart::DECLARE_FLAG	(	int	,
		early_tenuring_threshold
	)

DECLARE_FLAG() [47/69]

dart::DECLARE_FLAG	(	int	,
		gc_every
	)

DECLARE_FLAG() [48/69]

dart::DECLARE_FLAG	(	int	,
		inline_getters_setters_smaller_than
	)

DECLARE_FLAG() [49/69]

dart::DECLARE_FLAG	(	int	,
		inlining_callee_size_threshold
	)

DECLARE_FLAG() [50/69]

dart::DECLARE_FLAG	(	int	,
		inlining_caller_size_threshold
	)

DECLARE_FLAG() [51/69]

dart::DECLARE_FLAG	(	int	,
		inlining_constant_arguments_max_size_threshold
	)

DECLARE_FLAG() [52/69]

dart::DECLARE_FLAG	(	int	,
		inlining_constant_arguments_min_size_threshold
	)

DECLARE_FLAG() [53/69]

dart::DECLARE_FLAG	(	int	,
		inlining_depth_threshold
	)

DECLARE_FLAG() [54/69]

dart::DECLARE_FLAG	(	int	,
		inlining_hotness
	)

DECLARE_FLAG() [55/69]

dart::DECLARE_FLAG	(	int	,
		inlining_size_threshold
	)

DECLARE_FLAG() [56/69]

dart::DECLARE_FLAG	(	int	,
		max_deoptimization_counter_threshold
	)

DECLARE_FLAG() [57/69]

dart::DECLARE_FLAG	(	int	,
		max_polymorphic_checks
	)

DECLARE_FLAG() [58/69]

dart::DECLARE_FLAG	(	int	,
		max_profile_depth
	)

DECLARE_FLAG() [59/69]

dart::DECLARE_FLAG	(	int	,
		max_subtype_cache_entries
	)

DECLARE_FLAG() [60/69]

dart::DECLARE_FLAG	(	int	,
		old_gen_growth_space_ratio
	)

DECLARE_FLAG() [61/69]

dart::DECLARE_FLAG	(	int	,
		old_gen_growth_time_ratio
	)

DECLARE_FLAG() [62/69]

dart::DECLARE_FLAG	(	int	,
		optimization_counter_threshold
	)

DECLARE_FLAG() [63/69]

dart::DECLARE_FLAG	(	int	,
		profile_period
	)

DECLARE_FLAG() [64/69]

dart::DECLARE_FLAG	(	int	,
		regexp_optimization_counter_threshold
	)

DECLARE_FLAG() [65/69]

dart::DECLARE_FLAG	(	int	,
		reload_every
	)

DECLARE_FLAG() [66/69]

dart::DECLARE_FLAG	(	int	,
		reoptimization_counter_threshold
	)

DECLARE_FLAG() [67/69]

dart::DECLARE_FLAG	(	int	,
		stacktrace_every
	)

DECLARE_FLAG() [68/69]

dart::DECLARE_FLAG	(	int	,
		worker_timeout_millis
	)

DECLARE_FLAG() [69/69]

dart::DECLARE_FLAG	(	uint64_t	,
		random_seed
	)

DecodeBase64()

uint8_t * dart::DecodeBase64	(	const char *	str,
		intptr_t *	out_decoded_len
	)

Definition at line 39 of file base64.cc.

                                                                  {
  intptr_t len = strlen(str);
  if (len == 0 || (len % 4 != 0)) {
    return nullptr;
  }
 
  int pad_length = 0;
  for (intptr_t i = len - 1; i >= 0; i--) {
    const uint8_t current_code_unit = str[i];
    if (decode_table[current_code_unit] > 0) break;
    if (current_code_unit == PAD) pad_length++;
  }
  intptr_t decoded_en = ((len * 6) >> 3) - pad_length;
  uint8_t* bytes = static_cast<uint8_t*>(malloc(decoded_en));
 
  for (int i = 0, o = 0; o < decoded_en;) {
    // Accumulate 4 valid 6 bit Base 64 characters into an int.
    int x = 0;
    for (int j = 4; j > 0;) {
      int c = decode_table[(uint8_t)str[i++]];
      if (c >= 0) {
        x = ((x << 6) & 0xFFFFFF) | c;
        j--;
      }
    }
    bytes[o++] = x >> 16;
    if (o < decoded_en) {
      bytes[o++] = (x >> 8) & 0xFF;
      if (o < decoded_en) bytes[o++] = x & 0xFF;
    }
  }
  if (out_decoded_len != nullptr) {
    *out_decoded_len = decoded_en;
  }
  return bytes;
}

DecodeBTypeImm()

intptr_t dart::DecodeBTypeImm ( uint32_t  encoded )

inline

Definition at line 1020 of file constants_riscv.h.

                                                 {
  uint32_t imm = 0;
  imm |= (((encoded >> 31) & 0x1) << 12);
  imm |= (((encoded >> 25) & 0x3f) << 5);
  imm |= (((encoded >> 8) & 0xf) << 1);
  imm |= (((encoded >> 7) & 0x1) << 11);
  return SignExtend(12, imm);
}

DecodeCBImm()

intx_t dart::DecodeCBImm ( uint32_t  encoding )

inline

Definition at line 1336 of file constants_riscv.h.

                                             {
  uint32_t imm = 0;
  imm |= ((encoding >> 12) & 0x1) << 8;
  imm |= ((encoding >> 10) & 0x3) << 3;
  imm |= ((encoding >> 5) & 0x3) << 6;
  imm |= ((encoding >> 3) & 0x3) << 1;
  imm |= ((encoding >> 2) & 0x1) << 5;
  return SignExtend(8, imm);
}

DecodeCI16Imm()

intx_t dart::DecodeCI16Imm ( uint32_t  encoding )

inline

Definition at line 1393 of file constants_riscv.h.

                                               {
  uint32_t imm = 0;
  imm |= ((encoding >> 12) & 0x1) << 9;
  imm |= ((encoding >> 6) & 0x1) << 4;
  imm |= ((encoding >> 5) & 0x1) << 6;
  imm |= ((encoding >> 3) & 0x3) << 7;
  imm |= ((encoding >> 2) & 0x1) << 5;
  return SignExtend(10, imm);
}

DecodeCI4SPNImm()

intx_t dart::DecodeCI4SPNImm ( uint32_t  encoding )

inline

Definition at line 1415 of file constants_riscv.h.

                                                 {
  uint32_t imm = 0;
  imm |= ((encoding >> 11) & 0x3) << 4;
  imm |= ((encoding >> 7) & 0xF) << 6;
  imm |= ((encoding >> 6) & 0x1) << 2;
  imm |= ((encoding >> 5) & 0x1) << 3;
  return imm;
}

DecodeCIImm()

intx_t dart::DecodeCIImm ( uint32_t  encoding )

inline

Definition at line 1356 of file constants_riscv.h.

                                             {
  uint32_t imm = 0;
  imm |= ((encoding >> 12) & 0x1) << 5;
  imm |= ((encoding >> 2) & 0x1F) << 0;
  return SignExtend(6, imm);
}

DecodeCJImm()

intx_t dart::DecodeCJImm ( uint32_t  encoding )

inline

Definition at line 1310 of file constants_riscv.h.

                                             {
  uint32_t imm = 0;
  imm |= ((encoding >> 12) & 0x1) << 11;
  imm |= ((encoding >> 11) & 0x1) << 4;
  imm |= ((encoding >> 9) & 0x3) << 8;
  imm |= ((encoding >> 8) & 0x1) << 10;
  imm |= ((encoding >> 7) & 0x1) << 6;
  imm |= ((encoding >> 6) & 0x1) << 7;
  imm |= ((encoding >> 3) & 0x7) << 1;
  imm |= ((encoding >> 2) & 0x1) << 5;
  return SignExtend(11, imm);
}

DecodeCMem4Imm()

intx_t dart::DecodeCMem4Imm ( uint32_t  encoding )

inline

Definition at line 1269 of file constants_riscv.h.

                                                {
  uint32_t imm = 0;
  imm |= ((encoding >> 10) & 0x7) << 3;
  imm |= ((encoding >> 6) & 0x1) << 2;
  imm |= ((encoding >> 5) & 0x1) << 6;
  return imm;
}

DecodeCMem8Imm()

intx_t dart::DecodeCMem8Imm ( uint32_t  encoding )

inline

Definition at line 1287 of file constants_riscv.h.

                                                {
  uint32_t imm = 0;
  imm |= ((encoding >> 10) & 0x7) << 3;
  imm |= ((encoding >> 5) & 0x3) << 6;
  return imm;
}

DecodeCSPLoad4Imm()

intx_t dart::DecodeCSPLoad4Imm ( uint32_t  encoding )

inline

Definition at line 1197 of file constants_riscv.h.

                                                   {
  uint32_t imm = 0;
  imm |= ((encoding >> 12) & 0x1) << 5;
  imm |= ((encoding >> 4) & 0x7) << 2;
  imm |= ((encoding >> 2) & 0x3) << 6;
  return imm;
}

DecodeCSPLoad8Imm()

intx_t dart::DecodeCSPLoad8Imm ( uint32_t  encoding )

inline

Definition at line 1216 of file constants_riscv.h.

                                                   {
  uint32_t imm = 0;
  imm |= ((encoding >> 12) & 0x1) << 5;
  imm |= ((encoding >> 5) & 0x3) << 3;
  imm |= ((encoding >> 2) & 0x7) << 6;
  return imm;
}

DecodeCSPStore4Imm()

intx_t dart::DecodeCSPStore4Imm ( uint32_t  encoding )

inline

Definition at line 1234 of file constants_riscv.h.

                                                    {
  uint32_t imm = 0;
  imm |= ((encoding >> 9) & 0xF) << 2;
  imm |= ((encoding >> 7) & 0x3) << 6;
  return imm;
}

DecodeCSPStore8Imm()

intx_t dart::DecodeCSPStore8Imm ( uint32_t  encoding )

inline

Definition at line 1251 of file constants_riscv.h.

                                                    {
  uint32_t imm = 0;
  imm |= ((encoding >> 10) & 0x7) << 3;
  imm |= ((encoding >> 7) & 0x7) << 6;
  return imm;
}

DecodeCUImm()

intx_t dart::DecodeCUImm ( uint32_t  encoding )

inline

Definition at line 1373 of file constants_riscv.h.

                                             {
  uint32_t imm = 0;
  imm |= ((encoding >> 12) & 0x1) << 17;
  imm |= ((encoding >> 2) & 0x1F) << 12;
  return SignExtend(17, imm);
}

DecodeITypeImm()

intptr_t dart::DecodeITypeImm ( uint32_t  encoded )

inline

Definition at line 1057 of file constants_riscv.h.

                                                 {
  return SignExtend(12, encoded >> 20);
}

DecodeJTypeImm()

intptr_t dart::DecodeJTypeImm ( uint32_t  encoded )

inline

Definition at line 1041 of file constants_riscv.h.

                                                 {
  uint32_t imm = 0;
  imm |= (((encoded >> 31) & 0x1) << 20);
  imm |= (((encoded >> 21) & 0x3ff) << 1);
  imm |= (((encoded >> 20) & 0x1) << 11);
  imm |= (((encoded >> 12) & 0xff) << 12);
  return SignExtend(20, imm);
}

DecodeKernelBuffer()

ExternalTypedDataPtr dart::DecodeKernelBuffer

(

const char *

kernel_buffer_base64

)

Definition at line 3307 of file service.cc.

                                                                          {
  intptr_t kernel_length;
  uint8_t* kernel_buffer = DecodeBase64(kernel_buffer_base64, &kernel_length);
  return ExternalTypedData::NewFinalizeWithFree(kernel_buffer, kernel_length);
}

DecodeLoadObjectFromPoolOrThread()

bool dart::DecodeLoadObjectFromPoolOrThread	(	uword	pc,
		const Code &	code,
		Object *	obj
	)

DecodeSTypeImm()

intptr_t dart::DecodeSTypeImm ( uint32_t  encoded )

inline

Definition at line 1082 of file constants_riscv.h.

                                                 {
  uint32_t imm = 0;
  imm |= (((encoded >> 25) & 0x7f) << 5);
  imm |= (((encoded >> 7) & 0x1f) << 0);
  return SignExtend(12, imm);
}

DecodeUTypeImm()

intptr_t dart::DecodeUTypeImm ( uint32_t  encoded )

inline

Definition at line 1068 of file constants_riscv.h.

                                                 {
  return SignExtend(32, encoded & ~((1 << 12) - 1));
}

DecreaseRefcount()

DART_EXPORT void dart::DecreaseRefcount

(

void *

peer

)

Definition at line 1352 of file ffi_test_functions_vmspecific.cc.

                                              {
  auto* resource = static_cast<RefCountedResource*>(peer);
  ref_counted_resource_mutex.lock();
  resource->refcount--;
  if (resource->refcount <= 0) {
    free(resource->resource);
    free(peer);
  }
  ref_counted_resource_mutex.unlock();
}

DeepLiveness()

static void dart::DeepLiveness ( MaterializeObjectInstr *  mat, BitVector *  live_in  )

static

Definition at line 151 of file linearscan.cc.

                                                                          {
  if (mat->was_visited_for_liveness()) {
    return;
  }
  mat->mark_visited_for_liveness();
 
  for (intptr_t i = 0; i < mat->InputCount(); i++) {
    if (!mat->InputAt(i)->BindsToConstant()) {
      Definition* defn = mat->InputAt(i)->definition();
      MaterializeObjectInstr* inner_mat = defn->AsMaterializeObject();
      if (inner_mat != nullptr) {
        DeepLiveness(inner_mat, live_in);
      } else {
        intptr_t idx = defn->vreg(0);
        live_in->Add(idx);
      }
    }
  }
}

DeferredLoadComplete()

static Dart_Handle dart::DeferredLoadComplete ( intptr_t  loading_unit_id, bool  error, const uint8_t *  snapshot_data, const uint8_t *  snapshot_instructions, const char *  error_message, bool  transient_error  )

static

Definition at line 5848 of file dart_api_impl.cc.

                                                              {
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  auto IG = T->isolate_group();
  CHECK_CALLBACK_STATE(T);
 
  const Array& loading_units =
      Array::Handle(IG->object_store()->loading_units());
  if (loading_units.IsNull() || (loading_unit_id < LoadingUnit::kRootId) ||
      (loading_unit_id >= loading_units.Length())) {
    return Api::NewError("Invalid loading unit");
  }
  LoadingUnit& unit = LoadingUnit::Handle();
  unit ^= loading_units.At(loading_unit_id);
  if (unit.loaded()) {
    return Api::NewError("Unit already loaded");
  }
 
  if (error) {
    CHECK_NULL(error_message);
    return Api::NewHandle(
        T, unit.CompleteLoad(String::Handle(String::New(error_message)),
                             transient_error));
  } else {
#if defined(SUPPORT_TIMELINE)
    TimelineBeginEndScope tbes(T, Timeline::GetIsolateStream(),
                               "ReadUnitSnapshot");
#endif  // defined(SUPPORT_TIMELINE)
    const Snapshot* snapshot = Snapshot::SetupFromBuffer(snapshot_data);
    if (snapshot == nullptr) {
      return Api::NewError("Invalid snapshot");
    }
    if (!IsSnapshotCompatible(Dart::vm_snapshot_kind(), snapshot->kind())) {
      const String& message = String::Handle(String::NewFormatted(
          "Incompatible snapshot kinds: vm '%s', isolate '%s'",
          Snapshot::KindToCString(Dart::vm_snapshot_kind()),
          Snapshot::KindToCString(snapshot->kind())));
      return Api::NewHandle(T, ApiError::New(message));
    }
 
    FullSnapshotReader reader(snapshot, snapshot_instructions, T);
    const Error& error = Error::Handle(reader.ReadUnitSnapshot(unit));
    if (!error.IsNull()) {
      return Api::NewHandle(T, error.ptr());
    }
 
    return Api::NewHandle(T, unit.CompleteLoad(String::Handle(), false));
  }
}

DEFINE_BACKEND()

dart::DEFINE_BACKEND	(	LoadThread	,
		(Register out)
	)

Definition at line 7960 of file il.cc.

                                           {
  __ MoveRegister(out, THR);
}

DEFINE_FFI_NATIVE_ENTRY() [1/3]

dart::DEFINE_FFI_NATIVE_ENTRY	(	FinalizerEntry_SetExternalSize	,
		void	,
		(Dart_Handle entry_handle, intptr_t external_size)
	)

Definition at line 100 of file ffi.cc.

                                                                            {
  Thread* const thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();
  const auto& entry_object =
      Object::Handle(zone, Api::UnwrapHandle(entry_handle));
  const auto& entry = FinalizerEntry::Cast(entry_object);
 
  Heap::Space space;
  intptr_t external_size_diff;
  {
    NoSafepointScope no_safepoint;
    space = SpaceForExternal(entry.ptr());
    const intptr_t external_size_old = entry.external_size();
    if (FLAG_trace_finalizers) {
      THR_Print("Setting external size from  %" Pd " to  %" Pd
                " bytes in %s space\n",
                external_size_old, external_size, space == 0 ? "new" : "old");
    }
    external_size_diff = external_size - external_size_old;
    if (external_size_diff == 0) {
      return;
    }
    entry.set_external_size(external_size);
  }
  // The next call cannot be in safepoint.
  if (external_size_diff > 0) {
    if (!thread->isolate_group()->heap()->AllocatedExternal(external_size_diff,
                                                            space)) {
      Exceptions::ThrowOOM();
    }
  } else {
    thread->isolate_group()->heap()->FreedExternal(-external_size_diff, space);
  }
};

DEFINE_FFI_NATIVE_ENTRY() [2/3]

dart::DEFINE_FFI_NATIVE_ENTRY	(	Pointer_asTypedListFinalizerAllocateData	,
		void *	,
		()
	)

Definition at line 145 of file ffi.cc.

                                                                             {
  auto* result = malloc(sizeof(AsTypedListFinalizerData));
  // Initialized with FFI stores.
  MSAN_UNPOISON(result, sizeof(AsTypedListFinalizerData));
  return result;
};

DEFINE_FFI_NATIVE_ENTRY() [3/3]

dart::DEFINE_FFI_NATIVE_ENTRY	(	Pointer_asTypedListFinalizerCallbackPointer	,
		void *	,
		()
	)

Definition at line 158 of file ffi.cc.

                            {
  return reinterpret_cast<void*>(&AsTypedListFinalizerCallback);
};

DEFINE_FLAG() [1/160]

dart::DEFINE_FLAG	(	bool	,
		align_all_loops	,
		false	,
		"Align all loop headers to 32 byte boundary"
	)

DEFINE_FLAG() [2/160]

dart::DEFINE_FLAG	(	bool	,
		array_bounds_check_elimination	,
		true	,
		"Eliminate redundant bounds checks."
	)

DEFINE_FLAG() [3/160]

dart::DEFINE_FLAG	(	bool	,
		basic_flag	,
		true	,
		"Testing of a basic boolean flag."
	)

DEFINE_FLAG() [4/160]

dart::DEFINE_FLAG	(	bool	,
		check_code_pointer	,
		false	,
		"Verify instructions offset in code object." "NOTE: This breaks the profiler."
	)

DEFINE_FLAG() [5/160]

dart::DEFINE_FLAG	(	bool	,
		check_reloaded	,
		false	,
		"Assert that an isolate has reloaded at least once."
	)

DEFINE_FLAG() [6/160]

dart::DEFINE_FLAG	(	bool	,
		compress_deopt_info	,
		true	,
		"Compress the size of the deoptimization info for optimized code."
	)

DEFINE_FLAG() [7/160]

dart::DEFINE_FLAG	(	bool	,
		dead_store_elimination	,
		true	,
		"Eliminate dead stores"
	)

DEFINE_FLAG() [8/160]

dart::DEFINE_FLAG	(	bool	,
		disable_heap_verification	,
		false	,
		"Explicitly disable heap verification."
	)

DEFINE_FLAG() [9/160]

dart::DEFINE_FLAG	(	bool	,
		disable_thread_pool_limit	,
		false	,
		"Disables the limit of the thread pool (simulates custom embedder " "with custom message handler on unlimited number of threads)."
	)

DEFINE_FLAG() [10/160]

dart::DEFINE_FLAG	(	bool	,
		dump_tables	,
		false	,
		"Dump common hash tables before snapshotting."
	)

DEFINE_FLAG() [11/160]

dart::DEFINE_FLAG	(	bool	,
		enable_deprecated_wait_for	,
		false	,
		"Enable deprecated dart:cli waitFor. " "This feature will be fully removed in Dart 3.4 release. " "See https://dartbug.com/52121."
	)

DEFINE_FLAG() [12/160]

dart::DEFINE_FLAG	(	bool	,
		enable_fast_object_copy	,
		true	,
		"Enable fast path for fast object copy."
	)

DEFINE_FLAG() [13/160]

dart::DEFINE_FLAG	(	bool	,
		enable_peephole	,
		true	,
		"Enable peephole optimization"
	)

DEFINE_FLAG() [14/160]

dart::DEFINE_FLAG	(	bool	,
		enable_simd_inline	,
		true	,
		"Enable inlining of SIMD related method calls."
	)

DEFINE_FLAG() [15/160]

dart::DEFINE_FLAG	(	bool	,
		force_evacuation	,
		false	,
		"Force compaction to move every movable object"
	)

DEFINE_FLAG() [16/160]

dart::DEFINE_FLAG	(	bool	,
		force_indirect_calls	,
		false	,
		"Do not emit PC relative calls."
	)

DEFINE_FLAG() [17/160]

dart::DEFINE_FLAG	(	bool	,
		force_log_flush	,
		false	,
		"Always flush log messages."
	)

DEFINE_FLAG() [18/160]

dart::DEFINE_FLAG	(	bool	,
		gc_on_foc_slow_path	,
		false	,
		"Cause a GC when falling off the fast path for fast object copy."
	)

DEFINE_FLAG() [19/160]

dart::DEFINE_FLAG	(	bool	,
		identity_reload	,
		false	,
		"Enable checks for identity reload."
	)

DEFINE_FLAG() [20/160]

dart::DEFINE_FLAG	(	bool	,
		ignore_unrecognized_flags	,
		false	,
		"Ignore unrecognized flags."
	)

DEFINE_FLAG() [21/160]

dart::DEFINE_FLAG	(	bool	,
		include_inlining_info_in_disassembly	,
		true	,
		"Include inlining information when printing disassembly"
	)

Definition at line 28 of file disassembler.cc.

                                                       {
  const int kHexColumnWidth = 23;
#if defined(TARGET_ARCH_IS_32_BIT)
  THR_Print("0x%" Px32 "    %s", static_cast<uint32_t>(pc), hex_buffer);
#else
  THR_Print("0x%" Px64 "    %s", static_cast<uint64_t>(pc), hex_buffer);
#endif
  int hex_length = strlen(hex_buffer);
  if (hex_length < kHexColumnWidth) {
    for (int i = kHexColumnWidth - hex_length; i > 0; i--) {
      THR_Print(" ");
    }
  }
  THR_Print("%s", human_buffer);
  if (object != nullptr) {
    THR_Print("   %s", object->ToCString());
  }
  THR_Print("\n");
}

DEFINE_FLAG() [22/160]

dart::DEFINE_FLAG	(	bool	,
		intrinsify	,
		true	,
		"Instrinsify when possible"
	)

DEFINE_FLAG() [23/160]

dart::DEFINE_FLAG	(	bool	,
		load_cse	,
		true	,
		"Use redundant load elimination."
	)

DEFINE_FLAG() [24/160]

dart::DEFINE_FLAG	(	bool	,
		log_growth	,
		false	,
		"Log PageSpace growth policy decisions."
	)

DEFINE_FLAG() [25/160]

dart::DEFINE_FLAG	(	bool	,
		optimize_lazy_initializer_calls	,
		true	,
		"Eliminate redundant lazy initializer calls."
	)

DEFINE_FLAG() [26/160]

dart::DEFINE_FLAG	(	bool	,
		parse_flag_bool_test	,
		true	,
		"Flags::Parse (bool) testing"
	)

DEFINE_FLAG() [27/160]

dart::DEFINE_FLAG	(	bool	,
		print_class_table	,
		false	,
		"Print initial class table."
	)

DEFINE_FLAG() [28/160]

dart::DEFINE_FLAG	(	bool	,
		print_classes	,
		false	,
		"Prints details about loaded classes."
	)

DEFINE_FLAG() [29/160]

dart::DEFINE_FLAG	(	bool	,
		print_cluster_information	,
		false	,
		"Print information about clusters written to snapshot"
	)

DEFINE_FLAG() [30/160]

dart::DEFINE_FLAG	(	bool	,
		print_code_source_map	,
		false	,
		"Print code source map."
	)

DEFINE_FLAG() [31/160]

dart::DEFINE_FLAG	(	bool	,
		print_flags	,
		false	,
		"Print flags as they are being parsed."
	)

DEFINE_FLAG() [32/160]

dart::DEFINE_FLAG	(	bool	,
		print_flow_graph	,
		false	,
		"Print the IR flow graph."
	)

DEFINE_FLAG() [33/160]

dart::DEFINE_FLAG	(	bool	,
		print_flow_graph_optimized	,
		false	,
		"Print the IR flow graph when optimizing."
	)

DEFINE_FLAG() [34/160]

dart::DEFINE_FLAG	(	bool	,
		print_free_list_after_gc	,
		false	,
		"Print free list statistics after a GC"
	)

DEFINE_FLAG() [35/160]

dart::DEFINE_FLAG	(	bool	,
		print_free_list_before_gc	,
		false	,
		"Print free list statistics before a GC"
	)

DEFINE_FLAG() [36/160]

dart::DEFINE_FLAG	(	bool	,
		print_huge_methods	,
		false	,
		"Print huge methods (less optimized)"
	)

DEFINE_FLAG() [37/160]

dart::DEFINE_FLAG	(	bool	,
		print_ic_data_map	,
		false	,
		"Print the deopt-id to ICData map in optimizing compiler."
	)

DEFINE_FLAG() [38/160]

dart::DEFINE_FLAG	(	bool	,
		print_inlining_tree	,
		false	,
		"Print inlining tree"
	)

DEFINE_FLAG() [39/160]

dart::DEFINE_FLAG	(	bool	,
		print_metrics	,
		false	,
		"Print metrics when isolates (and the VM) are shutdown."
	)

DEFINE_FLAG() [40/160]

dart::DEFINE_FLAG	(	bool	,
		print_precompiler_timings	,
		false	,
		"Print per-phase breakdown of time spent precompiling"
	)

DEFINE_FLAG() [41/160]

dart::DEFINE_FLAG	(	bool	,
		print_stacktrace_at_throw	,
		false	,
		"Prints a stack trace everytime a throw occurs."
	)

DEFINE_FLAG() [42/160]

dart::DEFINE_FLAG	(	bool	,
		print_type_testing_stub_test_headers	,
		true	,
		"Print headers for executed type testing stub tests"
	)

DEFINE_FLAG() [43/160]

dart::DEFINE_FLAG	(	bool	,
		print_unique_targets	,
		false	,
		"Print unique dynamic targets"
	)

DEFINE_FLAG() [44/160]

dart::DEFINE_FLAG	(	bool	,
		profile_vm	,
		false	,
		"Always collect native stack traces."
	)

DEFINE_FLAG() [45/160]

dart::DEFINE_FLAG	(	bool	,
		profile_vm_allocation	,
		false	,
		"Collect native stack traces when tracing Dart allocations."
	)

DEFINE_FLAG() [46/160]

dart::DEFINE_FLAG	(	bool	,
		propagate_ic_data	,
		true	,
		"Propagate IC data from unoptimized to optimized IC calls."
	)

DEFINE_FLAG() [47/160]

dart::DEFINE_FLAG	(	bool	,
		prune_dead_locals	,
		true	,
		"optimize dead locals away"
	)

DEFINE_FLAG() [48/160]

dart::DEFINE_FLAG	(	bool	,
		reload_every_back_off	,
		false	,
		"Double the --reload-every value after each reload."
	)

DEFINE_FLAG() [49/160]

dart::DEFINE_FLAG	(	bool	,
		reload_every_optimized	,
		true	,
		"Only from optimized code."
	)

DEFINE_FLAG() [50/160]

dart::DEFINE_FLAG	(	bool	,
		reload_force_rollback	,
		false	,
		"Force all reloads to fail and rollback."
	)

DEFINE_FLAG() [51/160]

dart::DEFINE_FLAG	(	bool	,
		remove_redundant_phis	,
		true	,
		"Remove redundant phis."
	)

DEFINE_FLAG() [52/160]

dart::DEFINE_FLAG	(	bool	,
		remove_script_timestamps_for_test	,
		false	,
		"Remove script timestamps to allow for deterministic testing."
	)

DEFINE_FLAG() [53/160]

dart::DEFINE_FLAG	(	bool	,
		runtime_allocate_old	,
		false	,
		"Use old-space for allocation via runtime calls."
	)

DEFINE_FLAG() [54/160]

dart::DEFINE_FLAG	(	bool	,
		runtime_allocate_spill_tlab	,
		false	,
		"Ensure results of allocation via runtime calls are not in an " "active TLAB."
	)

DEFINE_FLAG() [55/160]

dart::DEFINE_FLAG	(	bool	,
		service_testing_flag	,
		false	,
		"Comment"
	)

DEFINE_FLAG() [56/160]

dart::DEFINE_FLAG	(	bool	,
		share_enclosing_context	,
		true	,
		"Allocate captured variables in the existing context of an " "enclosing scope (up to innermost loop) and spare the allocation " "of a local context."
	)

DEFINE_FLAG() [57/160]

dart::DEFINE_FLAG	(	bool	,
		show_internal_names	,
		false	,
		"Show names of internal classes (e.g. \"OneByteString\") in error messages " "instead of showing the corresponding interface names (e.g. \"String\"). " "Also show legacy nullability in type names."
	)

DEFINE_FLAG() [58/160]

dart::DEFINE_FLAG	(	bool	,
		silent_warnings	,
		false	,
		"Silence warnings."
	)

DEFINE_FLAG() [59/160]

dart::DEFINE_FLAG	(	bool	,
		source_lines	,
		false	,
		"Emit source line as assembly comment."
	)

DEFINE_FLAG() [60/160]

dart::DEFINE_FLAG	(	bool	,
		stop_on_excessive_deoptimization	,
		false	,
		"Debugging: stops program if deoptimizing same function too often"
	)

DEFINE_FLAG() [61/160]

dart::DEFINE_FLAG	(	bool	,
		stress_test_background_compilation	,
		false	,
		"Keep background compiler running all the time"
	)

DEFINE_FLAG() [62/160]

dart::DEFINE_FLAG	(	bool	,
		test_il_serialization	,
		false	,
		"Test IL serialization."
	)

DEFINE_FLAG() [63/160]

dart::DEFINE_FLAG	(	bool	,
		trace_bailout	,
		false	,
		"Print bailout from ssa compiler."
	)

DEFINE_FLAG() [64/160]

dart::DEFINE_FLAG	(	bool	,
		trace_class_finalization	,
		false	,
		"Trace class finalization."
	)

DEFINE_FLAG() [65/160]

dart::DEFINE_FLAG	(	bool	,
		trace_compiler	,
		false	,
		"Trace compiler operations."
	)

DEFINE_FLAG() [66/160]

dart::DEFINE_FLAG	(	bool	,
		trace_constant_propagation	,
		false	,
		"Print constant propagation and useless code elimination."
	)

DEFINE_FLAG() [67/160]

dart::DEFINE_FLAG	(	bool	,
		trace_debugger_stacktrace	,
		false	,
		"Trace debugger stacktrace collection"
	)

DEFINE_FLAG() [68/160]

dart::DEFINE_FLAG	(	bool	,
		trace_deoptimization	,
		false	,
		"Trace deoptimization"
	)

DEFINE_FLAG() [69/160]

dart::DEFINE_FLAG	(	bool	,
		trace_deoptimization_verbose	,
		false	,
		"Trace deoptimization verbose"
	)

DEFINE_FLAG() [70/160]

dart::DEFINE_FLAG	(	bool	,
		trace_failed_optimization_attempts	,
		false	,
		"Traces all failed optimization attempts"
	)

DEFINE_FLAG() [71/160]

dart::DEFINE_FLAG	(	bool	,
		trace_inlining	,
		false	,
		"Trace inlining"
	)

DEFINE_FLAG() [72/160]

dart::DEFINE_FLAG	(	bool	,
		trace_inlining_intervals	,
		false	,
		"Inlining interval diagnostics"
	)

DEFINE_FLAG() [73/160]

dart::DEFINE_FLAG	(	bool	,
		trace_integer_ir_selection	,
		false	,
		"Print integer IR selection optimization pass."
	)

DEFINE_FLAG() [74/160]

dart::DEFINE_FLAG	(	bool	,
		trace_intrinsifier	,
		false	,
		"Trace intrinsifier"
	)

DEFINE_FLAG() [75/160]

dart::DEFINE_FLAG	(	bool	,
		trace_kernel	,
		false	,
		"Trace Kernel service requests."
	)

DEFINE_FLAG() [76/160]

dart::DEFINE_FLAG	(	bool	,
		trace_load_optimization	,
		false	,
		"Print live sets for load optimization pass."
	)

DEFINE_FLAG() [77/160]

dart::DEFINE_FLAG	(	bool	,
		trace_optimizing_compiler	,
		false	,
		"Trace only optimizing compiler operations."
	)

DEFINE_FLAG() [78/160]

dart::DEFINE_FLAG	(	bool	,
		trace_osr	,
		false	,
		"Trace attempts at on-stack replacement."
	)

DEFINE_FLAG() [79/160]

dart::DEFINE_FLAG	(	bool	,
		trace_precompiler	,
		false	,
		"Trace precompiler."
	)

DEFINE_FLAG() [80/160]

dart::DEFINE_FLAG	(	bool	,
		trace_profiled_isolates	,
		false	,
		"Trace profiled isolates."
	)

DEFINE_FLAG() [81/160]

dart::DEFINE_FLAG	(	bool	,
		trace_range_analysis	,
		false	,
		"Trace range analysis progress"
	)

DEFINE_FLAG() [82/160]

dart::DEFINE_FLAG	(	bool	,
		trace_regexp_bytecodes	,
		false	,
		"trace_regexp_bytecodes"
	)

DEFINE_FLAG() [83/160]

dart::DEFINE_FLAG	(	bool	,
		trace_reload	,
		false	,
		"Trace isolate reloading"
	)

DEFINE_FLAG() [84/160]

dart::DEFINE_FLAG	(	bool	,
		trace_reload_verbose	,
		false	,
		"trace isolate reloading verbose"
	)

DEFINE_FLAG() [85/160]

dart::DEFINE_FLAG	(	bool	,
		trace_resolving	,
		false	,
		"Trace resolving."
	)

DEFINE_FLAG() [86/160]

dart::DEFINE_FLAG	(	bool	,
		trace_rewind	,
		false	,
		"Trace frame rewind"
	)

DEFINE_FLAG() [87/160]

dart::DEFINE_FLAG	(	bool	,
		trace_safepoint	,
		false	,
		"Trace Safepoint logic."
	)

DEFINE_FLAG() [88/160]

dart::DEFINE_FLAG	(	bool	,
		trace_service	,
		false	,
		"Trace VM service requests."
	)

DEFINE_FLAG() [89/160]

dart::DEFINE_FLAG	(	bool	,
		trace_service_pause_events	,
		false	,
		"Trace VM service isolate pause events."
	)

DEFINE_FLAG() [90/160]

dart::DEFINE_FLAG	(	bool	,
		trace_service_verbose	,
		false	,
		"Provide extra service tracing information."
	)

DEFINE_FLAG() [91/160]

dart::DEFINE_FLAG	(	bool	,
		trace_shutdown	,
		false	,
		"Trace VM shutdown on stderr"
	)

DEFINE_FLAG() [92/160]

dart::DEFINE_FLAG	(	bool	,
		trace_source_positions	,
		false	,
		"Source position diagnostics"
	)

DEFINE_FLAG() [93/160]

dart::DEFINE_FLAG	(	bool	,
		trace_thread_interrupter	,
		false	,
		"Trace thread interrupter"
	)

DEFINE_FLAG() [94/160]

dart::DEFINE_FLAG	(	bool	,
		trace_type_finalization	,
		false	,
		"Trace type finalization."
	)

DEFINE_FLAG() [95/160]

dart::DEFINE_FLAG	(	bool	,
		trace_type_propagation	,
		false	,
		"Trace flow graph type propagation"
	)

DEFINE_FLAG() [96/160]

dart::DEFINE_FLAG	(	bool	,
		trace_type_testing_stub_tests	,
		false	,
		"Trace type testing stub tests"
	)

DEFINE_FLAG() [97/160]

dart::DEFINE_FLAG	(	bool	,
		two_args_smi_icd	,
		true	,
		"Generate special IC stubs for two args Smi operations"
	)

DEFINE_FLAG() [98/160]

dart::DEFINE_FLAG	(	bool	,
		unopt_megamorphic_calls	,
		true	,
		"Enable specializing megamorphic calls from unoptimized code."
	)

DEFINE_FLAG() [99/160]

dart::DEFINE_FLAG	(	bool	,
		unopt_monomorphic_calls	,
		true	,
		"Enable specializing monomorphic calls from unoptimized code."
	)

DEFINE_FLAG() [100/160]

dart::DEFINE_FLAG	(	bool	,
		use_register_cc	,
		true	,
		"Use register calling conventions"
	)

DEFINE_FLAG() [101/160]

dart::DEFINE_FLAG	(	bool	,
		verbose_debug	,
		false	,
		"Verbose debugger messages"
	)

DEFINE_FLAG() [102/160]

dart::DEFINE_FLAG	(	bool	,
		verbose_stack_overflow	,
		false	,
		"Print additional details about stack overflow."
	)

DEFINE_FLAG() [103/160]

dart::DEFINE_FLAG	(	bool	,
		verify_acquired_data	,
		false	,
		"Verify correct API acquire/release of typed data."
	)

DEFINE_FLAG() [104/160]

dart::DEFINE_FLAG	(	bool	,
		warn_on_pause_with_no_debugger	,
		false	,
		"Print a message when an isolate is paused but there is no " "debugger attached."
	)

DEFINE_FLAG() [105/160]

dart::DEFINE_FLAG	(	bool	,
		warning_as_error	,
		false	,
		"Treat warnings as errors."
	)

DEFINE_FLAG() [106/160]

dart::DEFINE_FLAG	(	bool	,
		write_protect_code	,
		kShouldWriteProtectCodeByDefault	,
		"Write protect jitted code"
	)

DEFINE_FLAG() [107/160]

dart::DEFINE_FLAG	(	bool	,
		write_protect_vm_isolate	,
		true	,
		"Write protect vm_isolate."
	)

DEFINE_FLAG() [108/160]

dart::DEFINE_FLAG	(	charp	,
		deoptimize_filter	,
		nullptr	,
		"Deoptimize in named function on stack overflow checks"
	)

DEFINE_FLAG() [109/160]

dart::DEFINE_FLAG	(	charp	,
		deoptimize_on_runtime_call_name_filter	,
		nullptr	,
		"Runtime call name filter for --deoptimize-on-runtime-call-every."
	)

DEFINE_FLAG() [110/160]

dart::DEFINE_FLAG	(	charp	,
		entrypoint_test	,
		"main"	,
		"Testing: entrypoint"
	)

DEFINE_FLAG() [111/160]

dart::DEFINE_FLAG	(	charp	,
		inlining_filter	,
		nullptr	,
		"Inline only in named function"
	)

DEFINE_FLAG() [112/160]

dart::DEFINE_FLAG	(	charp	,
		isolate_log_filter	,
		nullptr	,
		"Log isolates whose name include the filter. " "Default: service isolate log messages are suppressed " "(specify 'vm-service' to log them)."
	)

DEFINE_FLAG() [113/160]

dart::DEFINE_FLAG	(	charp	,
		kernel_multiroot_filepaths	,
		nullptr	,
		"Comma-separated list of file paths that should be treated as roots" " by frontend compiler."
	)

DEFINE_FLAG() [114/160]

dart::DEFINE_FLAG	(	charp	,
		kernel_multiroot_scheme	,
		nullptr	,
		"URI scheme that replaces filepaths prefixes specified" " by kernel_multiroot_filepaths option"
	)

DEFINE_FLAG() [115/160]

dart::DEFINE_FLAG	(	charp	,
		log_service_response_sizes	,
		nullptr	,
		"Log sizes of service responses and events to a file in CSV format."
	)

DEFINE_FLAG() [116/160]

dart::DEFINE_FLAG	(	charp	,
		optimization_filter	,
		nullptr	,
		"Optimize only named function"
	)

DEFINE_FLAG() [117/160]

dart::DEFINE_FLAG	(	charp	,
		print_object_layout_to	,
		nullptr	,
		"Print layout of Dart objects to the given file"
	)

DEFINE_FLAG() [118/160]

dart::DEFINE_FLAG	(	charp	,
		redirect_isolate_log_to	,
		nullptr	,
		"Log isolate messages into the given file."
	)

DEFINE_FLAG() [119/160]

dart::DEFINE_FLAG	(	charp	,
		stacktrace_filter	,
		nullptr	,
		"Compute stacktrace in named function on stack overflow checks"
	)

DEFINE_FLAG() [120/160]

dart::DEFINE_FLAG	(	charp	,
		string_opt_test	,
		nullptr	,
		"Testing: string option."
	)

DEFINE_FLAG() [121/160]

dart::DEFINE_FLAG	(	charp	,
		vm_name	,
		"vm"	,
		"The default name of this vm as reported by the VM service " "protocol"
	)

DEFINE_FLAG() [122/160]

dart::DEFINE_FLAG	(	charp	,
		write_retained_reasons_to	,
		nullptr	,
		"Print reasons for retaining objects to the given file"
	)

DEFINE_FLAG() [123/160]

dart::DEFINE_FLAG	(	int	,
		counter	,
		100	,
		"Testing: int flag"
	)

DEFINE_FLAG() [124/160]

dart::DEFINE_FLAG	(	int	,
		deoptimization_counter_inlining_threshold	,
		12	,
		"How many times we allow deoptimization before we stop inlining."
	)

DEFINE_FLAG() [125/160]

dart::DEFINE_FLAG	(	int	,
		early_tenuring_threshold	,
		66	,
		"When more than this percentage of promotion candidates	survive,
		" "promote all survivors of next scavenge."
	)

DEFINE_FLAG() [126/160]

dart::DEFINE_FLAG	(	int	,
		force_log_flush_at_size	,
		0	,
		"Flush log messages when buffer exceeds given size (disabled when 0)."
	)

DEFINE_FLAG() [127/160]

dart::DEFINE_FLAG	(	int	,
		force_switch_dispatch_type	,
		-	1,
		"Force switch statements to use a particular dispatch type: " "-	1 = auto,
		0	= linear scan,
		1	= binary search
	)

DEFINE_FLAG() [128/160]

dart::DEFINE_FLAG	(	int	,
		gc_every	,
		0	,
		"Run major GC on every N stack overflow checks"
	)

DEFINE_FLAG() [129/160]

dart::DEFINE_FLAG	(	int	,
		inline_getters_setters_smaller_than	,
		10	,
		"Always inline getters and setters that have fewer instructions"
	)

DEFINE_FLAG() [130/160]

dart::DEFINE_FLAG	(	int	,
		inlining_callee_call_sites_threshold	,
		1	,
		"Always inline functions containing threshold or fewer calls."
	)

DEFINE_FLAG() [131/160]

dart::DEFINE_FLAG	(	int	,
		inlining_callee_size_threshold	,
		160	,
		"Do not inline callees larger than threshold"
	)

DEFINE_FLAG() [132/160]

dart::DEFINE_FLAG	(	int	,
		inlining_caller_size_threshold	,
		50000	,
		"Stop inlining once caller reaches the threshold."
	)

DEFINE_FLAG() [133/160]

dart::DEFINE_FLAG	(	int	,
		inlining_depth_threshold	,
		6	,
		"Inline function calls up to threshold nesting depth"
	)

DEFINE_FLAG() [134/160]

dart::DEFINE_FLAG	(	int	,
		inlining_hotness	,
		10	,
		"Inline only hotter	calls,
		in percents(0 .. 100);" "default 10%:calls above-equal 10% of max-count are inlined."
	)

DEFINE_FLAG() [135/160]

dart::DEFINE_FLAG	(	int	,
		inlining_recursion_depth_threshold	,
		1	,
		"Inline recursive function calls up to threshold recursion depth."
	)

DEFINE_FLAG() [136/160]

dart::DEFINE_FLAG	(	int	,
		inlining_size_threshold	,
		25	,
		"Always inline functions that have threshold or fewer instructions"
	)

DEFINE_FLAG() [137/160]

dart::DEFINE_FLAG	(	int	,
		inlining_small_leaf_size_threshold	,
		50	,
		"Do not inline leaf callees larger than threshold"
	)

DEFINE_FLAG() [138/160]

dart::DEFINE_FLAG	(	int	,
		max_deoptimization_counter_threshold	,
		16	,
		"How many times we allow deoptimization before we disallow optimization."
	)

DEFINE_FLAG() [139/160]

dart::DEFINE_FLAG	(	int	,
		max_exhaustive_polymorphic_checks	,
		5	,
		"If a call receiver is known to be of at most this many	classes,
		" "generate exhaustive class tests instead of a megamorphic call"
	)

DEFINE_FLAG() [140/160]

dart::DEFINE_FLAG	(	int	,
		max_inlined_per_depth	,
		500	,
		"Max. number of inlined calls per depth"
	)

DEFINE_FLAG() [141/160]

dart::DEFINE_FLAG	(	int	,
		max_profile_depth	,
		Sample::kPCArraySizeInWords *	kMaxSamplesPerTick,
		"Maximum number stack frames walked. Minimum 1. Maximum 255."
	)

DEFINE_FLAG() [142/160]

dart::DEFINE_FLAG	(	int	,
		max_speculative_inlining_attempts	,
		1	,
		"Max number of attempts with speculative inlining (precompilation only)"
	)

DEFINE_FLAG() [143/160]

dart::DEFINE_FLAG	(	int	,
		max_subtype_cache_entries	,
		kDefaultMaxSubtypeCacheEntries	,
		"Maximum number of subtype cache entries (number of checks cached)."
	)

DEFINE_FLAG() [144/160]

dart::DEFINE_FLAG	(	int	,
		min_optimization_counter_threshold	,
		5000	,
		"The minimum invocation count for a function."
	)

DEFINE_FLAG() [145/160]

dart::DEFINE_FLAG	(	int	,
		new_gen_garbage_threshold	,
		90	,
		"Grow new gen when less than this percentage is garbage."
	)

DEFINE_FLAG() [146/160]

dart::DEFINE_FLAG	(	int	,
		new_gen_growth_factor	,
		2	,
		"Grow new gen by this factor."
	)

DEFINE_FLAG() [147/160]

dart::DEFINE_FLAG	(	int	,
		old_gen_growth_rate	,
		280	,
		"The max number of pages the old generation can grow at a time"
	)

DEFINE_FLAG() [148/160]

dart::DEFINE_FLAG	(	int	,
		old_gen_growth_space_ratio	,
		20	,
		"The desired maximum percentage of free space after old gen GC"
	)

DEFINE_FLAG() [149/160]

dart::DEFINE_FLAG	(	int	,
		old_gen_growth_time_ratio	,
		3	,
		"The desired maximum percentage of time spent in old gen GC"
	)

DEFINE_FLAG() [150/160]

dart::DEFINE_FLAG	(	int	,
		optimization_counter_scale	,
		2000	,
		"The scale of invocation	count,
		by size of the function."
	)

DEFINE_FLAG() [151/160]

dart::DEFINE_FLAG	(	int	,
		profile_period	,
		1000	,
		"Time between profiler samples in microseconds. Minimum 50."
	)

DEFINE_FLAG() [152/160]

dart::DEFINE_FLAG	(	int	,
		regexp_backtrack_stack_size_kb	,
		256	,
		"Size of backtracking stack"
	)

DEFINE_FLAG() [153/160]

dart::DEFINE_FLAG	(	int	,
		regexp_optimization_counter_threshold	,
		1000	,
		"RegExp's usage-counter value before it is	optimized,
		-1 means never"
	)

DEFINE_FLAG() [154/160]

dart::DEFINE_FLAG	(	int	,
		reload_every	,
		0	,
		"Reload every N stack overflow checks."
	)

DEFINE_FLAG() [155/160]

dart::DEFINE_FLAG	(	int	,
		reoptimization_counter_threshold	,
		4000	,
		"Counter threshold before a function gets reoptimized."
	)

DEFINE_FLAG() [156/160]

dart::DEFINE_FLAG	(	int	,
		sample_buffer_duration	,
		0	,
		"Defines the size of the profiler sample buffer to contain at least " "N seconds of samples at a given sample rate. If not	provided,
		the " "default is ~4 seconds. Large values will greatly increase memory " "consumption."
	)

DEFINE_FLAG() [157/160]

dart::DEFINE_FLAG	(	int	,
		stacktrace_every	,
		0	,
		"Compute debugger stacktrace on every N stack overflow checks"
	)

DEFINE_FLAG() [158/160]

dart::DEFINE_FLAG	(	int	,
		worker_timeout_millis	,
		5000	,
		"Free workers when they have been idle for this amount of time."
	)

DEFINE_FLAG() [159/160]

dart::DEFINE_FLAG	(	uint64_t	,
		huge_method_cutoff_in_code_size	,
		200000	,
		"Huge method cutoff in unoptimized code size (in bytes)."
	)

DEFINE_FLAG() [160/160]

dart::DEFINE_FLAG	(	uint64_t	,
		random_seed	,
		0	,
		"Override the random seed for debugging."
	)

DEFINE_FLAG_HANDLER() [1/3]

dart::DEFINE_FLAG_HANDLER	(	DeterministicModeHandler	,
		deterministic	,
		"Enable deterministic mode."
	)

DEFINE_FLAG_HANDLER() [2/3]

dart::DEFINE_FLAG_HANDLER	(	DwarfStackTracesHandler	,
		dwarf_stack_traces	,
		"Omit CodeSourceMaps in precompiled snapshots and don't " "symbolize stack traces in the precompiled runtime."
	)

DEFINE_FLAG_HANDLER() [3/3]

dart::DEFINE_FLAG_HANDLER	(	PrecompilationModeHandler	,
		precompilation	,
		"Precompilation mode"
	)

DEFINE_LEAF_RUNTIME_ENTRY() [1/7]

dart::DEFINE_LEAF_RUNTIME_ENTRY	(	bool	,
		TryDoubleAsInteger	,
		1	,
		Thread *	thread
	)

Definition at line 3549 of file runtime_entry.cc.

                                                                       {
  double value = thread->unboxed_double_runtime_arg();
  int64_t int_value = static_cast<int64_t>(value);
  double converted_double = static_cast<double>(int_value);
  if (converted_double != value) {
    return false;
  }
  thread->set_unboxed_int64_runtime_arg(int_value);
  return true;
}

DEFINE_LEAF_RUNTIME_ENTRY() [2/7]

END_LEAF_RUNTIME_ENTRY dart::DEFINE_LEAF_RUNTIME_ENTRY	(	intptr_t	,
		DeoptimizeCopyFrame	,
		2	,
		uword	saved_registers_address,
		uword	is_lazy_deopt
	)

Definition at line 3566 of file runtime_entry.cc.

                                               {
#if !defined(DART_PRECOMPILED_RUNTIME)
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  StackZone zone(thread);
 
  // All registers have been saved below last-fp as if they were locals.
  const uword last_fp =
      saved_registers_address + (kNumberOfSavedCpuRegisters * kWordSize) +
      (kNumberOfSavedFpuRegisters * kFpuRegisterSize) -
      ((runtime_frame_layout.first_local_from_fp + 1) * kWordSize);
 
  // Get optimized code and frame that need to be deoptimized.
  DartFrameIterator iterator(last_fp, thread,
                             StackFrameIterator::kNoCrossThreadIteration);
 
  StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame != nullptr);
  const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
  ASSERT(optimized_code.is_optimized());
  const Function& top_function =
      Function::Handle(thread->zone(), optimized_code.function());
  const bool deoptimizing_code = top_function.HasOptimizedCode();
  if (FLAG_trace_deoptimization) {
    const Function& function = Function::Handle(optimized_code.function());
    THR_Print("== Deoptimizing code for '%s', %s, %s\n",
              function.ToFullyQualifiedCString(),
              deoptimizing_code ? "code & frame" : "frame",
              (is_lazy_deopt != 0u) ? "lazy-deopt" : "");
  }
 
  if (is_lazy_deopt != 0u) {
    const uword deopt_pc =
        thread->pending_deopts().FindPendingDeopt(caller_frame->fp());
 
    // N.B.: Update frame before updating pending deopt table. The profiler
    // may attempt a stack walk in between.
    caller_frame->set_pc(deopt_pc);
    ASSERT(caller_frame->pc() == deopt_pc);
    ASSERT(optimized_code.ContainsInstructionAt(caller_frame->pc()));
    thread->pending_deopts().ClearPendingDeoptsAtOrBelow(
        caller_frame->fp(), PendingDeopts::kClearDueToDeopt);
  } else {
    if (FLAG_trace_deoptimization) {
      THR_Print("Eager deopt fp=%" Pp " pc=%" Pp "\n", caller_frame->fp(),
                caller_frame->pc());
    }
  }
 
  // Copy the saved registers from the stack.
  fpu_register_t* fpu_registers;
  intptr_t* cpu_registers;
  CopySavedRegisters(saved_registers_address, &fpu_registers, &cpu_registers);
 
  // Create the DeoptContext.
  DeoptContext* deopt_context = new DeoptContext(
      caller_frame, optimized_code, DeoptContext::kDestIsOriginalFrame,
      fpu_registers, cpu_registers, is_lazy_deopt != 0, deoptimizing_code);
  isolate->set_deopt_context(deopt_context);
 
  // Stack size (FP - SP) in bytes.
  return deopt_context->DestStackAdjustment() * kWordSize;
#else
  UNREACHABLE();
  return 0;
#endif  // !DART_PRECOMPILED_RUNTIME
}

DEFINE_LEAF_RUNTIME_ENTRY() [3/7]

dart::DEFINE_LEAF_RUNTIME_ENTRY	(	uword	,
		EnsureRememberedAndMarkingDeferred	,
		2	,
		uword	object_in,
		Thread *	thread
	)

Definition at line 557 of file runtime_entry.cc.

                                          {
  ObjectPtr object = static_cast<ObjectPtr>(object_in);
 
  // If we eliminate a generational write barriers on allocations of an object
  // we need to ensure it's either a new-space object or it has been added to
  // the remembered set.
  //
  // NOTE: We use static_cast<>() instead of ::RawCast() to avoid handle
  // allocations in debug mode. Handle allocations in leaf runtimes can cause
  // memory leaks because they will allocate into a handle scope from the next
  // outermost runtime code (to which the generated Dart code might not return
  // in a long time).
  bool add_to_remembered_set = true;
  if (object->IsNewObject()) {
    add_to_remembered_set = false;
  } else if (object->IsArray()) {
    const intptr_t length = Array::LengthOf(static_cast<ArrayPtr>(object));
    add_to_remembered_set =
        compiler::target::WillAllocateNewOrRememberedArray(length);
  } else if (object->IsContext()) {
    const intptr_t num_context_variables =
        Context::NumVariables(static_cast<ContextPtr>(object));
    add_to_remembered_set =
        compiler::target::WillAllocateNewOrRememberedContext(
            num_context_variables);
  }
 
  if (add_to_remembered_set) {
    object->untag()->EnsureInRememberedSet(thread);
  }
 
  // For incremental write barrier elimination, we need to ensure that the
  // allocation ends up in the new space or else the object needs to added
  // to deferred marking stack so it will be [re]scanned.
  if (thread->is_marking()) {
    thread->DeferredMarkingStackAddObject(object);
  }
 
  return static_cast<uword>(object);
}

DEFINE_LEAF_RUNTIME_ENTRY() [4/7]

END_LEAF_RUNTIME_ENTRY dart::DEFINE_LEAF_RUNTIME_ENTRY	(	void	,
		DeoptimizeFillFrame	,
		1	,
		uword	last_fp
	)

Definition at line 3641 of file runtime_entry.cc.

                                                                       {
#if !defined(DART_PRECOMPILED_RUNTIME)
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  StackZone zone(thread);
 
  DeoptContext* deopt_context = isolate->deopt_context();
  DartFrameIterator iterator(last_fp, thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame != nullptr);
 
#if defined(DEBUG)
  {
    // The code from the deopt_context.
    const Code& code = Code::Handle(deopt_context->code());
 
    // The code from our frame.
    const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
    const Function& function = Function::Handle(optimized_code.function());
    ASSERT(!function.IsNull());
 
    // The code will be the same as before.
    ASSERT(code.ptr() == optimized_code.ptr());
 
    // Some sanity checking of the optimized code.
    ASSERT(!optimized_code.IsNull() && optimized_code.is_optimized());
  }
#endif
 
  deopt_context->set_dest_frame(caller_frame);
  deopt_context->FillDestFrame();
 
#else
  UNREACHABLE();
#endif  // !DART_PRECOMPILED_RUNTIME
}

DEFINE_LEAF_RUNTIME_ENTRY() [5/7]

END_LEAF_RUNTIME_ENTRY dart::DEFINE_LEAF_RUNTIME_ENTRY	(	void	,
		MarkingStackBlockProcess	,
		1	,
		Thread *	thread
	)

Definition at line 18 of file pointer_block.cc.

                                                                             {
  thread->MarkingStackBlockProcess();
}

DEFINE_LEAF_RUNTIME_ENTRY() [6/7]

dart::DEFINE_LEAF_RUNTIME_ENTRY	(	void	,
		RememberCard	,
		2	,
		uword	object_in,
		ObjectPtr *	slot
	)

Definition at line 763 of file raw_object.cc.

                                           {
  ObjectPtr object = static_cast<ObjectPtr>(object_in);
  ASSERT(object->IsOldObject());
  ASSERT(object->untag()->IsCardRemembered());
  Page::Of(object)->RememberCard(slot);
}

DEFINE_LEAF_RUNTIME_ENTRY() [7/7]

dart::DEFINE_LEAF_RUNTIME_ENTRY	(	void	,
		StoreBufferBlockProcess	,
		1	,
		Thread *	thread
	)

Definition at line 13 of file pointer_block.cc.

                                                                            {
  thread->StoreBufferBlockProcess(StoreBuffer::kCheckThreshold);
}

DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION() [1/5]

template<typename Instr , typename Out , typename T0 >

dart::DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION	(	1	,
		(T0)
	)

DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION() [2/5]

template<typename Instr , typename Out , typename T0 , typename T1 >

dart::DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION	(	2	,
		(T0, T1)
	)

DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION() [3/5]

template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 >

dart::DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION	(	3	,
		(T0, T1, T2)
	)

DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION() [4/5]

template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 , typename T3 >

dart::DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION	(	4	,
		(T0, T1, T2, T3)
	)

DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION() [5/5]

template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >

dart::DEFINE_MAKE_LOCATION_SUMMARY_SPECIALIZATION	(	5	,
		(T0, T1, T2, T3, T4)
	)

DEFINE_NATIVE_ENTRY() [1/345]

dart::DEFINE_NATIVE_ENTRY	(	AbstractType_equality	,
		0	,
		2
	)

Definition at line 247 of file object.cc.

                                                 {
  const AbstractType& type =
      AbstractType::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Instance& other =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(1));
  if (type.ptr() == other.ptr()) {
    return Bool::True().ptr();
  }
  return Bool::Get(type.IsEquivalent(other, TypeEquality::kSyntactical)).ptr();
}

DEFINE_NATIVE_ENTRY() [2/345]

dart::DEFINE_NATIVE_ENTRY	(	AbstractType_getHashCode	,
		0	,
		1
	)

Definition at line 238 of file object.cc.

                                                    {
  const AbstractType& type =
      AbstractType::CheckedHandle(zone, arguments->NativeArgAt(0));
  intptr_t hash_val = type.Hash();
  ASSERT(hash_val > 0);
  ASSERT(Smi::IsValid(hash_val));
  return Smi::New(hash_val);
}

DEFINE_NATIVE_ENTRY() [3/345]

dart::DEFINE_NATIVE_ENTRY	(	AbstractType_toString	,
		0	,
		1
	)

Definition at line 232 of file object.cc.

                                                 {
  const AbstractType& type =
      AbstractType::CheckedHandle(zone, arguments->NativeArgAt(0));
  return type.UserVisibleName();
}

DEFINE_NATIVE_ENTRY() [4/345]

dart::DEFINE_NATIVE_ENTRY	(	AssertionError_throwNew	,
		0	,
		3
	)

Definition at line 67 of file errors.cc.

                                                   {
  // No need to type check the arguments. This function can only be called
  // internally from the VM.
  const TokenPosition assertion_start = TokenPosition::Deserialize(
      Smi::CheckedHandle(zone, arguments->NativeArgAt(0)).Value());
  const TokenPosition assertion_end = TokenPosition::Deserialize(
      Smi::CheckedHandle(zone, arguments->NativeArgAt(1)).Value());
 
  const Instance& message =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(2));
  const Array& args = Array::Handle(zone, Array::New(5));
 
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  iterator.NextFrame();  // Skip native call.
  const Script& script = Script::Handle(FindScript(&iterator));
 
  // Initialize argument 'failed_assertion' with source snippet.
  auto& condition_text = String::Handle();
  // Extract the assertion condition text (if source is available).
  intptr_t from_line = -1, from_column = -1;
  String& url = String::Handle();
  if (!script.IsNull()) {
    if (script.GetTokenLocation(assertion_start, &from_line, &from_column)) {
      // Extract the assertion condition text (if source is available).
      intptr_t to_line, to_column;
      script.GetTokenLocation(assertion_end, &to_line, &to_column);
      condition_text =
          script.GetSnippet(from_line, from_column, to_line, to_column);
    }
    url = script.url();
  }
  if (condition_text.IsNull()) {
    condition_text = Symbols::OptimizedOut().ptr();
  }
  args.SetAt(0, condition_text);
 
  // Initialize location arguments starting at position 1.
  args.SetAt(1, url);
  args.SetAt(2, Smi::Handle(Smi::New(from_line)));
  args.SetAt(3, Smi::Handle(Smi::New(from_column)));
  args.SetAt(4, message);
 
  Exceptions::ThrowByType(Exceptions::kAssertion, args);
  UNREACHABLE();
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [5/345]

dart::DEFINE_NATIVE_ENTRY	(	AssertionError_throwNewSource	,
		0	,
		5
	)

Definition at line 122 of file errors.cc.

                                                         {
  // No need to type check the arguments. This function can only be called
  // internally from the VM.
  const String& failed_assertion =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  const String& script_url =
      String::CheckedHandle(zone, arguments->NativeArgAt(1));
  const intptr_t line =
      Smi::CheckedHandle(zone, arguments->NativeArgAt(2)).Value();
  const intptr_t column =
      Smi::CheckedHandle(zone, arguments->NativeArgAt(3)).Value();
  const Instance& message =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(4));
 
  const Array& args = Array::Handle(zone, Array::New(5));
 
  args.SetAt(0, failed_assertion);
  args.SetAt(1, script_url);
  args.SetAt(2, Smi::Handle(zone, Smi::New(line)));
  args.SetAt(3, Smi::Handle(zone, Smi::New(column)));
  args.SetAt(4, message);
 
  Exceptions::ThrowByType(Exceptions::kAssertion, args);
  UNREACHABLE();
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [6/345]

dart::DEFINE_NATIVE_ENTRY	(	AsyncStarMoveNext_debuggerStepCheck	,
		0	,
		1
	)

Definition at line 14 of file async.cc.

                                                               {
#if !defined(PRODUCT)
  GET_NON_NULL_NATIVE_ARGUMENT(Closure, generator, arguments->NativeArgAt(0));
  Debugger* debugger = isolate->debugger();
  if (debugger != nullptr && debugger->IsSingleStepping()) {
    debugger->AsyncStepInto(generator);
  }
#endif
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [7/345]

dart::DEFINE_NATIVE_ENTRY	(	Bool_fromEnvironment	,
		0	,
		3
	)

Definition at line 19 of file bool.cc.

                                                {
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(1));
  GET_NATIVE_ARGUMENT(Bool, default_value, arguments->NativeArgAt(2));
  // Call the embedder to supply us with the environment.
  const String& env_value =
      String::Handle(Api::GetEnvironmentValue(thread, name));
  if (!env_value.IsNull()) {
    if (Symbols::True().Equals(env_value)) {
      return Bool::True().ptr();
    }
    if (Symbols::False().Equals(env_value)) {
      return Bool::False().ptr();
    }
  }
  return default_value.ptr();
}

DEFINE_NATIVE_ENTRY() [8/345]

dart::DEFINE_NATIVE_ENTRY	(	Bool_hasEnvironment	,
		0	,
		2
	)

Definition at line 36 of file bool.cc.

                                               {
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(1));
  // Call the embedder to supply us with the environment.
  const String& env_value =
      String::Handle(Api::GetEnvironmentValue(thread, name));
  if (!env_value.IsNull()) {
    return Bool::True().ptr();
  }
  return Bool::False().ptr();
}

DEFINE_NATIVE_ENTRY() [9/345]

dart::DEFINE_NATIVE_ENTRY	(	Capability_equals	,
		0	,
		2
	)

Definition at line 45 of file isolate.cc.

                                             {
  GET_NON_NULL_NATIVE_ARGUMENT(Capability, recv, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Capability, other, arguments->NativeArgAt(1));
  return (recv.Id() == other.Id()) ? Bool::True().ptr() : Bool::False().ptr();
}

DEFINE_NATIVE_ENTRY() [10/345]

dart::DEFINE_NATIVE_ENTRY	(	Capability_factory	,
		0	,
		1
	)

Definition at line 34 of file isolate.cc.

                                              {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
  // Keep capability IDs less than 2^53 so web clients of the service
  // protocol can process it properly.
  //
  // See https://github.com/dart-lang/sdk/issues/53081.
  uint64_t id = isolate->random()->NextJSInt();
  return Capability::New(id);
}

DEFINE_NATIVE_ENTRY() [11/345]

dart::DEFINE_NATIVE_ENTRY	(	Capability_get_hashcode	,
		0	,
		1
	)

Definition at line 51 of file isolate.cc.

                                                   {
  GET_NON_NULL_NATIVE_ARGUMENT(Capability, cap, arguments->NativeArgAt(0));
  int64_t id = cap.Id();
  int32_t hi = static_cast<int32_t>(id >> 32);
  int32_t lo = static_cast<int32_t>(id);
  int32_t hash = (hi ^ lo) & kSmiMax;
  return Smi::New(hash);
}

DEFINE_NATIVE_ENTRY() [12/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_constructors	,
		0	,
		3
	)

Definition at line 1069 of file mirrors.cc.

                                                    {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror,
                               arguments->NativeArgAt(0));
  GET_NATIVE_ARGUMENT(AbstractType, owner_instantiator,
                      arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(2));
  const Class& klass = Class::Handle(ref.GetClassReferent());
 
  const Error& error = Error::Handle(klass.EnsureIsFinalized(thread));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
  }
 
  const Array& functions = Array::Handle(klass.current_functions());
  const intptr_t num_functions = functions.Length();
 
  Instance& constructor_mirror = Instance::Handle();
  const GrowableObjectArray& constructor_mirrors =
      GrowableObjectArray::Handle(GrowableObjectArray::New(num_functions));
 
  Function& func = Function::Handle();
  for (intptr_t i = 0; i < num_functions; i++) {
    func ^= functions.At(i);
    if (func.is_reflectable() &&
        func.kind() == UntaggedFunction::kConstructor) {
      constructor_mirror =
          CreateMethodMirror(func, owner_mirror, owner_instantiator);
      constructor_mirrors.Add(constructor_mirror);
    }
  }
 
  return constructor_mirrors.ptr();
}

DEFINE_NATIVE_ENTRY() [13/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_interfaces	,
		0	,
		1
	)

Definition at line 944 of file mirrors.cc.

                                                  {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  ASSERT(type.IsFinalized());
  const Class& cls = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  const Error& error = Error::Handle(cls.EnsureIsFinalized(thread));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
  }
 
  return cls.interfaces();
}

DEFINE_NATIVE_ENTRY() [14/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_interfaces_instantiated	,
		0	,
		1
	)

Definition at line 959 of file mirrors.cc.

                                                               {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  ASSERT(type.IsFinalized());
  const Class& cls = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  const Error& error = Error::Handle(cls.EnsureIsFinalized(thread));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
  }
 
  Array& interfaces = Array::Handle(cls.interfaces());
  Array& interfaces_inst = Array::Handle(Array::New(interfaces.Length()));
  AbstractType& interface = AbstractType::Handle();
 
  for (int i = 0; i < interfaces.Length(); i++) {
    interface ^= interfaces.At(i);
    interface = InstantiateType(interface, type);
    interfaces_inst.SetAt(i, interface);
  }
 
  return interfaces_inst.ptr();
}

DEFINE_NATIVE_ENTRY() [15/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_invoke	,
		0	,
		5
	)

Definition at line 1302 of file mirrors.cc.

                                              {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Class& klass = Class::Handle(ref.GetClassReferent());
  GET_NON_NULL_NATIVE_ARGUMENT(String, function_name,
                               arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
  RETURN_OR_PROPAGATE(klass.Invoke(function_name, args, arg_names));
}

DEFINE_NATIVE_ENTRY() [16/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_invokeConstructor	,
		0	,
		5
	)

Definition at line 1341 of file mirrors.cc.

                                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  const Class& klass = Class::Handle(ref.GetClassReferent());
  GET_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(String, constructor_name,
                               arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, explicit_args, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
  const Error& error =
      Error::Handle(zone, klass.EnsureIsAllocateFinalized(thread));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
    UNREACHABLE();
  }
 
  // By convention, the static function implementing a named constructor 'C'
  // for class 'A' is labeled 'A.C', and the static function implementing the
  // unnamed constructor for class 'A' is labeled 'A.'.
  // This convention prevents users from explicitly calling constructors.
  const String& klass_name = String::Handle(klass.Name());
  String& external_constructor_name = String::Handle(klass_name.ptr());
  String& internal_constructor_name =
      String::Handle(String::Concat(klass_name, Symbols::Dot()));
  if (!constructor_name.IsNull() && constructor_name.Length() > 0) {
    internal_constructor_name =
        String::Concat(internal_constructor_name, constructor_name);
    external_constructor_name = internal_constructor_name.ptr();
  }
 
  Function& lookup_constructor = Function::Handle(
      Resolver::ResolveFunction(zone, klass, internal_constructor_name));
 
  if (lookup_constructor.IsNull() ||
      (lookup_constructor.kind() != UntaggedFunction::kConstructor) ||
      !lookup_constructor.is_reflectable()) {
    ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                      external_constructor_name, explicit_args, arg_names,
                      InvocationMirror::kConstructor,
                      InvocationMirror::kMethod);
    UNREACHABLE();
  }
 
  if (klass.is_abstract() && !lookup_constructor.IsFactory()) {
    const Array& error_args = Array::Handle(Array::New(3));
    error_args.SetAt(0, klass_name);
    // 1 = script url
    // 2 = token position
    Exceptions::ThrowByType(Exceptions::kAbstractClassInstantiation,
                            error_args);
    UNREACHABLE();
  }
 
  ASSERT(!type.IsNull());
  TypeArguments& type_arguments = TypeArguments::Handle();
  if (!type.IsInstantiated()) {
    // Must have been a declaration type.
    const Type& rare_type = Type::Handle(klass.RareType());
    ASSERT(rare_type.IsInstantiated());
    type_arguments = rare_type.GetInstanceTypeArguments(thread);
  } else {
    type_arguments = type.GetInstanceTypeArguments(thread);
  }
 
  Class& redirected_klass = Class::Handle(klass.ptr());
  const intptr_t num_explicit_args = explicit_args.Length();
  const intptr_t num_implicit_args = 1;
  const Array& args =
      Array::Handle(Array::New(num_implicit_args + num_explicit_args));
 
  // Copy over the explicit arguments.
  Object& explicit_argument = Object::Handle();
  for (int i = 0; i < num_explicit_args; i++) {
    explicit_argument = explicit_args.At(i);
    args.SetAt(i + num_implicit_args, explicit_argument);
  }
 
  const int kTypeArgsLen = 0;
  const Array& args_descriptor_array = Array::Handle(
      ArgumentsDescriptor::NewBoxed(kTypeArgsLen, args.Length(), arg_names));
 
  ArgumentsDescriptor args_descriptor(args_descriptor_array);
  if (!lookup_constructor.AreValidArguments(args_descriptor, nullptr)) {
    external_constructor_name = lookup_constructor.name();
    ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                      external_constructor_name, explicit_args, arg_names,
                      InvocationMirror::kConstructor,
                      InvocationMirror::kMethod);
    UNREACHABLE();
  }
#if defined(DEBUG)
  // Make sure the receiver is the null value, so that DoArgumentTypesMatch does
  // not attempt to retrieve the instantiator type arguments from the receiver.
  explicit_argument = args.At(args_descriptor.FirstArgIndex());
  ASSERT(explicit_argument.IsNull());
#endif
  const Object& type_error =
      Object::Handle(lookup_constructor.DoArgumentTypesMatch(
          args, args_descriptor, type_arguments));
  if (!type_error.IsNull()) {
    Exceptions::PropagateError(Error::Cast(type_error));
    UNREACHABLE();
  }
 
  Instance& new_object = Instance::Handle();
  if (lookup_constructor.IsGenerativeConstructor()) {
    // Constructors get the uninitialized object.
    // Note we have delayed allocation until after the function
    // type and argument matching checks.
    new_object = Instance::New(redirected_klass);
    if (!type_arguments.IsNull()) {
      // The type arguments will be null if the class has no type parameters, in
      // which case the following call would fail because there is no slot
      // reserved in the object for the type vector.
      new_object.SetTypeArguments(type_arguments);
    }
    args.SetAt(0, new_object);
  } else {
    // Factories get type arguments.
    args.SetAt(0, type_arguments);
  }
 
  // Invoke the constructor and return the new object.
  const Object& result = Object::Handle(DartEntry::InvokeFunction(
      lookup_constructor, args, args_descriptor_array));
  if (result.IsError()) {
    Exceptions::PropagateError(Error::Cast(result));
    UNREACHABLE();
  }
 
  // Factories may return null.
  ASSERT(result.IsInstance() || result.IsNull());
 
  if (lookup_constructor.IsGenerativeConstructor()) {
    return new_object.ptr();
  } else {
    return result.ptr();
  }
}

DEFINE_NATIVE_ENTRY() [17/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_invokeGetter	,
		0	,
		3
	)

Definition at line 1315 of file mirrors.cc.

                                                    {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Class& klass = Class::Handle(ref.GetClassReferent());
  const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
    UNREACHABLE();
  }
  GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2));
  RETURN_OR_PROPAGATE(klass.InvokeGetter(getter_name, true));
}

DEFINE_NATIVE_ENTRY() [18/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_invokeSetter	,
		0	,
		4
	)

Definition at line 1330 of file mirrors.cc.

                                                    {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Class& klass = Class::Handle(ref.GetClassReferent());
  GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
  GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
  RETURN_OR_PROPAGATE(klass.InvokeSetter(setter_name, value));
}

DEFINE_NATIVE_ENTRY() [19/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_libraryUri	,
		0	,
		1
	)

Definition at line 913 of file mirrors.cc.

                                                  {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  const Class& klass = Class::Handle(ref.GetClassReferent());
  const Library& library = Library::Handle(klass.library());
  ASSERT(!library.IsNull());
  return library.url();
}

DEFINE_NATIVE_ENTRY() [20/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_members	,
		0	,
		3
	)

Definition at line 1021 of file mirrors.cc.

                                               {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror,
                               arguments->NativeArgAt(0));
  GET_NATIVE_ARGUMENT(AbstractType, owner_instantiator,
                      arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(2));
  const Class& klass = Class::Handle(ref.GetClassReferent());
 
  const Error& error = Error::Handle(klass.EnsureIsFinalized(thread));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
  }
 
  const Array& fields = Array::Handle(klass.fields());
  const intptr_t num_fields = fields.Length();
 
  const Array& functions = Array::Handle(klass.current_functions());
  const intptr_t num_functions = functions.Length();
 
  Instance& member_mirror = Instance::Handle();
  const GrowableObjectArray& member_mirrors = GrowableObjectArray::Handle(
      GrowableObjectArray::New(num_fields + num_functions));
 
  Field& field = Field::Handle();
  for (intptr_t i = 0; i < num_fields; i++) {
    field ^= fields.At(i);
    if (field.is_reflectable()) {
      member_mirror = CreateVariableMirror(field, owner_mirror);
      member_mirrors.Add(member_mirror);
    }
  }
 
  Function& func = Function::Handle();
  for (intptr_t i = 0; i < num_functions; i++) {
    func ^= functions.At(i);
    if (func.is_reflectable() &&
        (func.kind() == UntaggedFunction::kRegularFunction ||
         func.kind() == UntaggedFunction::kGetterFunction ||
         func.kind() == UntaggedFunction::kSetterFunction)) {
      member_mirror =
          CreateMethodMirror(func, owner_mirror, owner_instantiator);
      member_mirrors.Add(member_mirror);
    }
  }
 
  return member_mirrors.ptr();
}

DEFINE_NATIVE_ENTRY() [21/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_mixin	,
		0	,
		1
	)

Definition at line 984 of file mirrors.cc.

                                             {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  ASSERT(type.IsFinalized());
  const Class& cls = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  AbstractType& mixin_type = AbstractType::Handle();
  if (cls.is_transformed_mixin_application()) {
    const Array& interfaces = Array::Handle(cls.interfaces());
    mixin_type ^= interfaces.At(interfaces.Length() - 1);
  }
  ASSERT(mixin_type.IsNull() || mixin_type.IsFinalized());
  return mixin_type.ptr();
}

DEFINE_NATIVE_ENTRY() [22/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_mixin_instantiated	,
		0	,
		2
	)

Definition at line 1000 of file mirrors.cc.

                                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, instantiator,
                               arguments->NativeArgAt(1));
  ASSERT(type.IsFinalized());
  const Class& cls = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  AbstractType& mixin_type = AbstractType::Handle();
  if (cls.is_transformed_mixin_application()) {
    const Array& interfaces = Array::Handle(cls.interfaces());
    mixin_type ^= interfaces.At(interfaces.Length() - 1);
  }
  if (mixin_type.IsNull()) {
    return mixin_type.ptr();
  }
 
  return InstantiateType(mixin_type, instantiator);
}

DEFINE_NATIVE_ENTRY() [23/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_supertype	,
		0	,
		1
	)

Definition at line 921 of file mirrors.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  ASSERT(type.IsFinalized());
  const Class& cls = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  const AbstractType& super_type = AbstractType::Handle(cls.super_type());
  ASSERT(super_type.IsNull() || super_type.IsFinalized());
  return super_type.ptr();
}

DEFINE_NATIVE_ENTRY() [24/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_supertype_instantiated	,
		0	,
		1
	)

Definition at line 933 of file mirrors.cc.

                                                              {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  ASSERT(type.IsFinalized());
  const Class& cls = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  const AbstractType& super_type = AbstractType::Handle(cls.super_type());
  return InstantiateType(super_type, type);
}

DEFINE_NATIVE_ENTRY() [25/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_type_arguments	,
		0	,
		1
	)

Definition at line 1170 of file mirrors.cc.

                                                      {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
 
  const Class& cls = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  const intptr_t num_params = cls.NumTypeParameters();
 
  if (num_params == 0) {
    return Object::empty_array().ptr();
  }
 
  const Array& result = Array::Handle(Array::New(num_params));
  AbstractType& arg_type = AbstractType::Handle();
  Instance& type_mirror = Instance::Handle();
  const TypeArguments& args =
      TypeArguments::Handle(Type::Cast(type).arguments());
 
  // Handle argument lists that have been optimized away, because either no
  // arguments have been provided, or all arguments are dynamic. Return a list
  // of typemirrors on dynamic in this case.
  if (args.IsNull()) {
    arg_type = Object::dynamic_type().ptr();
    type_mirror = CreateTypeMirror(arg_type);
    for (intptr_t i = 0; i < num_params; i++) {
      result.SetAt(i, type_mirror);
    }
    return result.ptr();
  }
 
  ASSERT(args.Length() == num_params);
  for (intptr_t i = 0; i < num_params; i++) {
    arg_type = args.TypeAt(i);
    type_mirror = CreateTypeMirror(arg_type);
    result.SetAt(i, type_mirror);
  }
  return result.ptr();
}

DEFINE_NATIVE_ENTRY() [26/345]

dart::DEFINE_NATIVE_ENTRY	(	ClassMirror_type_variables	,
		0	,
		1
	)

Definition at line 1159 of file mirrors.cc.

                                                      {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  const Class& klass = Class::Handle(ref.GetClassReferent());
  const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
    UNREACHABLE();
  }
  return CreateTypeVariableList(klass);
}

DEFINE_NATIVE_ENTRY() [27/345]

dart::DEFINE_NATIVE_ENTRY	(	Closure_computeHash	,
		0	,
		1
	)

Definition at line 122 of file function.cc.

                                               {
  const Closure& receiver =
      Closure::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Smi::New(receiver.ComputeHash());
}

DEFINE_NATIVE_ENTRY() [28/345]

dart::DEFINE_NATIVE_ENTRY	(	Closure_equals	,
		0	,
		2
	)

Definition at line 114 of file function.cc.

                                          {
  const Closure& receiver =
      Closure::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NATIVE_ARGUMENT(Instance, other, arguments->NativeArgAt(1));
  ASSERT(!other.IsNull());
  return Bool::Get(ClosureEqualsHelper(zone, receiver, other)).ptr();
}

DEFINE_NATIVE_ENTRY() [29/345]

dart::DEFINE_NATIVE_ENTRY	(	ClosureMirror_function	,
		0	,
		1
	)

Definition at line 1263 of file mirrors.cc.

                                                  {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0));
  ASSERT(!closure.IsNull());
 
  Function& function = Function::Handle();
  bool callable = closure.IsCallable(&function);
  if (callable) {
    const Function& parent = Function::Handle(function.parent_function());
    if (function.IsImplicitClosureFunction() || parent.is_extension_member() ||
        parent.is_extension_type_member()) {
      // The VM uses separate Functions for tear-offs, but the mirrors consider
      // the tear-offs to be the same as the torn-off methods. Avoid handing out
      // a reference to the tear-off here to avoid a special case in the
      // the equality test.
      // In the case of extension methods also we avoid handing out a reference
      // to the tear-off and instead get the parent function of the
      // anonymous closure.
      function = parent.ptr();
    }
 
    Type& instantiator = Type::Handle();
    if (closure.IsClosure()) {
      const TypeArguments& arguments = TypeArguments::Handle(
          Closure::Cast(closure).instantiator_type_arguments());
      // TODO(regis): Mirrors need work to properly support generic functions.
      // The 'instantiator' created below should not be a type, but two type
      // argument vectors: instantiator_type_arguments and
      // function_type_arguments.
      const Class& cls = Class::Handle(
          IsolateGroup::Current()->object_store()->object_class());
      instantiator = Type::New(cls, arguments);
      instantiator.SetIsFinalized();
    }
    return CreateMethodMirror(function, Instance::null_instance(),
                              instantiator);
  }
  return Instance::null();
}

DEFINE_NATIVE_ENTRY() [30/345]

dart::DEFINE_NATIVE_ENTRY	(	DartApiDLInitializeData	,
		0	,
		0
	)

Definition at line 96 of file ffi.cc.

                                                   {
  return Integer::New(reinterpret_cast<intptr_t>(&dart_api_data));
}

DEFINE_NATIVE_ENTRY() [31/345]

dart::DEFINE_NATIVE_ENTRY	(	DartApiDLMajorVersion	,
		0	,
		0
	)

Definition at line 78 of file ffi.cc.

                                                 {
  return Integer::New(DART_API_DL_MAJOR_VERSION);
}

DEFINE_NATIVE_ENTRY() [32/345]

dart::DEFINE_NATIVE_ENTRY	(	DartApiDLMinorVersion	,
		0	,
		0
	)

Definition at line 82 of file ffi.cc.

                                                 {
  return Integer::New(DART_API_DL_MINOR_VERSION);
}

DEFINE_NATIVE_ENTRY() [33/345]

dart::DEFINE_NATIVE_ENTRY	(	DartAsync_fatal	,
		0	,
		1
	)

Definition at line 21 of file object.cc.

                                           {
  // The dart:async library code entered an unrecoverable state.
  const Instance& instance =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  const char* msg = instance.ToCString();
  OS::PrintErr("Fatal error in dart:async: %s\n", msg);
  FATAL("%s", msg);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [34/345]

dart::DEFINE_NATIVE_ENTRY	(	DartNativeApiFunctionPointer	,
		0	,
		1
	)

Definition at line 62 of file ffi.cc.

                                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(String, name_dart, arguments->NativeArgAt(0));
  const char* name = name_dart.ToCString();
 
#define RETURN_FUNCTION_ADDRESS(function_name, R, A)                           \
  if (strcmp(name, #function_name) == 0) {                                     \
    return Integer::New(reinterpret_cast<intptr_t>(function_name));            \
  }
  DART_NATIVE_API_DL_SYMBOLS(RETURN_FUNCTION_ADDRESS)
#undef RETURN_FUNCTION_ADDRESS
 
  const String& error = String::Handle(
      String::NewFormatted("Unknown dart_native_api.h symbol: %s.", name));
  Exceptions::ThrowArgumentError(error);
}

DEFINE_NATIVE_ENTRY() [35/345]

dart::DEFINE_NATIVE_ENTRY	(	DateTime_currentTimeMicros	,
		0	,
		0
	)

Definition at line 39 of file date.cc.

                                                      {
  return Integer::New(OS::GetCurrentTimeMicros());
}

DEFINE_NATIVE_ENTRY() [36/345]

dart::DEFINE_NATIVE_ENTRY	(	DateTime_timeZoneName	,
		0	,
		1
	)

Definition at line 17 of file date.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, dart_seconds,
                               arguments->NativeArgAt(0));
  int64_t seconds = dart_seconds.AsInt64Value();
  if (llabs(seconds) > kMaxAllowedSeconds) {
    Exceptions::ThrowArgumentError(dart_seconds);
  }
  const char* name = OS::GetTimeZoneName(seconds);
  return String::New(name);
}

DEFINE_NATIVE_ENTRY() [37/345]

dart::DEFINE_NATIVE_ENTRY	(	DateTime_timeZoneOffsetInSeconds	,
		0	,
		1
	)

Definition at line 28 of file date.cc.

                                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, dart_seconds,
                               arguments->NativeArgAt(0));
  int64_t seconds = dart_seconds.AsInt64Value();
  if (llabs(seconds) > kMaxAllowedSeconds) {
    Exceptions::ThrowArgumentError(dart_seconds);
  }
  int offset = OS::GetTimeZoneOffsetInSeconds(seconds);
  return Integer::New(offset);
}

DEFINE_NATIVE_ENTRY() [38/345]

dart::DEFINE_NATIVE_ENTRY	(	DeclarationMirror_location	,
		0	,
		1
	)

Definition at line 1568 of file mirrors.cc.

                                                      {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(0));
  Object& decl = Object::Handle(zone);
  if (reflectee.IsMirrorReference()) {
    const MirrorReference& decl_ref = MirrorReference::Cast(reflectee);
    decl = decl_ref.referent();
  } else if (reflectee.IsTypeParameter()) {
    decl = reflectee.ptr();
  } else {
    UNREACHABLE();
  }
 
  Script& script = Script::Handle(zone);
  TokenPosition token_pos = TokenPosition::kNoSource;
 
  if (decl.IsFunction()) {
    const Function& func = Function::Cast(decl);
    if (func.IsImplicitConstructor()) {
      // These are synthetic methods; they have no source.
      return Instance::null();
    }
    script = func.script();
    token_pos = func.token_pos();
  } else if (decl.IsClass()) {
    const Class& cls = Class::Cast(decl);
    if (cls.is_synthesized_class() && !cls.is_enum_class()) {
      return Instance::null();  // Synthetic.
    }
    script = cls.script();
    token_pos = cls.token_pos();
  } else if (decl.IsField()) {
    const Field& field = Field::Cast(decl);
    script = field.Script();
    token_pos = field.token_pos();
  } else if (decl.IsTypeParameter()) {
    return Instance::null();
  } else if (decl.IsLibrary()) {
    const Library& lib = Library::Cast(decl);
    if (lib.ptr() == Library::NativeWrappersLibrary()) {
      return Instance::null();  // No source.
    }
    const Array& scripts = Array::Handle(zone, lib.LoadedScripts());
    ASSERT(scripts.Length() > 0);
    script ^= scripts.At(scripts.Length() - 1);
    ASSERT(!script.IsNull());
    const String& uri = String::Handle(zone, script.url());
    return CreateSourceLocation(uri, 1, 1);
  } else {
    FATAL("Unexpected declaration type: %s", decl.ToCString());
  }
 
  ASSERT(!script.IsNull());
  if (token_pos == TokenPosition::kNoSource) {
    return Instance::null();
  }
 
  const String& uri = String::Handle(zone, script.url());
  intptr_t from_line = 0, from_col = 0;
  script.GetTokenLocation(token_pos, &from_line, &from_col);
  return CreateSourceLocation(uri, from_line, from_col);
}

DEFINE_NATIVE_ENTRY() [39/345]

dart::DEFINE_NATIVE_ENTRY	(	DeclarationMirror_metadata	,
		0	,
		1
	)

Definition at line 843 of file mirrors.cc.

                                                      {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(0));
  Object& decl = Object::Handle();
  if (reflectee.IsMirrorReference()) {
    const MirrorReference& decl_ref = MirrorReference::Cast(reflectee);
    decl = decl_ref.referent();
  } else if (reflectee.IsTypeParameter()) {
    decl = reflectee.ptr();
  } else {
    UNREACHABLE();
  }
 
  Class& klass = Class::Handle();
  Library& library = Library::Handle();
 
  if (decl.IsClass()) {
    klass ^= decl.ptr();
    library = klass.library();
  } else if (decl.IsFunction()) {
    klass = Function::Cast(decl).Owner();
    library = klass.library();
  } else if (decl.IsField()) {
    klass = Field::Cast(decl).Owner();
    library = klass.library();
  } else if (decl.IsLibrary()) {
    library ^= decl.ptr();
  } else if (decl.IsTypeParameter()) {
    // There is no reference from a canonical type parameter to its declaration.
    return Object::empty_array().ptr();
  } else {
    return Object::empty_array().ptr();
  }
 
  const Object& metadata = Object::Handle(library.GetMetadata(decl));
  if (metadata.IsError()) {
    Exceptions::PropagateError(Error::Cast(metadata));
  }
  return metadata.ptr();
}

DEFINE_NATIVE_ENTRY() [40/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_debugger	,
		0	,
		2
	)

Definition at line 26 of file developer.cc.

                                              {
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, when, arguments->NativeArgAt(0));
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
  GET_NATIVE_ARGUMENT(String, msg, arguments->NativeArgAt(1));
  Debugger* debugger = isolate->debugger();
  if (debugger == nullptr) {
    return when.ptr();
  }
  if (when.value()) {
    debugger->PauseDeveloper(msg);
  }
#endif
  return when.ptr();
}

DEFINE_NATIVE_ENTRY() [41/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_getIsolateIdFromSendPort	,
		0	,
		1
	)

Definition at line 161 of file developer.cc.

                                                              {
#if defined(PRODUCT)
  return Object::null();
#else
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  int64_t port_id = port.Id();
  return String::NewFormatted(ISOLATE_SERVICE_ID_FORMAT_STRING, port_id);
#endif
}

DEFINE_NATIVE_ENTRY() [42/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_getObjectId	,
		0	,
		1
	)

Definition at line 171 of file developer.cc.

                                                 {
#if defined(PRODUCT)
  return Object::null();
#else
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0));
  JSONStream js;
  RingServiceIdZone& ring_service_id_zone =
      *reinterpret_cast<RingServiceIdZone*>(js.id_zone());
  return String::New(ring_service_id_zone.GetServiceId(instance));
#endif
}

DEFINE_NATIVE_ENTRY() [43/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_getServerInfo	,
		0	,
		1
	)

Definition at line 127 of file developer.cc.

                                                   {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
#if defined(PRODUCT)
  SendNull(port);
  return Object::null();
#else
  ServiceIsolate::WaitForServiceIsolateStartup();
  if (!ServiceIsolate::IsRunning()) {
    SendNull(port);
  } else {
    ServiceIsolate::RequestServerInfo(port);
  }
  return Object::null();
#endif
}

DEFINE_NATIVE_ENTRY() [44/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_getServiceMajorVersion	,
		0	,
		0
	)

Definition at line 105 of file developer.cc.

                                                            {
#if defined(PRODUCT)
  return Smi::New(0);
#else
  return Smi::New(SERVICE_PROTOCOL_MAJOR_VERSION);
#endif
}

DEFINE_NATIVE_ENTRY() [45/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_getServiceMinorVersion	,
		0	,
		0
	)

Definition at line 113 of file developer.cc.

                                                            {
#if defined(PRODUCT)
  return Smi::New(0);
#else
  return Smi::New(SERVICE_PROTOCOL_MINOR_VERSION);
#endif
}

DEFINE_NATIVE_ENTRY() [46/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_inspect	,
		0	,
		1
	)

Definition at line 41 of file developer.cc.

                                             {
  GET_NATIVE_ARGUMENT(Instance, inspectee, arguments->NativeArgAt(0));
#ifndef PRODUCT
  Service::SendInspectEvent(isolate, inspectee);
#endif  // !PRODUCT
  return inspectee.ptr();
}

DEFINE_NATIVE_ENTRY() [47/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_log	,
		0	,
		8
	)

Definition at line 49 of file developer.cc.

                                         {
#if defined(PRODUCT)
  return Object::null();
#else
  GET_NON_NULL_NATIVE_ARGUMENT(String, message, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, timestamp, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, sequence, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, level, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(4));
  GET_NATIVE_ARGUMENT(Instance, dart_zone, arguments->NativeArgAt(5));
  GET_NATIVE_ARGUMENT(Instance, error, arguments->NativeArgAt(6));
  GET_NATIVE_ARGUMENT(Instance, stack_trace, arguments->NativeArgAt(7));
  Service::SendLogEvent(isolate, sequence.AsInt64Value(),
                        timestamp.AsInt64Value(), level.Value(), name, message,
                        dart_zone, error, stack_trace);
  return Object::null();
#endif  // PRODUCT
}

DEFINE_NATIVE_ENTRY() [48/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_lookupExtension	,
		0	,
		1
	)

Definition at line 79 of file developer.cc.

                                                     {
#if defined(PRODUCT)
  return Object::null();
#else
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(0));
  return isolate->LookupServiceExtensionHandler(name);
#endif  // PRODUCT
}

DEFINE_NATIVE_ENTRY() [49/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_NativeRuntime_buildId	,
		0	,
		0
	)

Definition at line 191 of file developer.cc.

                                                           {
#if defined(DART_PRECOMPILED_RUNTIME)
  IsolateGroup* isolate_group = thread->isolate_group();
  ASSERT(isolate_group != nullptr);
  if (const uint8_t* instructions =
          isolate_group->source()->snapshot_instructions) {
    const auto& build_id = OS::GetAppBuildId(instructions);
    if (build_id.data != nullptr) {
      ZoneTextBuffer buffer(zone);
      for (intptr_t i = 0; i < build_id.len; i++) {
        buffer.Printf("%2.2x", build_id.data[i]);
      }
      return String::New(buffer.buffer());
    }
  }
#endif
  return String::null();
}

DEFINE_NATIVE_ENTRY() [50/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_NativeRuntime_writeHeapSnapshotToFile	,
		0	,
		1
	)

Definition at line 210 of file developer.cc.

                                                                           {
#if defined(DART_ENABLE_HEAP_SNAPSHOT_WRITER)
  const String& filename =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  bool successful = false;
  {
    FileHeapSnapshotWriter file_writer(thread, filename.ToCString(),
                                       &successful);
    HeapSnapshotWriter writer(thread, &file_writer);
    writer.Write();
  }
  if (!successful) {
    Exceptions::ThrowUnsupportedError(
        "Could not create & write heapsnapshot to disc. Possibly due to "
        "missing embedder functionality.");
  }
#else
  Exceptions::ThrowUnsupportedError(
      "Heap snapshots are only supported in non-product mode.");
#endif  // !defined(PRODUCT)
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [51/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_postEvent	,
		0	,
		2
	)

Definition at line 68 of file developer.cc.

                                               {
#if defined(PRODUCT)
  return Object::null();
#else
  GET_NON_NULL_NATIVE_ARGUMENT(String, event_kind, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(String, event_data, arguments->NativeArgAt(1));
  Service::SendExtensionEvent(isolate, event_kind, event_data);
  return Object::null();
#endif  // PRODUCT
}

DEFINE_NATIVE_ENTRY() [52/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_reachability_barrier	,
		0	,
		0
	)

Definition at line 183 of file developer.cc.

                                                          {
  IsolateGroup* isolate_group = thread->isolate_group();
  ASSERT(isolate_group != nullptr);
  Heap* heap = isolate_group->heap();
  ASSERT(heap != nullptr);
  return Integer::New(heap->ReachabilityBarrier());
}

DEFINE_NATIVE_ENTRY() [53/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_registerExtension	,
		0	,
		2
	)

Definition at line 88 of file developer.cc.

                                                       {
#if defined(PRODUCT)
  return Object::null();
#else
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, handler, arguments->NativeArgAt(1));
  // We don't allow service extensions to be registered for the
  // service isolate.  This can happen, for example, because the
  // service isolate uses dart:io.  If we decide that we want to start
  // supporting this in the future, it will take some work.
  if (!isolate->is_service_isolate()) {
    isolate->RegisterServiceExtensionHandler(name, handler);
  }
  return Object::null();
#endif  // PRODUCT
}

DEFINE_NATIVE_ENTRY() [54/345]

dart::DEFINE_NATIVE_ENTRY	(	Developer_webServerControl	,
		0	,
		3
	)

Definition at line 143 of file developer.cc.

                                                      {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
#if defined(PRODUCT)
  SendNull(port);
  return Object::null();
#else
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, enabled, arguments->NativeArgAt(1));
  GET_NATIVE_ARGUMENT(Bool, silence_output, arguments->NativeArgAt(2));
  ServiceIsolate::WaitForServiceIsolateStartup();
  if (!ServiceIsolate::IsRunning()) {
    SendNull(port);
  } else {
    ServiceIsolate::ControlWebServer(port, enabled.value(), silence_output);
  }
  return Object::null();
#endif
}

DEFINE_NATIVE_ENTRY() [55/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_add	,
		0	,
		2
	)

Definition at line 32 of file double.cc.

                                      {
  double left = Double::CheckedHandle(zone, arguments->NativeArgAt(0)).value();
  GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
  double right = right_object.value();
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Double_add %f + %f\n", left, right);
  }
  return Double::New(left + right);
}

DEFINE_NATIVE_ENTRY() [56/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_ceil	,
		0	,
		1
	)

Definition at line 130 of file double.cc.

                                       {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Double::New(ceil(arg.value()));
}

DEFINE_NATIVE_ENTRY() [57/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_div	,
		0	,
		2
	)

Definition at line 62 of file double.cc.

                                      {
  double left = Double::CheckedHandle(zone, arguments->NativeArgAt(0)).value();
  GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
  double right = right_object.value();
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Double_div %f / %f\n", left, right);
  }
  return Double::New(Utils::DivideAllowZero(left, right));
}

DEFINE_NATIVE_ENTRY() [58/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_doubleFromInteger	,
		0	,
		2
	)

Definition at line 22 of file double.cc.

                                                    {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, value, arguments->NativeArgAt(1));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Double_doubleFromInteger %s\n", value.ToCString());
  }
  return Double::New(value.AsDoubleValue());
}

DEFINE_NATIVE_ENTRY() [59/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_equal	,
		0	,
		2
	)

Definition at line 103 of file double.cc.

                                        {
  const Double& left = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1));
  bool result = right.IsNull() ? false : (left.value() == right.value());
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Double_equal %s == %s\n", left.ToCString(),
                 right.ToCString());
  }
  return Bool::Get(result).ptr();
}

DEFINE_NATIVE_ENTRY() [60/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_equalToInteger	,
		0	,
		2
	)

Definition at line 114 of file double.cc.

                                                 {
  const Double& left = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1));
  return Bool::Get(left.value() == right.AsDoubleValue()).ptr();
}

DEFINE_NATIVE_ENTRY() [61/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_flipSignBit	,
		0	,
		1
	)

Definition at line 239 of file double.cc.

                                              {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  const double in_val = arg.value();
  const int64_t bits = bit_cast<int64_t, double>(in_val) ^ kSignBitDouble;
  return Double::New(bit_cast<double, int64_t>(bits));
}

DEFINE_NATIVE_ENTRY() [62/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_floor	,
		0	,
		1
	)

Definition at line 125 of file double.cc.

                                        {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Double::New(floor(arg.value()));
}

DEFINE_NATIVE_ENTRY() [63/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_getIsInfinite	,
		0	,
		1
	)

Definition at line 222 of file double.cc.

                                                {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Bool::Get(isinf(arg.value())).ptr();
}

DEFINE_NATIVE_ENTRY() [64/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_getIsNaN	,
		0	,
		1
	)

Definition at line 227 of file double.cc.

                                           {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Bool::Get(isnan(arg.value())).ptr();
}

DEFINE_NATIVE_ENTRY() [65/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_getIsNegative	,
		0	,
		1
	)

Definition at line 232 of file double.cc.

                                                {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  // Include negative zero, infinity.
  double dval = arg.value();
  return Bool::Get(signbit(dval) && !isnan(dval)).ptr();
}

DEFINE_NATIVE_ENTRY() [66/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_greaterThan	,
		0	,
		2
	)

Definition at line 86 of file double.cc.

                                              {
  const Double& left = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1));
  bool result = right.IsNull() ? false : (left.value() > right.value());
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Double_greaterThan %s > %s\n", left.ToCString(),
                 right.ToCString());
  }
  return Bool::Get(result).ptr();
}

DEFINE_NATIVE_ENTRY() [67/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_greaterThanFromInteger	,
		0	,
		2
	)

Definition at line 97 of file double.cc.

                                                         {
  const Double& right = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1));
  return Bool::Get(left.AsDoubleValue() > right.value()).ptr();
}

DEFINE_NATIVE_ENTRY() [68/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_modulo	,
		0	,
		2
	)

Definition at line 72 of file double.cc.

                                         {
  double left = Double::CheckedHandle(zone, arguments->NativeArgAt(0)).value();
  GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
  double right = right_object.value();
  return Double::New(DartModulo(left, right));
}

DEFINE_NATIVE_ENTRY() [69/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_mul	,
		0	,
		2
	)

Definition at line 52 of file double.cc.

                                      {
  double left = Double::CheckedHandle(zone, arguments->NativeArgAt(0)).value();
  GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
  double right = right_object.value();
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Double_mul %f * %f\n", left, right);
  }
  return Double::New(left * right);
}

DEFINE_NATIVE_ENTRY() [70/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_parse	,
		0	,
		3
	)

Definition at line 150 of file double.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, startValue, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, endValue, arguments->NativeArgAt(2));
 
  const intptr_t start = startValue.AsTruncatedUint32Value();
  const intptr_t end = endValue.AsTruncatedUint32Value();
  const intptr_t len = value.Length();
 
  // Indices should be inside the string, and 0 <= start < end <= len.
  if (0 <= start && start < end && end <= len) {
    double double_value;
    if (String::ParseDouble(value, start, end, &double_value)) {
      return Double::New(double_value);
    }
  }
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [71/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_remainder	,
		0	,
		2
	)

Definition at line 79 of file double.cc.

                                            {
  double left = Double::CheckedHandle(zone, arguments->NativeArgAt(0)).value();
  GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
  double right = right_object.value();
  return Double::New(fmod_ieee(left, right));
}

DEFINE_NATIVE_ENTRY() [72/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_round	,
		0	,
		1
	)

Definition at line 120 of file double.cc.

                                        {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Double::New(round(arg.value()));
}

DEFINE_NATIVE_ENTRY() [73/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_sub	,
		0	,
		2
	)

Definition at line 42 of file double.cc.

                                      {
  double left = Double::CheckedHandle(zone, arguments->NativeArgAt(0)).value();
  GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
  double right = right_object.value();
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Double_sub %f - %f\n", left, right);
  }
  return Double::New(left - right);
}

DEFINE_NATIVE_ENTRY() [74/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_toInt	,
		0	,
		1
	)

Definition at line 145 of file double.cc.

                                        {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  return DoubleToInteger(zone, arg.value());
}

DEFINE_NATIVE_ENTRY() [75/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_toString	,
		0	,
		1
	)

Definition at line 169 of file double.cc.

                                           {
  const Number& number = Number::CheckedHandle(zone, arguments->NativeArgAt(0));
  return number.ToString(Heap::kNew);
}

DEFINE_NATIVE_ENTRY() [76/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_toStringAsExponential	,
		0	,
		2
	)

Definition at line 193 of file double.cc.

                                                        {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1));
  double d = arg.value();
  intptr_t fraction_digits_value = fraction_digits.Value();
  if (-1 <= fraction_digits_value && fraction_digits_value <= 20) {
    return DoubleToStringAsExponential(d,
                                       static_cast<int>(fraction_digits_value));
  } else {
    Exceptions::ThrowArgumentError(String::Handle(
        String::New("Illegal arguments to double.toStringAsExponential")));
    return Object::null();
  }
}

DEFINE_NATIVE_ENTRY() [77/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_toStringAsFixed	,
		0	,
		2
	)

Definition at line 174 of file double.cc.

                                                  {
  // The boundaries are exclusive.
  const double kLowerBoundary = -1e21;
  const double kUpperBoundary = 1e21;
 
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1));
  double d = arg.value();
  intptr_t fraction_digits_value = fraction_digits.Value();
  if (0 <= fraction_digits_value && fraction_digits_value <= 20 &&
      kLowerBoundary < d && d < kUpperBoundary) {
    return DoubleToStringAsFixed(d, static_cast<int>(fraction_digits_value));
  } else {
    Exceptions::ThrowArgumentError(String::Handle(
        String::New("Illegal arguments to double.toStringAsFixed")));
    return Object::null();
  }
}

DEFINE_NATIVE_ENTRY() [78/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_toStringAsPrecision	,
		0	,
		2
	)

Definition at line 208 of file double.cc.

                                                      {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, precision, arguments->NativeArgAt(1));
  double d = arg.value();
  intptr_t precision_value = precision.Value();
  if (1 <= precision_value && precision_value <= 21) {
    return DoubleToStringAsPrecision(d, static_cast<int>(precision_value));
  } else {
    Exceptions::ThrowArgumentError(String::Handle(
        String::New("Illegal arguments to double.toStringAsPrecision")));
    return Object::null();
  }
}

DEFINE_NATIVE_ENTRY() [79/345]

dart::DEFINE_NATIVE_ENTRY	(	Double_truncate	,
		0	,
		1
	)

Definition at line 135 of file double.cc.

                                           {
  const Double& arg = Double::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Double::New(trunc(arg.value()));
}

DEFINE_NATIVE_ENTRY() [80/345]

dart::DEFINE_NATIVE_ENTRY	(	Error_throwWithStackTrace	,
		0	,
		2
	)

Definition at line 174 of file errors.cc.

                                                     {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, error, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, stacktrace, arguments->NativeArgAt(1));
  Exceptions::ThrowWithStackTrace(thread, error, stacktrace);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [81/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_createNativeCallableIsolateLocal	,
		1	,
		3
	)

Definition at line 39 of file ffi.cc.

                                                                {
  const auto& trampoline =
      Function::CheckedHandle(zone, arguments->NativeArg0());
  const auto& target = Closure::CheckedHandle(zone, arguments->NativeArgAt(1));
  const bool keep_isolate_alive =
      Bool::CheckedHandle(zone, arguments->NativeArgAt(2)).value();
  return Pointer::New(isolate->CreateIsolateLocalFfiCallback(
      zone, trampoline, target, keep_isolate_alive));
}

DEFINE_NATIVE_ENTRY() [82/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_createNativeCallableListener	,
		1	,
		2
	)

Definition at line 30 of file ffi.cc.

                                                            {
  const auto& send_function =
      Function::CheckedHandle(zone, arguments->NativeArg0());
  const auto& port =
      ReceivePort::CheckedHandle(zone, arguments->NativeArgAt(1));
  return Pointer::New(
      isolate->CreateAsyncFfiCallback(zone, send_function, port.Id()));
}

DEFINE_NATIVE_ENTRY() [83/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_deleteNativeCallable	,
		1	,
		1
	)

Definition at line 49 of file ffi.cc.

                                                    {
  const auto& pointer = Pointer::CheckedHandle(zone, arguments->NativeArg0());
  isolate->DeleteFfiCallback(pointer.NativeAddress());
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [84/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_dl_close	,
		0	,
		1
	)

Definition at line 189 of file ffi_dynamic_library.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(DynamicLibrary, dlib, arguments->NativeArgAt(0));
  if (dlib.IsClosed()) {
    // Already closed, nothing to do
  } else if (!dlib.CanBeClosed()) {
    const String& msg = String::Handle(
        String::New("DynamicLibrary.process() and DynamicLibrary.executable() "
                    "can't be closed."));
    Exceptions::ThrowStateError(msg);
  } else {
    void* handle = dlib.GetHandle();
    char* error = nullptr;
    Utils::UnloadDynamicLibrary(handle, &error);
 
    if (error == nullptr) {
      dlib.SetClosed(true);
    } else {
      const String& msg = String::Handle(String::New(error));
      free(error);
      Exceptions::ThrowStateError(msg);
    }
  }
 
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [85/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_dl_executableLibrary	,
		0	,
		0
	)

Definition at line 185 of file ffi_dynamic_library.cc.

                                                    {
  return DynamicLibrary::New(LoadDynamicLibrary(nullptr), false);
}

DEFINE_NATIVE_ENTRY() [86/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_dl_getHandle	,
		0	,
		1
	)

Definition at line 240 of file ffi_dynamic_library.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(DynamicLibrary, dlib, arguments->NativeArgAt(0));
 
  intptr_t handle = reinterpret_cast<intptr_t>(dlib.GetHandle());
  return Integer::NewFromUint64(handle);
}

DEFINE_NATIVE_ENTRY() [87/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_dl_lookup	,
		1	,
		2
	)

Definition at line 215 of file ffi_dynamic_library.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(DynamicLibrary, dlib, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(String, argSymbolName,
                               arguments->NativeArgAt(1));
 
  if (dlib.IsClosed()) {
    const String& msg =
        String::Handle(String::New("Cannot lookup symbols in closed library."));
    Exceptions::ThrowStateError(msg);
  }
 
  void* handle = dlib.GetHandle();
 
  char* error = nullptr;
  const uword pointer = reinterpret_cast<uword>(
      ResolveSymbol(handle, argSymbolName.ToCString(), &error));
  if (error != nullptr) {
    const String& msg = String::Handle(String::NewFormatted(
        "Failed to lookup symbol '%s': %s", argSymbolName.ToCString(), error));
    free(error);
    Exceptions::ThrowArgumentError(msg);
  }
  return Pointer::New(pointer);
}

DEFINE_NATIVE_ENTRY() [88/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_dl_open	,
		0	,
		1
	)

Definition at line 163 of file ffi_dynamic_library.cc.

                                       {
  GET_NON_NULL_NATIVE_ARGUMENT(String, lib_path, arguments->NativeArgAt(0));
 
  char* error = nullptr;
  void* handle = LoadDynamicLibrary(lib_path.ToCString(), &error);
  if (error != nullptr) {
    const String& msg = String::Handle(String::New(error));
    free(error);
    Exceptions::ThrowArgumentError(msg);
  }
  return DynamicLibrary::New(handle, true);
}

DEFINE_NATIVE_ENTRY() [89/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_dl_processLibrary	,
		0	,
		0
	)

Definition at line 176 of file ffi_dynamic_library.cc.

                                                 {
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_MACOS) ||              \
    defined(DART_HOST_OS_ANDROID) || defined(DART_HOST_OS_FUCHSIA)
  return DynamicLibrary::New(RTLD_DEFAULT, false);
#else
  return DynamicLibrary::New(kWindowsDynamicLibraryProcessPtr, false);
#endif
}

DEFINE_NATIVE_ENTRY() [90/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_dl_providesSymbol	,
		0	,
		2
	)

Definition at line 247 of file ffi_dynamic_library.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(DynamicLibrary, dlib, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(String, argSymbolName,
                               arguments->NativeArgAt(1));
 
  void* handle = dlib.GetHandle();
  return Bool::Get(SymbolExists(handle, argSymbolName.ToCString())).ptr();
}

DEFINE_NATIVE_ENTRY() [91/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_GetFfiNativeResolver	,
		1	,
		0
	)

Definition at line 537 of file ffi_dynamic_library.cc.

                                                    {
  return Pointer::New(reinterpret_cast<intptr_t>(FfiResolve));
}

DEFINE_NATIVE_ENTRY() [92/345]

dart::DEFINE_NATIVE_ENTRY	(	Ffi_updateNativeCallableKeepIsolateAliveCounter	,
		1	,
		1
	)

Definition at line 55 of file ffi.cc.

                                                                           {
  const int64_t delta =
      Integer::CheckedHandle(zone, arguments->NativeArg0()).AsInt64Value();
  isolate->UpdateNativeCallableKeepIsolateAliveCounter(delta);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [93/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_abs	,
		0	,
		1
	)

Definition at line 177 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  float _x = fabsf(self.x());
  float _y = fabsf(self.y());
  float _z = fabsf(self.z());
  float _w = fabsf(self.w());
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [94/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_add	,
		0	,
		2
	)

Definition at line 57 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1));
  float _x = self.x() + other.x();
  float _y = self.y() + other.y();
  float _z = self.z() + other.z();
  float _w = self.w() + other.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [95/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_clamp	,
		0	,
		3
	)

Definition at line 186 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, lo, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, hi, arguments->NativeArgAt(2));
  // The order of the clamping must match the order of the optimized code:
  // MAX(MIN(self, hi), lo).
  float _x;
  float _y;
  float _z;
  float _w;
  // ARM semantics are different from X86/X64 at an instruction level. Ensure
  // that we match the semantics of the architecture in the C version.
#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64) ||                   \
    defined(USING_SIMULATOR)
  _x = self.x() < hi.x() ? self.x() : hi.x();
  _y = self.y() < hi.y() ? self.y() : hi.y();
  _z = self.z() < hi.z() ? self.z() : hi.z();
  _w = self.w() < hi.w() ? self.w() : hi.w();
  _x = lo.x() < _x ? _x : lo.x();
  _y = lo.y() < _y ? _y : lo.y();
  _z = lo.z() < _z ? _z : lo.z();
  _w = lo.w() < _w ? _w : lo.w();
#else
  _x = fminf(self.x(), hi.x());
  _y = fminf(self.y(), hi.y());
  _z = fminf(self.z(), hi.z());
  _w = fminf(self.w(), hi.w());
  _x = fmaxf(_x, lo.x());
  _y = fmaxf(_y, lo.y());
  _z = fmaxf(_z, lo.z());
  _w = fmaxf(_w, lo.w());
#endif
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [96/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_cmpequal	,
		0	,
		2
	)

Definition at line 146 of file simd128.cc.

                                              {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1));
  uint32_t _x = a.x() == b.x() ? 0xFFFFFFFF : 0x0;
  uint32_t _y = a.y() == b.y() ? 0xFFFFFFFF : 0x0;
  uint32_t _z = a.z() == b.z() ? 0xFFFFFFFF : 0x0;
  uint32_t _w = a.w() == b.w() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [97/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_cmpgt	,
		0	,
		2
	)

Definition at line 126 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1));
  uint32_t _x = a.x() > b.x() ? 0xFFFFFFFF : 0x0;
  uint32_t _y = a.y() > b.y() ? 0xFFFFFFFF : 0x0;
  uint32_t _z = a.z() > b.z() ? 0xFFFFFFFF : 0x0;
  uint32_t _w = a.w() > b.w() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [98/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_cmpgte	,
		0	,
		2
	)

Definition at line 136 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1));
  uint32_t _x = a.x() >= b.x() ? 0xFFFFFFFF : 0x0;
  uint32_t _y = a.y() >= b.y() ? 0xFFFFFFFF : 0x0;
  uint32_t _z = a.z() >= b.z() ? 0xFFFFFFFF : 0x0;
  uint32_t _w = a.w() >= b.w() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [99/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_cmplt	,
		0	,
		2
	)

Definition at line 106 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1));
  uint32_t _x = a.x() < b.x() ? 0xFFFFFFFF : 0x0;
  uint32_t _y = a.y() < b.y() ? 0xFFFFFFFF : 0x0;
  uint32_t _z = a.z() < b.z() ? 0xFFFFFFFF : 0x0;
  uint32_t _w = a.w() < b.w() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [100/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_cmplte	,
		0	,
		2
	)

Definition at line 116 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1));
  uint32_t _x = a.x() <= b.x() ? 0xFFFFFFFF : 0x0;
  uint32_t _y = a.y() <= b.y() ? 0xFFFFFFFF : 0x0;
  uint32_t _z = a.z() <= b.z() ? 0xFFFFFFFF : 0x0;
  uint32_t _w = a.w() <= b.w() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [101/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_cmpnequal	,
		0	,
		2
	)

Definition at line 156 of file simd128.cc.

                                               {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1));
  uint32_t _x = a.x() != b.x() ? 0xFFFFFFFF : 0x0;
  uint32_t _y = a.y() != b.y() ? 0xFFFFFFFF : 0x0;
  uint32_t _z = a.z() != b.z() ? 0xFFFFFFFF : 0x0;
  uint32_t _w = a.w() != b.w() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [102/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_div	,
		0	,
		2
	)

Definition at line 96 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1));
  float _x = Utils::DivideAllowZero(self.x(), other.x());
  float _y = Utils::DivideAllowZero(self.y(), other.y());
  float _z = Utils::DivideAllowZero(self.z(), other.z());
  float _w = Utils::DivideAllowZero(self.w(), other.w());
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [103/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_fromDoubles	,
		0	,
		4
	)

Definition at line 21 of file simd128.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, z, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, w, arguments->NativeArgAt(3));
  float _x = static_cast<float>(x.value());
  float _y = static_cast<float>(y.value());
  float _z = static_cast<float>(z.value());
  float _w = static_cast<float>(w.value());
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [104/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_fromFloat64x2	,
		0	,
		2
	)

Definition at line 50 of file simd128.cc.

                                                   {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, v, arguments->NativeArgAt(1));
  float _x = static_cast<float>(v.x());
  float _y = static_cast<float>(v.y());
  return Float32x4::New(_x, _y, 0.0f, 0.0f);
}

DEFINE_NATIVE_ENTRY() [105/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_fromInt32x4Bits	,
		0	,
		2
	)

Definition at line 45 of file simd128.cc.

                                                     {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, v, arguments->NativeArgAt(1));
  return Float32x4::New(v.value());
}

DEFINE_NATIVE_ENTRY() [106/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_getSignMask	,
		0	,
		1
	)

Definition at line 245 of file simd128.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  uint32_t mx = (bit_cast<uint32_t>(self.x()) & 0x80000000) >> 31;
  uint32_t my = (bit_cast<uint32_t>(self.y()) & 0x80000000) >> 31;
  uint32_t mz = (bit_cast<uint32_t>(self.z()) & 0x80000000) >> 31;
  uint32_t mw = (bit_cast<uint32_t>(self.w()) & 0x80000000) >> 31;
  uint32_t value = mx | (my << 1) | (mz << 2) | (mw << 3);
  return Integer::New(value);
}

DEFINE_NATIVE_ENTRY() [107/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_getW	,
		0	,
		1
	)

Definition at line 239 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  double value = static_cast<double>(self.w());
  return Double::New(value);
}

DEFINE_NATIVE_ENTRY() [108/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_getX	,
		0	,
		1
	)

Definition at line 221 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  double value = static_cast<double>(self.x());
  return Double::New(value);
}

DEFINE_NATIVE_ENTRY() [109/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_getY	,
		0	,
		1
	)

Definition at line 227 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  double value = static_cast<double>(self.y());
  return Double::New(value);
}

DEFINE_NATIVE_ENTRY() [110/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_getZ	,
		0	,
		1
	)

Definition at line 233 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  double value = static_cast<double>(self.z());
  return Double::New(value);
}

DEFINE_NATIVE_ENTRY() [111/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_max	,
		0	,
		2
	)

Definition at line 343 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1));
  float _x = self.x() > other.x() ? self.x() : other.x();
  float _y = self.y() > other.y() ? self.y() : other.y();
  float _z = self.z() > other.z() ? self.z() : other.z();
  float _w = self.w() > other.w() ? self.w() : other.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [112/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_min	,
		0	,
		2
	)

Definition at line 333 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1));
  float _x = self.x() < other.x() ? self.x() : other.x();
  float _y = self.y() < other.y() ? self.y() : other.y();
  float _z = self.z() < other.z() ? self.z() : other.z();
  float _w = self.w() < other.w() ? self.w() : other.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [113/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_mul	,
		0	,
		2
	)

Definition at line 86 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1));
  float _x = self.x() * other.x();
  float _y = self.y() * other.y();
  float _z = self.z() * other.z();
  float _w = self.w() * other.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [114/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_negate	,
		0	,
		1
	)

Definition at line 67 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  float _x = -self.x();
  float _y = -self.y();
  float _z = -self.z();
  float _w = -self.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [115/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_reciprocal	,
		0	,
		1
	)

Definition at line 362 of file simd128.cc.

                                                {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  float _x = Utils::DivideAllowZero(1.0f, self.x());
  float _y = Utils::DivideAllowZero(1.0f, self.y());
  float _z = Utils::DivideAllowZero(1.0f, self.z());
  float _w = Utils::DivideAllowZero(1.0f, self.w());
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [116/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_reciprocalSqrt	,
		0	,
		1
	)

Definition at line 371 of file simd128.cc.

                                                    {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  float _x = sqrtf(Utils::DivideAllowZero(1.0f, self.x()));
  float _y = sqrtf(Utils::DivideAllowZero(1.0f, self.y()));
  float _z = sqrtf(Utils::DivideAllowZero(1.0f, self.z()));
  float _w = sqrtf(Utils::DivideAllowZero(1.0f, self.w()));
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [117/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_scale	,
		0	,
		2
	)

Definition at line 166 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, scale, arguments->NativeArgAt(1));
  float _s = static_cast<float>(scale.value());
  float _x = self.x() * _s;
  float _y = self.y() * _s;
  float _z = self.z() * _s;
  float _w = self.w() * _s;
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [118/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_setW	,
		0	,
		2
	)

Definition at line 323 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, w, arguments->NativeArgAt(1));
  float _x = self.x();
  float _y = self.y();
  float _z = self.z();
  float _w = static_cast<float>(w.value());
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [119/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_setX	,
		0	,
		2
	)

Definition at line 293 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1));
  float _x = static_cast<float>(x.value());
  float _y = self.y();
  float _z = self.z();
  float _w = self.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [120/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_setY	,
		0	,
		2
	)

Definition at line 303 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1));
  float _x = self.x();
  float _y = static_cast<float>(y.value());
  float _z = self.z();
  float _w = self.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [121/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_setZ	,
		0	,
		2
	)

Definition at line 313 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, z, arguments->NativeArgAt(1));
  float _x = self.x();
  float _y = self.y();
  float _z = static_cast<float>(z.value());
  float _w = self.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [122/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_shuffle	,
		0	,
		2
	)

Definition at line 265 of file simd128.cc.

                                             {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(1));
  int64_t m = mask.AsInt64Value();
  ThrowMaskRangeException(m);
  float data[4] = {self.x(), self.y(), self.z(), self.w()};
  float _x = data[m & 0x3];
  float _y = data[(m >> 2) & 0x3];
  float _z = data[(m >> 4) & 0x3];
  float _w = data[(m >> 6) & 0x3];
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [123/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_shuffleMix	,
		0	,
		3
	)

Definition at line 278 of file simd128.cc.

                                                {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(2));
  int64_t m = mask.AsInt64Value();
  ThrowMaskRangeException(m);
  float data[4] = {self.x(), self.y(), self.z(), self.w()};
  float other_data[4] = {other.x(), other.y(), other.z(), other.w()};
  float _x = data[m & 0x3];
  float _y = data[(m >> 2) & 0x3];
  float _z = other_data[(m >> 4) & 0x3];
  float _w = other_data[(m >> 6) & 0x3];
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [124/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_splat	,
		0	,
		1
	)

Definition at line 33 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Double, v, arguments->NativeArgAt(0));
  float _v = v.value();
  return Float32x4::New(_v, _v, _v, _v);
}

DEFINE_NATIVE_ENTRY() [125/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_sqrt	,
		0	,
		1
	)

Definition at line 353 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  float _x = sqrtf(self.x());
  float _y = sqrtf(self.y());
  float _z = sqrtf(self.z());
  float _w = sqrtf(self.w());
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [126/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_sub	,
		0	,
		2
	)

Definition at line 76 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1));
  float _x = self.x() - other.x();
  float _y = self.y() - other.y();
  float _z = self.z() - other.z();
  float _w = self.w() - other.w();
  return Float32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [127/345]

dart::DEFINE_NATIVE_ENTRY	(	Float32x4_zero	,
		0	,
		1
	)

Definition at line 39 of file simd128.cc.

                                          {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
  return Float32x4::New(0.0f, 0.0f, 0.0f, 0.0f);
}

DEFINE_NATIVE_ENTRY() [128/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_abs	,
		0	,
		1
	)

Definition at line 727 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  double _x = fabs(self.x());
  double _y = fabs(self.y());
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [129/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_add	,
		0	,
		2
	)

Definition at line 679 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1));
  double _x = self.x() + other.x();
  double _y = self.y() + other.y();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [130/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_clamp	,
		0	,
		3
	)

Definition at line 734 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, lo, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, hi, arguments->NativeArgAt(2));
  // The order of the clamping must match the order of the optimized code:
  // MAX(MIN(self, hi), lo).
  double _x;
  double _y;
 
  // ARM semantics are different from X86/X64 at an instruction level. Ensure
  // that we match the semantics of the architecture in the C version.
#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64) ||                   \
    defined(USING_SIMULATOR)
  _x = self.x() < hi.x() ? self.x() : hi.x();
  _y = self.y() < hi.y() ? self.y() : hi.y();
  _x = lo.x() < _x ? _x : lo.x();
  _y = lo.y() < _y ? _y : lo.y();
#else
  _x = fmin(self.x(), hi.x());
  _y = fmin(self.y(), hi.y());
  _x = fmax(_x, lo.x());
  _y = fmax(_y, lo.y());
#endif
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [131/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_div	,
		0	,
		2
	)

Definition at line 710 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1));
  double _x = Utils::DivideAllowZero(self.x(), other.x());
  double _y = Utils::DivideAllowZero(self.y(), other.y());
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [132/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_fromDoubles	,
		0	,
		2
	)

Definition at line 653 of file simd128.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1));
  return Float64x2::New(x.value(), y.value());
}

DEFINE_NATIVE_ENTRY() [133/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_fromFloat32x4	,
		0	,
		2
	)

Definition at line 670 of file simd128.cc.

                                                   {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, v, arguments->NativeArgAt(1));
  double _x = v.x();
  double _y = v.y();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [134/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_getSignMask	,
		0	,
		1
	)

Definition at line 770 of file simd128.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  uint32_t mx = (bit_cast<uint64_t>(self.x()) & 0x8000000000000000LL) >> 63;
  uint32_t my = (bit_cast<uint64_t>(self.y()) & 0x8000000000000000LL) >> 63;
  uint32_t value = mx | (my << 1);
  return Integer::New(value);
}

DEFINE_NATIVE_ENTRY() [135/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_getX	,
		0	,
		1
	)

Definition at line 760 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  return Double::New(self.x());
}

DEFINE_NATIVE_ENTRY() [136/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_getY	,
		0	,
		1
	)

Definition at line 765 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  return Double::New(self.y());
}

DEFINE_NATIVE_ENTRY() [137/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_max	,
		0	,
		2
	)

Definition at line 802 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1));
  double _x = self.x() > other.x() ? self.x() : other.x();
  double _y = self.y() > other.y() ? self.y() : other.y();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [138/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_min	,
		0	,
		2
	)

Definition at line 794 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1));
  double _x = self.x() < other.x() ? self.x() : other.x();
  double _y = self.y() < other.y() ? self.y() : other.y();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [139/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_mul	,
		0	,
		2
	)

Definition at line 702 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1));
  double _x = self.x() * other.x();
  double _y = self.y() * other.y();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [140/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_negate	,
		0	,
		1
	)

Definition at line 687 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  double _x = -self.x();
  double _y = -self.y();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [141/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_scale	,
		0	,
		2
	)

Definition at line 718 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, scale, arguments->NativeArgAt(1));
  double _s = scale.value();
  double _x = self.x() * _s;
  double _y = self.y() * _s;
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [142/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_setX	,
		0	,
		2
	)

Definition at line 778 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1));
  double _x = x.value();
  double _y = self.y();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [143/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_setY	,
		0	,
		2
	)

Definition at line 786 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1));
  double _x = self.x();
  double _y = y.value();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [144/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_splat	,
		0	,
		1
	)

Definition at line 659 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Double, v, arguments->NativeArgAt(0));
  return Float64x2::New(v.value(), v.value());
}

DEFINE_NATIVE_ENTRY() [145/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_sqrt	,
		0	,
		1
	)

Definition at line 810 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  double _x = sqrt(self.x());
  double _y = sqrt(self.y());
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [146/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_sub	,
		0	,
		2
	)

Definition at line 694 of file simd128.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1));
  double _x = self.x() - other.x();
  double _y = self.y() - other.y();
  return Float64x2::New(_x, _y);
}

DEFINE_NATIVE_ENTRY() [147/345]

dart::DEFINE_NATIVE_ENTRY	(	Float64x2_zero	,
		0	,
		1
	)

Definition at line 664 of file simd128.cc.

                                          {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
  return Float64x2::New(0.0, 0.0);
}

DEFINE_NATIVE_ENTRY() [148/345]

dart::DEFINE_NATIVE_ENTRY	(	Function_apply	,
		0	,
		2
	)

Definition at line 16 of file function.cc.

                                          {
  const int kTypeArgsLen = 0;  // TODO(regis): Add support for generic function.
  const Array& fun_arguments =
      Array::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Array& fun_arg_names =
      Array::CheckedHandle(zone, arguments->NativeArgAt(1));
  const Array& fun_args_desc = Array::Handle(
      zone, ArgumentsDescriptor::NewBoxed(kTypeArgsLen, fun_arguments.Length(),
                                          fun_arg_names));
  const Object& result = Object::Handle(
      zone, DartEntry::InvokeClosure(thread, fun_arguments, fun_args_desc));
  if (result.IsError()) {
    Exceptions::PropagateError(Error::Cast(result));
  }
  return result.ptr();
}

DEFINE_NATIVE_ENTRY() [149/345]

dart::DEFINE_NATIVE_ENTRY	(	FunctionTypeMirror_call_method	,
		0	,
		2
	)

Definition at line 883 of file mirrors.cc.

                                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror,
                               arguments->NativeArgAt(0));
  // Return get:call() method on class _Closure.
  const auto& getter_name = Symbols::GetCall();
  const Class& closure_class =
      Class::Handle(IsolateGroup::Current()->object_store()->closure_class());
  const Function& get_call = Function::Handle(
      Resolver::ResolveDynamicAnyArgs(zone, closure_class, getter_name,
                                      /*allow_add=*/false));
  ASSERT(!get_call.IsNull());
  return CreateMethodMirror(get_call, owner_mirror, AbstractType::Handle());
}

DEFINE_NATIVE_ENTRY() [150/345]

dart::DEFINE_NATIVE_ENTRY	(	FunctionTypeMirror_parameters	,
		0	,
		2
	)

Definition at line 897 of file mirrors.cc.

                                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const FunctionType& sig = FunctionType::Handle(ref.GetFunctionTypeReferent());
  return CreateParameterMirrorList(Object::null_function(), sig, owner);
}

DEFINE_NATIVE_ENTRY() [151/345]

dart::DEFINE_NATIVE_ENTRY	(	FunctionTypeMirror_return_type	,
		0	,
		1
	)

Definition at line 904 of file mirrors.cc.

                                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  const FunctionType& sig = FunctionType::Handle(ref.GetFunctionTypeReferent());
  ASSERT(!sig.IsNull());
  AbstractType& type = AbstractType::Handle(sig.result_type());
  // Signatures of function types are instantiated, but not canonical.
  return type.Canonicalize(thread);
}

DEFINE_NATIVE_ENTRY() [152/345]

dart::DEFINE_NATIVE_ENTRY	(	GrowableList_allocate	,
		0	,
		2
	)

Definition at line 15 of file growable_array.cc.

                                                 {
  const TypeArguments& type_arguments =
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, data, arguments->NativeArgAt(1));
  if (data.Length() < 0) {
    Exceptions::ThrowRangeError("length",
                                Integer::Handle(Integer::New(data.Length())),
                                0,  // This is the limit the user sees.
                                Array::kMaxElements);
  }
  const GrowableObjectArray& new_array =
      GrowableObjectArray::Handle(GrowableObjectArray::New(data));
  new_array.SetTypeArguments(type_arguments);
  return new_array.ptr();
}

DEFINE_NATIVE_ENTRY() [153/345]

dart::DEFINE_NATIVE_ENTRY	(	GrowableList_getCapacity	,
		0	,
		1
	)

Definition at line 49 of file growable_array.cc.

                                                    {
  const GrowableObjectArray& array =
      GrowableObjectArray::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Smi::New(array.Capacity());
}

DEFINE_NATIVE_ENTRY() [154/345]

dart::DEFINE_NATIVE_ENTRY	(	GrowableList_getLength	,
		0	,
		1
	)

Definition at line 43 of file growable_array.cc.

                                                  {
  const GrowableObjectArray& array =
      GrowableObjectArray::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Smi::New(array.Length());
}

DEFINE_NATIVE_ENTRY() [155/345]

dart::DEFINE_NATIVE_ENTRY	(	GrowableList_setData	,
		0	,
		2
	)

Definition at line 64 of file growable_array.cc.

                                                {
  const GrowableObjectArray& array =
      GrowableObjectArray::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, data, arguments->NativeArgAt(1));
  ASSERT(data.Length() >= 0);
  array.SetData(data);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [156/345]

dart::DEFINE_NATIVE_ENTRY	(	GrowableList_setIndexed	,
		0	,
		3
	)

Definition at line 31 of file growable_array.cc.

                                                   {
  const GrowableObjectArray& array =
      GrowableObjectArray::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));
  if ((index.Value() < 0) || (index.Value() >= array.Length())) {
    Exceptions::ThrowRangeError("index", index, 0, array.Length() - 1);
  }
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(2));
  array.SetAt(index.Value(), value);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [157/345]

dart::DEFINE_NATIVE_ENTRY	(	GrowableList_setLength	,
		0	,
		2
	)

Definition at line 55 of file growable_array.cc.

                                                  {
  const GrowableObjectArray& array =
      GrowableObjectArray::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(1));
  ASSERT((length.Value() >= 0) && (length.Value() <= array.Capacity()));
  array.SetLength(length.Value());
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [158/345]

dart::DEFINE_NATIVE_ENTRY	(	Identical_comparison	,
		0	,
		2
	)

Definition at line 11 of file identical.cc.

                                                {
  GET_NATIVE_ARGUMENT(Instance, a, arguments->NativeArgAt(0));
  GET_NATIVE_ARGUMENT(Instance, b, arguments->NativeArgAt(1));
  const bool is_identical = a.IsIdenticalTo(b);
  return Bool::Get(is_identical).ptr();
}

DEFINE_NATIVE_ENTRY() [159/345]

dart::DEFINE_NATIVE_ENTRY	(	ImmutableList_from	,
		0	,
		4
	)

Definition at line 58 of file array.cc.

                                              {
  // Ignore first argument of this factory (type argument).
  const Array& from_array =
      Array::CheckedHandle(zone, arguments->NativeArgAt(1));
  const Smi& smi_offset = Smi::CheckedHandle(zone, arguments->NativeArgAt(2));
  const Smi& smi_length = Smi::CheckedHandle(zone, arguments->NativeArgAt(3));
  const intptr_t length = smi_length.Value();
  const intptr_t offset = smi_offset.Value();
  const Array& result = Array::Handle(Array::New(length));
  Object& temp = Object::Handle();
  for (intptr_t i = 0; i < length; i++) {
    temp = from_array.At(i + offset);
    result.SetAt(i, temp);
  }
  result.MakeImmutable();
  return result.ptr();
}

DEFINE_NATIVE_ENTRY() [160/345]

dart::DEFINE_NATIVE_ENTRY	(	InstanceMirror_computeType	,
		0	,
		1
	)

Definition at line 1255 of file mirrors.cc.

                                                      {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0));
  const AbstractType& type = AbstractType::Handle(instance.GetType(Heap::kNew));
  // The static type of null is specified to be the bottom type, however, the
  // runtime type of null is the Null type, which we correctly return here.
  return type.Canonicalize(thread);
}

DEFINE_NATIVE_ENTRY() [161/345]

dart::DEFINE_NATIVE_ENTRY	(	InstanceMirror_invoke	,
		0	,
		5
	)

Definition at line 1224 of file mirrors.cc.

                                                 {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(String, function_name,
                               arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
  RETURN_OR_PROPAGATE(reflectee.Invoke(function_name, args, arg_names));
}

DEFINE_NATIVE_ENTRY() [162/345]

dart::DEFINE_NATIVE_ENTRY	(	InstanceMirror_invokeGetter	,
		0	,
		3
	)

Definition at line 1236 of file mirrors.cc.

                                                       {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2));
  RETURN_OR_PROPAGATE(reflectee.InvokeGetter(getter_name));
}

DEFINE_NATIVE_ENTRY() [163/345]

dart::DEFINE_NATIVE_ENTRY	(	InstanceMirror_invokeSetter	,
		0	,
		4
	)

Definition at line 1245 of file mirrors.cc.

                                                       {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
  GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
  RETURN_OR_PROPAGATE(reflectee.InvokeSetter(setter_name, value));
}

DEFINE_NATIVE_ENTRY() [164/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_add	,
		0	,
		2
	)

Definition at line 439 of file simd128.cc.

                                       {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1));
  int32_t _x = self.x() + other.x();
  int32_t _y = self.y() + other.y();
  int32_t _z = self.z() + other.z();
  int32_t _w = self.w() + other.w();
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [165/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_and	,
		0	,
		2
	)

Definition at line 419 of file simd128.cc.

                                       {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1));
  int32_t _x = self.x() & other.x();
  int32_t _y = self.y() & other.y();
  int32_t _z = self.z() & other.z();
  int32_t _w = self.w() & other.w();
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [166/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_fromBools	,
		0	,
		4
	)

Definition at line 392 of file simd128.cc.

                                             {
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, x, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, y, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, z, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, w, arguments->NativeArgAt(3));
  int32_t _x = x.value() ? 0xFFFFFFFF : 0x0;
  int32_t _y = y.value() ? 0xFFFFFFFF : 0x0;
  int32_t _z = z.value() ? 0xFFFFFFFF : 0x0;
  int32_t _w = w.value() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [167/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_fromFloat32x4Bits	,
		0	,
		2
	)

Definition at line 404 of file simd128.cc.

                                                     {
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, v, arguments->NativeArgAt(1));
  return Int32x4::New(v.value());
}

DEFINE_NATIVE_ENTRY() [168/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_fromInts	,
		0	,
		4
	)

Definition at line 380 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, x, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, y, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, z, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, w, arguments->NativeArgAt(3));
  int32_t _x = static_cast<int32_t>(x.AsTruncatedUint32Value());
  int32_t _y = static_cast<int32_t>(y.AsTruncatedUint32Value());
  int32_t _z = static_cast<int32_t>(z.AsTruncatedUint32Value());
  int32_t _w = static_cast<int32_t>(w.AsTruncatedUint32Value());
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [169/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getFlagW	,
		0	,
		1
	)

Definition at line 569 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  int32_t value = self.w();
  return Bool::Get(value != 0).ptr();
}

DEFINE_NATIVE_ENTRY() [170/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getFlagX	,
		0	,
		1
	)

Definition at line 551 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  int32_t value = self.x();
  return Bool::Get(value != 0).ptr();
}

DEFINE_NATIVE_ENTRY() [171/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getFlagY	,
		0	,
		1
	)

Definition at line 557 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  int32_t value = self.y();
  return Bool::Get(value != 0).ptr();
}

DEFINE_NATIVE_ENTRY() [172/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getFlagZ	,
		0	,
		1
	)

Definition at line 563 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  int32_t value = self.z();
  return Bool::Get(value != 0).ptr();
}

DEFINE_NATIVE_ENTRY() [173/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getSignMask	,
		0	,
		1
	)

Definition at line 255 of file simd128.cc.

                                               {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  uint32_t mx = (self.x() & 0x80000000) >> 31;
  uint32_t my = (self.y() & 0x80000000) >> 31;
  uint32_t mz = (self.z() & 0x80000000) >> 31;
  uint32_t mw = (self.w() & 0x80000000) >> 31;
  uint32_t value = mx | (my << 1) | (mz << 2) | (mw << 3);
  return Integer::New(value);
}

DEFINE_NATIVE_ENTRY() [174/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getW	,
		0	,
		1
	)

Definition at line 477 of file simd128.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  int32_t value = self.w();
  return Integer::New(value);
}

DEFINE_NATIVE_ENTRY() [175/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getX	,
		0	,
		1
	)

Definition at line 459 of file simd128.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  int32_t value = self.x();
  return Integer::New(value);
}

DEFINE_NATIVE_ENTRY() [176/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getY	,
		0	,
		1
	)

Definition at line 465 of file simd128.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  int32_t value = self.y();
  return Integer::New(value);
}

DEFINE_NATIVE_ENTRY() [177/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_getZ	,
		0	,
		1
	)

Definition at line 471 of file simd128.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  int32_t value = self.z();
  return Integer::New(value);
}

DEFINE_NATIVE_ENTRY() [178/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_or	,
		0	,
		2
	)

Definition at line 409 of file simd128.cc.

                                      {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1));
  int32_t _x = self.x() | other.x();
  int32_t _y = self.y() | other.y();
  int32_t _z = self.z() | other.z();
  int32_t _w = self.w() | other.w();
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [179/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_select	,
		0	,
		3
	)

Definition at line 628 of file simd128.cc.

                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, tv, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, fv, arguments->NativeArgAt(2));
  int32_t _maskX = self.x();
  int32_t _maskY = self.y();
  int32_t _maskZ = self.z();
  int32_t _maskW = self.w();
  // Extract floats and interpret them as masks.
  float32_int32 tvx(tv.x());
  float32_int32 tvy(tv.y());
  float32_int32 tvz(tv.z());
  float32_int32 tvw(tv.w());
  float32_int32 fvx(fv.x());
  float32_int32 fvy(fv.y());
  float32_int32 fvz(fv.z());
  float32_int32 fvw(fv.w());
  // Perform select.
  float32_int32 tempX((_maskX & tvx.u) | (~_maskX & fvx.u));
  float32_int32 tempY((_maskY & tvy.u) | (~_maskY & fvy.u));
  float32_int32 tempZ((_maskZ & tvz.u) | (~_maskZ & fvz.u));
  float32_int32 tempW((_maskW & tvw.u) | (~_maskW & fvw.u));
  return Float32x4::New(tempX.f, tempY.f, tempZ.f, tempW.f);
}

DEFINE_NATIVE_ENTRY() [180/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_setFlagW	,
		0	,
		2
	)

Definition at line 608 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagW, arguments->NativeArgAt(1));
  int32_t _x = self.x();
  int32_t _y = self.y();
  int32_t _z = self.z();
  int32_t _w = self.w();
  _w = flagW.ptr() == Bool::True().ptr() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [181/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_setFlagX	,
		0	,
		2
	)

Definition at line 575 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagX, arguments->NativeArgAt(1));
  int32_t _x = self.x();
  int32_t _y = self.y();
  int32_t _z = self.z();
  int32_t _w = self.w();
  _x = flagX.ptr() == Bool::True().ptr() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [182/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_setFlagY	,
		0	,
		2
	)

Definition at line 586 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagY, arguments->NativeArgAt(1));
  int32_t _x = self.x();
  int32_t _y = self.y();
  int32_t _z = self.z();
  int32_t _w = self.w();
  _y = flagY.ptr() == Bool::True().ptr() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [183/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_setFlagZ	,
		0	,
		2
	)

Definition at line 597 of file simd128.cc.

                                            {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagZ, arguments->NativeArgAt(1));
  int32_t _x = self.x();
  int32_t _y = self.y();
  int32_t _z = self.z();
  int32_t _w = self.w();
  _z = flagZ.ptr() == Bool::True().ptr() ? 0xFFFFFFFF : 0x0;
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [184/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_setW	,
		0	,
		2
	)

Definition at line 541 of file simd128.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, w, arguments->NativeArgAt(1));
  int32_t _x = self.x();
  int32_t _y = self.y();
  int32_t _z = self.z();
  int32_t _w = static_cast<int32_t>(w.AsInt64Value() & 0xFFFFFFFF);
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [185/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_setX	,
		0	,
		2
	)

Definition at line 511 of file simd128.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, x, arguments->NativeArgAt(1));
  int32_t _x = static_cast<int32_t>(x.AsInt64Value() & 0xFFFFFFFF);
  int32_t _y = self.y();
  int32_t _z = self.z();
  int32_t _w = self.w();
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [186/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_setY	,
		0	,
		2
	)

Definition at line 521 of file simd128.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, y, arguments->NativeArgAt(1));
  int32_t _x = self.x();
  int32_t _y = static_cast<int32_t>(y.AsInt64Value() & 0xFFFFFFFF);
  int32_t _z = self.z();
  int32_t _w = self.w();
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [187/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_setZ	,
		0	,
		2
	)

Definition at line 531 of file simd128.cc.

                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, z, arguments->NativeArgAt(1));
  int32_t _x = self.x();
  int32_t _y = self.y();
  int32_t _z = static_cast<int32_t>(z.AsInt64Value() & 0xFFFFFFFF);
  int32_t _w = self.w();
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [188/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_shuffle	,
		0	,
		2
	)

Definition at line 483 of file simd128.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(1));
  int64_t m = mask.AsInt64Value();
  ThrowMaskRangeException(m);
  int32_t data[4] = {self.x(), self.y(), self.z(), self.w()};
  int32_t _x = data[m & 0x3];
  int32_t _y = data[(m >> 2) & 0x3];
  int32_t _z = data[(m >> 4) & 0x3];
  int32_t _w = data[(m >> 6) & 0x3];
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [189/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_shuffleMix	,
		0	,
		3
	)

Definition at line 496 of file simd128.cc.

                                              {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, zw, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(2));
  int64_t m = mask.AsInt64Value();
  ThrowMaskRangeException(m);
  int32_t data[4] = {self.x(), self.y(), self.z(), self.w()};
  int32_t zw_data[4] = {zw.x(), zw.y(), zw.z(), zw.w()};
  int32_t _x = data[m & 0x3];
  int32_t _y = data[(m >> 2) & 0x3];
  int32_t _z = zw_data[(m >> 4) & 0x3];
  int32_t _w = zw_data[(m >> 6) & 0x3];
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [190/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_sub	,
		0	,
		2
	)

Definition at line 449 of file simd128.cc.

                                       {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1));
  int32_t _x = self.x() - other.x();
  int32_t _y = self.y() - other.y();
  int32_t _z = self.z() - other.z();
  int32_t _w = self.w() - other.w();
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [191/345]

dart::DEFINE_NATIVE_ENTRY	(	Int32x4_xor	,
		0	,
		2
	)

Definition at line 429 of file simd128.cc.

                                       {
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1));
  int32_t _x = self.x() ^ other.x();
  int32_t _y = self.y() ^ other.y();
  int32_t _z = self.z() ^ other.z();
  int32_t _w = self.w() ^ other.w();
  return Int32x4::New(_x, _y, _z, _w);
}

DEFINE_NATIVE_ENTRY() [192/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_addFromInteger	,
		0	,
		2
	)

Definition at line 71 of file integers.cc.

                                                  {
  const Integer& right_int =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right_int));
  ASSERT(CheckInteger(left_int));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_addFromInteger %s + %s\n", left_int.ToCString(),
                 right_int.ToCString());
  }
  return left_int.ArithmeticOp(Token::kADD, right_int);
}

DEFINE_NATIVE_ENTRY() [193/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_bitAndFromInteger	,
		0	,
		2
	)

Definition at line 32 of file integers.cc.

                                                     {
  const Integer& right =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right));
  ASSERT(CheckInteger(left));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_bitAndFromInteger %s & %s\n", right.ToCString(),
                 left.ToCString());
  }
  return left.BitOp(Token::kBIT_AND, right);
}

DEFINE_NATIVE_ENTRY() [194/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_bitOrFromInteger	,
		0	,
		2
	)

Definition at line 45 of file integers.cc.

                                                    {
  const Integer& right =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right));
  ASSERT(CheckInteger(left));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_bitOrFromInteger %s | %s\n", left.ToCString(),
                 right.ToCString());
  }
  return left.BitOp(Token::kBIT_OR, right);
}

DEFINE_NATIVE_ENTRY() [195/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_bitXorFromInteger	,
		0	,
		2
	)

Definition at line 58 of file integers.cc.

                                                     {
  const Integer& right =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right));
  ASSERT(CheckInteger(left));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_bitXorFromInteger %s ^ %s\n", left.ToCString(),
                 right.ToCString());
  }
  return left.BitOp(Token::kBIT_XOR, right);
}

DEFINE_NATIVE_ENTRY() [196/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_equalToInteger	,
		0	,
		2
	)

Definition at line 150 of file integers.cc.

                                                  {
  const Integer& left = Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(left));
  ASSERT(CheckInteger(right));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_equalToInteger %s == %s\n", left.ToCString(),
                 right.ToCString());
  }
  return Bool::Get(left.CompareWith(right) == 0).ptr();
}

DEFINE_NATIVE_ENTRY() [197/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_fromEnvironment	,
		0	,
		3
	)

Definition at line 188 of file integers.cc.

                                                   {
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(1));
  GET_NATIVE_ARGUMENT(Integer, default_value, arguments->NativeArgAt(2));
  // Call the embedder to supply us with the environment.
  const String& env_value =
      String::Handle(Api::GetEnvironmentValue(thread, name));
  if (!env_value.IsNull()) {
    const Integer& result = Integer::Handle(ParseInteger(env_value));
    if (!result.IsNull()) {
      if (result.IsSmi()) {
        return result.ptr();
      }
      return result.Canonicalize(thread);
    }
  }
  return default_value.ptr();
}

DEFINE_NATIVE_ENTRY() [198/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_greaterThanFromInteger	,
		0	,
		2
	)

Definition at line 137 of file integers.cc.

                                                          {
  const Integer& right =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right));
  ASSERT(CheckInteger(left));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_greaterThanFromInteger %s > %s\n", left.ToCString(),
                 right.ToCString());
  }
  return Bool::Get(left.CompareWith(right) == 1).ptr();
}

DEFINE_NATIVE_ENTRY() [199/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_moduloFromInteger	,
		0	,
		2
	)

Definition at line 120 of file integers.cc.

                                                     {
  const Integer& right_int =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right_int));
  ASSERT(CheckInteger(left_int));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_moduloFromInteger %s mod %s\n", left_int.ToCString(),
                 right_int.ToCString());
  }
  if (right_int.IsZero()) {
    // Should have been caught before calling into runtime.
    UNIMPLEMENTED();
  }
  return left_int.ArithmeticOp(Token::kMOD, right_int);
}

DEFINE_NATIVE_ENTRY() [200/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_mulFromInteger	,
		0	,
		2
	)

Definition at line 97 of file integers.cc.

                                                  {
  const Integer& right_int =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right_int));
  ASSERT(CheckInteger(left_int));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_mulFromInteger %s * %s\n", left_int.ToCString(),
                 right_int.ToCString());
  }
  return left_int.ArithmeticOp(Token::kMUL, right_int);
}

DEFINE_NATIVE_ENTRY() [201/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_parse	,
		0	,
		1
	)

Definition at line 183 of file integers.cc.

                                         {
  GET_NON_NULL_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0));
  return ParseInteger(value);
}

DEFINE_NATIVE_ENTRY() [202/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_shlFromInteger	,
		0	,
		2
	)

Definition at line 241 of file integers.cc.

                                                  {
  const Integer& amount =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, value, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(amount));
  ASSERT(CheckInteger(value));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_shlFromInteger: %s << %s\n", value.ToCString(),
                 amount.ToCString());
  }
  return ShiftOperationHelper(Token::kSHL, value, amount);
}

DEFINE_NATIVE_ENTRY() [203/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_shrFromInteger	,
		0	,
		2
	)

Definition at line 215 of file integers.cc.

                                                  {
  const Integer& amount =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, value, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(amount));
  ASSERT(CheckInteger(value));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_shrFromInteger: %s >> %s\n", value.ToCString(),
                 amount.ToCString());
  }
  return ShiftOperationHelper(Token::kSHR, value, amount);
}

DEFINE_NATIVE_ENTRY() [204/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_subFromInteger	,
		0	,
		2
	)

Definition at line 84 of file integers.cc.

                                                  {
  const Integer& right_int =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right_int));
  ASSERT(CheckInteger(left_int));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_subFromInteger %s - %s\n", left_int.ToCString(),
                 right_int.ToCString());
  }
  return left_int.ArithmeticOp(Token::kSUB, right_int);
}

DEFINE_NATIVE_ENTRY() [205/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_truncDivFromInteger	,
		0	,
		2
	)

Definition at line 110 of file integers.cc.

                                                       {
  const Integer& right_int =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, left_int, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(right_int));
  ASSERT(CheckInteger(left_int));
  ASSERT(!right_int.IsZero());
  return left_int.ArithmeticOp(Token::kTRUNCDIV, right_int);
}

DEFINE_NATIVE_ENTRY() [206/345]

dart::DEFINE_NATIVE_ENTRY	(	Integer_ushrFromInteger	,
		0	,
		2
	)

Definition at line 228 of file integers.cc.

                                                   {
  const Integer& amount =
      Integer::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, value, arguments->NativeArgAt(1));
  ASSERT(CheckInteger(amount));
  ASSERT(CheckInteger(value));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Integer_ushrFromInteger: %s >>> %s\n", value.ToCString(),
                 amount.ToCString());
  }
  return ShiftOperationHelper(Token::kUSHR, value, amount);
}

DEFINE_NATIVE_ENTRY() [207/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_allocateObjectInstructionsEnd	,
		0	,
		0
	)

Definition at line 344 of file object.cc.

                                                                  {
  auto& stub = Code::Handle(
      zone, isolate->group()->object_store()->allocate_object_stub());
  ASSERT(!stub.IsUnknownDartCode());
  // We return the end offset in the isolate instructions instead of the
  // full address because that fits into small Smis on 32-bit architectures
  // or compressed pointer builds.
  const uword instructions_start =
      reinterpret_cast<uword>(isolate->source()->snapshot_instructions);
  return Smi::New((stub.PayloadStart() - instructions_start) + stub.Size());
}

DEFINE_NATIVE_ENTRY() [208/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_allocateObjectInstructionsStart	,
		0	,
		0
	)

Definition at line 332 of file object.cc.

                                                                    {
  auto& stub = Code::Handle(
      zone, isolate->group()->object_store()->allocate_object_stub());
  ASSERT(!stub.IsUnknownDartCode());
  // We return the start offset in the isolate instructions instead of the
  // full address because that fits into small Smis on 32-bit architectures
  // or compressed pointer builds.
  const uword instructions_start =
      reinterpret_cast<uword>(isolate->source()->snapshot_instructions);
  return Smi::New(stub.PayloadStart() - instructions_start);
}

DEFINE_NATIVE_ENTRY() [209/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_allocateOneByteString	,
		0	,
		1
	)

Definition at line 260 of file string.cc.

                                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, length_obj, arguments->NativeArgAt(0));
  const int64_t length = length_obj.AsInt64Value();
  if ((length < 0) || (length > OneByteString::kMaxElements)) {
    // Assume that negative lengths are the result of wrapping in code in
    // string_patch.dart.
    const Instance& exception = Instance::Handle(
        thread->isolate_group()->object_store()->out_of_memory());
    Exceptions::Throw(thread, exception);
    UNREACHABLE();
  }
  return OneByteString::New(static_cast<intptr_t>(length), Heap::kNew);
}

DEFINE_NATIVE_ENTRY() [210/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_allocateTwoByteString	,
		0	,
		1
	)

Definition at line 274 of file string.cc.

                                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, length_obj, arguments->NativeArgAt(0));
  const int64_t length = length_obj.AsInt64Value();
  if ((length < 0) || (length > TwoByteString::kMaxElements)) {
    // Assume that negative lengths are the result of wrapping in code in
    // string_patch.dart.
    const Instance& exception = Instance::Handle(
        thread->isolate_group()->object_store()->out_of_memory());
    Exceptions::Throw(thread, exception);
    UNREACHABLE();
  }
  return TwoByteString::New(static_cast<intptr_t>(length), Heap::kNew);
}

DEFINE_NATIVE_ENTRY() [211/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_boundsCheckForPartialInstantiation	,
		0	,
		2
	)

Definition at line 503 of file object.cc.

                                                                       {
  const Closure& closure =
      Closure::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Function& target = Function::Handle(zone, closure.function());
  ASSERT(target.IsGeneric());  // No need to check bounds for non-generics.
  const TypeParameters& type_params =
      TypeParameters::Handle(zone, target.type_parameters());
  if (type_params.IsNull() || type_params.AllDynamicBounds()) {
    // The function is not generic or the bounds are all dynamic.
    return Object::null();
  }
 
  const TypeArguments& type_args_to_check =
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(1));
 
  // This should be guaranteed by the front-end.
  ASSERT(type_args_to_check.IsNull() ||
         type_params.Length() <= type_args_to_check.Length());
 
  // The bounds on the closure may need instantiation.
  const TypeArguments& instantiator_type_args =
      TypeArguments::Handle(zone, closure.instantiator_type_arguments());
  const TypeArguments& function_type_args = TypeArguments::Handle(
      zone,
      type_args_to_check.Prepend(
          zone, TypeArguments::Handle(zone, closure.function_type_arguments()),
          target.NumParentTypeArguments(), target.NumTypeArguments()));
 
  AbstractType& supertype = AbstractType::Handle(zone);
  AbstractType& subtype = AbstractType::Handle(zone);
  for (intptr_t i = 0; i < type_params.Length(); ++i) {
    supertype = type_params.BoundAt(i);
    subtype = type_args_to_check.IsNull() ? Object::dynamic_type().ptr()
                                          : type_args_to_check.TypeAt(i);
 
    ASSERT(!subtype.IsNull());
    ASSERT(!supertype.IsNull());
 
    // The supertype may not be instantiated.
    if (!AbstractType::InstantiateAndTestSubtype(
            &subtype, &supertype, instantiator_type_args, function_type_args)) {
      // Throw a dynamic type error.
      TokenPosition location = TokenPosition::kNoSource;
      {
        DartFrameIterator iterator(Thread::Current(),
                                   StackFrameIterator::kNoCrossThreadIteration);
        StackFrame* caller_frame = iterator.NextFrame();
        ASSERT(caller_frame != nullptr);
        location = caller_frame->GetTokenPos();
      }
      const auto& parameter_name = String::Handle(zone, type_params.NameAt(i));
      Exceptions::CreateAndThrowTypeError(location, subtype, supertype,
                                          parameter_name);
      UNREACHABLE();
    }
  }
 
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [212/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_collectAllGarbage	,
		0	,
		0
	)

Definition at line 321 of file object.cc.

                                                      {
  isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging,
                                              /*compact=*/true);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [213/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_deoptimizeFunctionsOnStack	,
		0	,
		0
	)

Definition at line 327 of file object.cc.

                                                               {
  DeoptimizeFunctionsOnStack();
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [214/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_extractTypeArguments	,
		0	,
		2
	)

Definition at line 401 of file object.cc.

                                                         {
  const Instance& instance =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Instance& extract =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(1));
 
  Class& interface_cls = Class::Handle(zone);
  intptr_t num_type_args = 0;
  if (arguments->NativeTypeArgCount() >= 1) {
    const AbstractType& function_type_arg =
        AbstractType::Handle(zone, arguments->NativeTypeArgAt(0));
    if (function_type_arg.IsType() &&
        (Type::Cast(function_type_arg).arguments() == TypeArguments::null())) {
      interface_cls = function_type_arg.type_class();
      num_type_args = interface_cls.NumTypeParameters();
    }
  }
  if (num_type_args == 0) {
    Exceptions::ThrowArgumentError(String::Handle(
        zone,
        String::New(
            "single function type argument must specify a generic class")));
  }
  if (instance.IsNull()) {
    Exceptions::ThrowArgumentError(instance);
  }
  // Function 'extract' must be generic and accept the same number of type args,
  // unless we execute Dart 1.0 code.
  if (extract.IsNull() || !extract.IsClosure() ||
      ((num_type_args > 0) &&  // Dart 1.0 if num_type_args == 0.
       (Function::Handle(zone, Closure::Cast(extract).function())
            .NumTypeParameters() != num_type_args))) {
    Exceptions::ThrowArgumentError(String::Handle(
        zone,
        String::New("argument 'extract' is not a generic function or not one "
                    "accepting the correct number of type arguments")));
  }
  TypeArguments& extracted_type_args = TypeArguments::Handle(zone);
  if (num_type_args > 0) {
    // The passed instance must implement interface_cls.
    TypeArguments& interface_type_args = TypeArguments::Handle(zone);
    interface_type_args = TypeArguments::New(num_type_args);
    Class& instance_cls = Class::Handle(zone, instance.clazz());
    TypeArguments& instance_type_args = TypeArguments::Handle(zone);
    if (instance_cls.NumTypeArguments() > 0) {
      instance_type_args = instance.GetTypeArguments();
    }
    if (!ExtractInterfaceTypeArgs(zone, instance_cls, instance_type_args,
                                  interface_cls, &interface_type_args)) {
      Exceptions::ThrowArgumentError(String::Handle(
          zone, String::New("type of argument 'instance' is not a subtype of "
                            "the function type argument")));
    }
    if (!interface_type_args.IsNull()) {
      extracted_type_args = TypeArguments::New(num_type_args);
      const intptr_t offset = interface_cls.NumTypeArguments() - num_type_args;
      AbstractType& type_arg = AbstractType::Handle(zone);
      for (intptr_t i = 0; i < num_type_args; i++) {
        type_arg = interface_type_args.TypeAt(offset + i);
        extracted_type_args.SetTypeAt(i, type_arg);
      }
      extracted_type_args =
          extracted_type_args.Canonicalize(thread);  // Can be null.
    }
  }
  // Call the closure 'extract'.
  Array& args_desc = Array::Handle(zone);
  Array& args = Array::Handle(zone);
  if (extracted_type_args.IsNull()) {
    args_desc = ArgumentsDescriptor::NewBoxed(0, 1);
    args = Array::New(1);
    args.SetAt(0, extract);
  } else {
    args_desc = ArgumentsDescriptor::NewBoxed(num_type_args, 1);
    args = Array::New(2);
    args.SetAt(0, extracted_type_args);
    args.SetAt(1, extract);
  }
  const Object& result =
      Object::Handle(zone, DartEntry::InvokeClosure(thread, args, args_desc));
  if (result.IsError()) {
    Exceptions::PropagateError(Error::Cast(result));
    UNREACHABLE();
  }
  return result.ptr();
}

DEFINE_NATIVE_ENTRY() [215/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_makeFixedListUnmodifiable	,
		0	,
		1
	)

Definition at line 79 of file growable_array.cc.

                                                              {
  GET_NON_NULL_NATIVE_ARGUMENT(Array, array, arguments->NativeArgAt(0));
  array.MakeImmutable();
  return array.ptr();
}

DEFINE_NATIVE_ENTRY() [216/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_makeListFixedLength	,
		0	,
		1
	)

Definition at line 73 of file growable_array.cc.

                                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(GrowableObjectArray, array,
                               arguments->NativeArgAt(0));
  return Array::MakeFixedLength(array, /* unique = */ true);
}

DEFINE_NATIVE_ENTRY() [217/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_nativeEffect	,
		0	,
		1
	)

Definition at line 317 of file object.cc.

                                                 {
  UNREACHABLE();
}

DEFINE_NATIVE_ENTRY() [218/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_prependTypeArguments	,
		0	,
		4
	)

Definition at line 488 of file object.cc.

                                                         {
  const TypeArguments& function_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0));
  const TypeArguments& parent_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, smi_parent_len, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, smi_len, arguments->NativeArgAt(3));
  return function_type_arguments.Prepend(
      zone, parent_type_arguments, smi_parent_len.Value(), smi_len.Value());
}

DEFINE_NATIVE_ENTRY() [219/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_unsafeCast	,
		0	,
		1
	)

Definition at line 312 of file object.cc.

                                               {
  UNREACHABLE();  // Should be erased at Kernel translation time.
  return arguments->NativeArgAt(0);
}

DEFINE_NATIVE_ENTRY() [220/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_writeIntoOneByteString	,
		0	,
		3
	)

Definition at line 341 of file string.cc.

                                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(String, receiver, arguments->NativeArgAt(0));
  ASSERT(receiver.IsOneByteString());
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, index_obj, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, code_point_obj, arguments->NativeArgAt(2));
  OneByteString::SetCharAt(receiver, index_obj.Value(),
                           code_point_obj.Value() & 0xFF);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [221/345]

dart::DEFINE_NATIVE_ENTRY	(	Internal_writeIntoTwoByteString	,
		0	,
		3
	)

Definition at line 351 of file string.cc.

                                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(String, receiver, arguments->NativeArgAt(0));
  ASSERT(receiver.IsTwoByteString());
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, index_obj, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, code_point_obj, arguments->NativeArgAt(2));
  TwoByteString::SetCharAt(receiver, index_obj.Value(),
                           code_point_obj.Value() & 0xFFFF);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [222/345]

dart::DEFINE_NATIVE_ENTRY	(	InvocationMirror_unpackTypeArguments	,
		0	,
		2
	)

Definition at line 563 of file object.cc.

                                                                {
  const TypeArguments& type_arguments =
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Smi& num_type_arguments =
      Smi::CheckedHandle(zone, arguments->NativeArgAt(1));
  bool all_dynamic = type_arguments.IsNull();
  const intptr_t len =
      all_dynamic ? num_type_arguments.Value() : type_arguments.Length();
  const Array& type_list = Array::Handle(
      zone, Array::New(len, Type::Handle(zone, Type::DartTypeType())));
  AbstractType& type = AbstractType::Handle(zone);
  for (intptr_t i = 0; i < len; i++) {
    if (all_dynamic) {
      type_list.SetAt(i, Object::dynamic_type());
    } else {
      type = type_arguments.TypeAt(i);
      type_list.SetAt(i, type);
    }
  }
  type_list.MakeImmutable();
  return type_list.ptr();
}

DEFINE_NATIVE_ENTRY() [223/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_exit_	,
		0	,
		2
	)

Definition at line 298 of file isolate.cc.

                                         {
  GET_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  if (!port.IsNull()) {
    GET_NATIVE_ARGUMENT(Instance, obj, arguments->NativeArgAt(1));
 
    const bool same_group = InSameGroup(isolate, port);
#if defined(DEBUG)
    if (same_group) {
      ASSERT(PortMap::IsReceiverInThisIsolateGroupOrClosed(port.Id(),
                                                           isolate->group()));
    }
#endif
    if (!same_group) {
      const auto& error =
          String::Handle(String::New("exit with final message is only allowed "
                                     "for isolates in one isolate group."));
      Exceptions::ThrowArgumentError(error);
      UNREACHABLE();
    }
 
    Object& validated_result = Object::Handle(zone);
    const Object& msg_obj = Object::Handle(zone, obj.ptr());
    validated_result = ValidateMessageObject(zone, isolate, msg_obj);
    // msg_array = [
    //     <message>,
    //     <collection-lib-objects-to-rehash>,
    //     <core-lib-objects-to-rehash>,
    // ]
    const Array& msg_array = Array::Handle(zone, Array::New(3));
    msg_array.SetAt(0, msg_obj);
    if (validated_result.IsUnhandledException()) {
      Exceptions::PropagateError(Error::Cast(validated_result));
      UNREACHABLE();
    }
    PersistentHandle* handle =
        isolate->group()->api_state()->AllocatePersistentHandle();
    handle->set_ptr(msg_array);
    isolate->bequeath(std::unique_ptr<Bequest>(new Bequest(handle, port.Id())));
  }
 
  Thread::Current()->StartUnwindError();
  const String& msg =
      String::Handle(String::New("isolate terminated by Isolate.exit"));
  const UnwindError& error = UnwindError::Handle(UnwindError::New(msg));
  error.set_is_user_initiated(true);
  Exceptions::PropagateError(error);
  UNREACHABLE();
  // We will never execute dart code again in this isolate.
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [224/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_getCurrentRootUriStr	,
		0	,
		0
	)

Definition at line 1034 of file isolate.cc.

                                                        {
  const Library& root_lib =
      Library::Handle(zone, isolate->group()->object_store()->root_library());
  return root_lib.url();
}

DEFINE_NATIVE_ENTRY() [225/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_getDebugName	,
		0	,
		1
	)

Definition at line 1015 of file isolate.cc.

                                                {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  auto name = Isolate::LookupIsolateNameByPort(port.Id());
  if (name == nullptr) {
    return String::null();
  }
  return String::New(name.get());
}

DEFINE_NATIVE_ENTRY() [226/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_getPortAndCapabilitiesOfCurrentIsolate	,
		0	,
		0
	)

Definition at line 1024 of file isolate.cc.

                                                                          {
  const Array& result = Array::Handle(Array::New(3));
  result.SetAt(0, SendPort::Handle(SendPort::New(isolate->main_port())));
  result.SetAt(
      1, Capability::Handle(Capability::New(isolate->pause_capability())));
  result.SetAt(
      2, Capability::Handle(Capability::New(isolate->terminate_capability())));
  return result.ptr();
}

DEFINE_NATIVE_ENTRY() [227/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_registerKernelBlob	,
		0	,
		1
	)

Definition at line 1040 of file isolate.cc.

                                                      {
  GET_NON_NULL_NATIVE_ARGUMENT(TypedData, kernel_blob,
                               arguments->NativeArgAt(0));
  auto register_kernel_blob_callback = Isolate::RegisterKernelBlobCallback();
  if (register_kernel_blob_callback == nullptr) {
    Exceptions::ThrowUnsupportedError(
        "Registration of kernel blobs is not supported by this Dart embedder.");
  }
  bool is_kernel = false;
  {
    NoSafepointScope no_safepoint;
    is_kernel =
        Dart_IsKernel(reinterpret_cast<uint8_t*>(kernel_blob.DataAddr(0)),
                      kernel_blob.LengthInBytes());
  }
  if (!is_kernel) {
    const auto& error = String::Handle(
        zone, String::New("kernelBlob doesn\'t contain a valid kernel.\n"));
    Exceptions::ThrowArgumentError(error);
    UNREACHABLE();
  }
  const char* uri = nullptr;
  {
    NoSafepointScope no_safepoint;
    uri = register_kernel_blob_callback(
        reinterpret_cast<uint8_t*>(kernel_blob.DataAddr(0)),
        kernel_blob.LengthInBytes());
  }
  if (uri == nullptr) {
    Exceptions::ThrowOOM();
  }
  return String::New(uri);
}

DEFINE_NATIVE_ENTRY() [228/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_sendOOB	,
		0	,
		2
	)

Definition at line 1087 of file isolate.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, msg, arguments->NativeArgAt(1));
 
  // Make sure to route this request to the isolate library OOB message handler.
  msg.SetAt(0, Smi::Handle(Smi::New(Message::kIsolateLibOOBMsg)));
 
  // Ensure message writer (and it's resources, e.g. forwarding tables) are
  // cleaned up before handling interrupts.
  {
    PortMap::PostMessage(WriteMessage(/*same_group=*/false, msg, port.Id(),
                                      Message::kOOBPriority));
  }
 
  // Drain interrupts before running so any IMMEDIATE operations on the current
  // isolate happen synchronously.
  const Error& error = Error::Handle(thread->HandleInterrupts());
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
    UNREACHABLE();
  }
 
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [229/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_spawnFunction	,
		0	,
		10
	)

Definition at line 866 of file isolate.cc.

                                                  {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(String, script_uri, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Closure, closure, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, message, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, paused, arguments->NativeArgAt(4));
  GET_NATIVE_ARGUMENT(Bool, fatalErrors, arguments->NativeArgAt(5));
  GET_NATIVE_ARGUMENT(SendPort, onExit, arguments->NativeArgAt(6));
  GET_NATIVE_ARGUMENT(SendPort, onError, arguments->NativeArgAt(7));
  GET_NATIVE_ARGUMENT(String, packageConfig, arguments->NativeArgAt(8));
  GET_NATIVE_ARGUMENT(String, debugName, arguments->NativeArgAt(9));
 
  PersistentHandle* closure_tuple_handle = nullptr;
  // We have a non-toplevel closure that we might need to copy.
  // Result will be [<closure-copy>, <objects-in-msg-to-rehash>]
  const auto& closure_copy_tuple = Object::Handle(
      zone, CopyMutableObjectGraph(closure));  // Throws if it fails.
  ASSERT(closure_copy_tuple.IsArray());
  ASSERT(
      Object::Handle(zone, Array::Cast(closure_copy_tuple).At(0)).IsClosure());
  closure_tuple_handle =
      isolate->group()->api_state()->AllocatePersistentHandle();
  closure_tuple_handle->set_ptr(closure_copy_tuple.ptr());
 
  bool fatal_errors = fatalErrors.IsNull() ? true : fatalErrors.value();
  Dart_Port on_exit_port = onExit.IsNull() ? ILLEGAL_PORT : onExit.Id();
  Dart_Port on_error_port = onError.IsNull() ? ILLEGAL_PORT : onError.Id();
 
  // We first try to serialize the message.  In case the message is not
  // serializable this will throw an exception.
  SerializedObjectBuffer message_buffer;
  message_buffer.set_message(WriteMessage(
      /*same_group=*/true, message, ILLEGAL_PORT, Message::kNormalPriority));
 
  const char* utf8_package_config =
      packageConfig.IsNull() ? nullptr : String2UTF8(packageConfig);
  const char* utf8_debug_name =
      debugName.IsNull() ? nullptr : String2UTF8(debugName);
  if (closure_tuple_handle != nullptr && utf8_debug_name == nullptr) {
    const auto& closure_function = Function::Handle(zone, closure.function());
    utf8_debug_name =
        NewConstChar(closure_function.QualifiedUserVisibleNameCString());
  }
 
  std::unique_ptr<IsolateSpawnState> state(new IsolateSpawnState(
      port.Id(), isolate->origin_id(), String2UTF8(script_uri),
      closure_tuple_handle, &message_buffer, utf8_package_config,
      paused.value(), fatal_errors, on_exit_port, on_error_port,
      utf8_debug_name, isolate->group()));
 
  isolate->group()->thread_pool()->Run<SpawnIsolateTask>(isolate,
                                                         std::move(state));
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [230/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_spawnUri	,
		0	,
		12
	)

Definition at line 952 of file isolate.cc.

                                             {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(String, uri, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, args, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, message, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, paused, arguments->NativeArgAt(4));
  GET_NATIVE_ARGUMENT(SendPort, onExit, arguments->NativeArgAt(5));
  GET_NATIVE_ARGUMENT(SendPort, onError, arguments->NativeArgAt(6));
  GET_NATIVE_ARGUMENT(Bool, fatalErrors, arguments->NativeArgAt(7));
  GET_NATIVE_ARGUMENT(Bool, checked, arguments->NativeArgAt(8));
  GET_NATIVE_ARGUMENT(Array, environment, arguments->NativeArgAt(9));
  GET_NATIVE_ARGUMENT(String, packageConfig, arguments->NativeArgAt(10));
  GET_NATIVE_ARGUMENT(String, debugName, arguments->NativeArgAt(11));
 
  bool fatal_errors = fatalErrors.IsNull() ? true : fatalErrors.value();
  Dart_Port on_exit_port = onExit.IsNull() ? ILLEGAL_PORT : onExit.Id();
  Dart_Port on_error_port = onError.IsNull() ? ILLEGAL_PORT : onError.Id();
 
  // We first try to serialize the arguments and the message.  In case the
  // arguments or the message are not serializable this will throw an exception.
  SerializedObjectBuffer arguments_buffer;
  SerializedObjectBuffer message_buffer;
  {
    arguments_buffer.set_message(WriteMessage(
        /*same_group=*/false, args, ILLEGAL_PORT, Message::kNormalPriority));
  }
  {
    message_buffer.set_message(WriteMessage(
        /*same_group=*/false, message, ILLEGAL_PORT, Message::kNormalPriority));
  }
 
  // Canonicalize the uri with respect to the current isolate.
  const Library& root_lib =
      Library::Handle(isolate->group()->object_store()->root_library());
  char* error = nullptr;
  const char* canonical_uri = CanonicalizeUri(thread, root_lib, uri, &error);
  if (canonical_uri == nullptr) {
    const String& msg = String::Handle(String::New(error));
    ThrowIsolateSpawnException(msg);
  }
 
  const char* utf8_package_config =
      packageConfig.IsNull() ? nullptr : String2UTF8(packageConfig);
  const char* utf8_debug_name =
      debugName.IsNull() ? nullptr : String2UTF8(debugName);
 
  std::unique_ptr<IsolateSpawnState> state(new IsolateSpawnState(
      port.Id(), canonical_uri, utf8_package_config, &arguments_buffer,
      &message_buffer, paused.value(), fatal_errors, on_exit_port,
      on_error_port, utf8_debug_name, /*group=*/nullptr));
 
  // If we were passed a value then override the default flags state for
  // checked mode.
  if (!checked.IsNull()) {
    Dart_IsolateFlags* flags = state->isolate_flags();
    flags->enable_asserts = checked.value();
  }
 
  isolate->group()->thread_pool()->Run<SpawnIsolateTask>(isolate,
                                                         std::move(state));
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [231/345]

dart::DEFINE_NATIVE_ENTRY	(	Isolate_unregisterKernelBlob	,
		0	,
		1
	)

Definition at line 1074 of file isolate.cc.

                                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(String, kernel_blob_uri,
                               arguments->NativeArgAt(0));
  auto unregister_kernel_blob_callback =
      Isolate::UnregisterKernelBlobCallback();
  if (unregister_kernel_blob_callback == nullptr) {
    Exceptions::ThrowUnsupportedError(
        "Registration of kernel blobs is not supported by this Dart embedder.");
  }
  unregister_kernel_blob_callback(kernel_blob_uri.ToCString());
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [232/345]

dart::DEFINE_NATIVE_ENTRY	(	IsolateMirror_loadUri	,
		0	,
		1
	)

Definition at line 676 of file mirrors.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(String, uri, arguments->NativeArgAt(0));
 
  if (!isolate->group()->HasTagHandler()) {
    ThrowLanguageError("no library handler registered");
  }
 
  NoReloadScope no_reload(thread);
 
  // Canonicalize library URI.
  String& canonical_uri = String::Handle(zone);
  if (uri.StartsWith(Symbols::DartScheme())) {
    canonical_uri = uri.ptr();
  } else {
    isolate->BlockClassFinalization();
    const Object& result = Object::Handle(
        zone, isolate->group()->CallTagHandler(
                  Dart_kCanonicalizeUrl,
                  Library::Handle(
                      zone, isolate->group()->object_store()->root_library()),
                  uri));
    isolate->UnblockClassFinalization();
    if (result.IsError()) {
      if (result.IsLanguageError()) {
        Exceptions::ThrowCompileTimeError(LanguageError::Cast(result));
      }
      Exceptions::PropagateError(Error::Cast(result));
    } else if (!result.IsString()) {
      ThrowLanguageError("library handler failed URI canonicalization");
    }
 
    canonical_uri ^= result.ptr();
  }
 
  // Return the existing library if it has already been loaded.
  Library& library =
      Library::Handle(zone, Library::LookupLibrary(thread, canonical_uri));
  if (!library.IsNull()) {
    return CreateLibraryMirror(thread, library);
  }
 
  // Request the embedder to load the library.
  isolate->BlockClassFinalization();
  Object& result = Object::Handle(
      zone, isolate->group()->CallTagHandler(
                Dart_kImportTag,
                Library::Handle(
                    zone, isolate->group()->object_store()->root_library()),
                canonical_uri));
  isolate->UnblockClassFinalization();
  if (result.IsError()) {
    if (result.IsLanguageError()) {
      Exceptions::ThrowCompileTimeError(LanguageError::Cast(result));
    }
    Exceptions::PropagateError(Error::Cast(result));
  }
 
  // This code assumes a synchronous tag handler (which dart::bin and tonic
  // provide). Strictly though we should complete a future in response to
  // Dart_FinalizeLoading.
 
  if (!ClassFinalizer::ProcessPendingClasses()) {
    Exceptions::PropagateError(Error::Handle(thread->sticky_error()));
  }
 
  // Prefer the tag handler's idea of which library is represented by the URI.
  if (result.IsLibrary()) {
    return CreateLibraryMirror(thread, Library::Cast(result));
  }
 
  if (result.IsNull()) {
    library = Library::LookupLibrary(thread, canonical_uri);
    if (!library.IsNull()) {
      return CreateLibraryMirror(thread, library);
    }
  }
 
  FATAL("Non-library from tag handler");
}

DEFINE_NATIVE_ENTRY() [233/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryMirror_fromPrefix	,
		0	,
		1
	)

Definition at line 448 of file mirrors.cc.

                                                    {
  GET_NON_NULL_NATIVE_ARGUMENT(LibraryPrefix, prefix,
                               arguments->NativeArgAt(0));
  const Library& deferred_lib = Library::Handle(prefix.GetLibrary(0));
  if (!deferred_lib.Loaded()) {
    return Instance::null();
  }
  return CreateLibraryMirror(thread, deferred_lib);
}

DEFINE_NATIVE_ENTRY() [234/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryMirror_invoke	,
		0	,
		5
	)

Definition at line 1481 of file mirrors.cc.

                                                {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Library& library = Library::Handle(ref.GetLibraryReferent());
  GET_NON_NULL_NATIVE_ARGUMENT(String, function_name,
                               arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
  RETURN_OR_PROPAGATE(library.Invoke(function_name, args, arg_names));
}

DEFINE_NATIVE_ENTRY() [235/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryMirror_invokeGetter	,
		0	,
		3
	)

Definition at line 1494 of file mirrors.cc.

                                                      {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Library& library = Library::Handle(ref.GetLibraryReferent());
  GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2));
  RETURN_OR_PROPAGATE(library.InvokeGetter(getter_name, true));
}

DEFINE_NATIVE_ENTRY() [236/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryMirror_invokeSetter	,
		0	,
		4
	)

Definition at line 1504 of file mirrors.cc.

                                                      {
  // Argument 0 is the mirror, which is unused by the native. It exists
  // because this native is an instance method in order to be polymorphic
  // with its cousins.
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Library& library = Library::Handle(ref.GetLibraryReferent());
  GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
  GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
  RETURN_OR_PROPAGATE(library.InvokeSetter(setter_name, value));
}

DEFINE_NATIVE_ENTRY() [237/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryMirror_libraryDependencies	,
		0	,
		2
	)

Definition at line 458 of file mirrors.cc.

                                                             {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, lib_mirror, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Library& lib = Library::Handle(ref.GetLibraryReferent());
 
  Array& ports = Array::Handle();
  Namespace& ns = Namespace::Handle();
  Instance& dep = Instance::Handle();
  LibraryPrefix& prefix = LibraryPrefix::Handle();
  GrowableObjectArray& deps =
      GrowableObjectArray::Handle(GrowableObjectArray::New());
 
  // Unprefixed imports.
  ports = lib.imports();
  for (intptr_t i = 0; i < ports.Length(); i++) {
    ns ^= ports.At(i);
    if (!ns.IsNull()) {
      dep = CreateLibraryDependencyMirror(thread, lib_mirror, ns, prefix, true,
                                          false);
      if (!dep.IsNull()) {
        deps.Add(dep);
      }
    }
  }
 
  // Exports.
  ports = lib.exports();
  for (intptr_t i = 0; i < ports.Length(); i++) {
    ns ^= ports.At(i);
    dep = CreateLibraryDependencyMirror(thread, lib_mirror, ns, prefix, false,
                                        false);
    if (!dep.IsNull()) {
      deps.Add(dep);
    }
  }
 
  // Prefixed imports.
  DictionaryIterator entries(lib);
  Object& entry = Object::Handle();
  while (entries.HasNext()) {
    entry = entries.GetNext();
    if (entry.IsLibraryPrefix()) {
      prefix ^= entry.ptr();
      ports = prefix.imports();
      for (intptr_t i = 0; i < ports.Length(); i++) {
        ns ^= ports.At(i);
        if (!ns.IsNull()) {
          dep = CreateLibraryDependencyMirror(thread, lib_mirror, ns, prefix,
                                              true, prefix.is_deferred_load());
          if (!dep.IsNull()) {
            deps.Add(dep);
          }
        }
      }
    }
  }
 
  return deps.ptr();
}

DEFINE_NATIVE_ENTRY() [238/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryMirror_members	,
		0	,
		2
	)

Definition at line 1103 of file mirrors.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner_mirror,
                               arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Library& library = Library::Handle(zone, ref.GetLibraryReferent());
 
  library.EnsureTopLevelClassIsFinalized();
 
  Instance& member_mirror = Instance::Handle(zone);
  const GrowableObjectArray& member_mirrors =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
 
  Object& entry = Object::Handle(zone);
  DictionaryIterator entries(library);
 
  Error& error = Error::Handle(zone);
  AbstractType& type = AbstractType::Handle(zone);
 
  while (entries.HasNext()) {
    entry = entries.GetNext();
    if (entry.IsClass()) {
      const Class& klass = Class::Cast(entry);
      ASSERT(!klass.IsDynamicClass());
      ASSERT(!klass.IsVoidClass());
      ASSERT(!klass.IsNeverClass());
      error = klass.EnsureIsFinalized(thread);
      if (!error.IsNull()) {
        Exceptions::PropagateError(error);
      }
      type = klass.DeclarationType();
      member_mirror = CreateClassMirror(klass, type,
                                        Bool::True(),  // is_declaration
                                        owner_mirror);
      member_mirrors.Add(member_mirror);
    } else if (entry.IsField()) {
      const Field& field = Field::Cast(entry);
      if (field.is_reflectable()) {
        member_mirror = CreateVariableMirror(field, owner_mirror);
        member_mirrors.Add(member_mirror);
      }
    } else if (entry.IsFunction()) {
      const Function& func = Function::Cast(entry);
      if (func.is_reflectable() &&
          (func.kind() == UntaggedFunction::kRegularFunction ||
           func.kind() == UntaggedFunction::kGetterFunction ||
           func.kind() == UntaggedFunction::kSetterFunction)) {
        member_mirror =
            CreateMethodMirror(func, owner_mirror, AbstractType::Handle());
        member_mirrors.Add(member_mirror);
      }
    }
  }
 
  return member_mirrors.ptr();
}

DEFINE_NATIVE_ENTRY() [239/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryPrefix_isLoaded	,
		0	,
		1
	)

Definition at line 268 of file object.cc.

                                                  {
  const LibraryPrefix& prefix =
      LibraryPrefix::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Bool::Get(isolate->IsPrefixLoaded(prefix)).ptr();
}

DEFINE_NATIVE_ENTRY() [240/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryPrefix_issueLoad	,
		0	,
		1
	)

Definition at line 289 of file object.cc.

                                                   {
  const Smi& id = Smi::CheckedHandle(zone, arguments->NativeArgAt(0));
  Array& units =
      Array::Handle(zone, isolate->group()->object_store()->loading_units());
  if (units.IsNull()) {
    // Not actually split.
    const Library& lib = Library::Handle(zone, Library::CoreLibrary());
    const String& sel = String::Handle(zone, String::New("_completeLoads"));
    const Function& func =
        Function::Handle(zone, lib.LookupFunctionAllowPrivate(sel));
    ASSERT(!func.IsNull());
    const Array& args = Array::Handle(zone, Array::New(3));
    args.SetAt(0, id);
    args.SetAt(1, String::Handle(zone));
    args.SetAt(2, Bool::Get(false));
    return DartEntry::InvokeFunction(func, args);
  }
  ASSERT(id.Value() != LoadingUnit::kIllegalId);
  LoadingUnit& unit = LoadingUnit::Handle(zone);
  unit ^= units.At(id.Value());
  return unit.IssueLoad();
}

DEFINE_NATIVE_ENTRY() [241/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryPrefix_loadingUnit	,
		0	,
		1
	)

Definition at line 281 of file object.cc.

                                                     {
  const LibraryPrefix& prefix =
      LibraryPrefix::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Library& target = Library::Handle(zone, prefix.GetLibrary(0));
  const LoadingUnit& unit = LoadingUnit::Handle(zone, target.loading_unit());
  return Smi::New(unit.IsNull() ? LoadingUnit::kIllegalId : unit.id());
}

DEFINE_NATIVE_ENTRY() [242/345]

dart::DEFINE_NATIVE_ENTRY	(	LibraryPrefix_setLoaded	,
		0	,
		1
	)

Definition at line 274 of file object.cc.

                                                   {
  const LibraryPrefix& prefix =
      LibraryPrefix::CheckedHandle(zone, arguments->NativeArgAt(0));
  isolate->SetPrefixIsLoaded(prefix);
  return Instance::null();
}

DEFINE_NATIVE_ENTRY() [243/345]

dart::DEFINE_NATIVE_ENTRY	(	List_allocate	,
		0	,
		2
	)

Definition at line 13 of file array.cc.

                                         {
  // Implemented in FlowGraphBuilder::VisitNativeBody.
  UNREACHABLE();
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [244/345]

dart::DEFINE_NATIVE_ENTRY	(	List_getLength	,
		0	,
		1
	)

Definition at line 31 of file array.cc.

                                          {
  const Array& array = Array::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Smi::New(array.Length());
}

DEFINE_NATIVE_ENTRY() [245/345]

dart::DEFINE_NATIVE_ENTRY	(	List_setIndexed	,
		0	,
		3
	)

Definition at line 19 of file array.cc.

                                           {
  const Array& array = Array::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));
  const Instance& value =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(2));
  if ((index.Value() < 0) || (index.Value() >= array.Length())) {
    Exceptions::ThrowRangeError("index", index, 0, array.Length() - 1);
  }
  array.SetAt(index.Value(), value);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [246/345]

dart::DEFINE_NATIVE_ENTRY	(	List_slice	,
		0	,
		4
	)

Definition at line 37 of file array.cc.

                                      {
  const Array& src = Array::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, count, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, needs_type_arg, arguments->NativeArgAt(3));
  intptr_t istart = start.Value();
  if ((istart < 0) || (istart > src.Length())) {
    Exceptions::ThrowRangeError("start", start, 0, src.Length());
  }
  intptr_t icount = count.Value();
  // Zero count should be handled outside already.
  if ((icount <= 0) || (icount > src.Length())) {
    Exceptions::ThrowRangeError("count", count,
                                0,  // This is the limit the user sees.
                                src.Length() - istart);
  }
 
  return src.Slice(istart, icount, needs_type_arg.value());
}

DEFINE_NATIVE_ENTRY() [247/345]

dart::DEFINE_NATIVE_ENTRY	(	Math_doublePow	,
		0	,
		2
	)

Definition at line 16 of file math.cc.

                                          {
  const double operand =
      Double::CheckedHandle(zone, arguments->NativeArgAt(0)).value();
  GET_NON_NULL_NATIVE_ARGUMENT(Double, exponent_object,
                               arguments->NativeArgAt(1));
  const double exponent = exponent_object.value();
  return Double::New(pow(operand, exponent));
}

DEFINE_NATIVE_ENTRY() [248/345]

dart::DEFINE_NATIVE_ENTRY	(	MethodMirror_owner	,
		0	,
		2
	)

Definition at line 1515 of file mirrors.cc.

                                              {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1));
  const Function& func = Function::Handle(ref.GetFunctionReferent());
  if (func.IsNonImplicitClosureFunction()) {
    return CreateMethodMirror(Function::Handle(func.parent_function()),
                              Object::null_instance(), instantiator);
  }
  const Class& owner = Class::Handle(func.Owner());
  if (owner.IsTopLevel()) {
    return CreateLibraryMirror(thread, Library::Handle(owner.library()));
  }
 
  AbstractType& type = AbstractType::Handle(owner.DeclarationType());
  return CreateClassMirror(owner, type, Bool::True(), Object::null_instance());
}

DEFINE_NATIVE_ENTRY() [249/345]

dart::DEFINE_NATIVE_ENTRY	(	MethodMirror_parameters	,
		0	,
		2
	)

Definition at line 1532 of file mirrors.cc.

                                                   {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Function& func = Function::Handle(ref.GetFunctionReferent());
  const FunctionType& sig = FunctionType::Handle(func.signature());
  return CreateParameterMirrorList(func, sig, owner);
}

DEFINE_NATIVE_ENTRY() [250/345]

dart::DEFINE_NATIVE_ENTRY	(	MethodMirror_return_type	,
		0	,
		2
	)

Definition at line 1540 of file mirrors.cc.

                                                    {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  const Function& func = Function::Handle(ref.GetFunctionReferent());
  GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1));
  // We handle constructors in Dart code.
  ASSERT(!func.IsGenerativeConstructor());
  AbstractType& type = AbstractType::Handle(func.result_type());
  type =
      type.Canonicalize(thread);  // Instantiated signatures are not canonical.
  return InstantiateType(type, instantiator);
}

DEFINE_NATIVE_ENTRY() [251/345]

dart::DEFINE_NATIVE_ENTRY	(	MethodMirror_source	,
		0	,
		1
	)

Definition at line 1552 of file mirrors.cc.

                                               {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  const Function& func = Function::Handle(ref.GetFunctionReferent());
  return func.GetSource();
}

DEFINE_NATIVE_ENTRY() [252/345]

dart::DEFINE_NATIVE_ENTRY	(	Mint_bitLength	,
		0	,
		1
	)

Definition at line 316 of file integers.cc.

                                          {
  const Mint& operand = Mint::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(CheckInteger(operand));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Mint_bitLength: %s\n", operand.ToCString());
  }
  int64_t value = operand.AsInt64Value();
  intptr_t result = Utils::BitLength(value);
  ASSERT(Smi::IsValid(result));
  return Smi::New(result);
}

DEFINE_NATIVE_ENTRY() [253/345]

dart::DEFINE_NATIVE_ENTRY	(	Mint_bitNegate	,
		0	,
		1
	)

Definition at line 306 of file integers.cc.

                                          {
  const Mint& operand = Mint::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(CheckInteger(operand));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Mint_bitNegate: %s\n", operand.ToCString());
  }
  int64_t result = ~operand.value();
  return Integer::New(result);
}

DEFINE_NATIVE_ENTRY() [254/345]

dart::DEFINE_NATIVE_ENTRY	(	MirrorReference_equals	,
		0	,
		2
	)

Definition at line 837 of file mirrors.cc.

                                                  {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, a, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, b, arguments->NativeArgAt(1));
  return Bool::Get(a.referent() == b.referent()).ptr();
}

DEFINE_NATIVE_ENTRY() [255/345]

dart::DEFINE_NATIVE_ENTRY	(	Mirrors_instantiateGenericType	,
		0	,
		2
	)

Definition at line 778 of file mirrors.cc.

                                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(1));
 
  const Class& clz = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  if (!clz.IsGeneric()) {
    const Array& error_args = Array::Handle(Array::New(3));
    error_args.SetAt(0, type);
    error_args.SetAt(1, String::Handle(String::New("key")));
    error_args.SetAt(2, String::Handle(String::New(
                            "Type must be a generic class or function.")));
    Exceptions::ThrowByType(Exceptions::kArgumentValue, error_args);
    UNREACHABLE();
  }
  if (clz.NumTypeParameters() != args.Length()) {
    const Array& error_args = Array::Handle(Array::New(3));
    error_args.SetAt(0, args);
    error_args.SetAt(1, String::Handle(String::New("typeArguments")));
    error_args.SetAt(2, String::Handle(String::New(
                            "Number of type arguments does not match.")));
    Exceptions::ThrowByType(Exceptions::kArgumentValue, error_args);
    UNREACHABLE();
  }
 
  intptr_t num_expected_type_arguments = args.Length();
  TypeArguments& type_args_obj = TypeArguments::Handle();
  type_args_obj = TypeArguments::New(num_expected_type_arguments);
  AbstractType& type_arg = AbstractType::Handle();
  Instance& instance = Instance::Handle();
  for (intptr_t i = 0; i < args.Length(); i++) {
    instance ^= args.At(i);
    if (!instance.IsType()) {
      const Array& error_args = Array::Handle(Array::New(3));
      error_args.SetAt(0, args);
      error_args.SetAt(1, String::Handle(String::New("typeArguments")));
      error_args.SetAt(2, String::Handle(String::New(
                              "Type arguments must be instances of Type.")));
      Exceptions::ThrowByType(Exceptions::kArgumentValue, error_args);
      UNREACHABLE();
    }
    type_arg ^= args.At(i);
    type_args_obj.SetTypeAt(i, type_arg);
  }
 
  Type& instantiated_type = Type::Handle(Type::New(clz, type_args_obj));
  instantiated_type ^= ClassFinalizer::FinalizeType(instantiated_type);
  return instantiated_type.ptr();
}

DEFINE_NATIVE_ENTRY() [256/345]

dart::DEFINE_NATIVE_ENTRY	(	Mirrors_makeLocalClassMirror	,
		0	,
		1
	)

Definition at line 756 of file mirrors.cc.

                                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  ASSERT(type.IsFinalized());
  const Class& cls = Class::Handle(
      type.IsFunctionType()
          ? IsolateGroup::Current()->object_store()->closure_class()
          : type.type_class());
  ASSERT(!cls.IsNull());
  if (cls.IsDynamicClass() || cls.IsVoidClass() || cls.IsNeverClass()) {
    Exceptions::ThrowArgumentError(type);
    UNREACHABLE();
  }
  return CreateClassMirror(cls, AbstractType::Handle(cls.DeclarationType()),
                           Bool::True(),  // is_declaration
                           Object::null_instance());
}

DEFINE_NATIVE_ENTRY() [257/345]

dart::DEFINE_NATIVE_ENTRY	(	Mirrors_makeLocalTypeMirror	,
		0	,
		1
	)

Definition at line 773 of file mirrors.cc.

                                                       {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
  return CreateTypeMirror(type);
}

DEFINE_NATIVE_ENTRY() [258/345]

dart::DEFINE_NATIVE_ENTRY	(	Mirrors_mangleName	,
		0	,
		2
	)

Definition at line 830 of file mirrors.cc.

                                              {
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
  const Library& lib = Library::Handle(ref.GetLibraryReferent());
  return lib.IsPrivate(name) ? lib.PrivateName(name) : name.ptr();
}

DEFINE_NATIVE_ENTRY() [259/345]

dart::DEFINE_NATIVE_ENTRY	(	MirrorSystem_isolate	,
		0	,
		0
	)

Definition at line 664 of file mirrors.cc.

                                                {
  VerifyMethodKindShifts();
 
  return CreateIsolateMirror();
}

DEFINE_NATIVE_ENTRY() [260/345]

dart::DEFINE_NATIVE_ENTRY	(	MirrorSystem_libraries	,
		0	,
		0
	)

Definition at line 644 of file mirrors.cc.

                                                  {
  const GrowableObjectArray& libraries = GrowableObjectArray::Handle(
      zone, isolate->group()->object_store()->libraries());
 
  const intptr_t num_libraries = libraries.Length();
  const GrowableObjectArray& library_mirrors = GrowableObjectArray::Handle(
      zone, GrowableObjectArray::New(num_libraries));
  Library& library = Library::Handle(zone);
  Instance& library_mirror = Instance::Handle(zone);
 
  for (int i = 0; i < num_libraries; i++) {
    library ^= libraries.At(i);
    library_mirror = CreateLibraryMirror(thread, library);
    if (!library_mirror.IsNull() && library.Loaded()) {
      library_mirrors.Add(library_mirror);
    }
  }
  return library_mirrors.ptr();
}

DEFINE_NATIVE_ENTRY() [261/345]

dart::DEFINE_NATIVE_ENTRY	(	NoSuchMethodError_existingMethodSignature	,
		0	,
		3
	)

Definition at line 586 of file object.cc.

                                                                     {
  const Instance& receiver =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(String, method_name, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, invocation_type, arguments->NativeArgAt(2));
  InvocationMirror::Level level;
  InvocationMirror::Kind kind;
  InvocationMirror::DecodeType(invocation_type.Value(), &level, &kind);
 
  Function& function = Function::Handle(zone);
  if (level == InvocationMirror::Level::kTopLevel) {
    if (receiver.IsString()) return receiver.ptr();
    ASSERT(receiver.IsNull());
    return String::null();
  }
  if (receiver.IsType()) {
    const auto& cls = Class::Handle(zone, Type::Cast(receiver).type_class());
    const auto& error = Error::Handle(zone, cls.EnsureIsFinalized(thread));
    if (!error.IsNull()) {
      Exceptions::PropagateError(error);
      UNREACHABLE();
    }
    if (level == InvocationMirror::kConstructor) {
      function = cls.LookupConstructor(method_name);
      if (function.IsNull()) {
        function = cls.LookupFactory(method_name);
      }
    } else {
      function = cls.LookupStaticFunction(method_name);
    }
  } else if (receiver.IsClosure()) {
    function = Closure::Cast(receiver).function();
  } else {
    auto& cls = Class::Handle(zone, receiver.clazz());
    if (level == InvocationMirror::kSuper) {
      cls = cls.SuperClass();
    }
    function = Resolver::ResolveDynamicAnyArgs(zone, cls, method_name,
                                               /*allow_add=*/false);
  }
  if (!function.IsNull()) {
    return function.UserVisibleSignature();
  }
  return String::null();
}

DEFINE_NATIVE_ENTRY() [262/345]

dart::DEFINE_NATIVE_ENTRY	(	Object_equals	,
		0	,
		1
	)

Definition at line 31 of file object.cc.

                                         {
  // Implemented in the flow graph builder.
  UNREACHABLE();
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [263/345]

dart::DEFINE_NATIVE_ENTRY	(	Object_getHash	,
		0	,
		1
	)

Definition at line 47 of file object.cc.

                                          {
  // Please note that no handle is created for the argument.
  // This is safe since the argument is only used in a tail call.
  // The performance benefit is more than 5% when using hashCode.
  intptr_t hash = GetHash(isolate, arguments->NativeArgAt(0));
  if (LIKELY(hash != 0)) {
    return Smi::New(hash);
  }
 
  const Instance& instance =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  return instance.IdentityHashCode(arguments->thread());
}

DEFINE_NATIVE_ENTRY() [264/345]

dart::DEFINE_NATIVE_ENTRY	(	Object_haveSameRuntimeType	,
		0	,
		2
	)

Definition at line 186 of file object.cc.

                                                      {
  const Instance& left =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Instance& right =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(1));
  return Bool::Get(HaveSameRuntimeTypeHelper(zone, left, right)).ptr();
}

DEFINE_NATIVE_ENTRY() [265/345]

dart::DEFINE_NATIVE_ENTRY	(	Object_instanceOf	,
		0	,
		4
	)

Definition at line 194 of file object.cc.

                                             {
  const Instance& instance =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  const TypeArguments& instantiator_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(1));
  const TypeArguments& function_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(2));
  const AbstractType& type =
      AbstractType::CheckedHandle(zone, arguments->NativeArgAt(3));
  ASSERT(type.IsFinalized());
  const bool is_instance_of = instance.IsInstanceOf(
      type, instantiator_type_arguments, function_type_arguments);
  if (FLAG_trace_type_checks) {
    LogBlock lb;
    const char* result_str = is_instance_of ? "true" : "false";
    THR_Print("Native Object.instanceOf: result %s\n", result_str);
    const AbstractType& instance_type =
        AbstractType::Handle(zone, instance.GetType(Heap::kNew));
    THR_Print("  instance type: %s\n", instance_type.NameCString());
    THR_Print("  test type: %s\n", type.NameCString());
  }
  return Bool::Get(is_instance_of).ptr();
}

DEFINE_NATIVE_ENTRY() [266/345]

dart::DEFINE_NATIVE_ENTRY	(	Object_runtimeType	,
		0	,
		1
	)

Definition at line 74 of file object.cc.

                                              {
  const Instance& instance =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  if (instance.IsString()) {
    return Type::StringType();
  } else if (instance.IsInteger()) {
    return Type::IntType();
  } else if (instance.IsDouble()) {
    return Type::Double();
  } else if (instance.IsAbstractType()) {
    return Type::DartTypeType();
  } else if (IsArrayClassId(instance.GetClassId())) {
    const auto& cls = Class::Handle(
        zone, thread->isolate_group()->object_store()->list_class());
    auto& type_arguments =
        TypeArguments::Handle(zone, instance.GetTypeArguments());
    type_arguments = type_arguments.FromInstanceTypeArguments(thread, cls);
    const auto& type = Type::Handle(
        zone,
        Type::New(cls, type_arguments, Nullability::kNonNullable, Heap::kNew));
    type.SetIsFinalized();
    return type.Canonicalize(thread);
  }
 
  return instance.GetType(Heap::kNew);
}

DEFINE_NATIVE_ENTRY() [267/345]

dart::DEFINE_NATIVE_ENTRY	(	Object_simpleInstanceOf	,
		0	,
		2
	)

Definition at line 218 of file object.cc.

                                                   {
  // This native is only called when the right hand side passes
  // SimpleInstanceOfType and it is a non-negative test.
  const Instance& instance =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  const AbstractType& type =
      AbstractType::CheckedHandle(zone, arguments->NativeArgAt(1));
  ASSERT(type.IsFinalized());
  ASSERT(type.IsInstantiated());
  const bool is_instance_of = instance.IsInstanceOf(
      type, Object::null_type_arguments(), Object::null_type_arguments());
  return Bool::Get(is_instance_of).ptr();
}

DEFINE_NATIVE_ENTRY() [268/345]

dart::DEFINE_NATIVE_ENTRY	(	Object_toString	,
		0	,
		1
	)

Definition at line 61 of file object.cc.

                                           {
  const Instance& instance =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  if (instance.IsString()) {
    return instance.ptr();
  }
  if (instance.IsAbstractType()) {
    return AbstractType::Cast(instance).UserVisibleName();
  }
  const char* c_str = instance.ToCString();
  return String::New(c_str);
}

DEFINE_NATIVE_ENTRY() [269/345]

dart::DEFINE_NATIVE_ENTRY	(	OneByteString_allocateFromOneByteList	,
		0	,
		3
	)

Definition at line 288 of file string.cc.

                                                                 {
  Instance& list = Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_obj, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
 
  intptr_t start = start_obj.Value();
  intptr_t end = end_obj.Value();
  if (start < 0) {
    Exceptions::ThrowArgumentError(start_obj);
  }
  intptr_t length = end - start;
  if (length < 0) {
    Exceptions::ThrowArgumentError(end_obj);
  }
  ASSERT(length >= 0);
 
  Heap::Space space = Heap::kNew;
  if (list.IsTypedDataBase()) {
    const TypedDataBase& array = TypedDataBase::Cast(list);
    if (array.ElementType() != kUint8ArrayElement) {
      Exceptions::ThrowArgumentError(list);
    }
    if (end > array.Length()) {
      Exceptions::ThrowArgumentError(end_obj);
    }
    return OneByteString::New(array, start, length, space);
  } else if (list.IsArray()) {
    const Array& array = Array::Cast(list);
    if (end > array.Length()) {
      Exceptions::ThrowArgumentError(end_obj);
    }
    String& string = String::Handle(OneByteString::New(length, space));
    for (int i = 0; i < length; i++) {
      intptr_t value = Smi::Value(static_cast<SmiPtr>(array.At(start + i)));
      OneByteString::SetCharAt(string, i, value);
    }
    return string.ptr();
  } else if (list.IsGrowableObjectArray()) {
    const GrowableObjectArray& array = GrowableObjectArray::Cast(list);
    if (end > array.Length()) {
      Exceptions::ThrowArgumentError(end_obj);
    }
    String& string = String::Handle(OneByteString::New(length, space));
    for (int i = 0; i < length; i++) {
      intptr_t value = Smi::Value(static_cast<SmiPtr>(array.At(start + i)));
      OneByteString::SetCharAt(string, i, value);
    }
    return string.ptr();
  }
  UNREACHABLE();
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [270/345]

dart::DEFINE_NATIVE_ENTRY	(	OneByteString_substringUnchecked	,
		0	,
		3
	)

Definition at line 248 of file string.cc.

                                                            {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(receiver.IsOneByteString());
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_obj, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
 
  const intptr_t start = start_obj.Value();
  const intptr_t end = end_obj.Value();
  return OneByteString::New(receiver, start, end - start, Heap::kNew);
}

DEFINE_NATIVE_ENTRY() [271/345]

dart::DEFINE_NATIVE_ENTRY	(	ParameterMirror_type	,
		0	,
		3
	)

Definition at line 1630 of file mirrors.cc.

                                                {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, pos, arguments->NativeArgAt(1));
  GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(2));
  const FunctionType& signature =
      FunctionType::Handle(ref.GetFunctionTypeReferent());
  AbstractType& type = AbstractType::Handle(signature.ParameterTypeAt(
      signature.num_implicit_parameters() + pos.Value()));
  type =
      type.Canonicalize(thread);  // Instantiated signatures are not canonical.
  return InstantiateType(type, instantiator);
}

DEFINE_NATIVE_ENTRY() [272/345]

dart::DEFINE_NATIVE_ENTRY	(	Profiler_getCurrentTag	,
		0	,
		0
	)

Definition at line 42 of file profiler.cc.

                                                  {
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Profiler_getCurrentTag\n");
  }
  return isolate->current_tag();
}

DEFINE_NATIVE_ENTRY() [273/345]

dart::DEFINE_NATIVE_ENTRY	(	Random_initialSeed	,
		0	,
		0
	)

Definition at line 25 of file math.cc.

                                              {
  Random* rnd = isolate->random();
  uint64_t seed = rnd->NextUInt32();
  seed |= (static_cast<uint64_t>(rnd->NextUInt32()) << 32);
  return Integer::New(seed);
}

DEFINE_NATIVE_ENTRY() [274/345]

dart::DEFINE_NATIVE_ENTRY	(	RawReceivePort_closeInternal	,
		0	,
		1
	)

Definition at line 72 of file isolate.cc.

                                                        {
  GET_NON_NULL_NATIVE_ARGUMENT(ReceivePort, port, arguments->NativeArgAt(0));
  Dart_Port id = port.Id();
  isolate->CloseReceivePort(port);
  return Integer::New(id);
}

DEFINE_NATIVE_ENTRY() [275/345]

dart::DEFINE_NATIVE_ENTRY	(	RawReceivePort_factory	,
		0	,
		2
	)

Definition at line 60 of file isolate.cc.

                                                  {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
  GET_NON_NULL_NATIVE_ARGUMENT(String, debug_name, arguments->NativeArgAt(1));
  return isolate->CreateReceivePort(debug_name);
}

DEFINE_NATIVE_ENTRY() [276/345]

dart::DEFINE_NATIVE_ENTRY	(	RawReceivePort_get_id	,
		0	,
		1
	)

Definition at line 67 of file isolate.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(ReceivePort, port, arguments->NativeArgAt(0));
  return Integer::New(port.Id());
}

DEFINE_NATIVE_ENTRY() [277/345]

dart::DEFINE_NATIVE_ENTRY	(	RawReceivePort_getActive	,
		0	,
		1
	)

Definition at line 86 of file isolate.cc.

                                                    {
  GET_NON_NULL_NATIVE_ARGUMENT(ReceivePort, port, arguments->NativeArgAt(0));
  return Bool::Get(port.keep_isolate_alive()).ptr();
}

DEFINE_NATIVE_ENTRY() [278/345]

dart::DEFINE_NATIVE_ENTRY	(	RawReceivePort_setActive	,
		0	,
		2
	)

Definition at line 79 of file isolate.cc.

                                                    {
  GET_NON_NULL_NATIVE_ARGUMENT(ReceivePort, port, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, active, arguments->NativeArgAt(1));
  isolate->SetReceivePortKeepAliveState(port, active.value());
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [279/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_ExecuteMatch	,
		0	,
		3
	)

Definition at line 173 of file regexp.cc.

                                               {
  // This function is intrinsified. See Intrinsifier::RegExp_ExecuteMatch.
  return ExecuteMatch(zone, arguments, /*sticky=*/false);
}

DEFINE_NATIVE_ENTRY() [280/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_ExecuteMatchSticky	,
		0	,
		3
	)

Definition at line 178 of file regexp.cc.

                                                     {
  // This function is intrinsified. See Intrinsifier::RegExp_ExecuteMatchSticky.
  return ExecuteMatch(zone, arguments, /*sticky=*/true);
}

DEFINE_NATIVE_ENTRY() [281/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_factory	,
		0	,
		6
	)

Definition at line 24 of file regexp.cc.

                                          {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
  GET_NON_NULL_NATIVE_ARGUMENT(String, pattern, arguments->NativeArgAt(1));
 
  bool multi_line = arguments->NativeArgAt(2) == Bool::True().ptr();
  bool ignore_case = arguments->NativeArgAt(3) != Bool::True().ptr();
  bool unicode = arguments->NativeArgAt(4) == Bool::True().ptr();
  bool dot_all = arguments->NativeArgAt(5) == Bool::True().ptr();
 
  RegExpFlags flags;
  flags.SetGlobal();  // All dart regexps are global.
  if (ignore_case) flags.SetIgnoreCase();
  if (multi_line) flags.SetMultiLine();
  if (unicode) flags.SetUnicode();
  if (dot_all) flags.SetDotAll();
 
  RegExpKey lookup_key(pattern, flags);
  RegExp& regexp = RegExp::Handle(thread->zone());
  {
    REUSABLE_OBJECT_HANDLESCOPE(thread);
    REUSABLE_SMI_HANDLESCOPE(thread);
    REUSABLE_WEAK_ARRAY_HANDLESCOPE(thread);
    Object& key = thread->ObjectHandle();
    Smi& value = thread->SmiHandle();
    WeakArray& data = thread->WeakArrayHandle();
    data = thread->isolate_group()->object_store()->regexp_table();
    CanonicalRegExpSet table(&key, &value, &data);
    regexp ^= table.GetOrNull(lookup_key);
    table.Release();
    if (!regexp.IsNull()) {
      return regexp.ptr();
    }
  }
 
  // Parse the pattern once in order to throw any format exceptions within
  // the factory constructor. It is parsed again upon compilation.
  RegExpCompileData compileData;
  // Throws an exception on parsing failure.
  RegExpParser::ParseRegExp(pattern, flags, &compileData);
 
  {
    RegExpKey lookup_symbol_key(String::Handle(Symbols::New(thread, pattern)),
                                flags);
    SafepointMutexLocker ml(thread->isolate_group()->symbols_mutex());
    CanonicalRegExpSet table(
        thread->zone(),
        thread->isolate_group()->object_store()->regexp_table());
    regexp ^= table.InsertNewOrGet(lookup_symbol_key);
    thread->isolate_group()->object_store()->set_regexp_table(table.Release());
  }
 
  ASSERT(regexp.flags() == flags);
  return regexp.ptr();
}

DEFINE_NATIVE_ENTRY() [282/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_getGroupCount	,
		0	,
		1
	)

Definition at line 110 of file regexp.cc.

                                                {
  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!regexp.IsNull());
  if (regexp.is_initialized()) {
    return Smi::New(regexp.num_bracket_expressions());
  }
  const String& pattern = String::Handle(regexp.pattern());
  const String& errmsg =
      String::Handle(String::New("Regular expression is not initialized yet."));
  const String& message = String::Handle(String::Concat(errmsg, pattern));
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, message);
  Exceptions::ThrowByType(Exceptions::kFormat, args);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [283/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_getGroupNameMap	,
		0	,
		1
	)

Definition at line 126 of file regexp.cc.

                                                  {
  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!regexp.IsNull());
  if (regexp.is_initialized()) {
    return regexp.capture_name_map();
  }
  const String& pattern = String::Handle(regexp.pattern());
  const String& errmsg = String::Handle(
      String::New("Regular expression is not initialized yet. "));
  const String& message = String::Handle(String::Concat(errmsg, pattern));
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, message);
  Exceptions::ThrowByType(Exceptions::kFormat, args);
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [284/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_getIsCaseSensitive	,
		0	,
		1
	)

Definition at line 104 of file regexp.cc.

                                                     {
  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!regexp.IsNull());
  return Bool::Get(!regexp.flags().IgnoreCase()).ptr();
}

DEFINE_NATIVE_ENTRY() [285/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_getIsDotAll	,
		0	,
		1
	)

Definition at line 98 of file regexp.cc.

                                              {
  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!regexp.IsNull());
  return Bool::Get(regexp.flags().IsDotAll()).ptr();
}

DEFINE_NATIVE_ENTRY() [286/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_getIsMultiLine	,
		0	,
		1
	)

Definition at line 86 of file regexp.cc.

                                                 {
  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!regexp.IsNull());
  return Bool::Get(regexp.flags().IsMultiLine()).ptr();
}

DEFINE_NATIVE_ENTRY() [287/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_getIsUnicode	,
		0	,
		1
	)

Definition at line 92 of file regexp.cc.

                                               {
  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!regexp.IsNull());
  return Bool::Get(regexp.flags().IsUnicode()).ptr();
}

DEFINE_NATIVE_ENTRY() [288/345]

dart::DEFINE_NATIVE_ENTRY	(	RegExp_getPattern	,
		0	,
		1
	)

Definition at line 80 of file regexp.cc.

                                             {
  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!regexp.IsNull());
  return regexp.pattern();
}

DEFINE_NATIVE_ENTRY() [289/345]

dart::DEFINE_NATIVE_ENTRY	(	SecureRandom_getBytes	,
		0	,
		1
	)

Definition at line 32 of file math.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, count, arguments->NativeArgAt(0));
  const intptr_t n = count.Value();
  ASSERT((n > 0) && (n <= 8));
  uint8_t buffer[8];
  Dart_EntropySource entropy_source = Dart::entropy_source_callback();
  if ((entropy_source == nullptr) || !entropy_source(buffer, n)) {
    const String& error = String::Handle(String::New(
        "No source of cryptographically secure random numbers available."));
    const Array& args = Array::Handle(Array::New(1));
    args.SetAt(0, error);
    Exceptions::ThrowByType(Exceptions::kUnsupported, args);
  }
  uint64_t result = 0;
  for (intptr_t i = 0; i < n; i++) {
    result = (result << 8) | buffer[i];
  }
  return Integer::New(result);
}

DEFINE_NATIVE_ENTRY() [290/345]

dart::DEFINE_NATIVE_ENTRY	(	SendPort_get_hashcode	,
		0	,
		1
	)

Definition at line 96 of file isolate.cc.

                                                 {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  int64_t id = port.Id();
  int32_t hi = static_cast<int32_t>(id >> 32);
  int32_t lo = static_cast<int32_t>(id);
  int32_t hash = (hi ^ lo) & kSmiMax;
  return Smi::New(hash);
}

DEFINE_NATIVE_ENTRY() [291/345]

dart::DEFINE_NATIVE_ENTRY	(	SendPort_get_id	,
		0	,
		1
	)

Definition at line 91 of file isolate.cc.

                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  return Integer::New(port.Id());
}

DEFINE_NATIVE_ENTRY() [292/345]

dart::DEFINE_NATIVE_ENTRY	(	SendPort_sendInternal_	,
		0	,
		2
	)

Definition at line 113 of file isolate.cc.

                                                  {
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, obj, arguments->NativeArgAt(1));
 
  const Dart_Port destination_port_id = port.Id();
  const bool same_group = InSameGroup(isolate, port);
#if defined(DEBUG)
  if (same_group) {
    ASSERT(PortMap::IsReceiverInThisIsolateGroupOrClosed(destination_port_id,
                                                         isolate->group()));
  }
#endif
 
  // TODO(turnidge): Throw an exception when the return value is false?
  PortMap::PostMessage(WriteMessage(same_group, obj, destination_port_id,
                                    Message::kNormalPriority));
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [293/345]

dart::DEFINE_NATIVE_ENTRY	(	Smi_bitLength	,
		0	,
		1
	)

Definition at line 264 of file integers.cc.

                                         {
  const Smi& operand = Smi::CheckedHandle(zone, arguments->NativeArgAt(0));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Smi_bitLength: %s\n", operand.ToCString());
  }
  int64_t value = operand.AsInt64Value();
  intptr_t result = Utils::BitLength(value);
  ASSERT(Smi::IsValid(result));
  return Smi::New(result);
}

DEFINE_NATIVE_ENTRY() [294/345]

dart::DEFINE_NATIVE_ENTRY	(	Smi_bitNegate	,
		0	,
		1
	)

Definition at line 254 of file integers.cc.

                                         {
  const Smi& operand = Smi::CheckedHandle(zone, arguments->NativeArgAt(0));
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("Smi_bitNegate: %s\n", operand.ToCString());
  }
  intptr_t result = ~operand.Value();
  ASSERT(Smi::IsValid(result));
  return Smi::New(result);
}

DEFINE_NATIVE_ENTRY() [295/345]

dart::DEFINE_NATIVE_ENTRY	(	StackTrace_current	,
		0	,
		0
	)

Definition at line 61 of file stacktrace.cc.

                                              {
  return CurrentStackTrace(thread);
}

DEFINE_NATIVE_ENTRY() [296/345]

dart::DEFINE_NATIVE_ENTRY	(	Stopwatch_frequency	,
		0	,
		0
	)

Definition at line 16 of file stopwatch.cc.

                                               {
  return Integer::New(OS::GetCurrentMonotonicFrequency());
}

DEFINE_NATIVE_ENTRY() [297/345]

dart::DEFINE_NATIVE_ENTRY	(	Stopwatch_now	,
		0	,
		0
	)

Definition at line 12 of file stopwatch.cc.

                                         {
  return Integer::New(OS::GetCurrentMonotonicTicks());
}

DEFINE_NATIVE_ENTRY() [298/345]

dart::DEFINE_NATIVE_ENTRY	(	String_charAt	,
		0	,
		2
	)

Definition at line 443 of file string.cc.

                                         {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, index, arguments->NativeArgAt(1));
  uint16_t value = StringValueAt(receiver, index);
  return Symbols::FromCharCode(thread, static_cast<int32_t>(value));
}

DEFINE_NATIVE_ENTRY() [299/345]

dart::DEFINE_NATIVE_ENTRY	(	String_concat	,
		0	,
		2
	)

Definition at line 451 of file string.cc.

                                         {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(String, b, arguments->NativeArgAt(1));
  return String::Concat(receiver, b);
}

DEFINE_NATIVE_ENTRY() [300/345]

dart::DEFINE_NATIVE_ENTRY	(	String_concatRange	,
		0	,
		3
	)

Definition at line 472 of file string.cc.

                                              {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, argument, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, end, arguments->NativeArgAt(2));
  const intptr_t start_ix = start.Value();
  const intptr_t end_ix = end.Value();
  if (start_ix < 0) {
    Exceptions::ThrowArgumentError(start);
  }
  Array& strings = Array::Handle();
  intptr_t length = -1;
  if (argument.IsArray()) {
    strings ^= argument.ptr();
    length = strings.Length();
  } else if (argument.IsGrowableObjectArray()) {
    const GrowableObjectArray& g_array = GrowableObjectArray::Cast(argument);
    strings = g_array.data();
    length = g_array.Length();
  } else {
    Exceptions::ThrowArgumentError(argument);
  }
  if (end_ix > length) {
    Exceptions::ThrowArgumentError(end);
  }
#if defined(DEBUG)
  // Check that the array contains strings.
  Instance& elem = Instance::Handle();
  for (intptr_t i = start_ix; i < end_ix; i++) {
    elem ^= strings.At(i);
    ASSERT(elem.IsString());
  }
#endif
  return String::ConcatAllRange(strings, start_ix, end_ix, Heap::kNew);
}

DEFINE_NATIVE_ENTRY() [301/345]

dart::DEFINE_NATIVE_ENTRY	(	String_fromEnvironment	,
		0	,
		3
	)

Definition at line 19 of file string.cc.

                                                  {
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(1));
  GET_NATIVE_ARGUMENT(String, default_value, arguments->NativeArgAt(2));
  // Call the embedder to supply us with the environment.
  const String& env_value =
      String::Handle(Api::GetEnvironmentValue(thread, name));
  if (!env_value.IsNull()) {
    return Symbols::New(thread, env_value);
  }
  return default_value.ptr();
}

DEFINE_NATIVE_ENTRY() [302/345]

dart::DEFINE_NATIVE_ENTRY	(	String_getHashCode	,
		0	,
		1
	)

Definition at line 415 of file string.cc.

                                              {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  intptr_t hash_val = receiver.Hash();
  ASSERT(hash_val > 0);
  ASSERT(Smi::IsValid(hash_val));
  return Smi::New(hash_val);
}

DEFINE_NATIVE_ENTRY() [303/345]

dart::DEFINE_NATIVE_ENTRY	(	String_getLength	,
		0	,
		1
	)

Definition at line 424 of file string.cc.

                                            {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Smi::New(receiver.Length());
}

DEFINE_NATIVE_ENTRY() [304/345]

dart::DEFINE_NATIVE_ENTRY	(	String_toLowerCase	,
		0	,
		1
	)

Definition at line 458 of file string.cc.

                                              {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!receiver.IsNull());
  return String::ToLowerCase(receiver);
}

DEFINE_NATIVE_ENTRY() [305/345]

dart::DEFINE_NATIVE_ENTRY	(	String_toUpperCase	,
		0	,
		1
	)

Definition at line 465 of file string.cc.

                                              {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!receiver.IsNull());
  return String::ToUpperCase(receiver);
}

DEFINE_NATIVE_ENTRY() [306/345]

dart::DEFINE_NATIVE_ENTRY	(	StringBase_createFromCodePoints	,
		0	,
		3
	)

Definition at line 31 of file string.cc.

                                                           {
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, list, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_obj, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
 
  Array& a = Array::Handle();
  intptr_t length;
  if (list.IsGrowableObjectArray()) {
    const GrowableObjectArray& growableArray = GrowableObjectArray::Cast(list);
    a = growableArray.data();
    length = growableArray.Length();
  } else if (list.IsArray()) {
    a = Array::Cast(list).ptr();
    length = a.Length();
  } else {
    Exceptions::ThrowArgumentError(list);
    return nullptr;  // Unreachable.
  }
 
  intptr_t start = start_obj.Value();
  if ((start < 0) || (start > length)) {
    Exceptions::ThrowArgumentError(start_obj);
  }
 
  intptr_t end = end_obj.Value();
  if ((end < start) || (end > length)) {
    Exceptions::ThrowArgumentError(end_obj);
  }
 
  // Unbox the array and determine the maximum element width.
  bool is_one_byte_string = true;
  intptr_t array_len = end - start;
  intptr_t utf16_len = array_len;
  int32_t* utf32_array = zone->Alloc<int32_t>(array_len);
  Instance& index_object = Instance::Handle(zone);
  for (intptr_t i = 0; i < array_len; i++) {
    index_object ^= a.At(start + i);
    if (!index_object.IsSmi()) {
      Exceptions::ThrowArgumentError(index_object);
    }
    intptr_t value = Smi::Cast(index_object).Value();
    if (Utf::IsOutOfRange(value)) {
      Exceptions::ThrowByType(Exceptions::kArgument, Object::empty_array());
      UNREACHABLE();
    }
    // Now it is safe to cast the value.
    int32_t value32 = static_cast<int32_t>(value);
    if (!Utf::IsLatin1(value32)) {
      is_one_byte_string = false;
      if (Utf::IsSupplementary(value32)) {
        utf16_len += 1;
      }
    }
    utf32_array[i] = value32;
  }
  if (is_one_byte_string) {
    return OneByteString::New(utf32_array, array_len, Heap::kNew);
  }
  return TwoByteString::New(utf16_len, utf32_array, array_len, Heap::kNew);
}

DEFINE_NATIVE_ENTRY() [307/345]

dart::DEFINE_NATIVE_ENTRY	(	StringBase_intern	,
		0	,
		1
	)

Definition at line 242 of file string.cc.

                                             {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  return Symbols::New(thread, receiver);
}

DEFINE_NATIVE_ENTRY() [308/345]

dart::DEFINE_NATIVE_ENTRY	(	StringBase_joinReplaceAllResult	,
		0	,
		4
	)

Definition at line 157 of file string.cc.

                                                           {
  const String& base = String::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(GrowableObjectArray, matches_growable,
                               arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length_obj, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, is_onebyte_obj, arguments->NativeArgAt(3));
 
  intptr_t len = matches_growable.Length();
  const Array& matches = Array::Handle(zone, matches_growable.data());
 
  const intptr_t length = length_obj.Value();
  if (length < 0) {
    Exceptions::ThrowArgumentError(length_obj);
  }
 
  // Start out assuming result is one-byte if replacements are.
  bool is_onebyte = is_onebyte_obj.value();
  if (is_onebyte) {
    // If any of the base string slices are not one-byte, the result will be
    // a two-byte string.
    if (!base.IsOneByteString()) {
      is_onebyte = CheckSlicesOneByte(base, matches, len);
    }
  }
 
  const intptr_t base_length = base.Length();
  String& result = String::Handle(zone);
  if (is_onebyte) {
    result = OneByteString::New(length, Heap::kNew);
  } else {
    result = TwoByteString::New(length, Heap::kNew);
  }
  Instance& object = Instance::Handle(zone);
  intptr_t write_index = 0;
  for (intptr_t i = 0; i < len; i++) {
    object ^= matches.At(i);
    if (object.IsSmi()) {
      intptr_t slice_start = Smi::Cast(object).Value();
      intptr_t slice_length = -1;
      // Slices with limited ranges are stored in a single negative Smi.
      if (slice_start < 0) {
        intptr_t bits = -slice_start;
        slice_start = bits >> kLengthSize;
        slice_length = bits & kLengthMask;
      } else {
        i++;
        if (i < len) {  // Otherwise slice_length stays at -1.
          object ^= matches.At(i);
          if (object.IsSmi()) {
            intptr_t slice_end = Smi::Cast(object).Value();
            slice_length = slice_end - slice_start;
          }
        }
      }
      if (slice_length > 0) {
        if (0 <= slice_start && slice_start + slice_length <= base_length &&
            write_index + slice_length <= length) {
          String::Copy(result, write_index, base, slice_start, slice_length);
          write_index += slice_length;
          continue;
        }
      }
      // Either the slice_length was zero,
      // or the first smi was positive and not followed by another smi,
      // or the smis were not a valid slice of the base string,
      // or the slice was too large to fit in the result.
      // Something is wrong with the matches array!
      Exceptions::ThrowArgumentError(matches_growable);
    } else if (object.IsString()) {
      const String& replacement = String::Cast(object);
      intptr_t replacement_length = replacement.Length();
      if (write_index + replacement_length > length) {
        // Invalid input data, either in matches list or the total length.
        Exceptions::ThrowArgumentError(matches_growable);
      }
      String::Copy(result, write_index, replacement, 0, replacement_length);
      write_index += replacement_length;
    }
  }
  if (write_index < length) {
    Exceptions::ThrowArgumentError(matches_growable);
  }
  return result.ptr();
}

DEFINE_NATIVE_ENTRY() [309/345]

dart::DEFINE_NATIVE_ENTRY	(	StringBase_substringUnchecked	,
		0	,
		3
	)

Definition at line 92 of file string.cc.

                                                         {
  const String& receiver =
      String::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_obj, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
 
  intptr_t start = start_obj.Value();
  intptr_t end = end_obj.Value();
  return String::SubString(receiver, start, (end - start));
}

DEFINE_NATIVE_ENTRY() [310/345]

dart::DEFINE_NATIVE_ENTRY	(	StringBuffer_createStringFromUint16Array	,
		0	,
		3
	)

Definition at line 507 of file string.cc.

                                                                    {
  GET_NON_NULL_NATIVE_ARGUMENT(TypedData, codeUnits, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, isLatin1, arguments->NativeArgAt(2));
  intptr_t array_length = codeUnits.Length();
  intptr_t length_value = length.Value();
  if (length_value < 0 || length_value > array_length) {
    Exceptions::ThrowRangeError("length", length, 0, array_length);
  }
  const String& result =
      isLatin1.value()
          ? String::Handle(OneByteString::New(length_value, Heap::kNew))
          : String::Handle(TwoByteString::New(length_value, Heap::kNew));
  NoSafepointScope no_safepoint;
 
  uint16_t* data_position = reinterpret_cast<uint16_t*>(codeUnits.DataAddr(0));
  String::Copy(result, 0, data_position, length_value);
  return result.ptr();
}

DEFINE_NATIVE_ENTRY() [311/345]

dart::DEFINE_NATIVE_ENTRY	(	SuspendState_instantiateClosureWithFutureTypeArgument	,
		0	,
		2
	)

Definition at line 28 of file async.cc.

                       {
  GET_NON_NULL_NATIVE_ARGUMENT(Closure, closure, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, future, arguments->NativeArgAt(1));
  IsolateGroup* isolate_group = thread->isolate_group();
 
  const auto& future_class =
      Class::Handle(zone, isolate_group->object_store()->future_class());
  ASSERT(future_class.NumTypeArguments() == 1);
 
  const auto& cls = Class::Handle(zone, future.clazz());
  auto& type = Type::Handle(zone, cls.GetInstantiationOf(zone, future_class));
  ASSERT(!type.IsNull());
  if (!type.IsInstantiated()) {
    const auto& instance_type_args =
        TypeArguments::Handle(zone, future.GetTypeArguments());
    type ^=
        type.InstantiateFrom(instance_type_args, Object::null_type_arguments(),
                             kNoneFree, Heap::kOld);
  }
  auto& type_args = TypeArguments::Handle(zone, type.arguments());
  ASSERT(type_args.IsNull() || type_args.Length() == 1);
  type_args = type_args.Canonicalize(thread);
 
  ASSERT(closure.delayed_type_arguments() ==
         Object::empty_type_arguments().ptr());
  closure.set_delayed_type_arguments(type_args);
  return closure.ptr();
}

DEFINE_NATIVE_ENTRY() [312/345]

dart::DEFINE_NATIVE_ENTRY	(	Timeline_getNextTaskId	,
		0	,
		0
	)

Definition at line 27 of file timeline.cc.

                                                  {
#if !defined(SUPPORT_TIMELINE)
  return Integer::New(0);
#else
  return Integer::New(thread->GetNextTaskId());
#endif
}

DEFINE_NATIVE_ENTRY() [313/345]

dart::DEFINE_NATIVE_ENTRY	(	Timeline_getTraceClock	,
		0	,
		0
	)

Definition at line 35 of file timeline.cc.

                                                  {
  return Integer::New(OS::GetCurrentMonotonicMicros(), Heap::kNew);
}

DEFINE_NATIVE_ENTRY() [314/345]

dart::DEFINE_NATIVE_ENTRY	(	Timeline_isDartStreamEnabled	,
		0	,
		0
	)

Definition at line 18 of file timeline.cc.

                                                        {
#if defined(SUPPORT_TIMELINE)
  if (Timeline::GetDartStream()->enabled()) {
    return Bool::True().ptr();
  }
#endif
  return Bool::False().ptr();
}

DEFINE_NATIVE_ENTRY() [315/345]

dart::DEFINE_NATIVE_ENTRY	(	Timeline_reportTaskEvent	,
		0	,
		5
	)

Definition at line 39 of file timeline.cc.

                                                    {
#if defined(SUPPORT_TIMELINE)
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, id, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Integer, flow_id, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, type, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(String, args, arguments->NativeArgAt(4));
 
  TimelineEventRecorder* recorder = Timeline::recorder();
  if (recorder == nullptr) {
    return Object::null();
  }
 
  TimelineEvent* event = Timeline::GetDartStream()->StartEvent();
  if (event == nullptr) {
    // Stream was turned off.
    return Object::null();
  }
 
  std::unique_ptr<const int64_t[]> flow_ids;
  if (flow_id.AsInt64Value() != TimelineEvent::kNoFlowId) {
    int64_t* flow_ids_internal = new int64_t[1];
    flow_ids_internal[0] = flow_id.AsInt64Value();
    flow_ids = std::unique_ptr<const int64_t[]>(flow_ids_internal);
  }
  intptr_t flow_id_count =
      flow_id.AsInt64Value() == TimelineEvent::kNoFlowId ? 0 : 1;
  DartTimelineEventHelpers::ReportTaskEvent(
      event, id.AsInt64Value(), flow_id_count, flow_ids, type.Value(),
      name.ToMallocCString(), args.ToMallocCString());
#endif  // SUPPORT_TIMELINE
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [316/345]

dart::DEFINE_NATIVE_ENTRY	(	TransferableTypedData_factory	,
		0	,
		2
	)

Definition at line 1129 of file isolate.cc.

                                                         {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
 
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, array_instance,
                               arguments->NativeArgAt(1));
 
  Array& array = Array::Handle();
  intptr_t array_length;
  if (array_instance.IsGrowableObjectArray()) {
    const auto& growable_array = GrowableObjectArray::Cast(array_instance);
    array ^= growable_array.data();
    array_length = growable_array.Length();
  } else if (array_instance.IsArray()) {
    array ^= Array::Cast(array_instance).ptr();
    array_length = array.Length();
  } else {
    Exceptions::ThrowArgumentError(array_instance);
    UNREACHABLE();
  }
  Instance& instance = Instance::Handle();
  uint64_t total_bytes = 0;
  const uint64_t kMaxBytes = TypedData::MaxElements(kTypedDataUint8ArrayCid);
  for (intptr_t i = 0; i < array_length; i++) {
    instance ^= array.At(i);
    total_bytes += static_cast<uintptr_t>(GetTypedDataSizeOrThrow(instance));
    if (total_bytes > kMaxBytes) {
      const Array& error_args = Array::Handle(Array::New(3));
      error_args.SetAt(0, array);
      error_args.SetAt(1, String::Handle(String::New("data")));
      error_args.SetAt(
          2, String::Handle(String::NewFormatted(
                 "Aggregated list exceeds max size %" Pu64 "", kMaxBytes)));
      Exceptions::ThrowByType(Exceptions::kArgumentValue, error_args);
      UNREACHABLE();
    }
  }
 
  uint8_t* data = reinterpret_cast<uint8_t*>(::malloc(total_bytes));
  if (data == nullptr) {
    const Instance& exception = Instance::Handle(
        thread->isolate_group()->object_store()->out_of_memory());
    Exceptions::Throw(thread, exception);
    UNREACHABLE();
  }
  intptr_t offset = 0;
  for (intptr_t i = 0; i < array_length; i++) {
    instance ^= array.At(i);
 
    {
      NoSafepointScope no_safepoint;
      const auto& typed_data = TypedDataBase::Cast(instance);
      const intptr_t length_in_bytes = typed_data.LengthInBytes();
 
      void* source = typed_data.DataAddr(0);
      // The memory does not overlap.
      memcpy(data + offset, source, length_in_bytes);  // NOLINT
      offset += length_in_bytes;
    }
  }
  ASSERT(static_cast<uintptr_t>(offset) == total_bytes);
  return TransferableTypedData::New(data, total_bytes);
}

DEFINE_NATIVE_ENTRY() [317/345]

dart::DEFINE_NATIVE_ENTRY	(	TransferableTypedData_materialize	,
		0	,
		1
	)

Definition at line 1193 of file isolate.cc.

                                                             {
  GET_NON_NULL_NATIVE_ARGUMENT(TransferableTypedData, t,
                               arguments->NativeArgAt(0));
 
  void* peer;
  {
    NoSafepointScope no_safepoint;
    peer = thread->heap()->GetPeer(t.ptr());
    // Assume that object's Peer is only used to track transferability state.
    ASSERT(peer != nullptr);
  }
 
  TransferableTypedDataPeer* tpeer =
      reinterpret_cast<TransferableTypedDataPeer*>(peer);
  const intptr_t length = tpeer->length();
  uint8_t* data = tpeer->data();
  if (data == nullptr) {
    const auto& error = String::Handle(String::New(
        "Attempt to materialize object that was transferred already."));
    Exceptions::ThrowArgumentError(error);
    UNREACHABLE();
  }
  tpeer->handle()->EnsureFreedExternal(IsolateGroup::Current());
  tpeer->ClearData();
 
  const ExternalTypedData& typed_data = ExternalTypedData::Handle(
      ExternalTypedData::New(kExternalTypedDataUint8ArrayCid, data, length,
                             thread->heap()->SpaceForExternal(length)));
  FinalizablePersistentHandle* finalizable_ref =
      FinalizablePersistentHandle::New(thread->isolate_group(), typed_data,
                                       /* peer= */ data,
                                       &ExternalTypedDataFinalizer, length,
                                       /*auto_delete=*/true);
  ASSERT(finalizable_ref != nullptr);
  return typed_data.ptr();
}

DEFINE_NATIVE_ENTRY() [318/345]

dart::DEFINE_NATIVE_ENTRY	(	TwoByteString_allocateFromTwoByteList	,
		0	,
		3
	)

Definition at line 361 of file string.cc.

                                                                 {
  Instance& list = Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_obj, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
 
  intptr_t start = start_obj.Value();
  intptr_t end = end_obj.Value();
  if (start < 0) {
    Exceptions::ThrowArgumentError(start_obj);
  }
  intptr_t length = end - start;
  if (length < 0) {
    Exceptions::ThrowArgumentError(end_obj);
  }
 
  Heap::Space space = Heap::kNew;
  if (list.IsTypedDataBase()) {
    const TypedDataBase& array = TypedDataBase::Cast(list);
    if (array.ElementType() != kUint16ArrayElement) {
      Exceptions::ThrowArgumentError(list);
    }
    if (end > array.Length()) {
      Exceptions::ThrowArgumentError(end_obj);
    }
    return TwoByteString::New(array, start * sizeof(uint16_t), length, space);
  } else if (list.IsArray()) {
    const Array& array = Array::Cast(list);
    if (end > array.Length()) {
      Exceptions::ThrowArgumentError(end_obj);
    }
    const String& string =
        String::Handle(zone, TwoByteString::New(length, space));
    for (int i = 0; i < length; i++) {
      intptr_t value = Smi::Value(static_cast<SmiPtr>(array.At(start + i)));
      TwoByteString::SetCharAt(string, i, value);
    }
    return string.ptr();
  } else if (list.IsGrowableObjectArray()) {
    const GrowableObjectArray& array = GrowableObjectArray::Cast(list);
    if (end > array.Length()) {
      Exceptions::ThrowArgumentError(end_obj);
    }
    const String& string =
        String::Handle(zone, TwoByteString::New(length, space));
    for (int i = 0; i < length; i++) {
      intptr_t value = Smi::Value(static_cast<SmiPtr>(array.At(start + i)));
      TwoByteString::SetCharAt(string, i, value);
    }
    return string.ptr();
  }
  UNREACHABLE();
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [319/345]

dart::DEFINE_NATIVE_ENTRY	(	Type_equality	,
		0	,
		2
	)

Definition at line 258 of file object.cc.

                                         {
  const Type& type = Type::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Instance& other =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(1));
  if (type.ptr() == other.ptr()) {
    return Bool::True().ptr();
  }
  return Bool::Get(type.IsEquivalent(other, TypeEquality::kSyntactical)).ptr();
}

DEFINE_NATIVE_ENTRY() [320/345]

dart::DEFINE_NATIVE_ENTRY	(	TypedDataBase_length	,
		0	,
		1
	)

Definition at line 18 of file typed_data.cc.

                                                {
  GET_NON_NULL_NATIVE_ARGUMENT(TypedDataBase, array, arguments->NativeArgAt(0));
  return Smi::New(array.Length());
}

DEFINE_NATIVE_ENTRY() [321/345]

dart::DEFINE_NATIVE_ENTRY	(	TypedDataBase_setClampedRange	,
		0	,
		5
	)

Definition at line 46 of file typed_data.cc.

                                                         {
  // This is called after bounds checking, so the numeric inputs are
  // guaranteed to be Smis, and the length is guaranteed to be non-zero.
  const TypedDataBase& dst =
      TypedDataBase::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Smi& dst_start_smi =
      Smi::CheckedHandle(zone, arguments->NativeArgAt(1));
  const Smi& length_smi = Smi::CheckedHandle(zone, arguments->NativeArgAt(2));
  const TypedDataBase& src =
      TypedDataBase::CheckedHandle(zone, arguments->NativeArgAt(3));
  const Smi& src_start_smi =
      Smi::CheckedHandle(zone, arguments->NativeArgAt(4));
 
  const intptr_t element_size_in_bytes = dst.ElementSizeInBytes();
  ASSERT_EQUAL(src.ElementSizeInBytes(), element_size_in_bytes);
 
  const intptr_t dst_start_in_bytes =
      dst_start_smi.Value() * element_size_in_bytes;
  const intptr_t length_in_bytes = length_smi.Value() * element_size_in_bytes;
  const intptr_t src_start_in_bytes =
      src_start_smi.Value() * element_size_in_bytes;
 
#if defined(DEBUG)
  // Verify bounds checks weren't needed.
  ASSERT(dst_start_in_bytes >= 0);
  ASSERT(src_start_in_bytes >= 0);
  // The callers of this native function never call it for a zero-sized copy.
  ASSERT(length_in_bytes > 0);
 
  const intptr_t dst_length_in_bytes = dst.LengthInBytes();
  // Since the length is non-zero, the start can't be the same as the end.
  ASSERT(dst_start_in_bytes < dst_length_in_bytes);
  ASSERT(length_in_bytes <= dst_length_in_bytes - dst_start_in_bytes);
 
  const intptr_t src_length_in_bytes = src.LengthInBytes();
  // Since the length is non-zero, the start can't be the same as the end.
  ASSERT(src_start_in_bytes < src_length_in_bytes);
  ASSERT(length_in_bytes <= src_length_in_bytes - src_start_in_bytes);
#endif
 
  ASSERT(IsClampedTypedDataBaseClassId(dst.ptr()->GetClassId()));
  // The algorithm below assumes the clamped destination has uint8 elements.
  ASSERT_EQUAL(element_size_in_bytes, 1);
  ASSERT(IsTypedDataUint8ArrayClassId(dst.ptr()->GetClassId()));
  // The native entry should only be called when clamping is needed. When the
  // source has uint8 elements, a direct memory move should be used instead.
  ASSERT(!IsTypedDataUint8ArrayClassId(src.ptr()->GetClassId()));
 
  NoSafepointScope no_safepoint;
  uint8_t* dst_data =
      reinterpret_cast<uint8_t*>(dst.DataAddr(dst_start_in_bytes));
  int8_t* src_data =
      reinterpret_cast<int8_t*>(src.DataAddr(src_start_in_bytes));
  for (intptr_t ix = 0; ix < length_in_bytes; ix++) {
    int8_t v = *src_data;
    if (v < 0) v = 0;
    *dst_data = v;
    src_data++;
    dst_data++;
  }
 
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [322/345]

dart::DEFINE_NATIVE_ENTRY	(	TypedDataView_offsetInBytes	,
		0	,
		1
	)

Definition at line 23 of file typed_data.cc.

                                                       {
  // "this" is either a _*ArrayView class or _ByteDataView.
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0));
  ASSERT(instance.IsTypedDataView());
  return TypedDataView::Cast(instance).offset_in_bytes();
}

DEFINE_NATIVE_ENTRY() [323/345]

dart::DEFINE_NATIVE_ENTRY	(	TypedDataView_typedData	,
		0	,
		1
	)

Definition at line 30 of file typed_data.cc.

                                                   {
  // "this" is either a _*ArrayView class or _ByteDataView.
  GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0));
  ASSERT(instance.IsTypedDataView());
  return TypedDataView::Cast(instance).typed_data();
}

DEFINE_NATIVE_ENTRY() [324/345]

dart::DEFINE_NATIVE_ENTRY	(	TypeError_throwNew	,
		0	,
		4
	)

Definition at line 155 of file errors.cc.

                                              {
  // No need to type check the arguments. This function can only be called
  // internally from the VM.
  const TokenPosition location = TokenPosition::Deserialize(
      Smi::CheckedHandle(zone, arguments->NativeArgAt(0)).Value());
  const Instance& src_value =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(1));
  const AbstractType& dst_type =
      AbstractType::CheckedHandle(zone, arguments->NativeArgAt(2));
  const String& dst_name =
      String::CheckedHandle(zone, arguments->NativeArgAt(3));
  const AbstractType& src_type =
      AbstractType::Handle(src_value.GetType(Heap::kNew));
  Exceptions::CreateAndThrowTypeError(location, src_type, dst_type, dst_name);
  UNREACHABLE();
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [325/345]

dart::DEFINE_NATIVE_ENTRY	(	TypeMirror_subtypeTest	,
		0	,
		2
	)

Definition at line 1651 of file mirrors.cc.

                                                  {
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1));
  return Bool::Get(a.IsSubtypeOf(b, Heap::kNew)).ptr();
}

DEFINE_NATIVE_ENTRY() [326/345]

dart::DEFINE_NATIVE_ENTRY	(	TypeVariableMirror_owner	,
		0	,
		1
	)

Definition at line 1210 of file mirrors.cc.

                                                    {
  // Type parameters do not have a reference to their owner anymore.
  const AbstractType& type = AbstractType::Handle(Type::NullType());
  Class& owner = Class::Handle(type.type_class());
  return CreateClassMirror(owner, type,
                           Bool::True(),  // is_declaration
                           Instance::null_instance());
}

DEFINE_NATIVE_ENTRY() [327/345]

dart::DEFINE_NATIVE_ENTRY	(	TypeVariableMirror_upper_bound	,
		0	,
		1
	)

Definition at line 1219 of file mirrors.cc.

                                                          {
  GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0));
  return param.bound();
}

DEFINE_NATIVE_ENTRY() [328/345]

dart::DEFINE_NATIVE_ENTRY	(	Uri_isWindowsPlatform	,
		0	,
		0
	)

Definition at line 11 of file uri.cc.

                                                 {
#if defined(DART_HOST_OS_WINDOWS)
  return Bool::True().ptr();
#else
  return Bool::False().ptr();
#endif
}

DEFINE_NATIVE_ENTRY() [329/345]

dart::DEFINE_NATIVE_ENTRY	(	UserTag_defaultTag	,
		0	,
		0
	)

Definition at line 35 of file profiler.cc.

                                              {
  if (FLAG_trace_intrinsified_natives) {
    OS::PrintErr("UserTag_defaultTag\n");
  }
  return isolate->default_tag();
}

DEFINE_NATIVE_ENTRY() [330/345]

dart::DEFINE_NATIVE_ENTRY	(	UserTag_label	,
		0	,
		1
	)

Definition at line 25 of file profiler.cc.

                                         {
  const UserTag& self = UserTag::CheckedHandle(zone, arguments->NativeArgAt(0));
  return self.label();
}

DEFINE_NATIVE_ENTRY() [331/345]

dart::DEFINE_NATIVE_ENTRY	(	UserTag_makeCurrent	,
		0	,
		1
	)

Definition at line 30 of file profiler.cc.

                                               {
  const UserTag& self = UserTag::CheckedHandle(zone, arguments->NativeArgAt(0));
  return self.MakeActive();
}

DEFINE_NATIVE_ENTRY() [332/345]

dart::DEFINE_NATIVE_ENTRY	(	UserTag_new	,
		0	,
		2
	)

Definition at line 18 of file profiler.cc.

                                       {
  ASSERT(
      TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
  GET_NON_NULL_NATIVE_ARGUMENT(String, tag_label, arguments->NativeArgAt(1));
  return UserTag::New(tag_label);
}

DEFINE_NATIVE_ENTRY() [333/345]

dart::DEFINE_NATIVE_ENTRY	(	VariableMirror_type	,
		0	,
		2
	)

Definition at line 1643 of file mirrors.cc.

                                               {
  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
  const Field& field = Field::Handle(ref.GetFieldReferent());
  GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1));
  const AbstractType& type = AbstractType::Handle(field.type());
  return InstantiateType(type, instantiator);
}

DEFINE_NATIVE_ENTRY() [334/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_AddUserTagsToStreamableSampleList	,
		0	,
		1
	)

Definition at line 419 of file vmservice.cc.

                                                                       {
#ifndef PRODUCT
  GET_NON_NULL_NATIVE_ARGUMENT(GrowableObjectArray, user_tags,
                               arguments->NativeArgAt(0));
 
  Object& obj = Object::Handle();
  for (intptr_t i = 0; i < user_tags.Length(); ++i) {
    obj = user_tags.At(i);
    UserTags::AddStreamableTagName(obj.ToCString());
  }
  UserTagIsolatesVisitor visitor(thread, &user_tags, true);
  Isolate::VisitIsolates(&visitor);
#endif
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [335/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_CancelStream	,
		0	,
		1
	)

Definition at line 143 of file vmservice.cc.

                                                  {
#ifndef PRODUCT
  GET_NON_NULL_NATIVE_ARGUMENT(String, stream_id, arguments->NativeArgAt(0));
  Service::CancelStream(stream_id.ToCString());
#endif
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [336/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_DecodeAssets	,
		0	,
		1
	)

Definition at line 329 of file vmservice.cc.

                                                  {
#ifndef PRODUCT
  GET_NON_NULL_NATIVE_ARGUMENT(TypedData, data, arguments->NativeArgAt(0));
  Api::Scope scope(thread);
  Dart_Handle data_handle = Api::NewHandle(thread, data.ptr());
  Dart_Handle result_list;
  {
    TransitionVMToNative transition(thread);
 
    Dart_TypedData_Type typ;
    void* bytes;
    intptr_t length;
    Dart_Handle err =
        Dart_TypedDataAcquireData(data_handle, &typ, &bytes, &length);
    ASSERT(!Dart_IsError(err));
 
    TarArchive archive(reinterpret_cast<uint8_t*>(bytes), length);
    archive.Read();
 
    err = Dart_TypedDataReleaseData(data_handle);
    ASSERT(!Dart_IsError(err));
 
    intptr_t archive_size = archive.Length();
 
    result_list = Dart_NewList(2 * archive_size);
    ASSERT(!Dart_IsError(result_list));
 
    intptr_t idx = 0;
    while (archive.HasMore()) {
      char* filename = archive.NextFilename();
      intptr_t filename_length = strlen(filename);
      uint8_t* contents = archive.NextContent();
      intptr_t contents_length = archive.NextContentLength();
 
      Dart_Handle dart_filename = Dart_NewStringFromUTF8(
          reinterpret_cast<uint8_t*>(filename), filename_length);
      ASSERT(!Dart_IsError(dart_filename));
 
      Dart_Handle dart_contents = Dart_NewExternalTypedDataWithFinalizer(
          Dart_TypedData_kUint8, contents, contents_length, contents,
          contents_length, ContentsFinalizer);
      ASSERT(!Dart_IsError(dart_contents));
 
      Dart_ListSetAt(result_list, idx, dart_filename);
      Dart_ListSetAt(result_list, (idx + 1), dart_contents);
      idx += 2;
    }
  }
  return Api::UnwrapArrayHandle(thread->zone(), result_list).ptr();
#else
  return Object::null();
#endif
}

DEFINE_NATIVE_ENTRY() [337/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_ListenStream	,
		0	,
		2
	)

Definition at line 130 of file vmservice.cc.

                                                  {
#ifndef PRODUCT
  GET_NON_NULL_NATIVE_ARGUMENT(String, stream_id, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Bool, include_privates,
                               arguments->NativeArgAt(1));
  bool result =
      Service::ListenStream(stream_id.ToCString(), include_privates.value());
  return Bool::Get(result).ptr();
#else
  return Object::null();
#endif
}

DEFINE_NATIVE_ENTRY() [338/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_OnExit	,
		0	,
		0
	)

Definition at line 107 of file vmservice.cc.

                                            {
#ifndef PRODUCT
  if (FLAG_trace_service) {
    OS::PrintErr("vm-service: processed exit message.\n");
    OS::PrintErr("vm-service: has live ports: %s\n",
                 isolate->HasLivePorts() ? "yes" : "no");
  }
#endif
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [339/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_OnServerAddressChange	,
		0	,
		1
	)

Definition at line 118 of file vmservice.cc.

                                                           {
#ifndef PRODUCT
  GET_NATIVE_ARGUMENT(String, address, arguments->NativeArgAt(0));
  if (address.IsNull()) {
    ServiceIsolate::SetServerAddress(nullptr);
  } else {
    ServiceIsolate::SetServerAddress(address.ToCString());
  }
#endif
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [340/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_OnStart	,
		0	,
		0
	)

Definition at line 89 of file vmservice.cc.

                                             {
#ifndef PRODUCT
  if (FLAG_trace_service) {
    OS::PrintErr("vm-service: Booting dart:vmservice library.\n");
  }
  // Boot the dart:vmservice library.
  ServiceIsolate::BootVmServiceLibrary();
  // Register running isolates with service.
  RegisterRunningIsolatesVisitor register_isolates(thread);
  if (FLAG_trace_service) {
    OS::PrintErr("vm-service: Registering running isolates.\n");
  }
  Isolate::VisitIsolates(&register_isolates);
  register_isolates.RegisterIsolates();
#endif
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [341/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_RemoveUserTagsFromStreamableSampleList	,
		0	,
		1
	)

Definition at line 435 of file vmservice.cc.

                                                                            {
#ifndef PRODUCT
  GET_NON_NULL_NATIVE_ARGUMENT(GrowableObjectArray, user_tags,
                               arguments->NativeArgAt(0));
 
  Object& obj = Object::Handle();
  for (intptr_t i = 0; i < user_tags.Length(); ++i) {
    obj = user_tags.At(i);
    UserTags::RemoveStreamableTagName(obj.ToCString());
  }
  UserTagIsolatesVisitor visitor(thread, &user_tags, false);
  Isolate::VisitIsolates(&visitor);
#endif
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [342/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_RequestAssets	,
		0	,
		0
	)

Definition at line 151 of file vmservice.cc.

                                                   {
#ifndef PRODUCT
  return Service::RequestAssets();
#else
  return Object::null();
#endif
}

DEFINE_NATIVE_ENTRY() [343/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_SendIsolateServiceMessage	,
		0	,
		2
	)

Definition at line 54 of file vmservice.cc.

                                                               {
#ifndef PRODUCT
  GET_NON_NULL_NATIVE_ARGUMENT(SendPort, sp, arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Array, message, arguments->NativeArgAt(1));
 
  // Set the type of the OOB message.
  message.SetAt(0,
                Smi::Handle(thread->zone(), Smi::New(Message::kServiceOOBMsg)));
 
  // Serialize message.
  // TODO(turnidge): Throw an exception when the return value is false?
  bool result = PortMap::PostMessage(WriteMessage(
      /* same_group */ false, message, sp.Id(), Message::kOOBPriority));
  return Bool::Get(result).ptr();
#else
  return Object::null();
#endif
}

DEFINE_NATIVE_ENTRY() [344/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_SendObjectRootServiceMessage	,
		0	,
		1
	)

Definition at line 81 of file vmservice.cc.

                                                                  {
#ifndef PRODUCT
  GET_NON_NULL_NATIVE_ARGUMENT(Array, message, arguments->NativeArgAt(0));
  return Service::HandleObjectRootMessage(message);
#endif
  return Object::null();
}

DEFINE_NATIVE_ENTRY() [345/345]

dart::DEFINE_NATIVE_ENTRY	(	VMService_SendRootServiceMessage	,
		0	,
		1
	)

Definition at line 73 of file vmservice.cc.

                                                            {
#ifndef PRODUCT
  GET_NON_NULL_NATIVE_ARGUMENT(Array, message, arguments->NativeArgAt(0));
  return Service::HandleRootMessage(message);
#endif
  return Object::null();
}

DEFINE_OPTION_HANDLER() [1/2]

dart::DEFINE_OPTION_HANDLER	(	CompilerPass::ParseFiltersFromFlag	,
		compiler_passes	,
		"List of comma separated compilation passes flags. " "Use -Name to disable a	pass
	)

DEFINE_OPTION_HANDLER() [2/2]

dart::DEFINE_OPTION_HANDLER	(	KernelIsolate::AddExperimentalFlag	,
		enable_experiment	,
		"Comma separated list of experimental features."
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [1/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	AllocateHandle	,
		1	,
		false	,
		DLRT_AllocateHandle
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [2/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	CaseInsensitiveCompareUCS2	,
		4	,
		false	,
		CaseInsensitiveCompareUCS2
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [3/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	CaseInsensitiveCompareUTF16	,
		4	,
		false	,
		CaseInsensitiveCompareUTF16
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [4/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	DartModulo	,
		2	,
		true	,
		static_cast< BinaryMathCFunction >	DartModulo
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [5/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	EnterHandleScope	,
		1	,
		false	,
		DLRT_EnterHandleScope
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [6/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	EnterSafepoint	,
		0	,
		false	,
		DFLRT_EnterSafepoint
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [7/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	ExitHandleScope	,
		1	,
		false	,
		DLRT_ExitHandleScope
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [8/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	ExitSafepoint	,
		0	,
		false	,
		DFLRT_ExitSafepoint
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [9/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	ExitSafepointIgnoreUnwindInProgress	,
		0	,
		false	,
		DFLRT_ExitSafepointIgnoreUnwindInProgress
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [10/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcAcos	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	acos
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [11/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcAsin	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	asin
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [12/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcAtan	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	atan
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [13/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcAtan2	,
		2	,
		true	,
		static_cast< BinaryMathCFunction >	atan2_ieee
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [14/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcCeil	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	ceil
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [15/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcCos	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	cos
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [16/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcExp	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	exp
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [17/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcFloor	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	floor
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [18/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcLog	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	log
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [19/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcPow	,
		2	,
		true	,
		static_cast< BinaryMathCFunction >	pow
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [20/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcRound	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	round
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [21/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcSin	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	sin
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [22/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcTan	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	tan
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [23/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	LibcTrunc	,
		1	,
		true	,
		static_cast< UnaryMathCFunction >	trunc
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [24/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	MemoryMove	,
		3	,
		false	,
		static_cast< MemMoveCFunction >	memmove
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [25/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	MsanUnpoison	,
		2	,
		false	,
		__msan_unpoison
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [26/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	MsanUnpoisonParam	,
		1	,
		false	,
		__msan_unpoison_param
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [27/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	PropagateError	,
		1	,
		false	,
		DLRT_PropagateError
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [28/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	TsanLoadAcquire	,
		1	,
		false	,
		__tsan_acquire
	)

DEFINE_RAW_LEAF_RUNTIME_ENTRY() [29/29]

dart::DEFINE_RAW_LEAF_RUNTIME_ENTRY	(	TsanStoreRelease	,
		1	,
		false	,
		__tsan_release
	)

DEFINE_RUNTIME_ENTRY() [1/57]

dart::DEFINE_RUNTIME_ENTRY	(	AllocateArray	,
		2
	)

Definition at line 386 of file runtime_entry.cc.

                                       {
  const Instance& length = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  if (!length.IsInteger()) {
    // Throw: new ArgumentError.value(length, "length", "is not an integer");
    const Array& args = Array::Handle(zone, Array::New(3));
    args.SetAt(0, length);
    args.SetAt(1, Symbols::Length());
    args.SetAt(2, String::Handle(zone, String::New("is not an integer")));
    Exceptions::ThrowByType(Exceptions::kArgumentValue, args);
  }
  const int64_t len = Integer::Cast(length).AsInt64Value();
  if (len < 0) {
    // Throw: new RangeError.range(length, 0, Array::kMaxElements, "length");
    Exceptions::ThrowRangeError("length", Integer::Cast(length), 0,
                                Array::kMaxElements);
  }
  if (len > Array::kMaxElements) {
    Exceptions::ThrowOOM();
  }
 
  const Array& array = Array::Handle(
      zone,
      Array::New(static_cast<intptr_t>(len), SpaceForRuntimeAllocation()));
  TypeArguments& element_type =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
  // An Array is raw or takes one type argument. However, its type argument
  // vector may be longer than 1 due to a type optimization reusing the type
  // argument vector of the instantiator.
  ASSERT(element_type.IsNull() ||
         (element_type.Length() >= 1 && element_type.IsInstantiated()));
  array.SetTypeArguments(element_type);  // May be null.
  arguments.SetReturn(array);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [2/57]

dart::DEFINE_RUNTIME_ENTRY	(	AllocateClosure	,
		4
	)

Definition at line 729 of file runtime_entry.cc.

                                         {
  const auto& function = Function::CheckedHandle(zone, arguments.ArgAt(0));
  const auto& context = Object::Handle(zone, arguments.ArgAt(1));
  const auto& instantiator_type_args =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
  const auto& delayed_type_args =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(3));
  const Closure& closure = Closure::Handle(
      zone, Closure::New(instantiator_type_args, Object::null_type_arguments(),
                         delayed_type_args, function, context,
                         SpaceForRuntimeAllocation()));
  arguments.SetReturn(closure);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [3/57]

dart::DEFINE_RUNTIME_ENTRY	(	AllocateContext	,
		1
	)

Definition at line 747 of file runtime_entry.cc.

                                         {
  const Smi& num_variables = Smi::CheckedHandle(zone, arguments.ArgAt(0));
  const Context& context = Context::Handle(
      zone, Context::New(num_variables.Value(), SpaceForRuntimeAllocation()));
  arguments.SetReturn(context);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [4/57]

dart::DEFINE_RUNTIME_ENTRY	(	AllocateObject	,
		2
	)

Definition at line 534 of file runtime_entry.cc.

                                        {
  const Class& cls = Class::CheckedHandle(zone, arguments.ArgAt(0));
  ASSERT(cls.is_allocate_finalized());
  const Instance& instance = Instance::Handle(
      zone, Instance::NewAlreadyFinalized(cls, SpaceForRuntimeAllocation()));
  if (cls.NumTypeArguments() == 0) {
    // No type arguments required for a non-parameterized type.
    ASSERT(Instance::CheckedHandle(zone, arguments.ArgAt(1)).IsNull());
  } else {
    const auto& type_arguments =
        TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
    // Unless null (for a raw type), the type argument vector may be longer than
    // necessary due to a type optimization reusing the type argument vector of
    // the instantiator.
    ASSERT(type_arguments.IsNull() ||
           (type_arguments.IsInstantiated() &&
            (type_arguments.Length() >= cls.NumTypeArguments())));
    instance.SetTypeArguments(type_arguments);
  }
  arguments.SetReturn(instance);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [5/57]

dart::DEFINE_RUNTIME_ENTRY	(	AllocateRecord	,
		1
	)

Definition at line 776 of file runtime_entry.cc.

                                        {
  const RecordShape shape(Smi::RawCast(arguments.ArgAt(0)));
  const Record& record =
      Record::Handle(zone, Record::New(shape, SpaceForRuntimeAllocation()));
  arguments.SetReturn(record);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [6/57]

dart::DEFINE_RUNTIME_ENTRY	(	AllocateSmallRecord	,
		4
	)

Definition at line 788 of file runtime_entry.cc.

                                             {
  const RecordShape shape(Smi::RawCast(arguments.ArgAt(0)));
  const auto& value0 = Instance::CheckedHandle(zone, arguments.ArgAt(1));
  const auto& value1 = Instance::CheckedHandle(zone, arguments.ArgAt(2));
  const auto& value2 = Instance::CheckedHandle(zone, arguments.ArgAt(3));
  const Record& record =
      Record::Handle(zone, Record::New(shape, SpaceForRuntimeAllocation()));
  const intptr_t num_fields = shape.num_fields();
  ASSERT(num_fields == 2 || num_fields == 3);
  record.SetFieldAt(0, value0);
  record.SetFieldAt(1, value1);
  if (num_fields > 2) {
    record.SetFieldAt(2, value2);
  }
  arguments.SetReturn(record);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [7/57]

dart::DEFINE_RUNTIME_ENTRY	(	AllocateSuspendState	,
		2
	)

Definition at line 810 of file runtime_entry.cc.

                                              {
  const intptr_t frame_size =
      Smi::CheckedHandle(zone, arguments.ArgAt(0)).Value();
  const Object& previous_state = Object::Handle(zone, arguments.ArgAt(1));
  SuspendState& result = SuspendState::Handle(zone);
  if (previous_state.IsSuspendState()) {
    const auto& suspend_state = SuspendState::Cast(previous_state);
    const auto& function_data =
        Instance::Handle(zone, suspend_state.function_data());
    ObjectStore* object_store = thread->isolate_group()->object_store();
    if (function_data.GetClassId() ==
        Class::Handle(zone, object_store->async_star_stream_controller())
            .id()) {
      // Reset _AsyncStarStreamController.asyncStarBody to null in order
      // to create a new callback closure during next yield.
      // The new callback closure will capture the reallocated SuspendState.
      function_data.SetField(
          Field::Handle(
              zone,
              object_store->async_star_stream_controller_async_star_body()),
          Object::null_object());
    }
    result = SuspendState::New(frame_size, function_data,
                               SpaceForRuntimeAllocation());
    if (function_data.GetClassId() ==
        Class::Handle(zone, object_store->sync_star_iterator_class()).id()) {
      // Refresh _SyncStarIterator._state with the new SuspendState object.
      function_data.SetField(
          Field::Handle(zone, object_store->sync_star_iterator_state()),
          result);
    }
  } else {
    result = SuspendState::New(frame_size, Instance::Cast(previous_state),
                               SpaceForRuntimeAllocation());
  }
  arguments.SetReturn(result);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [8/57]

dart::DEFINE_RUNTIME_ENTRY	(	AllocateTypedData	,
		2
	)

Definition at line 491 of file runtime_entry.cc.

                                           {
  const intptr_t cid = Smi::CheckedHandle(zone, arguments.ArgAt(0)).Value();
  const auto& length = Instance::CheckedHandle(zone, arguments.ArgAt(1));
  if (!length.IsInteger()) {
    const Array& args = Array::Handle(zone, Array::New(1));
    args.SetAt(0, length);
    Exceptions::ThrowByType(Exceptions::kArgument, args);
  }
  const int64_t len = Integer::Cast(length).AsInt64Value();
  const intptr_t max = TypedData::MaxElements(cid);
  if (len < 0) {
    Exceptions::ThrowRangeError("length", Integer::Cast(length), 0, max);
  } else if (len > max) {
    Exceptions::ThrowOOM();
  }
  const auto& typed_data =
      TypedData::Handle(zone, TypedData::New(cid, static_cast<intptr_t>(len),
                                             SpaceForRuntimeAllocation()));
  arguments.SetReturn(typed_data);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [9/57]

dart::DEFINE_RUNTIME_ENTRY	(	ArgumentError	,
		1
	)

Definition at line 331 of file runtime_entry.cc.

                                       {
  const Instance& value = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  Exceptions::ThrowArgumentError(value);
}

DEFINE_RUNTIME_ENTRY() [10/57]

dart::DEFINE_RUNTIME_ENTRY	(	ArgumentErrorUnboxedInt64	,
		0
	)

Definition at line 336 of file runtime_entry.cc.

                                                   {
  // Unboxed value is passed through a dedicated slot in Thread.
  int64_t unboxed_value = arguments.thread()->unboxed_int64_runtime_arg();
  const Integer& value = Integer::Handle(zone, Integer::New(unboxed_value));
  Exceptions::ThrowArgumentError(value);
}

DEFINE_RUNTIME_ENTRY() [11/57]

dart::DEFINE_RUNTIME_ENTRY	(	ArgumentNullError	,
		0
	)

Definition at line 327 of file runtime_entry.cc.

                                           {
  DoThrowNullError(isolate, thread, zone, /*is_param=*/true);
}

DEFINE_RUNTIME_ENTRY() [12/57]

dart::DEFINE_RUNTIME_ENTRY	(	BreakpointRuntimeHandler	,
		0
	)

Definition at line 1534 of file runtime_entry.cc.

                                                  {
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame != nullptr);
  Code& orig_stub = Code::Handle(zone);
  orig_stub =
      isolate->group()->debugger()->GetPatchedStubAddress(caller_frame->pc());
  const Error& error =
      Error::Handle(zone, isolate->debugger()->PauseBreakpoint());
  ThrowIfError(error);
  arguments.SetReturn(orig_stub);
}

DEFINE_RUNTIME_ENTRY() [13/57]

dart::DEFINE_RUNTIME_ENTRY	(	CloneContext	,
		1
	)

Definition at line 759 of file runtime_entry.cc.

                                      {
  const Context& ctx = Context::CheckedHandle(zone, arguments.ArgAt(0));
  Context& cloned_ctx = Context::Handle(
      zone, Context::New(ctx.num_variables(), SpaceForRuntimeAllocation()));
  cloned_ctx.set_parent(Context::Handle(zone, ctx.parent()));
  Object& inst = Object::Handle(zone);
  for (int i = 0; i < ctx.num_variables(); i++) {
    inst = ctx.At(i);
    cloned_ctx.SetAt(i, inst);
  }
  arguments.SetReturn(cloned_ctx);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [14/57]

dart::DEFINE_RUNTIME_ENTRY	(	CloneSuspendState	,
		1
	)

Definition at line 852 of file runtime_entry.cc.

                                           {
  const SuspendState& src =
      SuspendState::CheckedHandle(zone, arguments.ArgAt(0));
  const SuspendState& dst = SuspendState::Handle(
      zone, SuspendState::Clone(thread, src, SpaceForRuntimeAllocation()));
  arguments.SetReturn(dst);
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY() [15/57]

dart::DEFINE_RUNTIME_ENTRY	(	CompileFunction	,
		1
	)

Definition at line 213 of file compiler.cc.

                                         {
  ASSERT(thread->IsDartMutatorThread());
  const Function& function = Function::CheckedHandle(zone, arguments.ArgAt(0));
 
  {
    // Another isolate's mutator thread may have created [function] and
    // published it via an ICData, MegamorphicCache etc. Entering the lock below
    // is an acquire operation that pairs with the release operation when the
    // other isolate exited the lock, ensuring the initializing stores for
    // [function] are visible in the current thread.
    SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
  }
 
  // Will throw if compilation failed (e.g. with compile-time error).
  function.EnsureHasCode();
}

DEFINE_RUNTIME_ENTRY() [16/57]

END_LEAF_RUNTIME_ENTRY dart::DEFINE_RUNTIME_ENTRY	(	DeoptimizeMaterialize	,
		0
	)

Definition at line 3685 of file runtime_entry.cc.

                                               {
#if !defined(DART_PRECOMPILED_RUNTIME)
#if defined(DEBUG)
  {
    // We may rendezvous for a safepoint at entry or GC from the allocations
    // below. Check the stack is walkable.
    ValidateFrames();
  }
#endif
  DeoptContext* deopt_context = isolate->deopt_context();
  intptr_t deopt_arg_count = deopt_context->MaterializeDeferredObjects();
  isolate->set_deopt_context(nullptr);
  delete deopt_context;
 
  // Return value tells deoptimization stub to remove the given number of bytes
  // from the stack.
  arguments.SetReturn(Smi::Handle(Smi::New(deopt_arg_count * kWordSize)));
#else
  UNREACHABLE();
#endif  // !DART_PRECOMPILED_RUNTIME
}

DEFINE_RUNTIME_ENTRY() [17/57]

dart::DEFINE_RUNTIME_ENTRY	(	DispatchTableNullError	,
		1
	)

Definition at line 303 of file runtime_entry.cc.

                                                {
  const Smi& cid = Smi::CheckedHandle(zone, arguments.ArgAt(0));
  if (cid.Value() != kNullCid) {
    // We hit null error, but receiver is not null itself. This most likely
    // is a memory corruption. Crash the VM but provide some additional
    // information about the arguments on the stack.
    DartFrameIterator iterator(thread,
                               StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* caller_frame = iterator.NextFrame();
    RELEASE_ASSERT(caller_frame->IsDartFrame());
    ReportImpossibleNullError(cid.Value(), caller_frame, thread);
  }
  DoThrowNullError(isolate, thread, zone, /*is_param=*/false);
}

DEFINE_RUNTIME_ENTRY() [18/57]

dart::DEFINE_RUNTIME_ENTRY	(	DoubleToInteger	,
		1
	)

Definition at line 343 of file runtime_entry.cc.

                                         {
  // Unboxed value is passed through a dedicated slot in Thread.
  double val = arguments.thread()->unboxed_double_runtime_arg();
  const Smi& recognized_kind = Smi::CheckedHandle(zone, arguments.ArgAt(0));
  switch (recognized_kind.Value()) {
    case MethodRecognizer::kDoubleToInteger:
      break;
    case MethodRecognizer::kDoubleFloorToInt:
      val = floor(val);
      break;
    case MethodRecognizer::kDoubleCeilToInt:
      val = ceil(val);
      break;
    default:
      UNREACHABLE();
  }
  arguments.SetReturn(Integer::Handle(zone, DoubleToInteger(zone, val)));
}

DEFINE_RUNTIME_ENTRY() [19/57]

dart::DEFINE_RUNTIME_ENTRY	(	FfiAsyncCallbackSend	,
		1
	)

Definition at line 3861 of file runtime_entry.cc.

                                              {
  Dart_Port target_port = Thread::Current()->unboxed_int64_runtime_arg();
  TRACE_RUNTIME_CALL("FfiAsyncCallbackSend %p", (void*)target_port);
  const Object& message = Object::Handle(zone, arguments.ArgAt(0));
  const Array& msg_array = Array::Handle(zone, Array::New(3));
  msg_array.SetAt(0, message);
  PersistentHandle* handle =
      isolate->group()->api_state()->AllocatePersistentHandle();
  handle->set_ptr(msg_array);
  PortMap::PostMessage(
      Message::New(target_port, handle, Message::kNormalPriority));
}

DEFINE_RUNTIME_ENTRY() [20/57]

dart::DEFINE_RUNTIME_ENTRY	(	FixAllocationStubTarget	,
		0
	)

Definition at line 3329 of file runtime_entry.cc.

                                                 {
#if !defined(DART_PRECOMPILED_RUNTIME)
  StackFrameIterator iterator(ValidationPolicy::kDontValidateFrames, thread,
                              StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = iterator.NextFrame();
  ASSERT(frame != nullptr);
  while (frame->IsStubFrame() || frame->IsExitFrame()) {
    frame = iterator.NextFrame();
    ASSERT(frame != nullptr);
  }
  if (frame->IsEntryFrame()) {
    // There must be a valid Dart frame.
    UNREACHABLE();
  }
  ASSERT(frame->IsDartFrame());
  const Code& caller_code = Code::Handle(zone, frame->LookupDartCode());
  ASSERT(!caller_code.IsNull());
  const Code& stub = Code::Handle(
      CodePatcher::GetStaticCallTargetAt(frame->pc(), caller_code));
  Class& alloc_class = Class::ZoneHandle(zone);
  alloc_class ^= stub.owner();
  Code& alloc_stub = Code::Handle(zone, alloc_class.allocation_stub());
  if (alloc_stub.IsNull()) {
    alloc_stub = StubCode::GetAllocationStubForClass(alloc_class);
    ASSERT(!alloc_stub.IsDisabled());
  }
  CodePatcher::PatchStaticCallAt(frame->pc(), caller_code, alloc_stub);
  caller_code.SetStubCallTargetCodeAt(frame->pc(), alloc_stub);
  if (FLAG_trace_patching) {
    OS::PrintErr("FixAllocationStubTarget: caller %#" Px
                 " alloc-class %s "
                 " -> %#" Px "\n",
                 frame->pc(), alloc_class.ToCString(), alloc_stub.EntryPoint());
  }
  arguments.SetReturn(alloc_stub);
#else
  UNREACHABLE();
#endif
}

DEFINE_RUNTIME_ENTRY() [21/57]

dart::DEFINE_RUNTIME_ENTRY	(	FixCallersTarget	,
		0
	)

Definition at line 3261 of file runtime_entry.cc.

                                          {
#if !defined(DART_PRECOMPILED_RUNTIME)
  StackFrameIterator iterator(ValidationPolicy::kDontValidateFrames, thread,
                              StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = iterator.NextFrame();
  ASSERT(frame != nullptr);
  while (frame->IsStubFrame() || frame->IsExitFrame()) {
    frame = iterator.NextFrame();
    ASSERT(frame != nullptr);
  }
  if (frame->IsEntryFrame()) {
    // Since function's current code is always unpatched, the entry frame always
    // calls to unpatched code.
    UNREACHABLE();
  }
  ASSERT(frame->IsDartFrame());
  const Code& caller_code = Code::Handle(zone, frame->LookupDartCode());
  RELEASE_ASSERT(caller_code.is_optimized());
  const Function& target_function = Function::Handle(
      zone, caller_code.GetStaticCallTargetFunctionAt(frame->pc()));
 
  const Code& current_target_code =
      Code::Handle(zone, target_function.EnsureHasCode());
  CodePatcher::PatchStaticCallAt(frame->pc(), caller_code, current_target_code);
  caller_code.SetStaticCallTargetCodeAt(frame->pc(), current_target_code);
  if (FLAG_trace_patching) {
    OS::PrintErr(
        "FixCallersTarget: caller %#" Px
        " "
        "target '%s' -> %#" Px " (%s)\n",
        frame->pc(), target_function.ToFullyQualifiedCString(),
        current_target_code.EntryPoint(),
        current_target_code.is_optimized() ? "optimized" : "unoptimized");
  }
  arguments.SetReturn(current_target_code);
#else
  UNREACHABLE();
#endif
}

DEFINE_RUNTIME_ENTRY() [22/57]

dart::DEFINE_RUNTIME_ENTRY	(	FixCallersTargetMonomorphic	,
		2
	)

Definition at line 3303 of file runtime_entry.cc.

                                                     {
#if !defined(DART_PRECOMPILED_RUNTIME)
  const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Array& switchable_call_data =
      Array::CheckedHandle(zone, arguments.ArgAt(1));
 
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* caller_frame = iterator.NextFrame();
  const auto& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
  const auto& caller_function =
      Function::Handle(zone, caller_frame->LookupDartFunction());
 
  GrowableArray<const Instance*> caller_arguments(1);
  caller_arguments.Add(&receiver);
  PatchableCallHandler handler(
      thread, caller_arguments, MissHandler::kFixCallersTargetMonomorphic,
      arguments, caller_frame, caller_code, caller_function);
  handler.ResolveSwitchAndReturn(switchable_call_data);
#else
  UNREACHABLE();
#endif
}

DEFINE_RUNTIME_ENTRY() [23/57]

dart::DEFINE_RUNTIME_ENTRY	(	InitInstanceField	,
		2
	)

Definition at line 3823 of file runtime_entry.cc.

                                           {
  const Instance& instance = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Field& field = Field::CheckedHandle(zone, arguments.ArgAt(1));
  Object& result = Object::Handle(zone, field.InitializeInstance(instance));
  ThrowIfError(result);
  result = instance.GetField(field);
  ASSERT((result.ptr() != Object::sentinel().ptr()) &&
         (result.ptr() != Object::transition_sentinel().ptr()));
  arguments.SetReturn(result);
}

DEFINE_RUNTIME_ENTRY() [24/57]

dart::DEFINE_RUNTIME_ENTRY	(	InitStaticField	,
		1
	)

Definition at line 3834 of file runtime_entry.cc.

                                         {
  const Field& field = Field::CheckedHandle(zone, arguments.ArgAt(0));
  Object& result = Object::Handle(zone, field.InitializeStatic());
  ThrowIfError(result);
  result = field.StaticValue();
  ASSERT((result.ptr() != Object::sentinel().ptr()) &&
         (result.ptr() != Object::transition_sentinel().ptr()));
  arguments.SetReturn(result);
}

DEFINE_RUNTIME_ENTRY() [25/57]

dart::DEFINE_RUNTIME_ENTRY	(	InlineCacheMissHandlerOneArg	,
		2
	)

Definition at line 2676 of file runtime_entry.cc.

                                                      {
  const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const ICData& ic_data = ICData::CheckedHandle(zone, arguments.ArgAt(1));
  RELEASE_ASSERT(!FLAG_precompiled_mode);
  GrowableArray<const Instance*> args(1);
  args.Add(&receiver);
  InlineCacheMissHandler(thread, zone, args, ic_data, arguments);
}

DEFINE_RUNTIME_ENTRY() [26/57]

dart::DEFINE_RUNTIME_ENTRY	(	InlineCacheMissHandlerTwoArgs	,
		3
	)

Definition at line 2691 of file runtime_entry.cc.

                                                       {
  const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Instance& other = Instance::CheckedHandle(zone, arguments.ArgAt(1));
  const ICData& ic_data = ICData::CheckedHandle(zone, arguments.ArgAt(2));
  RELEASE_ASSERT(!FLAG_precompiled_mode);
  GrowableArray<const Instance*> args(2);
  args.Add(&receiver);
  args.Add(&other);
  InlineCacheMissHandler(thread, zone, args, ic_data, arguments);
}

DEFINE_RUNTIME_ENTRY() [27/57]

dart::DEFINE_RUNTIME_ENTRY	(	Instanceof	,
		5
	)

Definition at line 1112 of file runtime_entry.cc.

                                    {
  const Instance& instance = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const AbstractType& type =
      AbstractType::CheckedHandle(zone, arguments.ArgAt(1));
  const TypeArguments& instantiator_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
  const TypeArguments& function_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(3));
  const SubtypeTestCache& cache =
      SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(4));
  ASSERT(type.IsFinalized());
  ASSERT(!type.IsDynamicType());  // No need to check assignment.
  ASSERT(!cache.IsNull());
#if defined(TARGET_ARCH_IA32)
  // Hash-based caches are still not handled by the stubs on IA32.
  if (cache.IsHash()) {
    const auto& result = Bool::Handle(
        zone, CheckHashBasedSubtypeTestCache(zone, thread, instance, type,
                                             instantiator_type_arguments,
                                             function_type_arguments, cache));
    if (!result.IsNull()) {
      // Early exit because an entry already exists in the cache.
      arguments.SetReturn(result);
      return;
    }
  }
#endif  // defined(TARGET_ARCH_IA32)
  const Bool& result = Bool::Get(instance.IsInstanceOf(
      type, instantiator_type_arguments, function_type_arguments));
  if (FLAG_trace_type_checks) {
    PrintTypeCheck("InstanceOf", instance, type, instantiator_type_arguments,
                   function_type_arguments, result);
  }
  UpdateTypeTestCache(zone, thread, instance, type, instantiator_type_arguments,
                      function_type_arguments, result, cache);
  arguments.SetReturn(result);
}

DEFINE_RUNTIME_ENTRY() [28/57]

END_LEAF_RUNTIME_ENTRY dart::DEFINE_RUNTIME_ENTRY	(	InstantiateType	,
		3
	)

Definition at line 608 of file runtime_entry.cc.

                                         {
  AbstractType& type = AbstractType::CheckedHandle(zone, arguments.ArgAt(0));
  const TypeArguments& instantiator_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
  const TypeArguments& function_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
  ASSERT(!type.IsNull());
  ASSERT(instantiator_type_arguments.IsNull() ||
         instantiator_type_arguments.IsInstantiated());
  ASSERT(function_type_arguments.IsNull() ||
         function_type_arguments.IsInstantiated());
  type = type.InstantiateFrom(instantiator_type_arguments,
                              function_type_arguments, kAllFree, Heap::kOld);
  ASSERT(!type.IsNull() && type.IsInstantiated());
  arguments.SetReturn(type);
}

DEFINE_RUNTIME_ENTRY() [29/57]

dart::DEFINE_RUNTIME_ENTRY	(	InstantiateTypeArguments	,
		3
	)

Definition at line 630 of file runtime_entry.cc.

                                                  {
  TypeArguments& type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(0));
  const TypeArguments& instantiator_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
  const TypeArguments& function_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
  ASSERT(!type_arguments.IsNull() && !type_arguments.IsInstantiated());
  ASSERT(instantiator_type_arguments.IsNull() ||
         instantiator_type_arguments.IsInstantiated());
  ASSERT(function_type_arguments.IsNull() ||
         function_type_arguments.IsInstantiated());
  // Code inlined in the caller should have optimized the case where the
  // instantiator can be reused as type argument vector.
  ASSERT(!type_arguments.IsUninstantiatedIdentity());
  type_arguments = type_arguments.InstantiateAndCanonicalizeFrom(
      instantiator_type_arguments, function_type_arguments);
  ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
  arguments.SetReturn(type_arguments);
}

DEFINE_RUNTIME_ENTRY() [30/57]

dart::DEFINE_RUNTIME_ENTRY	(	IntegerDivisionByZeroException	,
		0
	)

Definition at line 362 of file runtime_entry.cc.

                                                        {
  const Array& args = Array::Handle(zone, Array::New(0));
  Exceptions::ThrowByType(Exceptions::kIntegerDivisionByZeroException, args);
}

DEFINE_RUNTIME_ENTRY() [31/57]

dart::DEFINE_RUNTIME_ENTRY	(	InterruptOrStackOverflow	,
		0
	)

Definition at line 3135 of file runtime_entry.cc.

                                                  {
#if defined(USING_SIMULATOR)
  uword stack_pos = Simulator::Current()->get_sp();
  // If simulator was never called it may return 0 as a value of SPREG.
  if (stack_pos == 0) {
    // Use any reasonable value which would not be treated
    // as stack overflow.
    stack_pos = thread->saved_stack_limit();
  }
#else
  uword stack_pos = OSThread::GetCurrentStackPointer();
#endif
  // Always clear the stack overflow flags.  They are meant for this
  // particular stack overflow runtime call and are not meant to
  // persist.
  uword stack_overflow_flags = thread->GetAndClearStackOverflowFlags();
 
  // If an interrupt happens at the same time as a stack overflow, we
  // process the stack overflow now and leave the interrupt for next
  // time.
  if (!thread->os_thread()->HasStackHeadroom() ||
      IsCalleeFrameOf(thread->saved_stack_limit(), stack_pos)) {
    if (FLAG_verbose_stack_overflow) {
      OS::PrintErr("Stack overflow\n");
      OS::PrintErr("  Native SP = %" Px ", stack limit = %" Px "\n", stack_pos,
                   thread->saved_stack_limit());
      OS::PrintErr("Call stack:\n");
      OS::PrintErr("size | frame\n");
      StackFrameIterator frames(ValidationPolicy::kDontValidateFrames, thread,
                                StackFrameIterator::kNoCrossThreadIteration);
      uword fp = stack_pos;
      StackFrame* frame = frames.NextFrame();
      while (frame != nullptr) {
        uword delta = (frame->fp() - fp);
        fp = frame->fp();
        OS::PrintErr("%4" Pd " %s\n", delta, frame->ToCString());
        frame = frames.NextFrame();
      }
    }
 
    // Use the preallocated stack overflow exception to avoid calling
    // into dart code.
    const Instance& exception =
        Instance::Handle(isolate->group()->object_store()->stack_overflow());
    Exceptions::Throw(thread, exception);
    UNREACHABLE();
  }
 
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
  HandleStackOverflowTestCases(thread);
#endif  // !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
 
  // Handle interrupts:
  //  - store buffer overflow
  //  - OOB message (vm-service or dart:isolate)
  //  - marking ready for finalization
  const Error& error = Error::Handle(thread->HandleInterrupts());
  ThrowIfError(error);
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  if ((stack_overflow_flags & Thread::kOsrRequest) != 0) {
    HandleOSRRequest(thread);
  }
#else
  ASSERT((stack_overflow_flags & Thread::kOsrRequest) == 0);
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
}

DEFINE_RUNTIME_ENTRY() [32/57]

dart::DEFINE_RUNTIME_ENTRY	(	LateFieldAssignedDuringInitializationError	,
		1
	)

Definition at line 3844 of file runtime_entry.cc.

                                                                    {
  const Field& field = Field::CheckedHandle(zone, arguments.ArgAt(0));
  Exceptions::ThrowLateFieldAssignedDuringInitialization(
      String::Handle(field.name()));
}

DEFINE_RUNTIME_ENTRY() [33/57]

dart::DEFINE_RUNTIME_ENTRY	(	LateFieldNotInitializedError	,
		1
	)

Definition at line 3850 of file runtime_entry.cc.

                                                      {
  const Field& field = Field::CheckedHandle(zone, arguments.ArgAt(0));
  Exceptions::ThrowLateFieldNotInitialized(String::Handle(field.name()));
}

DEFINE_RUNTIME_ENTRY() [34/57]

dart::DEFINE_RUNTIME_ENTRY	(	NonBoolTypeError	,
		1
	)

Definition at line 1440 of file runtime_entry.cc.

                                          {
  const TokenPosition location = GetCallerLocation();
  const Instance& src_instance =
      Instance::CheckedHandle(zone, arguments.ArgAt(0));
 
  if (src_instance.IsNull()) {
    const Array& args = Array::Handle(zone, Array::New(5));
    args.SetAt(
        0, String::Handle(
               zone,
               String::New(
                   "Failed assertion: boolean expression must not be null")));
 
    // No source code for this assertion, set url to null.
    args.SetAt(1, String::Handle(zone, String::null()));
    args.SetAt(2, Object::smi_zero());
    args.SetAt(3, Object::smi_zero());
    args.SetAt(4, String::Handle(zone, String::null()));
 
    Exceptions::ThrowByType(Exceptions::kAssertion, args);
    UNREACHABLE();
  }
 
  ASSERT(!src_instance.IsBool());
  const Type& bool_interface = Type::Handle(Type::BoolType());
  const AbstractType& src_type =
      AbstractType::Handle(zone, src_instance.GetType(Heap::kNew));
  Exceptions::CreateAndThrowTypeError(location, src_type, bool_interface,
                                      Symbols::BooleanExpression());
  UNREACHABLE();
}

DEFINE_RUNTIME_ENTRY() [35/57]

dart::DEFINE_RUNTIME_ENTRY	(	NoSuchMethodFromCallStub	,
		4
	)

Definition at line 2898 of file runtime_entry.cc.

                                                  {
  ASSERT(!FLAG_lazy_dispatchers);
  const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Object& ic_data_or_cache = Object::Handle(zone, arguments.ArgAt(1));
  const Array& orig_arguments_desc =
      Array::CheckedHandle(zone, arguments.ArgAt(2));
  const Array& orig_arguments = Array::CheckedHandle(zone, arguments.ArgAt(3));
  String& target_name = String::Handle(zone);
  if (ic_data_or_cache.IsICData()) {
    target_name = ICData::Cast(ic_data_or_cache).target_name();
  } else {
    ASSERT(ic_data_or_cache.IsMegamorphicCache());
    target_name = MegamorphicCache::Cast(ic_data_or_cache).target_name();
  }
 
  const auto& result =
      Object::Handle(zone, InvokeCallThroughGetterOrNoSuchMethod(
                               thread, zone, receiver, target_name,
                               orig_arguments, orig_arguments_desc));
  ThrowIfError(result);
  arguments.SetReturn(result);
}

DEFINE_RUNTIME_ENTRY() [36/57]

dart::DEFINE_RUNTIME_ENTRY	(	NoSuchMethodFromPrologue	,
		4
	)

Definition at line 2926 of file runtime_entry.cc.

                                                  {
  const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Function& function = Function::CheckedHandle(zone, arguments.ArgAt(1));
  const Array& orig_arguments_desc =
      Array::CheckedHandle(zone, arguments.ArgAt(2));
  const Array& orig_arguments = Array::CheckedHandle(zone, arguments.ArgAt(3));
 
  String& orig_function_name = String::Handle(zone);
  if ((function.kind() == UntaggedFunction::kClosureFunction) ||
      (function.kind() == UntaggedFunction::kImplicitClosureFunction)) {
    // For closure the function name is always 'call'. Replace it with the
    // name of the closurized function so that exception contains more
    // relevant information.
    orig_function_name = function.QualifiedUserVisibleName();
  } else {
    orig_function_name = function.name();
  }
 
  const Object& result = Object::Handle(
      zone, DartEntry::InvokeNoSuchMethod(thread, receiver, orig_function_name,
                                          orig_arguments, orig_arguments_desc));
  ThrowIfError(result);
  arguments.SetReturn(result);
}

DEFINE_RUNTIME_ENTRY() [37/57]

dart::DEFINE_RUNTIME_ENTRY	(	NotLoaded	,
		0
	)

Definition at line 3855 of file runtime_entry.cc.

                                   {
  // We could just use a trap instruction in the stub, but we get better stack
  // traces when there is an exit frame.
  FATAL("Not loaded");
}

DEFINE_RUNTIME_ENTRY() [38/57]

dart::DEFINE_RUNTIME_ENTRY	(	NullCastError	,
		0
	)

Definition at line 323 of file runtime_entry.cc.

                                       {
  NullErrorHelper(zone, String::null_string());
}

DEFINE_RUNTIME_ENTRY() [39/57]

dart::DEFINE_RUNTIME_ENTRY	(	NullError	,
		0
	)

Definition at line 265 of file runtime_entry.cc.

                                   {
  DoThrowNullError(isolate, thread, zone, /*is_param=*/false);
}

DEFINE_RUNTIME_ENTRY() [40/57]

dart::DEFINE_RUNTIME_ENTRY	(	NullErrorWithSelector	,
		1
	)

Definition at line 318 of file runtime_entry.cc.

                                               {
  const String& selector = String::CheckedHandle(zone, arguments.ArgAt(0));
  NullErrorHelper(zone, selector);
}

DEFINE_RUNTIME_ENTRY() [41/57]

dart::DEFINE_RUNTIME_ENTRY	(	OptimizeInvokedFunction	,
		1
	)

Definition at line 3219 of file runtime_entry.cc.

                                                 {
#if !defined(DART_PRECOMPILED_RUNTIME)
  const Function& function = Function::CheckedHandle(zone, arguments.ArgAt(0));
  ASSERT(!function.IsNull());
  ASSERT(function.HasCode());
 
  if (Compiler::CanOptimizeFunction(thread, function)) {
    auto isolate_group = thread->isolate_group();
    if (FLAG_background_compilation) {
      if (isolate_group->background_compiler()->EnqueueCompilation(function)) {
        // Reduce the chance of triggering a compilation while the function is
        // being compiled in the background. INT32_MIN should ensure that it
        // takes long time to trigger a compilation.
        // Note that the background compilation queue rejects duplicate entries.
        function.SetUsageCounter(INT32_MIN);
        // Continue in the same code.
        arguments.SetReturn(function);
        return;
      }
    }
 
    // Reset usage counter for reoptimization before calling optimizer to
    // prevent recursive triggering of function optimization.
    function.SetUsageCounter(0);
    if (FLAG_trace_compiler || FLAG_trace_optimizing_compiler) {
      if (function.HasOptimizedCode()) {
        THR_Print("ReCompiling function: '%s' \n",
                  function.ToFullyQualifiedCString());
      }
    }
    Object& result = Object::Handle(
        zone, Compiler::CompileOptimizedFunction(thread, function));
    ThrowIfError(result);
  }
  arguments.SetReturn(function);
#else
  UNREACHABLE();
#endif  // !DART_PRECOMPILED_RUNTIME
}

DEFINE_RUNTIME_ENTRY() [42/57]

dart::DEFINE_RUNTIME_ENTRY	(	PatchStaticCall	,
		0
	)

Definition at line 1488 of file runtime_entry.cc.

                                         {
#if !defined(DART_PRECOMPILED_RUNTIME)
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame != nullptr);
  const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
  ASSERT(!caller_code.IsNull());
  ASSERT(caller_code.is_optimized());
  const Function& target_function = Function::Handle(
      zone, caller_code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
  const Code& target_code = Code::Handle(zone, target_function.EnsureHasCode());
  // Before patching verify that we are not repeatedly patching to the same
  // target.
  if (target_code.ptr() !=
      CodePatcher::GetStaticCallTargetAt(caller_frame->pc(), caller_code)) {
    GcSafepointOperationScope safepoint(thread);
    if (target_code.ptr() !=
        CodePatcher::GetStaticCallTargetAt(caller_frame->pc(), caller_code)) {
      CodePatcher::PatchStaticCallAt(caller_frame->pc(), caller_code,
                                     target_code);
      caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
      if (FLAG_trace_patching) {
        THR_Print("PatchStaticCall: patching caller pc %#" Px
                  ""
                  " to '%s' new entry point %#" Px " (%s)\n",
                  caller_frame->pc(), target_function.ToFullyQualifiedCString(),
                  target_code.EntryPoint(),
                  target_code.is_optimized() ? "optimized" : "unoptimized");
      }
    }
  }
  arguments.SetReturn(target_code);
#else
  UNREACHABLE();
#endif
}

DEFINE_RUNTIME_ENTRY() [43/57]

dart::DEFINE_RUNTIME_ENTRY	(	RangeError	,
		2
	)

Definition at line 118 of file runtime_entry.cc.

                                    {
  const Instance& length = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Instance& index = Instance::CheckedHandle(zone, arguments.ArgAt(1));
  if (!length.IsInteger()) {
    // Throw: new ArgumentError.value(length, "length", "is not an integer");
    const Array& args = Array::Handle(zone, Array::New(3));
    args.SetAt(0, length);
    args.SetAt(1, Symbols::Length());
    args.SetAt(2, String::Handle(zone, String::New("is not an integer")));
    Exceptions::ThrowByType(Exceptions::kArgumentValue, args);
  }
  if (!index.IsInteger()) {
    // Throw: new ArgumentError.value(index, "index", "is not an integer");
    const Array& args = Array::Handle(zone, Array::New(3));
    args.SetAt(0, index);
    args.SetAt(1, Symbols::Index());
    args.SetAt(2, String::Handle(zone, String::New("is not an integer")));
    Exceptions::ThrowByType(Exceptions::kArgumentValue, args);
  }
  // Throw: new RangeError.range(index, 0, length - 1, "length");
  const Array& args = Array::Handle(zone, Array::New(4));
  args.SetAt(0, index);
  args.SetAt(1, Integer::Handle(zone, Integer::New(0)));
  args.SetAt(
      2, Integer::Handle(
             zone, Integer::Cast(length).ArithmeticOp(
                       Token::kSUB, Integer::Handle(zone, Integer::New(1)))));
  args.SetAt(3, Symbols::Length());
  Exceptions::ThrowByType(Exceptions::kRange, args);
}

DEFINE_RUNTIME_ENTRY() [44/57]

dart::DEFINE_RUNTIME_ENTRY	(	RangeErrorUnboxedInt64	,
		0
	)

Definition at line 149 of file runtime_entry.cc.

                                                {
  int64_t unboxed_length = thread->unboxed_int64_runtime_arg();
  int64_t unboxed_index = thread->unboxed_int64_runtime_second_arg();
  const auto& length = Integer::Handle(zone, Integer::New(unboxed_length));
  const auto& index = Integer::Handle(zone, Integer::New(unboxed_index));
  // Throw: new RangeError.range(index, 0, length - 1, "length");
  const Array& args = Array::Handle(zone, Array::New(4));
  args.SetAt(0, index);
  args.SetAt(1, Integer::Handle(zone, Integer::New(0)));
  args.SetAt(
      2, Integer::Handle(
             zone, Integer::Cast(length).ArithmeticOp(
                       Token::kSUB, Integer::Handle(zone, Integer::New(1)))));
  args.SetAt(3, Symbols::Length());
  Exceptions::ThrowByType(Exceptions::kRange, args);
}

DEFINE_RUNTIME_ENTRY() [45/57]

dart::DEFINE_RUNTIME_ENTRY	(	ResumeFrame	,
		2
	)

Definition at line 3724 of file runtime_entry.cc.

                                     {
  const Instance& exception = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Instance& stacktrace =
      Instance::CheckedHandle(zone, arguments.ArgAt(1));
 
#if !defined(DART_PRECOMPILED_RUNTIME)
#if !defined(PRODUCT)
  if (isolate->has_resumption_breakpoints()) {
    isolate->debugger()->ResumptionBreakpoint();
  }
#endif
 
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = iterator.NextFrame();
  ASSERT(frame->IsDartFrame());
  ASSERT(Function::Handle(zone, frame->LookupDartFunction())
             .IsSuspendableFunction());
  const Code& caller_code = Code::Handle(zone, frame->LookupDartCode());
  if (caller_code.IsDisabled() && caller_code.is_optimized() &&
      !caller_code.is_force_optimized()) {
    const uword deopt_pc = frame->pc();
    thread->pending_deopts().AddPendingDeopt(frame->fp(), deopt_pc);
    frame->MarkForLazyDeopt();
 
    if (FLAG_trace_deoptimization) {
      THR_Print("Lazy deopt scheduled for resumed frame fp=%" Pp ", pc=%" Pp
                "\n",
                frame->fp(), deopt_pc);
    }
  }
#endif
 
  if (!exception.IsNull()) {
    Exceptions::ReThrow(thread, exception, stacktrace);
  }
}

DEFINE_RUNTIME_ENTRY() [46/57]

dart::DEFINE_RUNTIME_ENTRY	(	ReThrow	,
		3
	)

Definition at line 1477 of file runtime_entry.cc.

                                 {
  const Instance& exception = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Instance& stacktrace =
      Instance::CheckedHandle(zone, arguments.ArgAt(1));
  const Smi& bypass_debugger = Smi::CheckedHandle(zone, arguments.ArgAt(2));
  Exceptions::ReThrow(thread, exception, stacktrace,
                      bypass_debugger.Value() != 0);
}

DEFINE_RUNTIME_ENTRY() [47/57]

dart::DEFINE_RUNTIME_ENTRY	(	RewindPostDeopt	,
		0
	)

Definition at line 3707 of file runtime_entry.cc.

                                         {
#if !defined(DART_PRECOMPILED_RUNTIME)
#if !defined(PRODUCT)
  isolate->debugger()->RewindPostDeopt();
#endif  // !PRODUCT
#endif  // !DART_PRECOMPILED_RUNTIME
  UNREACHABLE();
}

DEFINE_RUNTIME_ENTRY() [48/57]

dart::DEFINE_RUNTIME_ENTRY	(	SingleStepHandler	,
		0
	)

Definition at line 1549 of file runtime_entry.cc.

                                           {
#if defined(PRODUCT) || defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  const Error& error =
      Error::Handle(zone, isolate->debugger()->PauseStepping());
  ThrowIfError(error);
#endif
}

DEFINE_RUNTIME_ENTRY() [49/57]

dart::DEFINE_RUNTIME_ENTRY	(	StaticCallMissHandlerOneArg	,
		2
	)

Definition at line 1772 of file runtime_entry.cc.

                                                     {
  const Instance& arg = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const ICData& ic_data = ICData::CheckedHandle(zone, arguments.ArgAt(1));
  // IC data for static call is prepopulated with the statically known target.
  ASSERT(ic_data.NumberOfChecksIs(1));
  const Function& target = Function::Handle(zone, ic_data.GetTargetAt(0));
  target.EnsureHasCode();
  ASSERT(!target.IsNull() && target.HasCode());
  ic_data.EnsureHasReceiverCheck(arg.GetClassId(), target, 1);
  if (FLAG_trace_ic) {
    DartFrameIterator iterator(thread,
                               StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* caller_frame = iterator.NextFrame();
    ASSERT(caller_frame != nullptr);
    OS::PrintErr("StaticCallMissHandler at %#" Px " target %s (%" Pd ")\n",
                 caller_frame->pc(), target.ToCString(), arg.GetClassId());
  }
  arguments.SetReturn(target);
}

DEFINE_RUNTIME_ENTRY() [50/57]

dart::DEFINE_RUNTIME_ENTRY	(	StaticCallMissHandlerTwoArgs	,
		3
	)

Definition at line 1797 of file runtime_entry.cc.

                                                      {
  const Instance& arg0 = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Instance& arg1 = Instance::CheckedHandle(zone, arguments.ArgAt(1));
  const ICData& ic_data = ICData::CheckedHandle(zone, arguments.ArgAt(2));
  // IC data for static call is prepopulated with the statically known target.
  ASSERT(!ic_data.NumberOfChecksIs(0));
  const Function& target = Function::Handle(zone, ic_data.GetTargetAt(0));
  target.EnsureHasCode();
  GrowableArray<intptr_t> cids(2);
  cids.Add(arg0.GetClassId());
  cids.Add(arg1.GetClassId());
  ic_data.EnsureHasCheck(cids, target);
  if (FLAG_trace_ic) {
    DartFrameIterator iterator(thread,
                               StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* caller_frame = iterator.NextFrame();
    ASSERT(caller_frame != nullptr);
    OS::PrintErr("StaticCallMissHandler at %#" Px " target %s (%" Pd ", %" Pd
                 ")\n",
                 caller_frame->pc(), target.ToCString(), cids[0], cids[1]);
  }
  arguments.SetReturn(target);
}

DEFINE_RUNTIME_ENTRY() [51/57]

dart::DEFINE_RUNTIME_ENTRY	(	SubtypeCheck	,
		5
	)

Definition at line 685 of file runtime_entry.cc.

                                      {
  const TypeArguments& instantiator_type_args =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(0));
  const TypeArguments& function_type_args =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
  AbstractType& subtype = AbstractType::CheckedHandle(zone, arguments.ArgAt(2));
  AbstractType& supertype =
      AbstractType::CheckedHandle(zone, arguments.ArgAt(3));
  const String& dst_name = String::CheckedHandle(zone, arguments.ArgAt(4));
 
  ASSERT(!supertype.IsNull());
  ASSERT(!subtype.IsNull());
 
  // Now that AssertSubtype may be checking types only available at runtime,
  // we can't guarantee the supertype isn't the top type.
  if (supertype.IsTopTypeForSubtyping()) return;
 
  // The supertype or subtype may not be instantiated.
  if (AbstractType::InstantiateAndTestSubtype(
          &subtype, &supertype, instantiator_type_args, function_type_args)) {
    if (FLAG_trace_type_checks) {
      // The supertype and subtype are now instantiated. Subtype check passed.
      PrintSubtypeCheck(subtype, supertype, true);
    }
    return;
  }
  if (FLAG_trace_type_checks) {
    // The supertype and subtype are now instantiated. Subtype check failed.
    PrintSubtypeCheck(subtype, supertype, false);
  }
 
  // Throw a dynamic type error.
  const TokenPosition location = GetCallerLocation();
  Exceptions::CreateAndThrowTypeError(location, subtype, supertype, dst_name);
  UNREACHABLE();
}

DEFINE_RUNTIME_ENTRY() [52/57]

dart::DEFINE_RUNTIME_ENTRY	(	SwitchableCallMiss	,
		2
	)

Definition at line 2706 of file runtime_entry.cc.

                                            {
  const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(1));
 
  StackFrameIterator iterator(ValidationPolicy::kDontValidateFrames, thread,
                              StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* exit_frame = iterator.NextFrame();
  ASSERT(exit_frame->IsExitFrame());
  StackFrame* miss_handler_frame = iterator.NextFrame();
  // This runtime entry can be called either from miss stub or from
  // switchable_call_miss "dart" stub/function set up in
  // [MegamorphicCacheTable::InitMissHandler].
  ASSERT(miss_handler_frame->IsStubFrame() ||
         miss_handler_frame->IsDartFrame());
  StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame->IsDartFrame());
  const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
  const Function& caller_function =
      Function::Handle(zone, caller_frame->LookupDartFunction());
 
  auto& old_data = Object::Handle(zone);
#if defined(DART_PRECOMPILED_RUNTIME)
  old_data =
      CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(), caller_code);
#else
  CodePatcher::GetInstanceCallAt(caller_frame->pc(), caller_code, &old_data);
#endif
 
  GrowableArray<const Instance*> caller_arguments(1);
  caller_arguments.Add(&receiver);
  PatchableCallHandler handler(thread, caller_arguments,
                               MissHandler::kSwitchableCallMiss, arguments,
                               caller_frame, caller_code, caller_function);
  handler.ResolveSwitchAndReturn(old_data);
}

DEFINE_RUNTIME_ENTRY() [53/57]

dart::DEFINE_RUNTIME_ENTRY	(	Throw	,
		1
	)

Definition at line 1472 of file runtime_entry.cc.

                               {
  const Instance& exception = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  Exceptions::Throw(thread, exception);
}

DEFINE_RUNTIME_ENTRY() [54/57]

dart::DEFINE_RUNTIME_ENTRY	(	TraceICCall	,
		2
	)

Definition at line 3203 of file runtime_entry.cc.

                                     {
  const ICData& ic_data = ICData::CheckedHandle(zone, arguments.ArgAt(0));
  const Function& function = Function::CheckedHandle(zone, arguments.ArgAt(1));
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = iterator.NextFrame();
  ASSERT(frame != nullptr);
  OS::PrintErr(
      "IC call @%#" Px ": ICData: %#" Px " cnt:%" Pd " nchecks: %" Pd " %s\n",
      frame->pc(), static_cast<uword>(ic_data.ptr()), function.usage_counter(),
      ic_data.NumberOfChecks(), function.ToFullyQualifiedCString());
}

DEFINE_RUNTIME_ENTRY() [55/57]

dart::DEFINE_RUNTIME_ENTRY	(	TypeCheck	,
		7
	)

Definition at line 1167 of file runtime_entry.cc.

                                   {
  const Instance& src_instance =
      Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const AbstractType& dst_type =
      AbstractType::CheckedHandle(zone, arguments.ArgAt(1));
  const TypeArguments& instantiator_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
  const TypeArguments& function_type_arguments =
      TypeArguments::CheckedHandle(zone, arguments.ArgAt(3));
  String& dst_name = String::Handle(zone);
  dst_name ^= arguments.ArgAt(4);
  ASSERT(dst_name.IsNull() || dst_name.IsString());
 
  SubtypeTestCache& cache = SubtypeTestCache::Handle(zone);
  cache ^= arguments.ArgAt(5);
  ASSERT(cache.IsNull() || cache.IsSubtypeTestCache());
 
  const TypeCheckMode mode = static_cast<TypeCheckMode>(
      Smi::CheckedHandle(zone, arguments.ArgAt(6)).Value());
 
#if defined(TESTING)
  TESTING_runtime_entered_on_TTS_invocation = true;
#endif
 
#if defined(TARGET_ARCH_IA32)
  ASSERT(mode == kTypeCheckFromInline);
  // Hash-based caches are still not handled by the stubs on IA32.
  if (cache.IsHash()) {
    const auto& result = Bool::Handle(
        zone, CheckHashBasedSubtypeTestCache(
                  zone, thread, src_instance, dst_type,
                  instantiator_type_arguments, function_type_arguments, cache));
    if (!result.IsNull()) {
      // Early exit because an entry already exists in the cache.
      arguments.SetReturn(result);
      return;
    }
  }
#endif  // defined(TARGET_ARCH_IA32)
 
  // This is guaranteed on the calling side.
  ASSERT(!dst_type.IsDynamicType());
 
  const bool is_instance_of = src_instance.IsAssignableTo(
      dst_type, instantiator_type_arguments, function_type_arguments);
 
  if (FLAG_trace_type_checks) {
    PrintTypeCheck("TypeCheck", src_instance, dst_type,
                   instantiator_type_arguments, function_type_arguments,
                   Bool::Get(is_instance_of));
  }
 
  // Most paths through this runtime entry don't need to know what the
  // destination name was or if this was a dynamic assert assignable call,
  // so only walk the stack to find the stored destination name when necessary.
  auto resolve_dst_name = [&]() {
    if (!dst_name.IsNull()) return;
#if !defined(TARGET_ARCH_IA32)
    // Can only come here from type testing stub.
    ASSERT(mode != kTypeCheckFromInline);
 
    // Grab the [dst_name] from the pool.  It's stored at one pool slot after
    // the subtype-test-cache.
    DartFrameIterator iterator(thread,
                               StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* caller_frame = iterator.NextFrame();
    const Code& caller_code =
        Code::Handle(zone, caller_frame->LookupDartCode());
    const ObjectPool& pool =
        ObjectPool::Handle(zone, caller_code.GetObjectPool());
    TypeTestingStubCallPattern tts_pattern(caller_frame->pc());
    const intptr_t stc_pool_idx = tts_pattern.GetSubtypeTestCachePoolIndex();
    const intptr_t dst_name_idx = stc_pool_idx + 1;
    dst_name ^= pool.ObjectAt(dst_name_idx);
#else
    UNREACHABLE();
#endif
  };
 
  if (!is_instance_of) {
    resolve_dst_name();
    if (dst_name.ptr() ==
        Symbols::dynamic_assert_assignable_stc_check().ptr()) {
#if !defined(TARGET_ARCH_IA32)
      // Can only come here from type testing stub via dynamic AssertAssignable.
      ASSERT(mode != kTypeCheckFromInline);
#endif
      // This was a dynamic closure call where the destination name was not
      // known at compile-time. Thus, fetch the original arguments and arguments
      // descriptor and re-do the type check  in the runtime, which causes the
      // error with the proper destination name to be thrown.
      DartFrameIterator iterator(thread,
                                 StackFrameIterator::kNoCrossThreadIteration);
      StackFrame* caller_frame = iterator.NextFrame();
      const auto& dispatcher =
          Function::Handle(zone, caller_frame->LookupDartFunction());
      ASSERT(dispatcher.IsInvokeFieldDispatcher());
      const auto& orig_arguments_desc =
          Array::Handle(zone, dispatcher.saved_args_desc());
      const ArgumentsDescriptor args_desc(orig_arguments_desc);
      const intptr_t arg_count = args_desc.CountWithTypeArgs();
      const auto& orig_arguments = Array::Handle(zone, Array::New(arg_count));
      auto& obj = Object::Handle(zone);
      for (intptr_t i = 0; i < arg_count; i++) {
        obj = *reinterpret_cast<ObjectPtr*>(
            ParamAddress(caller_frame->fp(), arg_count - i));
        orig_arguments.SetAt(i, obj);
      }
      const auto& receiver = Closure::CheckedHandle(
          zone, orig_arguments.At(args_desc.FirstArgIndex()));
      const auto& function = Function::Handle(zone, receiver.function());
      const auto& result = Object::Handle(
          zone, function.DoArgumentTypesMatch(orig_arguments, args_desc));
      if (result.IsError()) {
        Exceptions::PropagateError(Error::Cast(result));
      }
      // IsAssignableTo returned false, so we should have thrown a type
      // error in DoArgumentsTypesMatch.
      UNREACHABLE();
    }
 
    ASSERT(!dst_name.IsNull());
    // Throw a dynamic type error.
    const TokenPosition location = GetCallerLocation();
    const auto& src_type =
        AbstractType::Handle(zone, src_instance.GetType(Heap::kNew));
    auto& reported_type = AbstractType::Handle(zone, dst_type.ptr());
    if (!reported_type.IsInstantiated()) {
      // Instantiate dst_type before reporting the error.
      reported_type = reported_type.InstantiateFrom(instantiator_type_arguments,
                                                    function_type_arguments,
                                                    kAllFree, Heap::kNew);
    }
    Exceptions::CreateAndThrowTypeError(location, src_type, reported_type,
                                        dst_name);
    UNREACHABLE();
  }
 
  bool should_update_cache = true;
#if !defined(TARGET_ARCH_IA32)
  bool would_update_cache_if_not_lazy = false;
#if !defined(DART_PRECOMPILED_RUNTIME)
  // Checks against type parameters are done by loading the corresponding type
  // argument at runtime and calling the type argument's TTS. Thus, we install
  // specialized TTSes on the type argument, not the parameter itself.
  auto& tts_type = AbstractType::Handle(zone, dst_type.ptr());
  if (tts_type.IsTypeParameter()) {
    const auto& param = TypeParameter::Cast(tts_type);
    tts_type = param.GetFromTypeArguments(instantiator_type_arguments,
                                          function_type_arguments);
  }
  ASSERT(!tts_type.IsTypeParameter());
 
  if (mode == kTypeCheckFromLazySpecializeStub) {
    if (FLAG_trace_type_checks) {
      THR_Print("  Specializing type testing stub for %s\n",
                tts_type.ToCString());
    }
    const Code& code = Code::Handle(
        zone, TypeTestingStubGenerator::SpecializeStubFor(thread, tts_type));
    tts_type.SetTypeTestingStub(code);
 
    // Only create the cache if we failed to create a specialized TTS and doing
    // the same check would cause an update to the cache.
    would_update_cache_if_not_lazy =
        (!src_instance.IsNull() &&
         tts_type.type_test_stub() ==
             StubCode::DefaultNullableTypeTest().ptr()) ||
        tts_type.type_test_stub() == StubCode::DefaultTypeTest().ptr();
    should_update_cache = would_update_cache_if_not_lazy && cache.IsNull();
  }
 
  // Since dst_type is not a top type or type parameter, then the only default
  // stubs it can use are DefaultTypeTest or DefaultNullableTypeTest.
  if ((mode == kTypeCheckFromSlowStub) &&
      (tts_type.type_test_stub() != StubCode::DefaultNullableTypeTest().ptr() &&
       tts_type.type_test_stub() != StubCode::DefaultTypeTest().ptr())) {
    // The specialized type testing stub returned a false negative. That means
    // the specialization may have been generated using outdated cid ranges and
    // new classes appeared since the stub was generated. Try respecializing.
    if (FLAG_trace_type_checks) {
      THR_Print("  Rebuilding type testing stub for %s\n",
                tts_type.ToCString());
    }
    const auto& old_code = Code::Handle(zone, tts_type.type_test_stub());
    const auto& new_code = Code::Handle(
        zone, TypeTestingStubGenerator::SpecializeStubFor(thread, tts_type));
    ASSERT(old_code.ptr() != new_code.ptr());
    // A specialized stub should always respecialize to a non-default stub.
    ASSERT(new_code.ptr() != StubCode::DefaultNullableTypeTest().ptr() &&
           new_code.ptr() != StubCode::DefaultTypeTest().ptr());
    const auto& old_instructions =
        Instructions::Handle(old_code.instructions());
    const auto& new_instructions =
        Instructions::Handle(new_code.instructions());
    // Check if specialization produced exactly the same sequence of
    // instructions. If it did, then we have a false negative, which can
    // happen in some cases involving uninstantiated types. In these cases,
    // update the cache, because the only case in which these false negatives
    // could possibly turn into true positives is with reloads, which clear
    // all the SubtypeTestCaches.
    should_update_cache = old_instructions.Equals(new_instructions);
    if (FLAG_trace_type_checks) {
      THR_Print("  %s rebuilt type testing stub for %s\n",
                should_update_cache ? "Discarding" : "Installing",
                tts_type.ToCString());
    }
    if (!should_update_cache) {
      tts_type.SetTypeTestingStub(new_code);
    }
  }
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
#endif  // !defined(TARGET_ARCH_IA32)
 
  if (should_update_cache) {
    if (cache.IsNull()) {
#if !defined(TARGET_ARCH_IA32)
      ASSERT(mode == kTypeCheckFromSlowStub ||
             (mode == kTypeCheckFromLazySpecializeStub &&
              would_update_cache_if_not_lazy));
      // We lazily create [SubtypeTestCache] for those call sites which actually
      // need one and will patch the pool entry.
      DartFrameIterator iterator(thread,
                                 StackFrameIterator::kNoCrossThreadIteration);
      StackFrame* caller_frame = iterator.NextFrame();
      const Code& caller_code =
          Code::Handle(zone, caller_frame->LookupDartCode());
      const ObjectPool& pool =
          ObjectPool::Handle(zone, caller_code.GetObjectPool());
      TypeTestingStubCallPattern tts_pattern(caller_frame->pc());
      const intptr_t stc_pool_idx = tts_pattern.GetSubtypeTestCachePoolIndex();
      // Ensure we do have a STC (lazily create it if not) and all threads use
      // the same STC.
      {
        SafepointMutexLocker ml(isolate->group()->subtype_test_cache_mutex());
        cache ^= pool.ObjectAt<std::memory_order_acquire>(stc_pool_idx);
        if (cache.IsNull()) {
          resolve_dst_name();
          // If this is a dynamic AssertAssignable check, then we must assume
          // all inputs may be needed, as the type may vary from call to call.
          const intptr_t num_inputs =
              dst_name.ptr() ==
                      Symbols::dynamic_assert_assignable_stc_check().ptr()
                  ? SubtypeTestCache::kMaxInputs
                  : SubtypeTestCache::UsedInputsForType(dst_type);
          cache = SubtypeTestCache::New(num_inputs);
          pool.SetObjectAt<std::memory_order_release>(stc_pool_idx, cache);
          if (FLAG_trace_type_checks) {
            THR_Print("  Installed new subtype test cache %#" Px " with %" Pd
                      " inputs at index %" Pd " of pool for %s\n",
                      static_cast<uword>(cache.ptr()), num_inputs, stc_pool_idx,
                      caller_code.ToCString());
          }
        }
      }
#else
      UNREACHABLE();
#endif
    }
 
    UpdateTypeTestCache(zone, thread, src_instance, dst_type,
                        instantiator_type_arguments, function_type_arguments,
                        Bool::True(), cache);
  }
 
  arguments.SetReturn(src_instance);
}

DEFINE_RUNTIME_ENTRY() [56/57]

dart::DEFINE_RUNTIME_ENTRY	(	UpdateFieldCid	,
		2
	)

Definition at line 3813 of file runtime_entry.cc.

                                        {
#if !defined(DART_PRECOMPILED_RUNTIME)
  const Field& field = Field::CheckedHandle(zone, arguments.ArgAt(0));
  const Object& value = Object::Handle(arguments.ArgAt(1));
  field.RecordStore(value);
#else
  UNREACHABLE();
#endif
}

DEFINE_RUNTIME_ENTRY() [57/57]

dart::DEFINE_RUNTIME_ENTRY	(	WriteError	,
		2
	)

Definition at line 166 of file runtime_entry.cc.

                                    {
  const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
  const Smi& kind = Smi::CheckedHandle(zone, arguments.ArgAt(1));
  auto& message = String::Handle(zone);
  switch (kind.Value()) {
    case 0:  // CheckWritableInstr::Kind::kWriteUnmodifiableTypedData:
      message = String::NewFormatted("Cannot modify an unmodifiable list: %s",
                                     receiver.ToCString());
      break;
    case 1:  // CheckWritableInstr::Kind::kDeeplyImmutableAttachNativeFinalizer:
      message = String::NewFormatted(
          "Cannot attach NativeFinalizer to deeply immutable object: %s",
          receiver.ToCString());
      break;
  }
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, message);
  Exceptions::ThrowByType(Exceptions::kUnsupported, args);
}

DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT() [1/8]

dart::DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT	(	AllocateDouble	,
		0
	)

Definition at line 421 of file runtime_entry.cc.

                                                      {
  if (FLAG_shared_slow_path_triggers_gc) {
    isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
  arguments.SetReturn(
      Object::Handle(zone, Double::New(0.0, SpaceForRuntimeAllocation())));
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT() [2/8]

dart::DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT	(	AllocateFloat32x4	,
		0
	)

Definition at line 460 of file runtime_entry.cc.

                                                         {
  if (FLAG_shared_slow_path_triggers_gc) {
    isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
  arguments.SetReturn(Object::Handle(
      zone, Float32x4::New(0.0, 0.0, 0.0, 0.0, SpaceForRuntimeAllocation())));
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT() [3/8]

dart::DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT	(	AllocateFloat64x2	,
		0
	)

Definition at line 469 of file runtime_entry.cc.

                                                         {
  if (FLAG_shared_slow_path_triggers_gc) {
    isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
  arguments.SetReturn(Object::Handle(
      zone, Float64x2::New(0.0, 0.0, SpaceForRuntimeAllocation())));
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT() [4/8]

dart::DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT	(	AllocateInt32x4	,
		0
	)

Definition at line 478 of file runtime_entry.cc.

                                                       {
  if (FLAG_shared_slow_path_triggers_gc) {
    isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
  arguments.SetReturn(Object::Handle(
      zone, Int32x4::New(0, 0, 0, 0, SpaceForRuntimeAllocation())));
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT() [5/8]

dart::DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT	(	AllocateMint	,
		0
	)

Definition at line 451 of file runtime_entry.cc.

                                                    {
  if (FLAG_shared_slow_path_triggers_gc) {
    isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
  arguments.SetReturn(Object::Handle(
      zone, Integer::New(kMaxInt64, SpaceForRuntimeAllocation())));
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT() [6/8]

dart::DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT	(	BoxDouble	,
		0
	)

Definition at line 430 of file runtime_entry.cc.

                                                 {
  const double val = thread->unboxed_double_runtime_arg();
  arguments.SetReturn(
      Object::Handle(zone, Double::New(val, SpaceForRuntimeAllocation())));
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT() [7/8]

dart::DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT	(	BoxFloat32x4	,
		0
	)

Definition at line 437 of file runtime_entry.cc.

                                                    {
  const auto val = thread->unboxed_simd128_runtime_arg();
  arguments.SetReturn(
      Object::Handle(zone, Float32x4::New(val, SpaceForRuntimeAllocation())));
  RuntimeAllocationEpilogue(thread);
}

DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT() [8/8]

dart::DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT	(	BoxFloat64x2	,
		0
	)

Definition at line 444 of file runtime_entry.cc.

                                                    {
  const auto val = thread->unboxed_simd128_runtime_arg();
  arguments.SetReturn(
      Object::Handle(zone, Float64x2::New(val, SpaceForRuntimeAllocation())));
  RuntimeAllocationEpilogue(thread);
}

DeleteRegion()

static void dart::DeleteRegion ( const MemoryRegion &  region )

static

Definition at line 16 of file memory_region_test.cc.

                                                     {
  delete[] reinterpret_cast<uint8_t*>(region.pointer());
}

DeleteResource()

void dart::DeleteResource

(

intptr_t *

resource

)

Definition at line 1167 of file ffi_test_functions_vmspecific.cc.

                                        {
  delete resource;
}

DeleteThread()

static void dart::DeleteThread ( void *  thread )

static

Definition at line 172 of file os_thread.cc.

                                       {
  MSAN_UNPOISON(&thread, sizeof(thread));
  delete reinterpret_cast<OSThread*>(thread);
}

DeleteWeakHandleOnFinalization()

static void dart::DeleteWeakHandleOnFinalization ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 4027 of file dart_api_impl_test.cc.

                                                       {
  *static_cast<int*>(peer) = 42;
  Dart_DeleteWeakPersistentHandle(delete_on_finalization);
  delete_on_finalization = nullptr;
}

DeoptimizeAt()

void dart::DeoptimizeAt	(	Thread *	mutator_thread,
		const Code &	optimized_code,
		StackFrame *	frame
	)

Definition at line 3396 of file runtime_entry.cc.

                                     {
  ASSERT(optimized_code.is_optimized());
 
  // Force-optimized code is optimized code which cannot deoptimize and doesn't
  // have unoptimized code to fall back to.
  ASSERT(!optimized_code.is_force_optimized());
 
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const Function& function = Function::Handle(zone, optimized_code.function());
  const Error& error =
      Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, function));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
  }
  const Code& unoptimized_code =
      Code::Handle(zone, function.unoptimized_code());
  ASSERT(!unoptimized_code.IsNull());
  // The switch to unoptimized code may have already occurred.
  if (function.HasOptimizedCode()) {
    function.SwitchToUnoptimizedCode();
  }
 
  if (IsSuspendedFrame(zone, function, frame)) {
    // Frame is suspended and going to be removed from the stack.
    if (FLAG_trace_deoptimization) {
      THR_Print("Not deoptimizing suspended frame, fp=%" Pp "\n", frame->fp());
    }
  } else if (frame->IsMarkedForLazyDeopt()) {
    // Deopt already scheduled.
    if (FLAG_trace_deoptimization) {
      THR_Print("Lazy deopt already scheduled for fp=%" Pp "\n", frame->fp());
    }
  } else {
    uword deopt_pc = frame->pc();
    ASSERT(optimized_code.ContainsInstructionAt(deopt_pc));
 
#if defined(DEBUG)
    ValidateFrames();
#endif
 
    // N.B.: Update the pending deopt table before updating the frame. The
    // profiler may attempt a stack walk in between.
    mutator_thread->pending_deopts().AddPendingDeopt(frame->fp(), deopt_pc);
    frame->MarkForLazyDeopt();
 
    if (FLAG_trace_deoptimization) {
      THR_Print("Lazy deopt scheduled for fp=%" Pp ", pc=%" Pp "\n",
                frame->fp(), deopt_pc);
    }
  }
 
  // Mark code as dead (do not GC its embedded objects).
  optimized_code.set_is_alive(false);
}

DeoptimizeFunctionsOnStack()

void dart::DeoptimizeFunctionsOnStack

(

)

Definition at line 3456 of file runtime_entry.cc.

                                  {
  auto thread = Thread::Current();
  // Have to grab program_lock before stopping everybody else.
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
 
  auto isolate_group = thread->isolate_group();
  isolate_group->RunWithStoppedMutators([&]() {
    Code& optimized_code = Code::Handle();
    isolate_group->ForEachIsolate(
        [&](Isolate* isolate) {
          auto mutator_thread = isolate->mutator_thread();
          if (mutator_thread == nullptr) {
            return;
          }
          DartFrameIterator iterator(
              mutator_thread, StackFrameIterator::kAllowCrossThreadIteration);
          StackFrame* frame = iterator.NextFrame();
          while (frame != nullptr) {
            optimized_code = frame->LookupDartCode();
            if (optimized_code.is_optimized() &&
                !optimized_code.is_force_optimized()) {
              DeoptimizeAt(mutator_thread, optimized_code, frame);
            }
            frame = iterator.NextFrame();
          }
        },
        /*at_safepoint=*/true);
  });
}

DeoptimizeLastDartFrameIfOptimized()

static void dart::DeoptimizeLastDartFrameIfOptimized ( )

static

Definition at line 3486 of file runtime_entry.cc.

                                                 {
  auto thread = Thread::Current();
  // Have to grab program_lock before stopping everybody else.
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
 
  auto isolate = thread->isolate();
  auto isolate_group = thread->isolate_group();
  isolate_group->RunWithStoppedMutators([&]() {
    auto mutator_thread = isolate->mutator_thread();
    if (mutator_thread == nullptr) {
      return;
    }
    DartFrameIterator iterator(mutator_thread,
                               StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* frame = iterator.NextFrame();
    if (frame != nullptr) {
      const auto& optimized_code = Code::Handle(frame->LookupDartCode());
      if (optimized_code.is_optimized() &&
          !optimized_code.is_force_optimized()) {
        DeoptimizeAt(mutator_thread, optimized_code, frame);
      }
    }
  });
}

DeoptimizeToArray()

static ArrayPtr dart::DeoptimizeToArray ( Thread *  thread, StackFrame *  frame, const Code &  code  )

static

Definition at line 1648 of file debugger.cc.

                                                    {
  ASSERT(code.is_optimized() && !code.is_force_optimized());
  Isolate* isolate = thread->isolate();
  // Create the DeoptContext for this deoptimization.
  DeoptContext* deopt_context =
      new DeoptContext(frame, code, DeoptContext::kDestIsAllocated, nullptr,
                       nullptr, true, false /* deoptimizing_code */);
  isolate->set_deopt_context(deopt_context);
 
  deopt_context->FillDestFrame();
  deopt_context->MaterializeDeferredObjects();
  const Array& dest_frame =
      Array::Handle(thread->zone(), deopt_context->DestFrameAsArray());
 
  isolate->set_deopt_context(nullptr);
  delete deopt_context;
 
  return dest_frame.ptr();
}

DeoptimizeTypeTestingStubs()

void dart::DeoptimizeTypeTestingStubs

(

)

Definition at line 1528 of file type_testing_stubs.cc.

                                  {
  class CollectTypes : public ObjectVisitor {
   public:
    CollectTypes(Zone* zone, GrowableArray<AbstractType*>* types)
        : zone_(zone), types_(types), cache_(SubtypeTestCache::Handle(zone)) {}
 
    void VisitObject(ObjectPtr object) {
      // Only types and record types may have optimized TTSes,
      // see TypeTestingStubGenerator::OptimizedCodeForType.
      if (object->IsType() || object->IsRecordType()) {
        types_->Add(&AbstractType::CheckedHandle(zone_, object));
      } else if (object->IsSubtypeTestCache()) {
        cache_ ^= object;
        cache_.Reset();
      }
    }
 
   private:
    Zone* const zone_;
    GrowableArray<AbstractType*>* const types_;
    TypeTestingStubGenerator generator_;
    SubtypeTestCache& cache_;
  };
 
  Thread* thread = Thread::Current();
  TIMELINE_DURATION(thread, Isolate, "DeoptimizeTypeTestingStubs");
  HANDLESCOPE(thread);
  Zone* zone = thread->zone();
  GrowableArray<AbstractType*> types(zone, 0);
  {
    HeapIterationScope iter(thread);
    CollectTypes visitor(zone, &types);
    iter.IterateObjects(&visitor);
  }
  auto& stub = Code::Handle(zone);
  for (auto* const type : types) {
    stub = TypeTestingStubGenerator::DefaultCodeForType(*type);
    type->SetTypeTestingStub(stub);
  }
}

DeoptReasonToCString()

const char * dart::DeoptReasonToCString

(

ICData::DeoptReasonId

deopt_reason

)

Definition at line 3369 of file runtime_entry.cc.

                                                                   {
  switch (deopt_reason) {
#define DEOPT_REASON_TO_TEXT(name)                                             \
  case ICData::kDeopt##name:                                                   \
    return #name;
    DEOPT_REASONS(DEOPT_REASON_TO_TEXT)
#undef DEOPT_REASON_TO_TEXT
    default:
      UNREACHABLE();
      return "";
  }
}

DependOnSameSymbol()

static bool dart::DependOnSameSymbol ( const RangeBoundary &  a, const RangeBoundary &  b  )

static

Definition at line 326 of file range_analysis.cc.

                                                                               {
  return a.IsSymbol() && b.IsSymbol() &&
         AreEqualDefinitions(a.symbol(), b.symbol());
}

DependsOnSymbol()

static bool dart::DependsOnSymbol ( const RangeBoundary &  a, Definition *  symbol  )

static

Definition at line 2671 of file range_analysis.cc.

                                                                        {
  return a.IsSymbol() && (UnwrapConstraint(a.symbol()) == symbol);
}

DeserializeMessage()

static ObjectPtr dart::DeserializeMessage ( Thread *  thread, Message *  message  )

static

Definition at line 528 of file isolate.cc.

                                                                      {
  if (message == nullptr) {
    return Object::null();
  }
  if (message->IsRaw()) {
    return Object::RawCast(message->raw_obj());
  } else {
    return ReadMessage(thread, message);
  }
}

DeterminedAlready()

static bool dart::DeterminedAlready ( QuickCheckDetails *  quick_check, intptr_t  offset  )

static

Definition at line 2351 of file regexp.cc.

                                                                               {
  if (quick_check == nullptr) return false;
  if (offset >= quick_check->characters()) return false;
  return quick_check->positions(offset)->determines_perfectly;
}

DeterministicModeHandler()

static void dart::DeterministicModeHandler ( bool  value )

static

Definition at line 80 of file isolate.cc.

                                                 {
  if (value) {
    FLAG_background_compilation = false;  // Timing dependent.
    FLAG_concurrent_mark = false;         // Timing dependent.
    FLAG_concurrent_sweep = false;        // Timing dependent.
    FLAG_scavenger_tasks = 0;             // Timing dependent.
    FLAG_old_gen_growth_time_ratio = 0;   // Timing dependent.
    FLAG_random_seed = 0x44617274;        // "Dart"
  }
}

DevNullFloat()

DART_EXPORT void dart::DevNullFloat

(

float

a

)

Definition at line 823 of file ffi_test_functions.cc.

                                       {
  std::cout << "DevNullFloat(" << a << ")\n";
  std::cout << "returning nothing\n";
}

DFLRT_EnterSafepoint()

void dart::DFLRT_EnterSafepoint

(

NativeArguments

__unusable_

)

Definition at line 3959 of file runtime_entry.cc.

                                                                  {
  CHECK_STACK_ALIGNMENT;
  TRACE_RUNTIME_CALL("%s", "EnterSafepoint");
  Thread* thread = Thread::Current();
  ASSERT(thread->top_exit_frame_info() != 0);
  ASSERT(thread->execution_state() == Thread::kThreadInNative);
  thread->EnterSafepoint();
  TRACE_RUNTIME_CALL("%s", "EnterSafepoint done");
}

DFLRT_ExitSafepoint()

void dart::DFLRT_ExitSafepoint

(

NativeArguments

__unusable_

)

Definition at line 3973 of file runtime_entry.cc.

                                                                 {
  CHECK_STACK_ALIGNMENT;
  TRACE_RUNTIME_CALL("%s", "ExitSafepoint");
  Thread* thread = Thread::Current();
  ASSERT(thread->top_exit_frame_info() != 0);
 
  ASSERT(thread->execution_state() == Thread::kThreadInVM);
  if (thread->is_unwind_in_progress()) {
    // Clean up safepoint unwind error marker to prevent safepoint tripping.
    // The safepoint marker will get restored just before jumping back
    // to generated code.
    thread->SetUnwindErrorInProgress(false);
    NoSafepointScope no_safepoint;
    Error unwind_error;
    unwind_error ^=
        thread->isolate()->isolate_object_store()->preallocated_unwind_error();
    Exceptions::PropagateError(unwind_error);
  }
  thread->ExitSafepoint();
 
  TRACE_RUNTIME_CALL("%s", "ExitSafepoint done");
}

DFLRT_ExitSafepointIgnoreUnwindInProgress()

void dart::DFLRT_ExitSafepointIgnoreUnwindInProgress

(

NativeArguments

__unusable_

)

Definition at line 4002 of file runtime_entry.cc.

                                 {
  CHECK_STACK_ALIGNMENT;
  TRACE_RUNTIME_CALL("%s", "ExitSafepointIgnoreUnwindInProgress");
  Thread* thread = Thread::Current();
  ASSERT(thread->top_exit_frame_info() != 0);
 
  ASSERT(thread->execution_state() == Thread::kThreadInVM);
 
  // Compared to ExitSafepoint above we are going to ignore
  // is_unwind_in_progress flag because this is called as part of JumpToFrame
  // exception handler - we want this transition to complete so that the next
  // safepoint check does error propagation.
  thread->ExitSafepoint();
 
  TRACE_RUNTIME_CALL("%s", "ExitSafepointIgnoreUnwindInProgress done");
}

DLRT_AllocateHandle()

LocalHandle * dart::DLRT_AllocateHandle

(

ApiLocalScope *

scope

)

Definition at line 4179 of file runtime_entry.cc.

                                                                  {
  CHECK_STACK_ALIGNMENT;
  TRACE_RUNTIME_CALL("AllocateHandle %p", scope);
  LocalHandle* return_value = scope->local_handles()->AllocateHandle();
  // Don't return an uninitialised handle.
  return_value->set_ptr(Object::sentinel().ptr());
  TRACE_RUNTIME_CALL("AllocateHandle returning %p", return_value);
  return return_value;
}

DLRT_EnterHandleScope()

ApiLocalScope * dart::DLRT_EnterHandleScope

(

Thread *

thread

)

Definition at line 4155 of file runtime_entry.cc.

                                                                {
  CHECK_STACK_ALIGNMENT;
  TRACE_RUNTIME_CALL("EnterHandleScope %p", thread);
  thread->EnterApiScope();
  ApiLocalScope* return_value = thread->api_top_scope();
  TRACE_RUNTIME_CALL("EnterHandleScope returning %p", return_value);
  return return_value;
}

DLRT_ExitHandleScope()

void dart::DLRT_ExitHandleScope

(

Thread *

thread

)

Definition at line 4168 of file runtime_entry.cc.

                                                     {
  CHECK_STACK_ALIGNMENT;
  TRACE_RUNTIME_CALL("ExitHandleScope %p", thread);
  thread->ExitApiScope();
  TRACE_RUNTIME_CALL("ExitHandleScope %s", "done");
}

DLRT_ExitTemporaryIsolate()

void dart::DLRT_ExitTemporaryIsolate

(

)

Definition at line 4131 of file runtime_entry.cc.

                                            {
  TRACE_RUNTIME_CALL("ExitTemporaryIsolate%s", "");
  Thread* thread = Thread::Current();
  ASSERT(thread != nullptr);
  Isolate* source_isolate =
      reinterpret_cast<Isolate*>(thread->unboxed_int64_runtime_second_arg());
 
  // We're either inside a temp isolate, or inside the source_isolate.
  const bool inside_temp_isolate =
      source_isolate == nullptr || source_isolate != thread->isolate();
  if (inside_temp_isolate) {
    IsolateGroup::ExitTemporaryIsolate();
    if (source_isolate != nullptr) {
      TRACE_RUNTIME_CALL("ExitTemporaryIsolate re-entering source isolate %p",
                         source_isolate);
      Thread::EnterIsolate(source_isolate);
      Thread::Current()->EnterSafepoint();
    }
  } else {
    thread->EnterSafepoint();
  }
  TRACE_RUNTIME_CALL("ExitTemporaryIsolate %s", "done");
}

DLRT_GetFfiCallbackMetadata()

Thread * dart::DLRT_GetFfiCallbackMetadata	(	FfiCallbackMetadata::Trampoline	trampoline,
		uword *	out_entry_point,
		uword *	out_trampoline_type
	)

Definition at line 4027 of file runtime_entry.cc.

                                {
  CHECK_STACK_ALIGNMENT;
  TRACE_RUNTIME_CALL("GetFfiCallbackMetadata %p",
                     reinterpret_cast<void*>(trampoline));
  ASSERT(out_entry_point != nullptr);
  ASSERT(out_trampoline_type != nullptr);
 
  Thread* const current_thread = Thread::Current();
  auto* fcm = FfiCallbackMetadata::Instance();
  auto metadata = fcm->LookupMetadataForTrampoline(trampoline);
 
  // Is this an async callback?
  if (metadata.trampoline_type() ==
      FfiCallbackMetadata::TrampolineType::kAsync) {
    // It's possible that the callback was deleted, or the target isolate was
    // shut down, in between looking up the metadata above, and this point. So
    // grab the lock and then check that the callback is still alive.
    MutexLocker locker(fcm->lock());
    auto metadata2 = fcm->LookupMetadataForTrampoline(trampoline);
    *out_trampoline_type = static_cast<uword>(metadata2.trampoline_type());
 
    // Check IsLive, but also check that the metdata hasn't changed. This is
    // for the edge case that the callback was destroyed and recycled in between
    // the two lookups.
    if (!metadata.IsLive() || !metadata.IsSameCallback(metadata2)) {
      TRACE_RUNTIME_CALL("GetFfiCallbackMetadata callback deleted %p",
                         reinterpret_cast<void*>(trampoline));
      return nullptr;
    }
 
    *out_entry_point = metadata.target_entry_point();
    Isolate* target_isolate = metadata.target_isolate();
 
    Isolate* current_isolate = nullptr;
    if (current_thread != nullptr) {
      current_isolate = current_thread->isolate();
      ASSERT(current_thread->execution_state() == Thread::kThreadInNative);
      current_thread->ExitSafepoint();
      current_thread->set_execution_state(Thread::kThreadInVM);
    }
 
    // Enter the temporary isolate. If the current isolate is in the same group
    // as the target isolate, we can skip entering the temp isolate, and marshal
    // the args on the current isolate.
    if (current_isolate == nullptr ||
        current_isolate->group() != target_isolate->group()) {
      if (current_isolate != nullptr) {
        Thread::ExitIsolate(/*isolate_shutdown=*/false);
      }
      target_isolate->group()->EnterTemporaryIsolate();
    }
    Thread* const temp_thread = Thread::Current();
    ASSERT(temp_thread != nullptr);
    temp_thread->set_unboxed_int64_runtime_arg(metadata.send_port());
    temp_thread->set_unboxed_int64_runtime_second_arg(
        reinterpret_cast<intptr_t>(current_isolate));
    ASSERT(!temp_thread->IsAtSafepoint());
    return temp_thread;
  }
 
  // Otherwise, this is a sync callback, so verify that we're already entered
  // into the target isolate.
  if (!metadata.IsLive()) {
    FATAL("Callback invoked after it has been deleted.");
  }
  Isolate* target_isolate = metadata.target_isolate();
  *out_entry_point = metadata.target_entry_point();
  *out_trampoline_type = static_cast<uword>(metadata.trampoline_type());
  if (current_thread == nullptr) {
    FATAL("Cannot invoke native callback outside an isolate.");
  }
  if (current_thread->no_callback_scope_depth() != 0) {
    FATAL("Cannot invoke native callback when API callbacks are prohibited.");
  }
  if (current_thread->is_unwind_in_progress()) {
    FATAL("Cannot invoke native callback while unwind error propagates.");
  }
  if (!current_thread->IsDartMutatorThread()) {
    FATAL("Native callbacks must be invoked on the mutator thread.");
  }
  if (current_thread->isolate() != target_isolate) {
    FATAL("Cannot invoke native callback from a different isolate.");
  }
 
  // Set the execution state to VM while waiting for the safepoint to end.
  // This isn't strictly necessary but enables tests to check that we're not
  // in native code anymore. See tests/ffi/function_gc_test.dart for example.
  current_thread->set_execution_state(Thread::kThreadInVM);
 
  current_thread->ExitSafepoint();
 
  current_thread->set_unboxed_int64_runtime_arg(metadata.context());
 
  TRACE_RUNTIME_CALL("GetFfiCallbackMetadata thread %p", current_thread);
  TRACE_RUNTIME_CALL("GetFfiCallbackMetadata entry_point %p",
                     (void*)*out_entry_point);
  TRACE_RUNTIME_CALL("GetFfiCallbackMetadata trampoline_type %p",
                     (void*)*out_trampoline_type);
  return current_thread;
}

DLRT_PropagateError()

void dart::DLRT_PropagateError

(

Dart_Handle

handle

)

Definition at line 4203 of file runtime_entry.cc.

                                                        {
  CHECK_STACK_ALIGNMENT;
  TRACE_RUNTIME_CALL("PropagateError %p", handle);
  ASSERT(Thread::Current()->execution_state() == Thread::kThreadInNative);
  ASSERT(Dart_IsError(handle));
  Dart_PropagateError(handle);
  // We should never exit through normal control flow.
  UNREACHABLE();
}

DominatesPhi()

static bool dart::DominatesPhi ( BlockEntryInstr *  a, BlockEntryInstr *  phi_block  )

static

Definition at line 2734 of file range_analysis.cc.

                                                                         {
  return a->Dominates(phi_block) && (a != phi_block);
}

DontDeleteWeakHandleOnFinalization()

static void dart::DontDeleteWeakHandleOnFinalization ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 4034 of file dart_api_impl_test.cc.

                                                           {
  *static_cast<int*>(peer) = 42;
  delete_on_finalization = nullptr;
}

DoThrowNullError()

static void dart::DoThrowNullError ( Isolate *  isolate, Thread *  thread, Zone *  zone, bool  is_param  )

static

Definition at line 232 of file runtime_entry.cc.

                                            {
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  const StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame->IsDartFrame());
  const Code& code = Code::Handle(zone, caller_frame->LookupDartCode());
  const uword pc_offset = caller_frame->pc() - code.PayloadStart();
 
  if (FLAG_shared_slow_path_triggers_gc) {
    isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
 
  const CodeSourceMap& map =
      CodeSourceMap::Handle(zone, code.code_source_map());
  String& member_name = String::Handle(zone);
  if (!map.IsNull()) {
    CodeSourceMapReader reader(map, Array::null_array(),
                               Function::null_function());
    const intptr_t name_index = reader.GetNullCheckNameIndexAt(pc_offset);
    RELEASE_ASSERT(name_index >= 0);
 
    const ObjectPool& pool = ObjectPool::Handle(zone, code.GetObjectPool());
    member_name ^= pool.ObjectAt(name_index);
  } else {
    member_name = Symbols::OptimizedOut().ptr();
  }
 
  NullErrorHelper(zone, member_name, is_param);
}

double_to_uint64()

static uint64_t dart::double_to_uint64 ( double  d )

static

Definition at line 13 of file double_internals.h.

                                           {
  return bit_cast<uint64_t>(d);
}

DoubleToCString()

void dart::DoubleToCString	(	double	d,
		char *	buffer,
		int	buffer_size
	)

Definition at line 19 of file double_conversion.cc.

                                                              {
  const int kDecimalLow = -6;
  const int kDecimalHigh = 21;
 
  // The output contains the sign, at most kDecimalHigh - 1 digits,
  // the decimal point followed by a 0 plus the \0.
  ASSERT(buffer_size >= 1 + (kDecimalHigh - 1) + 1 + 1 + 1);
  // Or it contains the sign, a 0, the decimal point, kDecimalLow '0's,
  // 17 digits (the precision needed for doubles), plus the \0.
  ASSERT(buffer_size >= 1 + 1 + 1 + kDecimalLow + 17 + 1);
  // Alternatively it contains a sign, at most 17 digits (precision needed for
  // any double), the decimal point, the exponent character, the exponent's
  // sign, at most three exponent digits, plus the \0.
  ASSERT(buffer_size >= 1 + 17 + 1 + 1 + 1 + 3 + 1);
 
  const int kConversionFlags =
      double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
      double_conversion::DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
      double_conversion::DoubleToStringConverter::
          EMIT_TRAILING_ZERO_AFTER_POINT;
 
  const double_conversion::DoubleToStringConverter converter(
      kConversionFlags, kInfinitySymbol, kNaNSymbol, kExponentChar, kDecimalLow,
      kDecimalHigh, 0,
      0);  // Last two values are ignored in shortest mode.
 
  double_conversion::StringBuilder builder(buffer, buffer_size);
  bool status = converter.ToShortest(d, &builder);
  ASSERT(status);
  char* result = builder.Finalize();
  ASSERT(result == buffer);
}

DoubleToInteger()

IntegerPtr dart::DoubleToInteger	(	Zone *	zone,
		double	val
	)

Definition at line 170 of file double_conversion.cc.

                                                   {
  if (isinf(val) || isnan(val)) {
    const Array& args = Array::Handle(zone, Array::New(1));
    args.SetAt(0, String::Handle(zone, String::New("Infinity or NaN toInt")));
    Exceptions::ThrowByType(Exceptions::kUnsupported, args);
  }
  int64_t ival = 0;
  if (val <= static_cast<double>(kMinInt64)) {
    ival = kMinInt64;
  } else if (val >= static_cast<double>(kMaxInt64)) {
    ival = kMaxInt64;
  } else {  // Representable in int64_t.
    ival = static_cast<int64_t>(val);
  }
  return Integer::New(ival);
}

DoubleToStringAsExponential()

StringPtr dart::DoubleToStringAsExponential	(	double	d,
		int	fraction_digits
	)

Definition at line 91 of file double_conversion.cc.

                                                                     {
  const int kMinFractionDigits = -1;  // -1 represents shortest mode.
  const int kMaxFractionDigits = 20;
  const int kConversionFlags =
      double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
  const int kBufferSize = 128;
 
  USE(kMinFractionDigits);
  USE(kMaxFractionDigits);
  // The output contains the sign, at most 1 digits, the decimal point followed
  // by at most kMaxFractionDigits digits, the exponent-character, the
  // exponent-sign and three exponent digits plus \0.
  ASSERT(kBufferSize >= 1 + 1 + kMaxFractionDigits + 1 + 1 + 3 + 1);
 
  ASSERT(kMinFractionDigits <= fraction_digits &&
         fraction_digits <= kMaxFractionDigits);
 
  const double_conversion::DoubleToStringConverter converter(
      kConversionFlags, kInfinitySymbol, kNaNSymbol, kExponentChar, 0, 0, 0,
      0);  // Last four values are ignored in exponential mode.
 
  char* buffer = Thread::Current()->zone()->Alloc<char>(kBufferSize);
  buffer[kBufferSize - 1] = '\0';
  double_conversion::StringBuilder builder(buffer, kBufferSize);
  bool status = converter.ToExponential(d, fraction_digits, &builder);
  ASSERT(status);
  return String::New(builder.Finalize());
}

DoubleToStringAsFixed()

StringPtr dart::DoubleToStringAsFixed	(	double	d,
		int	fraction_digits
	)

Definition at line 52 of file double_conversion.cc.

                                                               {
  const int kMinFractionDigits = 0;
  const int kMaxFractionDigits = 20;
  const int kMaxDigitsBeforePoint = 20;
  // The boundaries are exclusive.
  const double kLowerBoundary = -1e21;
  const double kUpperBoundary = 1e21;
  // TODO(floitsch): remove the UNIQUE_ZERO flag when the test is updated.
  const int kConversionFlags =
      double_conversion::DoubleToStringConverter::NO_FLAGS;
  const int kBufferSize = 128;
 
  USE(kMaxDigitsBeforePoint);
  USE(kMaxFractionDigits);
  USE(kLowerBoundary);
  USE(kUpperBoundary);
  USE(kMinFractionDigits);
  USE(kMaxFractionDigits);
  // The output contains the sign, at most kMaxDigitsBeforePoint digits,
  // the decimal point followed by at most fraction_digits digits plus the \0.
  ASSERT(kBufferSize >= 1 + kMaxDigitsBeforePoint + 1 + kMaxFractionDigits + 1);
 
  ASSERT(kLowerBoundary < d && d < kUpperBoundary);
 
  ASSERT(kMinFractionDigits <= fraction_digits &&
         fraction_digits <= kMaxFractionDigits);
 
  const double_conversion::DoubleToStringConverter converter(
      kConversionFlags, kInfinitySymbol, kNaNSymbol, kExponentChar, 0, 0, 0,
      0);  // Last four values are ignored in fixed mode.
 
  char* buffer = Thread::Current()->zone()->Alloc<char>(kBufferSize);
  buffer[kBufferSize - 1] = '\0';
  double_conversion::StringBuilder builder(buffer, kBufferSize);
  bool status = converter.ToFixed(d, fraction_digits, &builder);
  ASSERT(status);
  return String::New(builder.Finalize());
}

DoubleToStringAsPrecision()

StringPtr dart::DoubleToStringAsPrecision	(	double	d,
		int	precision
	)

Definition at line 120 of file double_conversion.cc.

                                                             {
  const int kMinPrecisionDigits = 1;
  const int kMaxPrecisionDigits = 21;
  const int kMaxLeadingPaddingZeroes = 6;
  const int kMaxTrailingPaddingZeroes = 0;
  const int kConversionFlags =
      double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
  const int kBufferSize = 128;
 
  USE(kMinPrecisionDigits);
  USE(kMaxPrecisionDigits);
  // The output contains the sign, a potential leading 0, the decimal point,
  // at most kMax{Leading|Trailing} padding zeroes, precision digits,
  // the exponent-character, the exponent-sign, three exponent digits
  // plus the \0.
  // Note that padding and exponent are exclusive. We still add them up.
  ASSERT(kBufferSize >= 1 + 1 + 1 + kMaxLeadingPaddingZeroes +
                            kMaxTrailingPaddingZeroes + kMaxPrecisionDigits +
                            1 + 1 + 3 + 1);
 
  ASSERT(kMinPrecisionDigits <= precision && precision <= kMaxPrecisionDigits);
 
  const double_conversion::DoubleToStringConverter converter(
      kConversionFlags, kInfinitySymbol, kNaNSymbol, kExponentChar, 0,
      0,  // Ignored in precision mode.
      kMaxLeadingPaddingZeroes, kMaxTrailingPaddingZeroes);
 
  char* buffer = Thread::Current()->zone()->Alloc<char>(kBufferSize);
  buffer[kBufferSize - 1] = '\0';
  double_conversion::StringBuilder builder(buffer, kBufferSize);
  bool status = converter.ToPrecision(d, precision, &builder);
  ASSERT(status);
  return String::New(builder.Finalize());
}

DRegisterOf()

static DRegister dart::DRegisterOf ( SRegister  s )

inlinestatic

Definition at line 285 of file constants_arm.h.

                                                 {
  return static_cast<DRegister>(s / 2);
}

DropRegExpMatchCode()

static void dart::DropRegExpMatchCode ( Zone *  zone )

static

Definition at line 6719 of file dart_api_impl.cc.

                                            {
  const String& execute_match_name =
      String::Handle(zone, String::New("_ExecuteMatch"));
  const String& execute_match_sticky_name =
      String::Handle(zone, String::New("_ExecuteMatchSticky"));
 
  const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
  const Class& reg_exp_class =
      Class::Handle(zone, core_lib.LookupClassAllowPrivate(Symbols::_RegExp()));
  ASSERT(!reg_exp_class.IsNull());
 
  auto thread = Thread::Current();
  Function& func = Function::Handle(
      zone, reg_exp_class.LookupFunctionAllowPrivate(execute_match_name));
  ASSERT(!func.IsNull());
  Code& code = Code::Handle(zone);
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  if (func.HasCode()) {
    code = func.CurrentCode();
    ASSERT(!code.IsNull());
    code.DisableDartCode();
  }
  func.ClearCode();
  func.ClearICDataArray();
  ASSERT(!func.HasCode());
 
  func = reg_exp_class.LookupFunctionAllowPrivate(execute_match_sticky_name);
  ASSERT(!func.IsNull());
  if (func.HasCode()) {
    code = func.CurrentCode();
    ASSERT(!code.IsNull());
    code.DisableDartCode();
  }
  func.ClearCode();
  func.ClearICDataArray();
  ASSERT(!func.HasCode());
}

DummyResourceFinalizer()

void dart::DummyResourceFinalizer	(	void *	isolate_peer,
		void *	peer
	)

Definition at line 1175 of file ffi_test_functions_vmspecific.cc.

                                                            {
  *reinterpret_cast<intptr_t*>(peer) = 0;
}

DumpAliveIsolates()

static void dart::DumpAliveIsolates ( intptr_t  num_attempts, bool  only_application_isolates  )

static

Definition at line 542 of file dart.cc.

                                                              {
  IsolateGroup::ForEach([&](IsolateGroup* group) {
    group->ForEachIsolate([&](Isolate* isolate) {
      if (!only_application_isolates || !Isolate::IsSystemIsolate(isolate)) {
        OS::PrintErr("Attempt:%" Pd " waiting for isolate %s to check in\n",
                     num_attempts, isolate->name());
      }
    });
  });
}

DumpCompilerState()

static void dart::DumpCompilerState ( Thread *  thread )

static

Definition at line 460 of file profiler.cc.

                                              {
#if !defined(DART_PRECOMPILED_RUNTIME)
  if (thread != nullptr && thread->execution_state() == Thread::kThreadInVM &&
      thread->HasCompilerState()) {
    thread->compiler_state().ReportCrash();
  }
#endif
}

DumpFunctionTypeTable()

void dart::DumpFunctionTypeTable

(

Isolate *

isolate

)

Definition at line 27161 of file object.cc.

                                             {
  OS::PrintErr("canonical function types:\n");
  CanonicalFunctionTypeSet table(
      isolate->group()->object_store()->canonical_function_types());
  table.Dump();
  table.Release();
}

DumpRecordTypeTable()

void dart::DumpRecordTypeTable

(

Isolate *

isolate

)

Definition at line 27169 of file object.cc.

                                           {
  OS::PrintErr("canonical record types:\n");
  CanonicalRecordTypeSet table(
      isolate->group()->object_store()->canonical_record_types());
  table.Dump();
  table.Release();
}

DumpStackFrame() [1/2]

void dart::DumpStackFrame	(	intptr_t	frame_index,
		uword	pc,
		uword	fp
	)

Definition at line 77 of file profiler.cc.

                                                              {
  uword start = 0;
  // The pc for all frames except the top frame is a return address, which can
  // belong to a different inlining interval than the call. Subtract one to get
  // the symbolization for the call.
  uword lookup_pc = frame_index == 0 ? pc : pc - 1;
  if (auto const name =
          NativeSymbolResolver::LookupSymbolName(lookup_pc, &start)) {
    DumpStackFrame(pc, fp, name, pc - start);
    NativeSymbolResolver::FreeSymbolName(name);
    return;
  }
 
  char* dso_name;
  uword dso_base;
  if (NativeSymbolResolver::LookupSharedObject(pc, &dso_base, &dso_name)) {
    DumpStackFrame(pc, fp, dso_name, pc - dso_base);
    NativeSymbolResolver::FreeSymbolName(dso_name);
    return;
  }
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  // This relies on heap iteration, which might fail if we're crashing because
  // of heap corruption. A nested crash symbolizing a JIT frame will prevent
  // seeing all caller frames, so only do this when we aren't able to use the
  // safer StackFrameIterator.
  Thread* thread = Thread::Current();
  bool symbolize_jit_code =
      (thread != nullptr) &&
      (thread->execution_state() != Thread::kThreadInNative) &&
      (thread->execution_state() != Thread::kThreadInVM);
  if (symbolize_jit_code) {
    Code result;
    result = Code::FindCodeUnsafe(lookup_pc);
    if (!result.IsNull()) {
      DumpStackFrame(
          pc, fp,
          result.QualifiedName(NameFormattingParams(Object::kInternalName)),
          pc - result.PayloadStart());
      return;
    }
  }
#endif
 
  OS::PrintErr("  pc 0x%" Pp " fp 0x%" Pp " Unknown symbol\n", pc, fp);
}

DumpStackFrame() [2/2]

static void dart::DumpStackFrame ( uword  pc, uword  fp, const char *  name, uword  offset  )

static

Definition at line 72 of file profiler.cc.

                                                                               {
  OS::PrintErr("  pc 0x%" Pp " fp 0x%" Pp " %s+0x%" Px "\n", pc, fp, name,
               offset);
}

DumpTypeArgumentsTable()

void dart::DumpTypeArgumentsTable

(

Isolate *

isolate

)

Definition at line 27185 of file object.cc.

                                              {
  OS::PrintErr("canonical type arguments:\n");
  CanonicalTypeArgumentsSet table(
      isolate->group()->object_store()->canonical_type_arguments());
  table.Dump();
  table.Release();
}

DumpTypeParameterTable()

void dart::DumpTypeParameterTable

(

Isolate *

isolate

)

Definition at line 27177 of file object.cc.

                                              {
  OS::PrintErr("canonical type parameters (cloned from declarations):\n");
  CanonicalTypeParameterSet table(
      isolate->group()->object_store()->canonical_type_parameters());
  table.Dump();
  table.Release();
}

DumpTypeTable()

void dart::DumpTypeTable

(

Isolate *

isolate

)

Definition at line 27154 of file object.cc.

                                     {
  OS::PrintErr("canonical types:\n");
  CanonicalTypeSet table(isolate->group()->object_store()->canonical_types());
  table.Dump();
  table.Release();
}

DwarfStackTracesHandler()

static void dart::DwarfStackTracesHandler ( bool  value )

static

Definition at line 26568 of file object.cc.

                                                {
  FLAG_dwarf_stack_traces_mode = value;
 
#if defined(PRODUCT)
  // We can safely remove function objects in precompiled snapshots if the
  // runtime will generate DWARF stack traces and we don't have runtime
  // debugging options like the observatory available.
  if (value) {
    FLAG_retain_function_objects = false;
    FLAG_retain_code_objects = false;
  }
#endif
}

Echo()

static void dart::Echo ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1785 of file service.cc.

                                                 {
  JSONObject jsobj(js);
  HandleCommonEcho(&jsobj, js);
}

EchoInt()

static intptr_t dart::EchoInt ( double  x )

static

Definition at line 10116 of file dart_api_impl_test.cc.

                       {
        loop_test_exit = true;
        ml.Notify();

ElideJSONSubstring()

void dart::ElideJSONSubstring	(	const char *	prefix,
		const char *	in,
		char *	out,
		const char *	postfix
	)

Definition at line 776 of file unit_test.cc.

                                             {
  const char* pos = strstr(in, prefix);
  while (pos != nullptr) {
    // Copy up to pos into the output buffer.
    while (in < pos) {
      *out++ = *in++;
    }
 
    // Skip to the closing postfix.
    in += strlen(prefix);
    in += strcspn(in, postfix);
    pos = strstr(in, prefix);
  }
  // Copy the remainder of in to out.
  while (*in != '\0') {
    *out++ = *in++;
  }
  *out = '\0';
}

EliminateTrivialBlock()

static void dart::EliminateTrivialBlock ( BlockEntryInstr *  block, Definition *  instr, IfThenElseInstr *  before  )

static

Definition at line 229 of file branch_optimizer.cc.

                                                           {
  block->UnuseAllInputs();
  block->last_instruction()->UnuseAllInputs();
 
  if ((block->next() == instr) &&
      (instr->next() == block->last_instruction())) {
    before->previous()->LinkTo(instr);
    instr->LinkTo(before);
  }
}

EliminateWriteBarriers()

void dart::EliminateWriteBarriers

(

FlowGraph *

flow_graph

)

Definition at line 426 of file write_barrier_elimination.cc.

                                                   {
  WriteBarrierElimination elimination(Thread::Current()->zone(), flow_graph);
  elimination.Analyze();
  elimination.SaveResults();
}

EmbedderInformationCallback()

static void dart::EmbedderInformationCallback ( Dart_EmbedderInformation *  info )

static

Definition at line 284 of file run_vm_tests.cc.

                                                                        {
  info->version = DART_EMBEDDER_INFORMATION_CURRENT_VERSION;
  info->name = "Run VM Tests";
  bin::Process::GetRSSInformation(&(info->max_rss), &(info->current_rss));
}

EmitAtomLetter()

static bool dart::EmitAtomLetter ( Zone *  zone, RegExpCompiler *  compiler, uint16_t  c, BlockLabel *  on_failure, intptr_t  cp_offset, bool  check, bool  preloaded  )

inlinestatic

Definition at line 981 of file regexp.cc.

                                                  {
  RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
  bool one_byte = compiler->one_byte();
  int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
  intptr_t length = GetCaseIndependentLetters(c, one_byte, chars);
  if (length <= 1) return false;
  // We may not need to check against the end of the input string
  // if this character lies before a character that matched.
  if (!preloaded) {
    macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check);
  }
  BlockLabel ok;
  ASSERT(unibrow::Ecma262UnCanonicalize::kMaxWidth == 4);
  switch (length) {
    case 2: {
      if (ShortCutEmitCharacterPair(macro_assembler, one_byte, chars[0],
                                    chars[1], on_failure)) {
      } else {
        macro_assembler->CheckCharacter(chars[0], &ok);
        macro_assembler->CheckNotCharacter(chars[1], on_failure);
        macro_assembler->BindBlock(&ok);
      }
      break;
    }
    case 4:
      macro_assembler->CheckCharacter(chars[3], &ok);
      FALL_THROUGH;
    case 3:
      macro_assembler->CheckCharacter(chars[0], &ok);
      macro_assembler->CheckCharacter(chars[1], &ok);
      macro_assembler->CheckNotCharacter(chars[2], on_failure);
      macro_assembler->BindBlock(&ok);
      break;
    default:
      UNREACHABLE();
      break;
  }
  return true;
}

EmitAtomNonLetter()

static bool dart::EmitAtomNonLetter ( Zone *  zone, RegExpCompiler *  compiler, uint16_t  c, BlockLabel *  on_failure, intptr_t  cp_offset, bool  check, bool  preloaded  )

inlinestatic

Definition at line 902 of file regexp.cc.

                                                     {
  RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
  bool one_byte = compiler->one_byte();
  int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
  intptr_t length = GetCaseIndependentLetters(c, one_byte, chars);
  if (length < 1) {
    // This can't match.  Must be an one-byte subject and a non-one-byte
    // character.  We do not need to do anything since the one-byte pass
    // already handled this.
    return false;  // Bounds not checked.
  }
  bool checked = false;
  // We handle the length > 1 case in a later pass.
  if (length == 1) {
    if (one_byte && c > Symbols::kMaxOneCharCodeSymbol) {
      // Can't match - see above.
      return false;  // Bounds not checked.
    }
    if (!preloaded) {
      macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check);
      checked = check;
    }
    macro_assembler->CheckNotCharacter(c, on_failure);
  }
  return checked;
}

EmitBoundaryTest()

static void dart::EmitBoundaryTest ( RegExpMacroAssembler *  masm, uint16_t  border, BlockLabel *  fall_through, BlockLabel *  above_or_equal, BlockLabel *  below  )

static

Definition at line 1027 of file regexp.cc.

                                                {
  if (below != fall_through) {
    masm->CheckCharacterLT(border, below);
    if (above_or_equal != fall_through) masm->GoTo(above_or_equal);
  } else {
    masm->CheckCharacterGT(border - 1, above_or_equal);
  }
}

EmitCharClass()

static void dart::EmitCharClass ( RegExpMacroAssembler *  macro_assembler, RegExpCharacterClass *  cc, bool  one_byte, BlockLabel *  on_failure, intptr_t  cp_offset, bool  check_offset, bool  preloaded, Zone *  zone  )

static

Definition at line 1331 of file regexp.cc.

                                      {
  ZoneGrowableArray<CharacterRange>* ranges = cc->ranges();
  if (!CharacterRange::IsCanonical(ranges)) {
    CharacterRange::Canonicalize(ranges);
  }
 
  uint16_t max_char;
  if (one_byte) {
    max_char = Symbols::kMaxOneCharCodeSymbol;
  } else {
    max_char = Utf16::kMaxCodeUnit;
  }
 
  intptr_t range_count = ranges->length();
 
  intptr_t last_valid_range = range_count - 1;
  while (last_valid_range >= 0) {
    const CharacterRange& range = ranges->At(last_valid_range);
    if (range.from() <= max_char) {
      break;
    }
    last_valid_range--;
  }
 
  if (last_valid_range < 0) {
    if (!cc->is_negated()) {
      macro_assembler->GoTo(on_failure);
    }
    if (check_offset) {
      macro_assembler->CheckPosition(cp_offset, on_failure);
    }
    return;
  }
 
  if (last_valid_range == 0 && ranges->At(0).IsEverything(max_char)) {
    if (cc->is_negated()) {
      macro_assembler->GoTo(on_failure);
    } else {
      // This is a common case hit by non-anchored expressions.
      if (check_offset) {
        macro_assembler->CheckPosition(cp_offset, on_failure);
      }
    }
    return;
  }
 
  if (!preloaded) {
    macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check_offset);
  }
 
  if (cc->is_standard() && macro_assembler->CheckSpecialCharacterClass(
                               cc->standard_type(), on_failure)) {
    return;
  }
 
  // A new list with ascending entries.  Each entry is a code unit
  // where there is a boundary between code units that are part of
  // the class and code units that are not.  Normally we insert an
  // entry at zero which goes to the failure label, but if there
  // was already one there we fall through for success on that entry.
  // Subsequent entries have alternating meaning (success/failure).
  ZoneGrowableArray<uint16_t>* range_boundaries =
      new (zone) ZoneGrowableArray<uint16_t>(last_valid_range);
 
  bool zeroth_entry_is_failure = !cc->is_negated();
 
  for (intptr_t i = 0; i <= last_valid_range; i++) {
    const CharacterRange& range = ranges->At(i);
    if (range.from() == 0) {
      ASSERT(i == 0);
      zeroth_entry_is_failure = !zeroth_entry_is_failure;
    } else {
      range_boundaries->Add(range.from());
    }
    if (range.to() + 1 <= max_char) {
      range_boundaries->Add(range.to() + 1);
    }
  }
  intptr_t end_index = range_boundaries->length() - 1;
 
  BlockLabel fall_through;
  GenerateBranches(macro_assembler, range_boundaries,
                   0,  // start_index.
                   end_index,
                   0,  // min_char.
                   max_char, &fall_through,
                   zeroth_entry_is_failure ? &fall_through : on_failure,
                   zeroth_entry_is_failure ? on_failure : &fall_through);
  macro_assembler->BindBlock(&fall_through);
}

EmitDoubleBoundaryTest()

static void dart::EmitDoubleBoundaryTest ( RegExpMacroAssembler *  masm, uint16_t  first, uint16_t  last, BlockLabel *  fall_through, BlockLabel *  in_range, BlockLabel *  out_of_range  )

static

Definition at line 1040 of file regexp.cc.

                                                             {
  if (in_range == fall_through) {
    if (first == last) {
      masm->CheckNotCharacter(first, out_of_range);
    } else {
      masm->CheckCharacterNotInRange(first, last, out_of_range);
    }
  } else {
    if (first == last) {
      masm->CheckCharacter(first, in_range);
    } else {
      masm->CheckCharacterInRange(first, last, in_range);
    }
    if (out_of_range != fall_through) masm->GoTo(out_of_range);
  }
}

EmitHat()

static void dart::EmitHat ( RegExpCompiler *  compiler, RegExpNode *  on_success, Trace *  trace  )

static

Definition at line 2188 of file regexp.cc.

                                  {
  RegExpMacroAssembler* assembler = compiler->macro_assembler();
  // We will be loading the previous character into the current character
  // register.
  Trace new_trace(*trace);
  new_trace.InvalidateCurrentCharacter();
 
  BlockLabel ok;
  if (new_trace.cp_offset() == 0) {
    // The start of input counts as a newline in this context, so skip to
    // ok if we are at the start.
    assembler->CheckAtStart(&ok);
  }
  // We already checked that we are not at the start of input so it must be
  // OK to load the previous character.
  assembler->LoadCurrentCharacter(new_trace.cp_offset() - 1,
                                  new_trace.backtrack(), false);
  if (!assembler->CheckSpecialCharacterClass('n', new_trace.backtrack())) {
    // Newline means \n, \r, 0x2028 or 0x2029.
    if (!compiler->one_byte()) {
      assembler->CheckCharacterAfterAnd(0x2028, 0xfffe, &ok);
    }
    assembler->CheckCharacter('\n', &ok);
    assembler->CheckNotCharacter('\r', new_trace.backtrack());
  }
  assembler->BindBlock(&ok);
  on_success->Emit(compiler, &new_trace);
}

EmitMoveOnEdge()

static void dart::EmitMoveOnEdge ( BlockEntryInstr *  succ, BlockEntryInstr *  pred, const MoveOperands &  move  )

static

Definition at line 2984 of file linearscan.cc.

                                                     {
  Instruction* last = pred->last_instruction();
  if ((last->SuccessorCount() == 1) && !pred->IsGraphEntry()) {
    ASSERT(last->IsGoto());
    last->AsGoto()->GetParallelMove()->AddMove(move.dest(), move.src());
  } else {
    succ->GetParallelMove()->AddMove(move.dest(), move.src());
  }
}

EmitSimpleCharacter()

static bool dart::EmitSimpleCharacter ( Zone *  zone, RegExpCompiler *  compiler, uint16_t  c, BlockLabel *  on_failure, intptr_t  cp_offset, bool  check, bool  preloaded  )

inlinestatic

Definition at line 883 of file regexp.cc.

                                                       {
  RegExpMacroAssembler* assembler = compiler->macro_assembler();
  bool bound_checked = false;
  if (!preloaded) {
    assembler->LoadCurrentCharacter(cp_offset, on_failure, check);
    bound_checked = true;
  }
  assembler->CheckNotCharacter(c, on_failure);
  return bound_checked;
}

EmitUseLookupTable()

static void dart::EmitUseLookupTable ( RegExpMacroAssembler *  masm, ZoneGrowableArray< uint16_t > *  ranges, intptr_t  start_index, intptr_t  end_index, uint16_t  min_char, BlockLabel *  fall_through, BlockLabel *  even_label, BlockLabel *  odd_label  )

static

Definition at line 1064 of file regexp.cc.

                                                      {
  const intptr_t kSize = RegExpMacroAssembler::kTableSize;
  const intptr_t kMask = RegExpMacroAssembler::kTableMask;
 
  intptr_t base = (min_char & ~kMask);
 
  // Assert that everything is on one kTableSize page.
  for (intptr_t i = start_index; i <= end_index; i++) {
    ASSERT((ranges->At(i) & ~kMask) == base);
  }
  ASSERT(start_index == 0 || (ranges->At(start_index - 1) & ~kMask) <= base);
 
  char templ[kSize];
  BlockLabel* on_bit_set;
  BlockLabel* on_bit_clear;
  intptr_t bit;
  if (even_label == fall_through) {
    on_bit_set = odd_label;
    on_bit_clear = even_label;
    bit = 1;
  } else {
    on_bit_set = even_label;
    on_bit_clear = odd_label;
    bit = 0;
  }
  for (intptr_t i = 0; i < (ranges->At(start_index) & kMask) && i < kSize;
       i++) {
    templ[i] = bit;
  }
  intptr_t j = 0;
  bit ^= 1;
  for (intptr_t i = start_index; i < end_index; i++) {
    for (j = (ranges->At(i) & kMask); j < (ranges->At(i + 1) & kMask); j++) {
      templ[j] = bit;
    }
    bit ^= 1;
  }
  for (intptr_t i = j; i < kSize; i++) {
    templ[i] = bit;
  }
  // TODO(erikcorry): Cache these.
  const TypedData& ba = TypedData::ZoneHandle(
      masm->zone(), TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));
  for (intptr_t i = 0; i < kSize; i++) {
    ba.SetUint8(i, templ[i]);
  }
  masm->CheckBitInTable(ba, on_bit_set);
  if (on_bit_clear != fall_through) masm->GoTo(on_bit_clear);
}

EmitWordCheck()

static void dart::EmitWordCheck ( RegExpMacroAssembler *  assembler, BlockLabel *  word, BlockLabel *  non_word, bool  fall_through_on_word  )

static

Definition at line 2163 of file regexp.cc.

                                                     {
  if (assembler->CheckSpecialCharacterClass(
          fall_through_on_word ? 'w' : 'W',
          fall_through_on_word ? non_word : word)) {
    // Optimized implementation available.
    return;
  }
  assembler->CheckCharacterGT('z', non_word);
  assembler->CheckCharacterLT('0', non_word);
  assembler->CheckCharacterGT('a' - 1, word);
  assembler->CheckCharacterLT('9' + 1, word);
  assembler->CheckCharacterLT('A', non_word);
  assembler->CheckCharacterLT('Z' + 1, word);
  if (fall_through_on_word) {
    assembler->CheckNotCharacter('_', non_word);
  } else {
    assembler->CheckCharacter('_', word);
  }
}

EnableProfiler() [1/3]

static void dart::EnableProfiler ( )

static

Definition at line 277 of file profiler_test.cc.

                             {
  if (!FLAG_profiler) {
    FLAG_profiler = true;
    Profiler::Init();
  }
}

EnableProfiler() [2/3]

static void dart::EnableProfiler ( )

static

Definition at line 679 of file service_test.cc.

                             {
  if (!FLAG_profiler) {
    FLAG_profiler = true;
    Profiler::Init();
  }
}

EnableProfiler() [3/3]

static void dart::EnableProfiler ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4429 of file service.cc.

                                                           {
  if (!FLAG_profiler) {
    FLAG_profiler = true;
    Profiler::Init();
  }
  PrintSuccess(js);
}

EncodeBTypeImm()

uint32_t dart::EncodeBTypeImm ( intptr_t  imm )

inline

Definition at line 1011 of file constants_riscv.h.

                                             {
  ASSERT(IsBTypeImm(imm));
  uint32_t encoded = 0;
  encoded |= ((imm >> 12) & 0x1) << 31;
  encoded |= ((imm >> 5) & 0x3f) << 25;
  encoded |= ((imm >> 1) & 0xf) << 8;
  encoded |= ((imm >> 11) & 0x1) << 7;
  return encoded;
}

EncodeCBImm()

uint32_t dart::EncodeCBImm ( intptr_t  imm )

inline

Definition at line 1326 of file constants_riscv.h.

                                          {
  ASSERT(IsCBImm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 8) & 0x1) << 12;
  encoding |= ((imm >> 3) & 0x3) << 10;
  encoding |= ((imm >> 6) & 0x3) << 5;
  encoding |= ((imm >> 1) & 0x3) << 3;
  encoding |= ((imm >> 5) & 0x1) << 2;
  return encoding;
}

EncodeCI16Imm()

uint32_t dart::EncodeCI16Imm ( intptr_t  imm )

inline

Definition at line 1383 of file constants_riscv.h.

                                            {
  ASSERT(IsCI16Imm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 9) & 0x1) << 12;
  encoding |= ((imm >> 4) & 0x1) << 6;
  encoding |= ((imm >> 6) & 0x1) << 5;
  encoding |= ((imm >> 7) & 0x3) << 3;
  encoding |= ((imm >> 5) & 0x1) << 2;
  return encoding;
}

EncodeCI4SPNImm()

uint32_t dart::EncodeCI4SPNImm ( intptr_t  imm )

inline

Definition at line 1406 of file constants_riscv.h.

                                              {
  ASSERT(IsCI4SPNImm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 4) & 0x3) << 11;
  encoding |= ((imm >> 6) & 0xF) << 7;
  encoding |= ((imm >> 2) & 0x1) << 6;
  encoding |= ((imm >> 3) & 0x1) << 5;
  return encoding;
}

EncodeCIImm()

uint32_t dart::EncodeCIImm ( intptr_t  imm )

inline

Definition at line 1349 of file constants_riscv.h.

                                          {
  ASSERT(IsCIImm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 5) & 0x1) << 12;
  encoding |= ((imm >> 0) & 0x1F) << 2;
  return encoding;
}

EncodeCJImm()

uint32_t dart::EncodeCJImm ( intptr_t  imm )

inline

Definition at line 1297 of file constants_riscv.h.

                                          {
  ASSERT(IsCJImm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 11) & 0x1) << 12;
  encoding |= ((imm >> 4) & 0x1) << 11;
  encoding |= ((imm >> 8) & 0x3) << 9;
  encoding |= ((imm >> 10) & 0x1) << 8;
  encoding |= ((imm >> 6) & 0x1) << 7;
  encoding |= ((imm >> 7) & 0x1) << 6;
  encoding |= ((imm >> 1) & 0x7) << 3;
  encoding |= ((imm >> 5) & 0x1) << 2;
  return encoding;
}

EncodeCMem4Imm()

uint32_t dart::EncodeCMem4Imm ( intptr_t  imm )

inline

Definition at line 1261 of file constants_riscv.h.

                                             {
  ASSERT(IsCMem4Imm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 3) & 0x7) << 10;
  encoding |= ((imm >> 2) & 0x1) << 6;
  encoding |= ((imm >> 6) & 0x1) << 5;
  return encoding;
}

EncodeCMem8Imm()

uint32_t dart::EncodeCMem8Imm ( intptr_t  imm )

inline

Definition at line 1280 of file constants_riscv.h.

                                             {
  ASSERT(IsCMem8Imm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 3) & 0x7) << 10;
  encoding |= ((imm >> 6) & 0x3) << 5;
  return encoding;
}

EncodeCSPLoad4Imm()

uint32_t dart::EncodeCSPLoad4Imm ( intptr_t  imm )

inline

Definition at line 1189 of file constants_riscv.h.

                                                {
  ASSERT(IsCSPLoad4Imm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 5) & 0x1) << 12;
  encoding |= ((imm >> 2) & 0x7) << 4;
  encoding |= ((imm >> 6) & 0x3) << 2;
  return encoding;
}

EncodeCSPLoad8Imm()

uint32_t dart::EncodeCSPLoad8Imm ( intptr_t  imm )

inline

Definition at line 1208 of file constants_riscv.h.

                                                {
  ASSERT(IsCSPLoad8Imm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 5) & 0x1) << 12;
  encoding |= ((imm >> 3) & 0x3) << 5;
  encoding |= ((imm >> 6) & 0x7) << 2;
  return encoding;
}

EncodeCSPStore4Imm()

uint32_t dart::EncodeCSPStore4Imm ( intptr_t  imm )

inline

Definition at line 1227 of file constants_riscv.h.

                                                 {
  ASSERT(IsCSPStore4Imm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 2) & 0xF) << 9;
  encoding |= ((imm >> 6) & 0x3) << 7;
  return encoding;
}

EncodeCSPStore8Imm()

uint32_t dart::EncodeCSPStore8Imm ( intptr_t  imm )

inline

Definition at line 1244 of file constants_riscv.h.

                                                 {
  ASSERT(IsCSPStore8Imm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 3) & 0x7) << 10;
  encoding |= ((imm >> 6) & 0x7) << 7;
  return encoding;
}

EncodeCUImm()

uint32_t dart::EncodeCUImm ( intptr_t  imm )

inline

Definition at line 1366 of file constants_riscv.h.

                                          {
  ASSERT(IsCUImm(imm));
  uint32_t encoding = 0;
  encoding |= ((imm >> 17) & 0x1) << 12;
  encoding |= ((imm >> 12) & 0x1F) << 2;
  return encoding;
}

EncodeITypeImm()

uint32_t dart::EncodeITypeImm ( intptr_t  imm )

inline

Definition at line 1053 of file constants_riscv.h.

                                             {
  ASSERT(IsITypeImm(imm));
  return static_cast<uint32_t>(imm) << 20;
}

EncodeJTypeImm()

uint32_t dart::EncodeJTypeImm ( intptr_t  imm )

inline

Definition at line 1032 of file constants_riscv.h.

                                             {
  ASSERT(IsJTypeImm(imm));
  uint32_t encoded = 0;
  encoded |= ((imm >> 20) & 0x1) << 31;
  encoded |= ((imm >> 1) & 0x3ff) << 21;
  encoded |= ((imm >> 11) & 0x1) << 20;
  encoded |= ((imm >> 12) & 0xff) << 12;
  return encoded;
}

EncodeSTypeImm()

uint32_t dart::EncodeSTypeImm ( intptr_t  imm )

inline

Definition at line 1075 of file constants_riscv.h.

                                             {
  ASSERT(IsSTypeImm(imm));
  uint32_t encoded = 0;
  encoded |= ((imm >> 5) & 0x7f) << 25;
  encoded |= ((imm >> 0) & 0x1f) << 7;
  return encoded;
}

EncodeUTypeImm()

uint32_t dart::EncodeUTypeImm ( intptr_t  imm )

inline

Definition at line 1064 of file constants_riscv.h.

                                             {
  ASSERT(IsUTypeImm(imm));
  return imm;
}

EnsureAcyclicSymbol()

static RangeBoundary dart::EnsureAcyclicSymbol ( BlockEntryInstr *  phi_block, const RangeBoundary &  a, const RangeBoundary &  limit  )

static

Definition at line 2743 of file range_analysis.cc.

                                                                     {
  if (!a.IsSymbol() || DominatesPhi(a.symbol()->GetBlock(), phi_block)) {
    return a;
  }
 
  // Symbol does not dominate phi. Try unwrapping constraint and check again.
  Definition* unwrapped = UnwrapConstraint(a.symbol());
  if ((unwrapped != a.symbol()) &&
      DominatesPhi(unwrapped->GetBlock(), phi_block)) {
    return RangeBoundary::FromDefinition(unwrapped, a.offset());
  }
 
  return limit;
}

EnsureConstructorsAreCompiled()

static void dart::EnsureConstructorsAreCompiled ( const Function &  func )

static

Definition at line 81 of file mirrors.cc.

                                                                {
  // Only generative constructors can have initializing formals.
  if (!func.IsGenerativeConstructor()) return;
 
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const Class& cls = Class::Handle(zone, func.Owner());
  const Error& error = Error::Handle(zone, cls.EnsureIsFinalized(thread));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
    UNREACHABLE();
  }
  func.EnsureHasCode();
}

EnsureValidOOBMessage()

static void dart::EnsureValidOOBMessage ( Thread *  thread, Isolate *  isolate, std::unique_ptr< Message >  message  )

static

Definition at line 734 of file safepoint_test.cc.

                                                                  {
  EXPECT(message->IsOOB());
  EXPECT(message->dest_port() == isolate->main_port());
 
  const auto& msg = Object::Handle(ReadMessage(thread, message.get()));
  EXPECT(msg.IsArray());
 
  const auto& array = Array::Cast(msg);
  EXPECT(array.Length() == 3);
  EXPECT(Smi::Value(Smi::RawCast(array.At(0))) == Message::kIsolateLibOOBMsg);
  EXPECT(Smi::Value(Smi::RawCast(array.At(1))) == Isolate::kCheckForReload);
  // 3rd value is ignored.
}

EntryPointFieldInvocationError()

DART_WARN_UNUSED_RESULT ErrorPtr dart::EntryPointFieldInvocationError

(

const String &

getter_name

)

Definition at line 27272 of file object.cc.

                                                                   {
  if (!FLAG_verify_entry_points) return Error::null();
 
  char const* error = OS::SCreate(
      Thread::Current()->zone(),
      "ERROR: Entry-points do not allow invoking fields "
      "(failure to resolve '%s')\n"
      "ERROR: See "
      "https://github.com/dart-lang/sdk/blob/master/runtime/docs/compiler/"
      "aot/entry_point_pragma.md\n",
      getter_name.ToCString());
  OS::PrintErr("%s", error);
  return ApiError::New(String::Handle(String::New(error)));
}

EntryPointMemberInvocationError()

DART_WARN_UNUSED_RESULT ErrorPtr dart::EntryPointMemberInvocationError

(

const Object &

member

)

Definition at line 27288 of file object.cc.

                                                               {
  const char* member_cstring =
      member.IsFunction()
          ? OS::SCreate(
                Thread::Current()->zone(), "%s (kind %s)",
                Function::Cast(member).ToLibNamePrefixedQualifiedCString(),
                Function::KindToCString(Function::Cast(member).kind()))
          : member.ToCString();
  if (!FLAG_verify_entry_points) {
    // Print a warning, but do not return an error.
    char const* warning = OS::SCreate(
        Thread::Current()->zone(),
        "WARNING: '%s' is accessed through Dart C API without being marked as "
        "an entry point; its tree-shaken signature cannot be verified.\n"
        "WARNING: See "
        "https://github.com/dart-lang/sdk/blob/master/runtime/docs/compiler/"
        "aot/entry_point_pragma.md\n",
        member_cstring);
    OS::PrintErr("%s", warning);
    return Error::null();
  }
  char const* error = OS::SCreate(
      Thread::Current()->zone(),
      "ERROR: It is illegal to access '%s' through Dart C API.\n"
      "ERROR: See "
      "https://github.com/dart-lang/sdk/blob/master/runtime/docs/compiler/"
      "aot/entry_point_pragma.md\n",
      member_cstring);
  OS::PrintErr("%s", error);
  return ApiError::New(String::Handle(String::New(error)));
}

EnumMapper()

template<typename T >

T dart::EnumMapper	(	const char *	value,
		const char *const *	enums,
		T *	values
	)

Definition at line 865 of file service.cc.

                                                                     {
  ASSERT(value != nullptr);
  intptr_t i = 0;
  for (i = 0; enums[i] != nullptr; i++) {
    if (strcmp(value, enums[i]) == 0) {
      return values[i];
    }
  }
  // Default value.
  return values[i];
}

EnvIndexToStackLocation()

static Location dart::EnvIndexToStackLocation ( intptr_t  num_direct_parameters, intptr_t  env_index  )

static

Definition at line 1317 of file flow_graph.cc.

                                                            {
  return Location::StackSlot(
      compiler::target::frame_layout.FrameSlotForVariableIndex(
          num_direct_parameters - env_index),
      FPREG);
}

Equals()

static bool dart::Equals ( const Object &  expected, const Object &  actual  )

static

Definition at line 26 of file snapshot_test.cc.

                                                                 {
  if (expected.IsNull()) {
    return actual.IsNull();
  }
  if (expected.IsSmi()) {
    if (actual.IsSmi()) {
      return expected.ptr() == actual.ptr();
    }
    return false;
  }
  if (expected.IsDouble()) {
    if (actual.IsDouble()) {
      Double& dbl1 = Double::Handle();
      Double& dbl2 = Double::Handle();
      dbl1 ^= expected.ptr();
      dbl2 ^= actual.ptr();
      return dbl1.value() == dbl2.value();
    }
    return false;
  }
  if (expected.IsBool()) {
    if (actual.IsBool()) {
      return expected.ptr() == actual.ptr();
    }
    return false;
  }
  return false;
}

EqualsIgnoringPrivate()

bool dart::EqualsIgnoringPrivate	(	const String &	name,
		const String &	private_name
	)

EqualsIgnoringPrivateKey()

template<typename T1 , typename T2 >

static bool dart::EqualsIgnoringPrivateKey ( const String &  str1, const String &  str2  )

static

Definition at line 24326 of file object.cc.

                                                                             {
  intptr_t len = str1.Length();
  intptr_t str2_len = str2.Length();
  if (len == str2_len) {
    for (intptr_t i = 0; i < len; i++) {
      if (T1::CharAt(str1, i) != T2::CharAt(str2, i)) {
        return false;
      }
    }
    return true;
  }
  if (len < str2_len) {
    return false;  // No way they can match.
  }
  intptr_t pos = 0;
  intptr_t str2_pos = 0;
  while (pos < len) {
    int32_t ch = T1::CharAt(str1, pos);
    pos++;
 
    if ((str2_pos < str2_len) && (ch == T2::CharAt(str2, str2_pos))) {
      str2_pos++;
      continue;
    }
 
    if (ch == Library::kPrivateKeySeparator) {
      // Consume a private key separator if str1 has it but str2 does not.
      while ((pos < len) && (T1::CharAt(str1, pos) != '.') &&
             (T1::CharAt(str1, pos) != '&')) {
        pos++;
      }
      // Resume matching characters.
      continue;
    }
 
    return false;
  }
 
  // We have reached the end of mangled_name string.
  ASSERT(pos == len);
  return (str2_pos == str2_len);
}

EscapeOverhead()

static int32_t dart::EscapeOverhead ( int32_t  c )

static

Definition at line 520 of file object.cc.

                                         {
  if (IsSpecialCharacter(c)) {
    return 1;  // 1 additional byte for the backslash.
  } else if (IsAsciiNonprintable(c)) {
    return 3;  // 3 additional bytes to encode c as \x00.
  }
  return 0;
}

Eval()

static ArrayPtr dart::Eval ( Dart_Handle  lib, const char *  expr  )

static

Definition at line 81 of file service_test.cc.

                                                        {
  const String& dummy_isolate_id = String::Handle(String::New("isolateId"));
  Dart_Handle expr_val;
  {
    TransitionVMToNative transition(Thread::Current());
    expr_val = Dart_EvaluateStaticExpr(lib, NewString(expr));
    EXPECT_VALID(expr_val);
  }
  Zone* zone = Thread::Current()->zone();
  const GrowableObjectArray& value =
      Api::UnwrapGrowableObjectArrayHandle(zone, expr_val);
  const Array& result = Array::Handle(Array::MakeFixedLength(value));
  GrowableObjectArray& growable = GrowableObjectArray::Handle();
  growable ^= result.At(4);
  // Append dummy isolate id to parameter values.
  growable.Add(dummy_isolate_id);
  Array& array = Array::Handle(Array::MakeFixedLength(growable));
  result.SetAt(4, array);
  growable ^= result.At(5);
  // Append dummy isolate id to parameter values.
  growable.Add(dummy_isolate_id);
  array = Array::MakeFixedLength(growable);
  result.SetAt(5, array);
  return result.ptr();
}

EvalF()

static ArrayPtr dart::EvalF ( Dart_Handle  lib, const char *  fmt,   ...  )

static

Definition at line 107 of file service_test.cc.

                                                             {
  va_list measure_args;
  va_start(measure_args, fmt);
  intptr_t len = Utils::VSNPrint(nullptr, 0, fmt, measure_args);
  va_end(measure_args);
 
  char* buffer = Thread::Current()->zone()->Alloc<char>(len + 1);
  va_list print_args;
  va_start(print_args, fmt);
  Utils::VSNPrint(buffer, (len + 1), fmt, print_args);
  va_end(print_args);
 
  return Eval(lib, buffer);
}

Evaluate()

static void dart::Evaluate ( Thread *  thread, JSONStream *  js  )

static

Definition at line 2872 of file service.cc.

                                                     {
  // If a compilation service is available, this RPC invocation will have been
  // intercepted by RunningIsolates.routeRequest.
  js->PrintError(
      kExpressionCompilationError,
      "%s: No compilation service available; cannot evaluate from source.",
      js->method());
}

EvaluateCompiledExpression()

static void dart::EvaluateCompiledExpression ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3313 of file service.cc.

                                                                       {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  Isolate* isolate = thread->isolate();
 
  bool disable_breakpoints =
      BoolParameter::Parse(js->LookupParam("disableBreakpoints"), false);
  DisableBreakpointsScope db(isolate->debugger(), disable_breakpoints);
 
  DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
  intptr_t frame_pos = UIntParameter::Parse(js->LookupParam("frameIndex"));
  if (frame_pos >= stack->Length()) {
    PrintInvalidParamError(js, "frameIndex");
    return;
  }
  Zone* zone = thread->zone();
  const GrowableObjectArray& param_names =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  const GrowableObjectArray& param_values =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  if (BuildScope(thread, js, param_names, param_values)) {
    return;
  }
  const GrowableObjectArray& type_params_names =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  const GrowableObjectArray& type_params_bounds =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  const GrowableObjectArray& type_params_defaults =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
 
  const ExternalTypedData& kernel_data = ExternalTypedData::Handle(
      zone, DecodeKernelBuffer(js->LookupParam("kernelBytes")));
 
  if (js->HasParam("frameIndex")) {
    DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
    intptr_t frame_pos = UIntParameter::Parse(js->LookupParam("frameIndex"));
    if (frame_pos >= stack->Length()) {
      PrintInvalidParamError(js, "frameIndex");
      return;
    }
 
    ActivationFrame* frame = stack->FrameAt(frame_pos);
    TypeArguments& type_arguments = TypeArguments::Handle(
        zone,
        frame->BuildParameters(param_names, param_values, type_params_names,
                               type_params_bounds, type_params_defaults));
 
    const Object& result = Object::Handle(
        zone,
        frame->EvaluateCompiledExpression(
            kernel_data,
            Array::Handle(zone, Array::MakeFixedLength(type_params_names)),
            Array::Handle(zone, Array::MakeFixedLength(param_values)),
            type_arguments));
    result.PrintJSON(js, true);
  } else {
    // evaluating expression in the context of a given object
    if (!js->HasParam("targetId")) {
      js->PrintError(kInvalidParams,
                     "Either targetId or frameIndex has to be provided.");
      return;
    }
    const char* target_id = js->LookupParam("targetId");
    ObjectIdRing::LookupResult lookup_result;
    Object& obj = Object::Handle(
        zone, LookupHeapObject(thread, target_id, &lookup_result));
    if (obj.ptr() == Object::sentinel().ptr()) {
      if (lookup_result == ObjectIdRing::kCollected) {
        PrintSentinel(js, kCollectedSentinel);
      } else if (lookup_result == ObjectIdRing::kExpired) {
        PrintSentinel(js, kExpiredSentinel);
      } else {
        PrintInvalidParamError(js, "targetId");
      }
      return;
    }
    const auto& type_params_names_fixed =
        Array::Handle(zone, Array::MakeFixedLength(type_params_names));
    const auto& param_values_fixed =
        Array::Handle(zone, Array::MakeFixedLength(param_values));
 
    TypeArguments& type_arguments = TypeArguments::Handle(zone);
    if (obj.IsLibrary()) {
      const auto& lib = Library::Cast(obj);
      const auto& result = Object::Handle(
          zone,
          lib.EvaluateCompiledExpression(kernel_data, type_params_names_fixed,
                                         param_values_fixed, type_arguments));
      result.PrintJSON(js, true);
      return;
    }
    if (obj.IsClass()) {
      const auto& cls = Class::Cast(obj);
      const auto& result = Object::Handle(
          zone,
          cls.EvaluateCompiledExpression(kernel_data, type_params_names_fixed,
                                         param_values_fixed, type_arguments));
      result.PrintJSON(js, true);
      return;
    }
    if ((obj.IsInstance() || obj.IsNull()) && !ContainsNonInstance(obj)) {
      const auto& instance =
          Instance::Handle(zone, Instance::RawCast(obj.ptr()));
      const auto& receiver_cls = Class::Handle(zone, instance.clazz());
      const auto& result = Object::Handle(
          zone, instance.EvaluateCompiledExpression(
                    receiver_cls, kernel_data, type_params_names_fixed,
                    param_values_fixed, type_arguments));
      result.PrintJSON(js, true);
      return;
    }
    js->PrintError(kInvalidParams,
                   "%s: invalid 'targetId' parameter: "
                   "Cannot evaluate against a VM-internal object",
                   js->method());
  }
}

EvaluateCompiledExpressionHelper()

static ObjectPtr dart::EvaluateCompiledExpressionHelper ( Zone *  zone, const Function &  eval_function, const Array &  type_definitions, const Array &  arguments, const TypeArguments &  type_arguments  )

static

Definition at line 4837 of file object.cc.

                                         {
  // type_arguments is null if all type arguments are dynamic.
  if (type_definitions.Length() == 0 || type_arguments.IsNull()) {
    return DartEntry::InvokeFunction(eval_function, arguments);
  }
 
  intptr_t num_type_args = type_arguments.Length();
  const auto& real_arguments =
      Array::Handle(zone, Array::New(arguments.Length() + 1));
  real_arguments.SetAt(0, type_arguments);
  Object& arg = Object::Handle(zone);
  for (intptr_t i = 0; i < arguments.Length(); ++i) {
    arg = arguments.At(i);
    real_arguments.SetAt(i + 1, arg);
  }
 
  const Array& args_desc =
      Array::Handle(zone, ArgumentsDescriptor::NewBoxed(
                              num_type_args, arguments.Length(), Heap::kNew));
  return DartEntry::InvokeFunction(eval_function, real_arguments, args_desc);
}

EvaluateInFrame()

static void dart::EvaluateInFrame ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3440 of file service.cc.

                                                            {
  // If a compilation service is available, this RPC invocation will have been
  // intercepted by RunningIsolates.routeRequest.
  js->PrintError(
      kExpressionCompilationError,
      "%s: No compilation service available; cannot evaluate from source.",
      js->method());
}

EvaluateToString()

static const String & dart::EvaluateToString ( Zone *  zone, Definition *  defn  )

static

Definition at line 5694 of file il.cc.

                                                                    {
  if (auto konst = defn->AsConstant()) {
    const Object& obj = konst->value();
    if (obj.IsString()) {
      return String::Cast(obj);
    } else if (obj.IsSmi()) {
      const char* cstr = obj.ToCString();
      return String::Handle(zone, String::New(cstr, Heap::kOld));
    } else if (obj.IsBool()) {
      return Bool::Cast(obj).value() ? Symbols::True() : Symbols::False();
    } else if (obj.IsNull()) {
      return Symbols::null();
    }
  }
  return String::null_string();
}

EvaluationFunctionNeedsReceiver()

static bool dart::EvaluationFunctionNeedsReceiver ( Thread *  thread, Zone *  zone, const Function &  eval_function  )

static

Definition at line 4828 of file object.cc.

                                                                           {
  auto parsed_function = new ParsedFunction(
      thread, Function::ZoneHandle(zone, eval_function.ptr()));
  parsed_function->EnsureKernelScopes();
  return parsed_function->is_receiver_used();
}

EvenDRegisterOf()

static DRegister dart::EvenDRegisterOf ( QRegister  q )

inlinestatic

Definition at line 255 of file constants_arm.h.

                                                     {
  return static_cast<DRegister>(q * 2);
}

EvenSRegisterOf()

static SRegister dart::EvenSRegisterOf ( DRegister  d )

inlinestatic

Definition at line 263 of file constants_arm.h.

                                                     {
#if defined(VFPv3_D32)
  // When we have 32 D registers, the S registers only overlap the first 16.
  // That is, there are only ever 32 S registers in any extension.
  ASSERT(d < D16);
#endif
  return static_cast<SRegister>(d * 2);
}

ExceptionNative()

void dart::ExceptionNative

(

Dart_NativeArguments

args

)

Definition at line 7028 of file dart_api_impl_test.cc.

                                                {
  Dart_EnterScope();
  Dart_ThrowException(NewString("Hello from ExceptionNative!"));
  UNREACHABLE();
}

ExceptionPauseInfoToServiceEnum()

static const char * dart::ExceptionPauseInfoToServiceEnum ( Dart_ExceptionPauseInfo  pi )

static

Definition at line 2977 of file isolate.cc.

                                                                               {
  switch (pi) {
    case kPauseOnAllExceptions:
      return "All";
    case kNoPauseOnExceptions:
      return "None";
    case kPauseOnUnhandledExceptions:
      return "Unhandled";
    default:
      UNIMPLEMENTED();
      return nullptr;
  }
}

ExecRaw()

static ObjectPtr dart::ExecRaw ( const RegExp &  regexp, const String &  subject, int32_t  index, bool  sticky, int32_t *  output, intptr_t  output_size, Zone *  zone  )

static

Definition at line 470 of file regexp_assembler_bytecode.cc.

                                     {
  bool is_one_byte = subject.IsOneByteString();
 
  // We must have done EnsureCompiledIrregexp, so we can get the number of
  // registers.
  int number_of_capture_registers = (regexp.num_bracket_expressions() + 1) * 2;
  int32_t* raw_output = &output[number_of_capture_registers];
 
  // We do not touch the actual capture result registers until we know there
  // has been a match so that we can use those capture results to set the
  // last match info.
  for (int i = number_of_capture_registers - 1; i >= 0; i--) {
    raw_output[i] = -1;
  }
 
  const TypedData& bytecode =
      TypedData::Handle(zone, regexp.bytecode(is_one_byte, sticky));
  ASSERT(!bytecode.IsNull());
  const Object& result = Object::Handle(
      zone, IrregexpInterpreter::Match(bytecode, subject, raw_output, index));
 
  if (result.ptr() == Bool::True().ptr()) {
    // Copy capture results to the start of the registers array.
    memmove(output, raw_output, number_of_capture_registers * sizeof(int32_t));
  }
  if (result.ptr() == Object::null()) {
    // Exception during regexp processing
    Exceptions::ThrowStackOverflow();
    UNREACHABLE();
  }
  return result.ptr();
}

ExecuteCallback()

DART_EXPORT void dart::ExecuteCallback

(

Work *

work_ptr

)

Definition at line 604 of file ffi_test_functions_vmspecific.cc.

                                                 {
  printf("C Da:    ExecuteCallback(%" Pp ").\n",
         reinterpret_cast<intptr_t>(work_ptr));
  const Work work = *work_ptr;
  work();
  delete work_ptr;
  printf("C Da:    ExecuteCallback done.\n");
}

ExecuteMatch()

static ObjectPtr dart::ExecuteMatch ( Zone *  zone, NativeArguments *  arguments, bool  sticky  )

static

Definition at line 142 of file regexp.cc.

                                           {
  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
  ASSERT(!regexp.IsNull());
  GET_NON_NULL_NATIVE_ARGUMENT(String, subject, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_index, arguments->NativeArgAt(2));
 
  // Both generated code and the interpreter are using 32-bit registers and
  // 32-bit backtracking stack so they can't work with strings which are
  // larger than that. Validate these assumptions before running the regexp.
  if (!Utils::IsInt(32, subject.Length())) {
    Exceptions::ThrowRangeError("length",
                                Integer::Handle(Integer::New(subject.Length())),
                                0, kMaxInt32);
  }
  if (!Utils::IsInt(32, start_index.Value())) {
    Exceptions::ThrowRangeError("start_index", Integer::Cast(start_index),
                                kMinInt32, kMaxInt32);
  }
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  if (!FLAG_interpret_irregexp) {
    return IRRegExpMacroAssembler::Execute(regexp, subject, start_index,
                                           /*sticky=*/sticky, zone);
  }
#endif
  return BytecodeRegExpMacroAssembler::Interpret(regexp, subject, start_index,
                                                 /*sticky=*/sticky, zone);
}

ExecuteScript()

static ObjectPtr dart::ExecuteScript ( const char *  script, bool  allow_errors = false  )

static

Definition at line 13 of file source_report_test.cc.

                                                                              {
  Dart_Handle lib;
  {
    TransitionVMToNative transition(Thread::Current());
    if (allow_errors) {
      lib = TestCase::LoadTestScriptWithErrors(script, nullptr);
    } else {
      lib = TestCase::LoadTestScript(script, nullptr);
    }
    EXPECT_VALID(lib);
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
  }
  return Api::UnwrapHandle(lib);
}

ExitForMaterialization()

static Instruction * dart::ExitForMaterialization ( MaterializeObjectInstr *  mat )

static

Definition at line 3766 of file redundancy_elimination.cc.

                                                                        {
  while (mat->next()->IsMaterializeObject()) {
    mat = mat->next()->AsMaterializeObject();
  }
  return mat->next();
}

ExpectedValue()

static intptr_t dart::ExpectedValue ( intptr_t  i )

inlinestatic

Definition at line 44 of file memory_copy_test.cc.

                                                 {
  return 1 + i % 100;
}

ExpectEncodeFail()

static void dart::ExpectEncodeFail ( Zone *  zone, Dart_CObject *  root  )

static

Definition at line 119 of file snapshot_test.cc.

                                                             {
  std::unique_ptr<Message> message =
      WriteApiMessage(zone, root, ILLEGAL_PORT, Message::kNormalPriority);
  EXPECT(message == nullptr);
}

ExpectLocationForPosition()

void dart::ExpectLocationForPosition	(	const kernel::KernelLineStartsReader &	reader,
		intptr_t	position,
		intptr_t	expected_line,
		intptr_t	expected_col
	)

Definition at line 35 of file kernel_test.cc.

                                                      {
  intptr_t line;
  intptr_t col;
  EXPECT_EQ(true, reader.LocationForPosition(position, &line, &col));
  EXPECT_EQ(expected_line, line);
  EXPECT_EQ(expected_col, col);
}

ExpectRangesContainCid()

static bool dart::ExpectRangesContainCid ( const Expect &  expect, const CidRangeVector &  ranges, intptr_t  expected  )

static

Definition at line 455 of file il_test.cc.

                                                      {
  for (const auto& range : ranges) {
    for (intptr_t cid = range.cid_start; cid <= range.cid_end; cid++) {
      if (expected == cid) return true;
    }
  }
  TextBuffer buffer(128);
  buffer.AddString("Expected CidRangeVector to include cid ");
  WriteCidTo(expected, &buffer);
  expect.Fail("%s", buffer.buffer());
  return false;
}

ExpectStores()

static void dart::ExpectStores ( FlowGraph *  flow_graph, const std::vector< const char * > &  expected_stores  )

static

Definition at line 95 of file il_test.cc.

                                                                        {
  size_t next_expected_store = 0;
  for (BlockIterator block_it = flow_graph->reverse_postorder_iterator();
       !block_it.Done(); block_it.Advance()) {
    for (ForwardInstructionIterator it(block_it.Current()); !it.Done();
         it.Advance()) {
      if (auto store = it.Current()->AsStoreField()) {
        EXPECT_LT(next_expected_store, expected_stores.size());
        EXPECT_STREQ(expected_stores[next_expected_store],
                     store->slot().Name());
        next_expected_store++;
      }
    }
  }
}

ExpectTokenRangeAtLine()

void dart::ExpectTokenRangeAtLine	(	const kernel::KernelLineStartsReader &	reader,
		intptr_t	line,
		intptr_t	expected_first_token,
		intptr_t	expected_last_token
	)

Definition at line 66 of file kernel_test.cc.

                                                          {
  TokenPosition first_token = TokenPosition::Synthetic(0);
  TokenPosition last_token = TokenPosition::Synthetic(0);
  EXPECT_EQ(true, reader.TokenRangeAtLine(line, &first_token, &last_token));
  EXPECT_EQ(expected_first_token, first_token.Serialize());
  EXPECT_EQ(expected_last_token, last_token.Serialize());
}

ExpectTypesEquivalent()

static void dart::ExpectTypesEquivalent ( const Expect &  expect, const AbstractType &  expected, const AbstractType &  got, TypeEquality  kind  )

static

Definition at line 7514 of file object_test.cc.

ExportModifiedCallback()

static bool dart::ExportModifiedCallback ( const char *  url, int64_t  since  )

static

Definition at line 4592 of file isolate_reload_test.cc.

              {\n"
      "  return importedFunc() + ' pants';\n"
      "}\n";
 
  Dart_SetFileModifiedCallback(&ImportModifiedCallback);
  lib = TestCase::ReloadTestScript(kReloadScript);

ExternalByteDataNativeFunction()

static void dart::ExternalByteDataNativeFunction ( Dart_NativeArguments  args )

static

Definition at line 2261 of file dart_api_impl_test.cc.

                                                                      {
  Dart_EnterScope();
  Dart_Handle external_byte_data =
      Dart_NewExternalTypedData(Dart_TypedData_kByteData, data, 16);
  EXPECT_VALID(external_byte_data);
  EXPECT_EQ(Dart_TypedData_kByteData,
            Dart_GetTypeOfTypedData(external_byte_data));
  Dart_SetReturnValue(args, external_byte_data);
  Dart_ExitScope();
}

ExternalByteDataNativeResolver()

static Dart_NativeFunction dart::ExternalByteDataNativeResolver ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 2272 of file dart_api_impl_test.cc.

                            {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  return &ExternalByteDataNativeFunction;
}

ExternalTypedDataAccessTests()

static void dart::ExternalTypedDataAccessTests ( Dart_Handle  obj, Dart_TypedData_Type  expected_type, uint8_t  data[], intptr_t  data_length  )

static

Definition at line 3037 of file dart_api_impl_test.cc.

                                                               {
  EXPECT_VALID(obj);
  EXPECT_EQ(expected_type, Dart_GetTypeOfExternalTypedData(obj));
  EXPECT(Dart_IsList(obj));
 
  void* raw_data = nullptr;
  intptr_t len;
  Dart_TypedData_Type type;
  EXPECT_VALID(Dart_TypedDataAcquireData(obj, &type, &raw_data, &len));
  EXPECT(raw_data == data);
  EXPECT_EQ(data_length, len);
  EXPECT_EQ(expected_type, type);
  EXPECT_VALID(Dart_TypedDataReleaseData(obj));
 
  intptr_t list_length = 0;
  EXPECT_VALID(Dart_ListLength(obj, &list_length));
  EXPECT_EQ(data_length, list_length);
 
  // Load and check values from underlying array and API.
  for (intptr_t i = 0; i < list_length; ++i) {
    EXPECT_EQ(11 * i, data[i]);
    Dart_Handle elt = Dart_ListGetAt(obj, i);
    EXPECT_VALID(elt);
    int64_t value = 0;
    EXPECT_VALID(Dart_IntegerToInt64(elt, &value));
    EXPECT_EQ(data[i], value);
  }
 
  // Write values through the underlying array.
  for (intptr_t i = 0; i < data_length; ++i) {
    data[i] *= 2;
  }
  // Read them back through the API.
  for (intptr_t i = 0; i < list_length; ++i) {
    Dart_Handle elt = Dart_ListGetAt(obj, i);
    EXPECT_VALID(elt);
    int64_t value = 0;
    EXPECT_VALID(Dart_IntegerToInt64(elt, &value));
    EXPECT_EQ(22 * i, value);
  }
 
  // Write values through the API.
  for (intptr_t i = 0; i < list_length; ++i) {
    Dart_Handle value = Dart_NewInteger(33 * i);
    EXPECT_VALID(value);
    EXPECT_VALID(Dart_ListSetAt(obj, i, value));
  }
  // Read them back through the underlying array.
  for (intptr_t i = 0; i < data_length; ++i) {
    EXPECT_EQ(33 * i, data[i]);
  }
}

ExternalTypedDataFinalizer() [1/2]

static void dart::ExternalTypedDataFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 1112 of file isolate.cc.

                                                   {
  free(peer);
}

ExternalTypedDataFinalizer() [2/2]

static void dart::ExternalTypedDataFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3150 of file dart_api_impl_test.cc.

                                                   {
  *static_cast<int*>(peer) = 42;
}

ExtractElementTypeFromArrayType()

static AbstractTypePtr dart::ExtractElementTypeFromArrayType ( const AbstractType &  array_type )

static

Definition at line 1829 of file type_propagator.cc.

                                    {
  if (array_type.IsTypeParameter()) {
    return ExtractElementTypeFromArrayType(
        AbstractType::Handle(TypeParameter::Cast(array_type).bound()));
  }
  if (!array_type.IsType()) {
    return Object::dynamic_type().ptr();
  }
  const intptr_t cid = array_type.type_class_id();
  if (cid == kGrowableObjectArrayCid || cid == kArrayCid ||
      cid == kImmutableArrayCid ||
      array_type.type_class() ==
          IsolateGroup::Current()->object_store()->list_class()) {
    const auto& type_args =
        TypeArguments::Handle(Type::Cast(array_type).arguments());
    return type_args.TypeAtNullSafe(Array::kElementTypeTypeArgPos);
  }
  return Object::dynamic_type().ptr();
}

ExtractInterfaceTypeArgs()

static bool dart::ExtractInterfaceTypeArgs ( Zone *  zone, const Class &  instance_cls, const TypeArguments &  instance_type_args, const Class &  interface_cls, TypeArguments *  interface_type_args  )

static

Definition at line 356 of file object.cc.

                                                                         {
  Thread* thread = Thread::Current();
  Class& cur_cls = Class::Handle(zone, instance_cls.ptr());
  // The following code is a specialization of Class::IsSubtypeOf().
  Array& interfaces = Array::Handle(zone);
  Type& interface = Type::Handle(zone);
  Class& cur_interface_cls = Class::Handle(zone);
  TypeArguments& cur_interface_type_args = TypeArguments::Handle(zone);
  while (true) {
    // Additional subtyping rules related to 'FutureOr' are not applied.
    if (cur_cls.ptr() == interface_cls.ptr()) {
      *interface_type_args = instance_type_args.ptr();
      return true;
    }
    interfaces = cur_cls.interfaces();
    for (intptr_t i = 0; i < interfaces.Length(); i++) {
      interface ^= interfaces.At(i);
      ASSERT(interface.IsFinalized());
      cur_interface_cls = interface.type_class();
      cur_interface_type_args =
          interface.GetInstanceTypeArguments(thread, /*canonicalize=*/false);
      if (!cur_interface_type_args.IsNull() &&
          !cur_interface_type_args.IsInstantiated()) {
        cur_interface_type_args = cur_interface_type_args.InstantiateFrom(
            instance_type_args, Object::null_type_arguments(), kNoneFree,
            Heap::kNew);
      }
      if (ExtractInterfaceTypeArgs(zone, cur_interface_cls,
                                   cur_interface_type_args, interface_cls,
                                   interface_type_args)) {
        return true;
      }
    }
    cur_cls = cur_cls.SuperClass();
    if (cur_cls.IsNull()) {
      return false;
    }
  }
}

Failure()

static TTSTestCase dart::Failure ( const TTSTestCase &  original )

static

Definition at line 363 of file type_testing_stubs_test.cc.

                                                        {
  return TTSTestCase(original.instance, original.instantiator_tav,
                     original.function_tav, kFail);
}

FalseNegative()

static TTSTestCase dart::FalseNegative ( const TTSTestCase &  original )

static

Definition at line 377 of file type_testing_stubs_test.cc.

                                                              {
  return TTSTestCase(original.instance, original.instantiator_tav,
                     original.function_tav, kNewSTCEntry);
}

Fatal()

void dart::Fatal	(	char const *	file,
		int	line,
		char const *	error
	)

Definition at line 427 of file ffi_test_functions_vmspecific.cc.

                                                          {
  printf("FATAL %s:%i\n", file, line);
  printf("%s\n", error);
  Dart_DumpNativeStackTrace(nullptr);
  Dart_PrepareToAbort();
  abort();
}

FfiNativeResolver() [1/2]

static void * dart::FfiNativeResolver ( const char *  name, uintptr_t  args_n  )

static

Definition at line 1222 of file ffi_test_functions_vmspecific.cc.

                                                                   {
  if (strcmp(name, "Dart_SetNativeInstanceField") == 0 && args_n == 3) {
    return reinterpret_cast<void*>(Dart_SetNativeInstanceField);
  }
  if (strcmp(name, "IsThreadInGenerated") == 0 && args_n == 0) {
    return reinterpret_cast<void*>(IsThreadInGenerated);
  }
  if (strcmp(name, "ReturnIntPtr") == 0 && args_n == 1) {
    return reinterpret_cast<void*>(ReturnIntPtr);
  }
  if (strcmp(name, "PassAsHandle") == 0 && args_n == 1) {
    return reinterpret_cast<void*>(PassAsHandle);
  }
  if (strcmp(name, "PassAsPointer") == 0 && args_n == 1) {
    return reinterpret_cast<void*>(PassAsPointer);
  }
  if (strcmp(name, "PassAsPointerAndValue") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(PassAsPointerAndValue);
  }
  if (strcmp(name, "PassAsValueAndPointer") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(PassAsValueAndPointer);
  }
  if (strcmp(name, "AllocateResource") == 0 && args_n == 1) {
    return reinterpret_cast<void*>(AllocateResource);
  }
  if (strcmp(name, "DeleteResource") == 0 && args_n == 1) {
    return reinterpret_cast<void*>(DeleteResource);
  }
  if (strcmp(name, "GetResourceValue") == 0 && args_n == 1) {
    return reinterpret_cast<void*>(GetResourceValue);
  }
  if (strcmp(name, "SetResourceFinalizer") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(SetResourceFinalizer);
  }
  if (strcmp(name, "AddPtrAndInt") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(AddPtrAndInt);
  }
  if (strcmp(name, "AddHandleFieldAndInt") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(AddHandleFieldAndInt);
  }
  if (strcmp(name, "AddPtrAndPtr") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(AddPtrAndPtr);
  }
  if (strcmp(name, "AddHandleFieldAndPtr") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(AddHandleFieldAndPtr);
  }
  if (strcmp(name, "AddHandleFieldAndHandleField") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(AddHandleFieldAndHandleField);
  }
  if (strcmp(name, "AddPtrAndHandleField") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(AddPtrAndHandleField);
  }
  if (strcmp(name, "ReturnIntPtrMethod") == 0 && args_n == 2) {
    return reinterpret_cast<void*>(ReturnIntPtrMethod);
  }
  // This should be unreachable in tests.
  ENSURE(false);
}

FfiNativeResolver() [2/2]

static void * dart::FfiNativeResolver ( const char *  name, uintptr_t  args_n  )

static

Definition at line 10120 of file dart_api_impl_test.cc.

FfiResolve()

static intptr_t dart::FfiResolve ( Dart_Handle  asset_handle, Dart_Handle  symbol_handle, uintptr_t  args_n  )

static

Definition at line 518 of file ffi_dynamic_library.cc.

                                             {
  auto* const thread = Thread::Current();
  DARTSCOPE(thread);
  auto* const zone = thread->zone();
  const String& asset = Api::UnwrapStringHandle(zone, asset_handle);
  const String& symbol = Api::UnwrapStringHandle(zone, symbol_handle);
  char* error = nullptr;
 
  const intptr_t result = FfiResolveInternal(asset, symbol, args_n, &error);
  if (error != nullptr) {
    ThrowFfiResolveError(symbol, asset, error);
  }
  ASSERT(result != 0x0);
  return result;
}

FfiResolveAsset()

static void * dart::FfiResolveAsset ( Thread *const  thread, const Array &  asset_location, const String &  symbol, char **  error  )

static

Definition at line 385 of file ffi_dynamic_library.cc.

                                           {
  Zone* const zone = thread->zone();
 
  const auto& asset_type =
      String::Cast(Object::Handle(zone, asset_location.At(0)));
  String& path = String::Handle(zone);
  if (asset_type.Equals(Symbols::absolute()) ||
      asset_type.Equals(Symbols::relative()) ||
      asset_type.Equals(Symbols::system())) {
    path = String::RawCast(asset_location.At(1));
  }
  void* handle = nullptr;
  if (asset_type.Equals(Symbols::absolute())) {
    handle = LoadDynamicLibrary(path.ToCString(), error);
  } else if (asset_type.Equals(Symbols::relative())) {
    const auto& platform_script_uri = String::Handle(
        zone,
        String::NewFormatted(
            "%s%s", file_schema,
            String::Handle(zone, GetPlatformScriptPath(thread)).ToCString()));
    const char* target_uri = nullptr;
    char* path_cstr = path.ToMallocCString();
#if defined(DART_TARGET_OS_WINDOWS)
    ReplaceBackSlashes(path_cstr);
#endif
    const bool resolved =
        ResolveUri(path_cstr, platform_script_uri.ToCString(), &target_uri);
    free(path_cstr);
    if (!resolved) {
      *error = OS::SCreate(/*use malloc*/ nullptr,
                           "Failed to resolve '%s' relative to '%s'.",
                           path.ToCString(), platform_script_uri.ToCString());
    } else {
      const char* target_path = target_uri + file_schema_length;
      handle = LoadDynamicLibrary(target_path, error);
    }
  } else if (asset_type.Equals(Symbols::system())) {
    handle = LoadDynamicLibrary(path.ToCString(), error);
  } else if (asset_type.Equals(Symbols::process())) {
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_MACOS) ||              \
    defined(DART_HOST_OS_ANDROID) || defined(DART_HOST_OS_FUCHSIA)
    handle = RTLD_DEFAULT;
#else
    handle = kWindowsDynamicLibraryProcessPtr;
#endif
  } else if (asset_type.Equals(Symbols::executable())) {
    handle = LoadDynamicLibrary(nullptr, error);
  } else {
    UNREACHABLE();
  }
  if (*error != nullptr) {
    char* inner_error = *error;
    *error = OS::SCreate(/*use malloc*/ nullptr,
                         "Failed to load dynamic library '%s': %s",
                         path.ToCString(), inner_error);
    free(inner_error);
  } else {
    void* const result = ResolveSymbol(handle, symbol.ToCString(), error);
    if (*error != nullptr) {
      char* inner_error = *error;
      *error = OS::SCreate(/*use malloc*/ nullptr,
                           "Failed to lookup symbol '%s': %s",
                           symbol.ToCString(), inner_error);
      free(inner_error);
    } else {
      return result;
    }
  }
  ASSERT(*error != nullptr);
  return nullptr;
}

FfiResolveInternal()

intptr_t dart::FfiResolveInternal	(	const String &	asset,
		const String &	symbol,
		uintptr_t	args_n,
		char **	error
	)

Definition at line 471 of file ffi_dynamic_library.cc.

                                          {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  // Resolver resolution.
  auto resolver = GetFfiNativeResolver(thread, asset);
  if (resolver != nullptr) {
    void* ffi_native_result = FfiResolveWithFfiNativeResolver(
        thread, resolver, symbol, args_n, error);
    return reinterpret_cast<intptr_t>(ffi_native_result);
  }
 
  // Native assets resolution.
  const auto& asset_location =
      Array::Handle(zone, GetAssetLocation(thread, asset));
  if (!asset_location.IsNull()) {
    void* asset_result = FfiResolveAsset(thread, asset_location, symbol, error);
    return reinterpret_cast<intptr_t>(asset_result);
  }
 
  // Resolution in current process.
#if !defined(DART_HOST_OS_WINDOWS)
  void* const result = Utils::ResolveSymbolInDynamicLibrary(
      RTLD_DEFAULT, symbol.ToCString(), error);
#else
  void* const result = LookupSymbolInProcess(symbol.ToCString(), error);
#endif
 
  if (*error != nullptr) {
    // Process lookup failed, but the user might have tried to use native
    // asset lookup. So augment the error message to include native assets info.
    char* process_lookup_error = *error;
    *error = OS::SCreate(/*use malloc*/ nullptr,
                         "No asset with id '%s' found. %s "
                         "Attempted to fallback to process lookup. %s",
                         asset.ToCString(), AvailableAssetsToCString(thread),
                         process_lookup_error);
    free(process_lookup_error);
  }
 
  return reinterpret_cast<intptr_t>(result);
}

FfiResolveWithFfiNativeResolver()

static void * dart::FfiResolveWithFfiNativeResolver ( Thread *const  thread, Dart_FfiNativeResolver  resolver, const String &  symbol, intptr_t  args_n, char **  error  )

static

Definition at line 270 of file ffi_dynamic_library.cc.

                                                           {
  auto* result = resolver(symbol.ToCString(), args_n);
  if (result == nullptr) {
    *error = OS::SCreate(/*use malloc*/ nullptr,
                         "Couldn't resolve function: '%s'", symbol.ToCString());
  }
  return result;
}

FillDeferredSlots()

static void dart::FillDeferredSlots ( DeoptContext *  deopt_context, DeferredSlot **  slot_list  )

static

Definition at line 343 of file deopt_instructions.cc.

                                                        {
  DeferredSlot* slot = *slot_list;
  *slot_list = nullptr;
 
  while (slot != nullptr) {
    DeferredSlot* current = slot;
    slot = slot->next();
 
    current->Materialize(deopt_context);
 
    delete current;
  }
}

FillSummary()

static void dart::FillSummary ( LocationSummary *  locs, Location  expected_output, const LocationArray *  expected_inputs, const LocationArray *  expected_temps  )

static

Definition at line 55 of file locations_helpers_test.cc.

                                                             {
  locs->set_out(0, expected_output);
  for (intptr_t i = 0; i < expected_inputs->length(); i++) {
    locs->set_in(i, expected_inputs->At(i));
  }
  for (intptr_t i = 0; i < expected_temps->length(); i++) {
    locs->set_temp(i, expected_temps->At(i));
  }
}

FinalizableHandleCallback()

static void dart::FinalizableHandleCallback ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3594 of file dart_api_impl_test.cc.

                                                                               {
  if (peer == finalizable_new_ref_peer) {
    finalizable_new_ref_peer = 0;
    finalizable_new_ref = nullptr;
  } else if (peer == finalizable_old_ref_peer) {
    finalizable_old_ref_peer = 0;
    finalizable_old_ref = nullptr;
  }
}

FinalizableHandlePeerCleanupFinalizer()

static void dart::FinalizableHandlePeerCleanupFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3890 of file dart_api_impl_test.cc.

                                                              {
  Dart_DeletePersistentHandle(persistent_handle1);
  Dart_DeleteWeakPersistentHandle(weak_persistent_handle2);
  *static_cast<int*>(peer) = 42;
}

FinalizableHandlePeerFinalizer()

static void dart::FinalizableHandlePeerFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3952 of file dart_api_impl_test.cc.

                                                       {
  *static_cast<int*>(peer) = 42;
}

FinalizeAndCanonicalize() [1/2]

static void dart::FinalizeAndCanonicalize ( AbstractType *  type )

static

Definition at line 7398 of file object_test.cc.

FinalizeAndCanonicalize() [2/2]

static void dart::FinalizeAndCanonicalize ( AbstractType *  type )

static

Definition at line 190 of file type_testing_stubs_test.cc.

                                                        {
  *type = ClassFinalizer::FinalizeType(*type);
  ASSERT(type->IsCanonical());
}

FinalizeBuiltinClasses()

static void dart::FinalizeBuiltinClasses ( Thread *  thread )

static

Definition at line 896 of file dart.cc.

                                                   {
  auto class_table = thread->isolate_group()->class_table();
  Class& cls = Class::Handle(thread->zone());
  for (intptr_t cid = kInstanceCid; cid < kNumPredefinedCids; cid++) {
    if (class_table->HasValidClassAt(cid)) {
      cls = class_table->At(cid);
      RELEASE_ASSERT(cls.EnsureIsFinalized(thread) == Object::null());
    }
  }
}

FinalizeHash()

uint32_t dart::FinalizeHash ( uint32_t  hash, intptr_t  hashbits = kBitsPerInt32  )

inline

Definition at line 20 of file hash.h.

                                                                               {
  // Keep in sync with AssemblerBase::FinalizeHash.
  hash += hash << 3;
  hash ^= hash >> 11;  // Logical shift, unsigned hash.
  hash += hash << 15;
  if (hashbits < kBitsPerInt32) {
    hash &= (static_cast<uint32_t>(1) << hashbits) - 1;
  }
  return (hash == 0) ? 1 : hash;
}

Finalizer() [1/2]

static void dart::Finalizer ( void *  isolate_callback_data, void *  buffer  )

static

Definition at line 192 of file json_stream.cc.

                                                                 {
  free(buffer);
}

Finalizer() [2/2]

static void dart::Finalizer ( void *  isolate_callback_data, void *  buffer  )

static

Definition at line 1075 of file service.cc.

                                                                 {
  free(buffer);
}

Finalizer_ClearDetachOne()

static void dart::Finalizer_ClearDetachOne ( Thread *  thread, Heap::Space  space  )

static

Definition at line 3918 of file object_test.cc.

                                                                      {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif
 
  MessageHandler* handler = thread->isolate()->message_handler();
  {
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
 
  const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
  finalizer.set_isolate(thread->isolate());
  const auto& entry =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
  const auto& value = String::Handle(OneByteString::New("value", space));
  entry.set_value(value);
  const auto& token = String::Handle(OneByteString::New("token", space));
  entry.set_token(token);
 
  {
    HANDLESCOPE(thread);
    const auto& detach = String::Handle(OneByteString::New("detach", space));
    entry.set_detach(detach);
  }
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  // Detach should have been collected.
  EXPECT_NE(Object::null(), entry.value());
  EXPECT_EQ(Object::null(), entry.detach());
  EXPECT_NE(Object::null(), entry.token());
 
  // The entry should not have moved to the collected list.
  EXPECT_EQ(0,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));
 
  // We should have no messages.
  {
    // Acquire ownership of message handler queues.
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
}

Finalizer_ClearValueOne()

static void dart::Finalizer_ClearValueOne ( Thread *  thread, Heap::Space  space, bool  null_token  )

static

Definition at line 3975 of file object_test.cc.

                                                     {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif
 
  MessageHandler* handler = thread->isolate()->message_handler();
  {
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
 
  const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
  finalizer.set_isolate(thread->isolate());
  const auto& entry =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
  const auto& detach = String::Handle(OneByteString::New("detach", space));
  auto& token = Object::Handle();
  if (null_token) {
    // Null is a valid token in Dart finalizers.
    token = Object::null();
  } else {
    token = OneByteString::New("token", space);
  }
  entry.set_token(token);
  entry.set_detach(detach);
 
  {
    HANDLESCOPE(thread);
    const auto& value = String::Handle(OneByteString::New("value", space));
    entry.set_value(value);
  }
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  // Value should have been collected.
  EXPECT_EQ(Object::null(), entry.value());
  EXPECT_NE(Object::null(), entry.detach());
 
  // The entry should have moved to the collected list.
  EXPECT_EQ(1,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));
 
  // We should have 1 message.
  {
    // Acquire ownership of message handler queues.
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(1, aq.queue()->Length());
  }
}

Finalizer_DetachOne()

static void dart::Finalizer_DetachOne ( Thread *  thread, Heap::Space  space, bool  clear_value  )

static

Definition at line 4047 of file object_test.cc.

                                                  {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif
 
  MessageHandler* handler = thread->isolate()->message_handler();
  {
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
 
  const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
  finalizer.set_isolate(thread->isolate());
  const auto& entry =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
  const auto& detach = String::Handle(OneByteString::New("detach", space));
  entry.set_detach(detach);
 
  // Simulate calling detach, setting the token of the entry to the entry.
  entry.set_token(entry);
 
  auto& value = String::Handle();
  {
    HANDLESCOPE(thread);
 
    const auto& object = String::Handle(OneByteString::New("value", space));
    entry.set_value(object);
    if (!clear_value) {
      value = object.ptr();
    }
  }
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  EXPECT((entry.value() == Object::null()) ^ !clear_value);
  EXPECT_NE(Object::null(), entry.detach());
  EXPECT_EQ(entry.ptr(), entry.token());
 
  // The entry should have been removed entirely
  EXPECT_EQ(0,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));
 
  // We should have no message.
  {
    // Acquire ownership of message handler queues.
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
}

Finalizer_GcFinalizer()

static void dart::Finalizer_GcFinalizer ( Thread *  thread, Heap::Space  space  )

static

Definition at line 4119 of file object_test.cc.

                                                                   {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif
 
  MessageHandler* handler = thread->isolate()->message_handler();
  {
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
 
  const auto& detach = String::Handle(OneByteString::New("detach", space));
  const auto& token = String::Handle(OneByteString::New("token", space));
 
  {
    HANDLESCOPE(thread);
    const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
    finalizer.set_isolate(thread->isolate());
    const auto& entry =
        FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
    entry.set_detach(detach);
    entry.set_token(token);
    const auto& value = String::Handle(OneByteString::New("value", space));
    entry.set_value(value);
  }
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  // We should have no message, the Finalizer itself has been GCed.
  {
    // Acquire ownership of message handler queues.
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
}

Finalizer_PreserveOne()

static void dart::Finalizer_PreserveOne ( Thread *  thread, Heap::Space  space, bool  with_detach  )

static

Definition at line 3850 of file object_test.cc.

                                                    {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif
 
  MessageHandler* handler = thread->isolate()->message_handler();
  {
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
 
  const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
  finalizer.set_isolate(thread->isolate());
  const auto& entry =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
  const auto& value = String::Handle(OneByteString::New("value", space));
  entry.set_value(value);
  auto& detach = Object::Handle();
  if (with_detach) {
    detach = OneByteString::New("detach", space);
  } else {
    detach = Object::null();
  }
  entry.set_detach(detach);
  const auto& token = String::Handle(OneByteString::New("token", space));
  entry.set_token(token);
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  // Nothing in the entry should have been collected.
  EXPECT_NE(Object::null(), entry.value());
  EXPECT((entry.detach() == Object::null()) ^ with_detach);
  EXPECT_NE(Object::null(), entry.token());
 
  // The entry should not have moved to the collected list.
  EXPECT_EQ(0,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));
 
  // We should have no messages.
  {
    // Acquire ownership of message handler queues.
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(0, aq.queue()->Length());
  }
}

Finalizer_TwoEntries()

static void dart::Finalizer_TwoEntries ( Thread *  thread, Heap::Space  space, bool  clear_value_1, bool  clear_value_2, bool  clear_detach_1, bool  clear_detach_2  )

static

Definition at line 4269 of file object_test.cc.

                                                      {
  const bool collect_old_space = true;
  const bool collect_new_space = space == Heap::kNew;
  const bool evacuate_new_space_and_collect_old_space = !collect_new_space;
 
  Heap::Space spaces[kFinalizerTwoEntriesNumObjects];
  for (intptr_t i = 0; i < kFinalizerTwoEntriesNumObjects; i++) {
    spaces[i] = space;
  }
  Finalizer_TwoEntriesCrossGen(
      thread, spaces, collect_old_space, collect_new_space,
      evacuate_new_space_and_collect_old_space, clear_value_1, clear_value_2,
      clear_detach_1, clear_detach_2);
}

Finalizer_TwoEntriesCrossGen() [1/2]

static void dart::Finalizer_TwoEntriesCrossGen ( Thread *  thread, Heap::Space *  spaces, bool  collect_old_space, bool  collect_new_space, bool  evacuate_new_space_and_collect_old_space, bool  clear_value_1, bool  clear_value_2, bool  clear_detach_1, bool  clear_detach_2  )

static

Definition at line 4167 of file object_test.cc.

                         {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif
 
  MessageHandler* handler = thread->isolate()->message_handler();
  // We're reusing the isolate in a loop, so there are messages from previous
  // runs of this test.
  intptr_t queue_length_start = 0;
  {
    MessageHandler::AcquiredQueues aq(handler);
    queue_length_start = aq.queue()->Length();
  }
 
  const auto& finalizer = Finalizer::Handle(Finalizer::New(spaces[0]));
  finalizer.set_isolate(thread->isolate());
  const auto& entry1 =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, spaces[1]));
  const auto& entry2 =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, spaces[2]));
 
  auto& value1 = String::Handle();
  auto& detach1 = String::Handle();
  const auto& token1 = String::Handle(OneByteString::New("token1", spaces[3]));
  entry1.set_token(token1);
 
  auto& value2 = String::Handle();
  auto& detach2 = String::Handle();
  const auto& token2 = String::Handle(OneByteString::New("token2", spaces[4]));
  entry2.set_token(token2);
  entry2.set_detach(detach2);
 
  {
    HANDLESCOPE(thread);
    auto& object = String::Handle();
 
    object ^= OneByteString::New("value1", spaces[5]);
    entry1.set_value(object);
    if (!clear_value_1) {
      value1 = object.ptr();
    }
 
    object ^= OneByteString::New("detach", spaces[6]);
    entry1.set_detach(object);
    if (!clear_detach_1) {
      detach1 = object.ptr();
    }
 
    object ^= OneByteString::New("value2", spaces[7]);
    entry2.set_value(object);
    if (!clear_value_2) {
      value2 = object.ptr();
    }
 
    object ^= OneByteString::New("detach", spaces[8]);
    entry2.set_detach(object);
    if (!clear_detach_2) {
      detach2 = object.ptr();
    }
  }
 
  if (collect_old_space) {
    GCTestHelper::CollectOldSpace();
  }
  if (collect_new_space) {
    GCTestHelper::CollectNewSpace();
  }
  if (evacuate_new_space_and_collect_old_space) {
    GCTestHelper::CollectAllGarbage();
  }
 
  EXPECT((entry1.value() == Object::null()) ^ !clear_value_1);
  EXPECT((entry2.value() == Object::null()) ^ !clear_value_2);
  EXPECT((entry1.detach() == Object::null()) ^ !clear_detach_1);
  EXPECT((entry2.detach() == Object::null()) ^ !clear_detach_2);
  EXPECT_NE(Object::null(), entry1.token());
  EXPECT_NE(Object::null(), entry2.token());
 
  const intptr_t expect_num_cleared =
      (clear_value_1 ? 1 : 0) + (clear_value_2 ? 1 : 0);
  EXPECT_EQ(expect_num_cleared,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));
 
  const intptr_t expect_num_messages = expect_num_cleared == 0 ? 0 : 1;
  {
    // Acquire ownership of message handler queues.
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(expect_num_messages + queue_length_start, aq.queue()->Length());
  }
}

Finalizer_TwoEntriesCrossGen() [2/2]

static void dart::Finalizer_TwoEntriesCrossGen ( Thread *  thread, intptr_t  test_i  )

static

Definition at line 4329 of file object_test.cc.

                                                                          {
  ASSERT(test_i < (1 << kFinalizerTwoEntriesNumObjects));
  Heap::Space spaces[kFinalizerTwoEntriesNumObjects];
  for (intptr_t i = 0; i < kFinalizerTwoEntriesNumObjects; i++) {
    spaces[i] = ((test_i >> i) & 0x1) == 0x1 ? Heap::kOld : Heap::kNew;
  }
  // Either collect or evacuate new space.
  for (const bool collect_new_space : {false, true}) {
    // Always run old space collection first.
    const bool collect_old_space = true;
    // Always run old space collection after new space.
    const bool evacuate_new_space_and_collect_old_space = true;
    for (intptr_t test_j = 0; test_j < 16; test_j++) {
      const bool clear_value_1 = (test_j >> 0 & 0x1) == 0x1;
      const bool clear_value_2 = (test_j >> 1 & 0x1) == 0x1;
      const bool clear_detach_1 = (test_j >> 2 & 0x1) == 0x1;
      const bool clear_detach_2 = (test_j >> 3 & 0x1) == 0x1;
      Finalizer_TwoEntriesCrossGen(
          thread, spaces, collect_old_space, collect_new_space,
          evacuate_new_space_and_collect_old_space, clear_value_1,
          clear_value_2, clear_detach_1, clear_detach_2);
    }
  }
}

FinalizerEntry_Generations()

static void dart::FinalizerEntry_Generations ( Generation  entry_space, Generation  value_space, bool  cleared_after_minor, bool  cleared_after_major, bool  cleared_after_all  )

static

Definition at line 1156 of file heap_test.cc.

                                                               {
  FinalizerEntry& entry = FinalizerEntry::Handle();
  GCTestHelper::CollectAllGarbage();
  {
    HANDLESCOPE(Thread::Current());
    switch (entry_space) {
      case kNew:
        entry = FinalizerEntry::New(FinalizerBase::Handle(), Heap::kNew);
        break;
      case kOld:
        entry = FinalizerEntry::New(FinalizerBase::Handle(), Heap::kOld);
        break;
      case kImm:
        UNREACHABLE();
    }
 
    Object& value = Object::Handle();
    switch (value_space) {
      case kNew:
        value = OneByteString::New("value", Heap::kNew);
        break;
      case kOld:
        value = OneByteString::New("value", Heap::kOld);
        break;
      case kImm:
        value = Smi::New(42);
        break;
    }
 
    entry.set_value(value);
  }
 
  OS::PrintErr("%d %d\n", entry_space, value_space);
 
  GCTestHelper::CollectNewSpace();
  if (cleared_after_minor) {
    EXPECT(entry.value() == Object::null());
  } else {
    EXPECT(entry.value() != Object::null());
  }
 
  GCTestHelper::CollectOldSpace();
  if (cleared_after_major) {
    EXPECT(entry.value() == Object::null());
  } else {
    EXPECT(entry.value() != Object::null());
  }
 
  GCTestHelper::CollectAllGarbage();
  if (cleared_after_all) {
    EXPECT(entry.value() == Object::null());
  } else {
    EXPECT(entry.value() != Object::null());
  }
}

FinalizeTypedData()

static void dart::FinalizeTypedData ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 8239 of file dart_api_impl_test.cc.

FindBinarySmiOp()

static FunctionPtr dart::FindBinarySmiOp ( Zone *  zone, const String &  name  )

static

Definition at line 5226 of file il.cc.

                                                                   {
  const auto& smi_class = Class::Handle(zone, Smi::Class());
  auto& smi_op_target = Function::Handle(
      zone, Resolver::ResolveDynamicAnyArgs(zone, smi_class, name));
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  if (smi_op_target.IsNull() &&
      Function::IsDynamicInvocationForwarderName(name)) {
    const String& demangled = String::Handle(
        zone, Function::DemangleDynamicInvocationForwarderName(name));
    smi_op_target = Resolver::ResolveDynamicAnyArgs(zone, smi_class, demangled);
  }
#endif
  return smi_op_target.ptr();
}

FindCoreLibPrivateFunction()

static FunctionPtr dart::FindCoreLibPrivateFunction ( Zone *  zone, const String &  name  )

static

Definition at line 287 of file dart_api_impl.cc.

                                                                              {
  const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
  ASSERT(!core_lib.IsNull());
  const Function& function =
      Function::Handle(zone, core_lib.LookupFunctionAllowPrivate(name));
  ASSERT(!function.IsNull());
  return function.ptr();
}

FindCover()

static LiveRange * dart::FindCover ( LiveRange *  parent, intptr_t  pos  )

static

Definition at line 2963 of file linearscan.cc.

                                                             {
  for (LiveRange* range = parent; range != nullptr;
       range = range->next_sibling()) {
    if (range->CanCover(pos)) {
      return range;
    }
  }
  UNREACHABLE();
  return nullptr;
}

FindDoubleConstant()

uword dart::FindDoubleConstant

(

double

value

)

Definition at line 30 of file flow_graph_builder.cc.

                                       {
  intptr_t len = sizeof(kCommonDoubleConstants) / sizeof(double);  // NOLINT
  for (intptr_t i = 0; i < len; i++) {
    if (Utils::DoublesBitEqual(value, kCommonDoubleConstants[i])) {
      return reinterpret_cast<uword>(&kCommonDoubleConstants[i]);
    }
  }
  return 0;
}

FindEntryPointPragma()

EntryPointPragma dart::FindEntryPointPragma	(	IsolateGroup *	IG,
		const Array &	metadata,
		Field *	reusable_field_handle,
		Object *	pragma
	)

Definition at line 27193 of file object.cc.

                                                      {
  for (intptr_t i = 0; i < metadata.Length(); i++) {
    *pragma = metadata.At(i);
    if (pragma->clazz() != IG->object_store()->pragma_class()) {
      continue;
    }
    *reusable_field_handle = IG->object_store()->pragma_name();
    if (Instance::Cast(*pragma).GetField(*reusable_field_handle) !=
        Symbols::vm_entry_point().ptr()) {
      continue;
    }
    *reusable_field_handle = IG->object_store()->pragma_options();
    *pragma = Instance::Cast(*pragma).GetField(*reusable_field_handle);
    if (pragma->ptr() == Bool::null() || pragma->ptr() == Bool::True().ptr()) {
      return EntryPointPragma::kAlways;
      break;
    }
    if (pragma->ptr() == Symbols::get().ptr()) {
      return EntryPointPragma::kGetterOnly;
    }
    if (pragma->ptr() == Symbols::set().ptr()) {
      return EntryPointPragma::kSetterOnly;
    }
    if (pragma->ptr() == Symbols::call().ptr()) {
      return EntryPointPragma::kCallOnly;
    }
  }
  return EntryPointPragma::kNever;
}

FindErrorHandler()

static void dart::FindErrorHandler ( uword *  handler_pc, uword *  handler_sp, uword *  handler_fp  )

static

Definition at line 562 of file exceptions.cc.

                                                {
  StackFrameIterator frames(ValidationPolicy::kDontValidateFrames,
                            Thread::Current(),
                            StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = frames.NextFrame();
  ASSERT(frame != nullptr);
  while (!frame->IsEntryFrame()) {
    frame = frames.NextFrame();
    ASSERT(frame != nullptr);
  }
  ASSERT(frame->IsEntryFrame());
  *handler_pc = frame->pc();
  *handler_sp = frame->sp();
  *handler_fp = frame->fp();
}

FindExactTokenPosition()

static TokenPosition dart::FindExactTokenPosition ( const Script &  script, TokenPosition  start_of_line, intptr_t  column_number  )

static

Definition at line 3736 of file debugger.cc.

                                                                    {
  intptr_t line;
  intptr_t col;
  if (script.GetTokenLocation(start_of_line, &line, &col)) {
    return TokenPosition::Deserialize(start_of_line.Pos() +
                                      (column_number - col));
  }
  return TokenPosition::kNoSource;
}

FindFirstNonEmptySuccessor()

static BlockEntryInstr * dart::FindFirstNonEmptySuccessor ( TargetEntryInstr *  block, BitVector *  empty_blocks  )

static

Definition at line 1695 of file constant_propagator.cc.

                                                                            {
  BlockEntryInstr* current = block;
  while (IsEmptyBlock(current) && block->Dominates(current)) {
    ASSERT(!HasPhis(block));
    empty_blocks->Add(current->preorder_number());
    current = current->next()->AsGoto()->successor();
  }
  return current;
}

FindICData()

static void dart::FindICData ( const Array &  ic_data_array, intptr_t  deopt_id, ICData *  ic_data  )

static

Definition at line 97 of file object_reload.cc.

                                        {
  // ic_data_array is sorted because of how it is constructed in
  // Function::SaveICDataMap.
  intptr_t lo = Function::ICDataArrayIndices::kFirstICData;
  intptr_t hi = ic_data_array.Length() - 1;
  while (lo <= hi) {
    intptr_t mid = (hi - lo + 1) / 2 + lo;
    ASSERT(mid >= lo);
    ASSERT(mid <= hi);
    *ic_data ^= ic_data_array.At(mid);
    if (ic_data->deopt_id() == deopt_id) {
      return;
    } else if (ic_data->deopt_id() > deopt_id) {
      hi = mid - 1;
    } else {
      lo = mid + 1;
    }
  }
  FATAL("Missing deopt id %" Pd "\n", deopt_id);
}

FindInnermostClosure()

static FunctionPtr dart::FindInnermostClosure ( Zone *  zone, const Function &  function, TokenPosition  token_pos  )

static

Definition at line 2891 of file debugger.cc.

                                                                 {
  ASSERT(function.end_token_pos().IsReal());
  const TokenPosition& func_start = function.token_pos();
  const Script& outer_origin = Script::Handle(zone, function.script());
 
  Function& best_fit = Function::Handle(zone);
  ClosureFunctionsCache::ForAllClosureFunctions([&](const Function& closure) {
    const TokenPosition& closure_start = closure.token_pos();
    const TokenPosition& closure_end = closure.end_token_pos();
    // We're only interested in closures that have real ending token positions.
    // The starting token position can be synthetic.
    if (closure_end.IsReal() && (function.end_token_pos() > closure_end) &&
        (!closure_start.IsReal() || !func_start.IsReal() ||
         (closure_start > func_start)) &&
        token_pos.IsWithin(closure_start, closure_end) &&
        (closure.script() == outer_origin.ptr())) {
      UpdateBestFit(&best_fit, closure);
    }
    return true;  // Continue iteration.
  });
  return best_fit.ptr();
}

FindMethod()

const ServiceMethodDescriptor * dart::FindMethod

(

const char *

method_name

)

Definition at line 6006 of file service.cc.

                                                                   {
  intptr_t num_methods = sizeof(service_methods_) / sizeof(service_methods_[0]);
  for (intptr_t i = 0; i < num_methods; i++) {
    const ServiceMethodDescriptor& method = service_methods_[i];
    if (strcmp(method_name, method.name) == 0) {
      return &method;
    }
  }
  return nullptr;
}

FindNextRewindFrameIndex()

static intptr_t dart::FindNextRewindFrameIndex ( DebuggerStackTrace *  stack, intptr_t  frame_index  )

static

Definition at line 3180 of file debugger.cc.

                                                               {
  for (intptr_t i = frame_index + 1; i < stack->Length(); i++) {
    ActivationFrame* frame = stack->FrameAt(i);
    if (frame->IsRewindable()) {
      return i;
    }
  }
  return -1;
}

FindPCForTokenPosition()

static uword dart::FindPCForTokenPosition ( const Code &  code, TokenPosition  tp  )

static

Definition at line 2192 of file profiler_test.cc.

                                                                        {
  GrowableArray<const Function*> functions;
  GrowableArray<TokenPosition> token_positions;
  for (uword pc_offset = 0; pc_offset < code.Size(); pc_offset++) {
    code.GetInlinedFunctionsAtInstruction(pc_offset, &functions,
                                          &token_positions);
    if (token_positions[0] == tp) {
      return code.PayloadStart() + pc_offset;
    }
  }
 
  return 0;
}

FindPragmaInMetadata()

bool dart::FindPragmaInMetadata	(	Thread *	T,
		const Object &	metadata_obj,
		const String &	pragma_name,
		bool	multiple,
		Object *	options
	)

Definition at line 4142 of file object.cc.

                                           {
  auto IG = T->isolate_group();
  auto Z = T->zone();
 
  // If there is a compile-time error while evaluating the metadata, we will
  // simply claim there was no @pragma annotation.
  if (metadata_obj.IsNull() || metadata_obj.IsLanguageError()) {
    return false;
  }
  ASSERT(metadata_obj.IsArray());
 
  auto& metadata = Array::Cast(metadata_obj);
  auto& pragma_class = Class::Handle(Z, IG->object_store()->pragma_class());
  if (pragma_class.IsNull()) {
    // Precompiler may drop pragma class.
    return false;
  }
  auto& pragma_name_field =
      Field::Handle(Z, pragma_class.LookupField(Symbols::name()));
  auto& pragma_options_field =
      Field::Handle(Z, pragma_class.LookupField(Symbols::options()));
 
  auto& pragma = Object::Handle(Z);
  bool found = false;
  auto& options_value = Object::Handle(Z);
  auto& results = GrowableObjectArray::Handle(Z);
  if (multiple) {
    ASSERT(options != nullptr);
    results ^= GrowableObjectArray::New(1);
  }
  for (intptr_t i = 0; i < metadata.Length(); ++i) {
    pragma = metadata.At(i);
    if (pragma.clazz() != pragma_class.ptr() ||
        Instance::Cast(pragma).GetField(pragma_name_field) !=
            pragma_name.ptr()) {
      continue;
    }
    options_value = Instance::Cast(pragma).GetField(pragma_options_field);
    found = true;
    if (multiple) {
      results.Add(options_value);
      continue;
    }
    if (options != nullptr) {
      *options = options_value.ptr();
    }
    return true;
  }
 
  if (found && options != nullptr) {
    *options = results.ptr();
  }
  return false;
}

FindRetainingPath()

const char * dart::FindRetainingPath	(	Zone *	zone_,
		Isolate *	isolate,
		const Object &	from,
		const Object &	to,
		TraversalRules	traversal_rules
	)

Definition at line 1288 of file object_graph_copy.cc.

                                                              {
  RetainingPath rr(zone_, isolate, from, to, traversal_rules);
  return rr.FindPath();
}

FindScript()

static ScriptPtr dart::FindScript ( DartFrameIterator *  iterator )

static

Definition at line 16 of file errors.cc.

                                                         {
#if defined(DART_PRECOMPILED_RUNTIME)
  // The precompiled runtime faces two issues in recovering the correct
  // assertion text. First, the precompiled runtime does not include
  // the inlining meta-data so we cannot walk the inline-aware stack trace.
  // Second, the script text itself is missing so whatever script is returned
  // from here will be missing the assertion expression text.
  iterator->NextFrame();  // Skip _AssertionError._evaluateAssertion frame
  return Exceptions::GetCallerScript(iterator);
#else
  StackFrame* stack_frame = iterator->NextFrame();
  Code& code = Code::Handle();
  Function& func = Function::Handle();
  const Class& assert_error_class =
      Class::Handle(Library::LookupCoreClass(Symbols::AssertionError()));
  ASSERT(!assert_error_class.IsNull());
  bool hit_assertion_error = false;
  for (; stack_frame != nullptr; stack_frame = iterator->NextFrame()) {
    code = stack_frame->LookupDartCode();
    if (code.is_optimized()) {
      InlinedFunctionsIterator inlined_iterator(code, stack_frame->pc());
      while (!inlined_iterator.Done()) {
        func = inlined_iterator.function();
        if (hit_assertion_error) {
          return func.script();
        }
        ASSERT(!hit_assertion_error);
        hit_assertion_error = (func.Owner() == assert_error_class.ptr());
        inlined_iterator.Advance();
      }
      continue;
    } else {
      func = code.function();
    }
    ASSERT(!func.IsNull());
    if (hit_assertion_error) {
      return func.script();
    }
    ASSERT(!hit_assertion_error);
    hit_assertion_error = (func.Owner() == assert_error_class.ptr());
  }
  UNREACHABLE();
  return Script::null();
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

Finish()

static void dart::Finish ( Thread *  thread )

static

Definition at line 44 of file bootstrap.cc.

                                   {
  Bootstrap::SetupNativeResolver();
  if (!ClassFinalizer::ProcessPendingClasses()) {
    FATAL("Error in class finalization during bootstrapping.");
  }
 
  // Eagerly compile the _Closure class as it is the class of all closure
  // instances. This allows us to just finalize function types without going
  // through the hoops of trying to compile their scope class.
  ObjectStore* object_store = thread->isolate_group()->object_store();
  Zone* zone = thread->zone();
  Class& cls = Class::Handle(zone, object_store->closure_class());
  cls.EnsureIsFinalized(thread);
 
  // Make sure _Closure fields are not marked as unboxed as they are accessed
  // with plain loads.
  const Array& fields = Array::Handle(zone, cls.fields());
  Field& field = Field::Handle(zone);
  for (intptr_t i = 0; i < fields.Length(); ++i) {
    field ^= fields.At(i);
    field.set_is_unboxed(false);
  }
  // _Closure._hash field should be explicitly marked as nullable because
  // VM creates instances of _Closure without compiling its constructors,
  // so it won't get nullability info from a constructor.
  field ^= fields.At(fields.Length() - 1);
  // Note that UserVisibleName depends on --show-internal-names.
  ASSERT(strncmp(field.UserVisibleNameCString(), "_hash", 5) == 0);
  field.RecordStore(Object::null_object());
 
#if defined(DEBUG)
  // Verify that closure field offsets are identical in Dart and C++.
  ASSERT_EQUAL(fields.Length(), 6);
  field ^= fields.At(0);
  ASSERT_EQUAL(field.HostOffset(),
               Closure::instantiator_type_arguments_offset());
  field ^= fields.At(1);
  ASSERT_EQUAL(field.HostOffset(), Closure::function_type_arguments_offset());
  field ^= fields.At(2);
  ASSERT_EQUAL(field.HostOffset(), Closure::delayed_type_arguments_offset());
  field ^= fields.At(3);
  ASSERT_EQUAL(field.HostOffset(), Closure::function_offset());
  field ^= fields.At(4);
  ASSERT_EQUAL(field.HostOffset(), Closure::context_offset());
  field ^= fields.At(5);
  ASSERT_EQUAL(field.HostOffset(), Closure::hash_offset());
#endif  // defined(DEBUG)
 
  // Eagerly compile to avoid repeated checks when loading constants or
  // serializing.
  cls = object_store->null_class();
  cls.EnsureIsFinalized(thread);
  cls = object_store->bool_class();
  cls.EnsureIsFinalized(thread);
  cls = object_store->array_class();
  cls.EnsureIsFinalized(thread);
  cls = object_store->immutable_array_class();
  cls.EnsureIsFinalized(thread);
  cls = object_store->map_impl_class();
  cls.EnsureIsFinalized(thread);
  cls = object_store->const_map_impl_class();
  cls.EnsureIsFinalized(thread);
  cls = object_store->set_impl_class();
  cls.EnsureIsFinalized(thread);
  cls = object_store->const_set_impl_class();
  cls.EnsureIsFinalized(thread);
}

FirstIntersection()

static intptr_t dart::FirstIntersection ( UseInterval *  a, UseInterval *  u  )

static

Definition at line 1853 of file linearscan.cc.

                                                                  {
  while (a != nullptr && u != nullptr) {
    const intptr_t pos = a->Intersect(u);
    if (pos != kIllegalPosition) return pos;
 
    if (a->start() < u->start()) {
      a = a->next();
    } else {
      u = u->next();
    }
  }
 
  return kMaxPosition;
}

FirstMaterializationAt()

static Instruction * dart::FirstMaterializationAt ( Instruction *  exit )

static

Definition at line 3775 of file redundancy_elimination.cc.

                                                              {
  while (exit->previous()->IsMaterializeObject()) {
    exit = exit->previous();
  }
  return exit;
}

FirstUseAfter()

static UsePosition * dart::FirstUseAfter ( UsePosition *  use, intptr_t  after  )

static

Definition at line 1790 of file linearscan.cc.

                                                                    {
  while ((use != nullptr) && (use->pos() < after)) {
    use = use->next();
  }
  return use;
}

FlattenScopeIntoEnvironment()

static void dart::FlattenScopeIntoEnvironment ( FlowGraph *  graph, LocalScope *  scope, GrowableArray< LocalVariable * > *  env  )

static

Definition at line 41 of file redundancy_elimination_test.cc.

                                                                            {
  for (intptr_t i = 0; i < scope->num_variables(); i++) {
    auto var = scope->VariableAt(i);
    if (var->is_captured()) {
      continue;
    }
 
    auto index = graph->EnvIndex(var);
    env->EnsureLength(index + 1, nullptr);
    (*env)[index] = var;
  }
 
  if (scope->sibling() != nullptr) {
    FlattenScopeIntoEnvironment(graph, scope->sibling(), env);
  }
  if (scope->child() != nullptr) {
    FlattenScopeIntoEnvironment(graph, scope->child(), env);
  }
}

FlushSampleBlocks()

static void dart::FlushSampleBlocks ( Isolate *  isolate )

static

Definition at line 739 of file profiler.cc.

                                                {
  ASSERT(isolate != nullptr);
 
  SampleBlock* block = isolate->current_sample_block();
  if (block != nullptr) {
    isolate->set_current_sample_block(nullptr);
    block->MarkCompleted();
  }
 
  block = isolate->current_allocation_sample_block();
  if (block != nullptr) {
    isolate->set_current_allocation_sample_block(nullptr);
    block->MarkCompleted();
  }
}

ForwardedObj()

static DART_FORCE_INLINE ObjectPtr dart::ForwardedObj ( uword  header )

static

Definition at line 73 of file scavenger.cc.

                                            {
  ASSERT(IsForwarding(header));
  return static_cast<ObjectPtr>(header);
}

ForwardingHeader()

static DART_FORCE_INLINE uword dart::ForwardingHeader ( ObjectPtr  target )

static

Definition at line 79 of file scavenger.cc.

                                                {
  uword result = static_cast<uword>(target);
  ASSERT(IsForwarding(result));
  return result;
}

ForwardObjectTo()

static void dart::ForwardObjectTo ( ObjectPtr  before_obj, ObjectPtr  after_obj  )

static

Definition at line 61 of file become.cc.

                                                                       {
  const intptr_t size_before = before_obj->untag()->HeapSize();
 
  uword corpse_addr = static_cast<uword>(before_obj) - kHeapObjectTag;
  ForwardingCorpse* forwarder =
      ForwardingCorpse::AsForwarder(corpse_addr, size_before);
  forwarder->set_target(after_obj);
  if (!IsForwardingObject(before_obj)) {
    FATAL("become: ForwardObjectTo failure.");
  }
  // Still need to be able to iterate over the forwarding corpse.
  const intptr_t size_after = before_obj->untag()->HeapSize();
  if (size_before != size_after) {
    FATAL("become: Before and after sizes do not match.");
  }
}

Free()

static void dart::Free ( FreeList *  free_list, uword  address, intptr_t  size, bool  is_protected  )

static

Definition at line 23 of file freelist_test.cc.

                                    {
  if (is_protected) {
    VirtualMemory::Protect(reinterpret_cast<void*>(address), size,
                           VirtualMemory::kReadWrite);
  }
  free_list->Free(address, size);
  if (is_protected) {
    VirtualMemory::Protect(reinterpret_cast<void*>(address), size,
                           VirtualMemory::kReadExecute);
  }
}

FreeExternalTypedData()

void dart::FreeExternalTypedData	(	void *	isolate_callback_data,
		void *	buffer
	)

Definition at line 361 of file object_graph_copy.cc.

                                                                      {
  free(buffer);
}

FreeFinalizer()

DART_EXPORT void dart::FreeFinalizer	(	void *	,
		void *	value
	)

Definition at line 624 of file ffi_test_functions_vmspecific.cc.

                                                   {
  free(value);
}

FreeStruct9Uint8()

DART_EXPORT void dart::FreeStruct9Uint8

(

Struct9Uint8 *

address

)

Definition at line 781 of file ffi_test_functions.cc.

                                                         {
#if defined(_WIN32)
  VirtualFree(address, 0, MEM_RELEASE);
#else
  size_t size = sizeof(Struct9Uint8) * 64 * 1024;
  munmap(address, size * 2);
#endif
}

FreeTransferablePeer()

void dart::FreeTransferablePeer	(	void *	isolate_callback_data,
		void *	peer
	)

Definition at line 365 of file object_graph_copy.cc.

                                                                   {
  delete static_cast<TransferableTypedDataPeer*>(peer);
}

FunctionOverlaps()

static bool dart::FunctionOverlaps ( const Function &  func, const String &  script_url, TokenPosition  token_pos, TokenPosition  end_token_pos  )

static

Definition at line 378 of file debugger.cc.

                                                          {
  const TokenPosition& func_start = func.token_pos();
  if (token_pos.IsWithin(func_start, func.end_token_pos()) ||
      func_start.IsWithin(token_pos, end_token_pos)) {
    // Check script equality last because it allocates handles as a side effect.
    Script& func_script = Script::Handle(func.script());
    String& url = String::Handle(func_script.url());
    return script_url.Equals(url);
  }
  return false;
}

FunctionPrintNameHelper()

static void dart::FunctionPrintNameHelper ( const Function &  fun, const NameFormattingParams &  params, BaseTextBuffer *  printer  )

static

Definition at line 11095 of file object.cc.

                                                             {
  if (fun.IsNonImplicitClosureFunction()) {
    if (params.include_parent_name) {
      const auto& parent = Function::Handle(fun.parent_function());
      if (parent.IsNull()) {
        printer->AddString(Symbols::OptimizedOut().ToCString());
      } else {
        parent.PrintName(params, printer);
      }
      // A function's scrubbed name and its user visible name are identical.
      printer->AddString(".");
    }
    if (params.disambiguate_names &&
        fun.name() == Symbols::AnonymousClosure().ptr()) {
      if (fun.token_pos().IsReal()) {
        printer->Printf("<anonymous closure @%" Pd ">", fun.token_pos().Pos());
      } else {
        printer->Printf("<anonymous closure @no position>");
      }
    } else {
      printer->AddString(fun.NameCString(params.name_visibility));
      if (params.disambiguate_names) {
        if (fun.token_pos().IsReal()) {
          printer->Printf("@<%" Pd ">", fun.token_pos().Pos());
        } else {
          printer->Printf("@<no position>");
        }
      }
    }
    return;
  }
  if (params.disambiguate_names) {
    if (fun.IsInvokeFieldDispatcher()) {
      printer->AddString("[invoke-field] ");
    }
    if (fun.IsNoSuchMethodDispatcher()) {
      printer->AddString("[no-such-method] ");
    }
    if (fun.IsImplicitClosureFunction()) {
      printer->AddString("[tear-off] ");
    }
    if (fun.IsMethodExtractor()) {
      printer->AddString("[tear-off-extractor] ");
    }
  }
 
  if (fun.kind() == UntaggedFunction::kConstructor) {
    printer->AddString("new ");
  } else if (params.include_class_name) {
    const Class& cls = Class::Handle(fun.Owner());
    if (!cls.IsTopLevel()) {
      const Class& mixin = Class::Handle(cls.Mixin());
      printer->AddString(params.name_visibility == Object::kUserVisibleName
                             ? mixin.UserVisibleNameCString()
                             : cls.NameCString(params.name_visibility));
      printer->AddString(".");
    }
  }
 
  printer->AddString(fun.NameCString(params.name_visibility));
 
  // Dispatchers that are created with an arguments descriptor need both the
  // name and the saved arguments descriptor to disambiguate.
  if (params.disambiguate_names && fun.HasSavedArgumentsDescriptor()) {
    const auto& args_desc_array = Array::Handle(fun.saved_args_desc());
    const ArgumentsDescriptor args_desc(args_desc_array);
    args_desc.PrintTo(printer);
  }
}

GenerateBranches()

static void dart::GenerateBranches ( RegExpMacroAssembler *  masm, ZoneGrowableArray< uint16_t > *  ranges, intptr_t  start_index, intptr_t  end_index, uint16_t  min_char, uint16_t  max_char, BlockLabel *  fall_through, BlockLabel *  even_label, BlockLabel *  odd_label  )

static

Definition at line 1217 of file regexp.cc.

                                                    {
  uint16_t first = ranges->At(start_index);
  uint16_t last = ranges->At(end_index) - 1;
 
  ASSERT(min_char < first);
 
  // Just need to test if the character is before or on-or-after
  // a particular character.
  if (start_index == end_index) {
    EmitBoundaryTest(masm, first, fall_through, even_label, odd_label);
    return;
  }
 
  // Another almost trivial case:  There is one interval in the middle that is
  // different from the end intervals.
  if (start_index + 1 == end_index) {
    EmitDoubleBoundaryTest(masm, first, last, fall_through, even_label,
                           odd_label);
    return;
  }
 
  // It's not worth using table lookup if there are very few intervals in the
  // character class.
  if (end_index - start_index <= 6) {
    // It is faster to test for individual characters, so we look for those
    // first, then try arbitrary ranges in the second round.
    static intptr_t kNoCutIndex = -1;
    intptr_t cut = kNoCutIndex;
    for (intptr_t i = start_index; i < end_index; i++) {
      if (ranges->At(i) == ranges->At(i + 1) - 1) {
        cut = i;
        break;
      }
    }
    if (cut == kNoCutIndex) cut = start_index;
    CutOutRange(masm, ranges, start_index, end_index, cut, even_label,
                odd_label);
    ASSERT(end_index - start_index >= 2);
    GenerateBranches(masm, ranges, start_index + 1, end_index - 1, min_char,
                     max_char, fall_through, even_label, odd_label);
    return;
  }
 
  // If there are a lot of intervals in the regexp, then we will use tables to
  // determine whether the character is inside or outside the character class.
  const intptr_t kBits = RegExpMacroAssembler::kTableSizeBits;
 
  if ((max_char >> kBits) == (min_char >> kBits)) {
    EmitUseLookupTable(masm, ranges, start_index, end_index, min_char,
                       fall_through, even_label, odd_label);
    return;
  }
 
  if ((min_char >> kBits) != (first >> kBits)) {
    masm->CheckCharacterLT(first, odd_label);
    GenerateBranches(masm, ranges, start_index + 1, end_index, first, max_char,
                     fall_through, odd_label, even_label);
    return;
  }
 
  intptr_t new_start_index = 0;
  intptr_t new_end_index = 0;
  uint16_t border = 0;
 
  SplitSearchSpace(ranges, start_index, end_index, &new_start_index,
                   &new_end_index, &border);
 
  BlockLabel handle_rest;
  BlockLabel* above = &handle_rest;
  if (border == last + 1) {
    // We didn't find any section that started after the limit, so everything
    // above the border is one of the terminal labels.
    above = (end_index & 1) != (start_index & 1) ? odd_label : even_label;
    ASSERT(new_end_index == end_index - 1);
  }
 
  ASSERT(start_index <= new_end_index);
  ASSERT(new_start_index <= end_index);
  ASSERT(start_index < new_start_index);
  ASSERT(new_end_index < end_index);
  ASSERT(new_end_index + 1 == new_start_index ||
         (new_end_index + 2 == new_start_index &&
          border == ranges->At(new_end_index + 1)));
  ASSERT(min_char < border - 1);
  ASSERT(border < max_char);
  ASSERT(ranges->At(new_end_index) < border);
  ASSERT(border < ranges->At(new_start_index) ||
         (border == ranges->At(new_start_index) &&
          new_start_index == end_index && new_end_index == end_index - 1 &&
          border == last + 1));
  ASSERT(new_start_index == 0 || border >= ranges->At(new_start_index - 1));
 
  masm->CheckCharacterGT(border - 1, above);
  BlockLabel dummy;
  GenerateBranches(masm, ranges, start_index, new_end_index, min_char,
                   border - 1, &dummy, even_label, odd_label);
 
  if (handle_rest.is_linked()) {
    masm->BindBlock(&handle_rest);
    bool flip = (new_start_index & 1) != (start_index & 1);
    GenerateBranches(masm, ranges, new_start_index, end_index, border, max_char,
                     &dummy, flip ? odd_label : even_label,
                     flip ? even_label : odd_label);
  }
}

GenerateInvokeInstantiateTAVStub()

static void dart::GenerateInvokeInstantiateTAVStub ( compiler::Assembler *  assembler )

static

Definition at line 7947 of file object_test.cc.

  {
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_non_nullable_int, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_non_nullable_int));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
}
 
#define __ assembler->
 
static void GenerateInvokeInstantiateTAVStub(compiler::Assembler* assembler) {
  __ EnterDartFrame(0);
 
  // Load the arguments into the right stub calling convention registers.
  const intptr_t uninstantiated_offset =
      (kCallerSpSlotFromFp + 2) * compiler::target::kWordSize;
  const intptr_t inst_type_args_offset =
      (kCallerSpSlotFromFp + 1) * compiler::target::kWordSize;
  const intptr_t fun_type_args_offset =
      (kCallerSpSlotFromFp + 0) * compiler::target::kWordSize;
 
  __ LoadMemoryValue(InstantiationABI::kUninstantiatedTypeArgumentsReg, FPREG,
                     uninstantiated_offset);
  __ LoadMemoryValue(InstantiationABI::kInstantiatorTypeArgumentsReg, FPREG,
                     inst_type_args_offset);

GenerateInvokeTTSStub()

static void dart::GenerateInvokeTTSStub ( compiler::Assembler *  assembler )

static

Definition at line 69 of file type_testing_stubs_test.cc.

                                                                {
  auto calculate_breadcrumb = [](const Register& reg) {
    return 0x10 + 2 * (static_cast<intptr_t>(reg));
  };
 
  __ EnterDartFrame(0);
 
  for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
    if (((1 << i) & kDartAvailableCpuRegs) == 0) continue;
    if (((1 << i) & TypeTestABI::kAbiRegisters) != 0) continue;
    if (((1 << i) & TTSInternalRegs::kInternalRegisters) != 0) continue;
    const Register reg = static_cast<Register>(i);
    __ LoadImmediate(reg, calculate_breadcrumb(reg));
  }
 
  // Load the arguments into the right TTS calling convention registers.
  const intptr_t instance_offset =
      (kCallerSpSlotFromFp + 3) * compiler::target::kWordSize;
  const intptr_t inst_type_args_offset =
      (kCallerSpSlotFromFp + 2) * compiler::target::kWordSize;
  const intptr_t fun_type_args_offset =
      (kCallerSpSlotFromFp + 1) * compiler::target::kWordSize;
  const intptr_t dst_type_offset =
      (kCallerSpSlotFromFp + 0) * compiler::target::kWordSize;
 
  __ LoadMemoryValue(TypeTestABI::kInstanceReg, FPREG, instance_offset);
  __ LoadMemoryValue(TypeTestABI::kInstantiatorTypeArgumentsReg, FPREG,
                     inst_type_args_offset);
  __ LoadMemoryValue(TypeTestABI::kFunctionTypeArgumentsReg, FPREG,
                     fun_type_args_offset);
  __ LoadMemoryValue(TypeTestABI::kDstTypeReg, FPREG, dst_type_offset);
 
  const intptr_t subtype_test_cache_index = __ object_pool_builder().AddObject(
      Object::null_object(), compiler::ObjectPoolBuilderEntry::kPatchable);
  const intptr_t dst_name_index = __ object_pool_builder().AddObject(
      Symbols::OptimizedOut(), compiler::ObjectPoolBuilderEntry::kPatchable);
  ASSERT_EQUAL(subtype_test_cache_index + 1, dst_name_index);
  ASSERT(__ constant_pool_allowed());
 
  FlowGraphCompiler::GenerateIndirectTTSCall(
      assembler, TypeTestABI::kDstTypeReg, subtype_test_cache_index);
 
  // We have the guarantee that TTS preserves all input registers, if the TTS
  // handles the type test successfully.
  //
  // Let the test know which TTS abi registers were not preserved.
  ASSERT(((1 << static_cast<intptr_t>(TypeTestABI::kInstanceReg)) &
          TypeTestABI::kPreservedAbiRegisters) != 0);
  // First we check the instance register, freeing it up in case there are no
  // other safe registers to use since we need two registers: one to accumulate
  // the register mask, another to load the array address when saving the mask.
  __ LoadFromOffset(TypeTestABI::kScratchReg, FPREG, instance_offset);
  compiler::Label instance_matches, done_with_instance;
  __ CompareRegisters(TypeTestABI::kScratchReg, TypeTestABI::kInstanceReg);
  __ BranchIf(EQUAL, &instance_matches, compiler::Assembler::kNearJump);
  __ LoadImmediate(TypeTestABI::kScratchReg,
                   1 << static_cast<intptr_t>(TypeTestABI::kInstanceReg));
  __ Jump(&done_with_instance, compiler::Assembler::kNearJump);
  __ Bind(&instance_matches);
  __ LoadImmediate(TypeTestABI::kScratchReg, 0);
  __ Bind(&done_with_instance);
  for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
    if (((1 << i) & TypeTestABI::kPreservedAbiRegisters) == 0) continue;
    const Register reg = static_cast<Register>(i);
    compiler::Label done;
    switch (reg) {
      case TypeTestABI::kInstanceReg:
        // Skip the already handled instance register.
        continue;
      case TypeTestABI::kDstTypeReg:
        __ LoadFromOffset(TypeTestABI::kInstanceReg, FPREG, dst_type_offset);
        break;
      case TypeTestABI::kFunctionTypeArgumentsReg:
        __ LoadFromOffset(TypeTestABI::kInstanceReg, FPREG,
                          fun_type_args_offset);
        break;
      case TypeTestABI::kInstantiatorTypeArgumentsReg:
        __ LoadFromOffset(TypeTestABI::kInstanceReg, FPREG,
                          inst_type_args_offset);
        break;
      default:
        FATAL("Unexpected register %s", RegisterNames::RegisterName(reg));
        break;
    }
    __ CompareRegisters(reg, TypeTestABI::kInstanceReg);
    __ BranchIf(EQUAL, &done, compiler::Assembler::kNearJump);
    __ AddImmediate(TypeTestABI::kScratchReg, 1 << i);
    __ Bind(&done);
  }
  __ SmiTag(TypeTestABI::kScratchReg);
  __ LoadFromOffset(TypeTestABI::kInstanceReg, FPREG,
                    (kCallerSpSlotFromFp + 5) * compiler::target::kWordSize);
  __ StoreFieldToOffset(TypeTestABI::kScratchReg, TypeTestABI::kInstanceReg,
                        compiler::target::Array::element_offset(0));
 
  // Let the test know which non-TTS abi registers were not preserved.
  __ LoadImmediate(TypeTestABI::kScratchReg, 0);
  for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
    if (((1 << i) & kDartAvailableCpuRegs) == 0) continue;
    if (((1 << i) & TypeTestABI::kAbiRegisters) != 0) continue;
    const Register reg = static_cast<Register>(i);
    compiler::Label done;
    __ CompareImmediate(reg, calculate_breadcrumb(reg));
    __ BranchIf(EQUAL, &done, compiler::Assembler::kNearJump);
    __ AddImmediate(TypeTestABI::kScratchReg, 1 << i);
    __ Bind(&done);
  }
  __ SmiTag(TypeTestABI::kScratchReg);
  __ LoadFromOffset(TypeTestABI::kInstanceReg, FPREG,
                    (kCallerSpSlotFromFp + 4) * compiler::target::kWordSize);
  __ StoreFieldToOffset(TypeTestABI::kScratchReg, TypeTestABI::kInstanceReg,
                        compiler::target::Array::element_offset(0));
 
  // Set the return from the stub to be null.
  __ LoadObject(CallingConventions::kReturnReg, Object::null_object());
  __ LeaveDartFrame();
  __ Ret();
}

GetAllocationProfile()

static void dart::GetAllocationProfile ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4550 of file service.cc.

                                                                 {
  GetAllocationProfileImpl(thread, js, true);
}

GetAllocationProfileImpl()

static void dart::GetAllocationProfileImpl ( Thread *  thread, JSONStream *  js, bool  internal  )

static

Definition at line 4509 of file service.cc.

                                                    {
  bool should_reset_accumulator = false;
  bool should_collect = false;
  if (js->HasParam("reset")) {
    if (js->ParamIs("reset", "true")) {
      should_reset_accumulator = true;
    } else {
      PrintInvalidParamError(js, "reset");
      return;
    }
  }
  if (js->HasParam("gc")) {
    if (js->ParamIs("gc", "true")) {
      should_collect = true;
    } else {
      PrintInvalidParamError(js, "gc");
      return;
    }
  }
  auto isolate_group = thread->isolate_group();
  if (should_reset_accumulator) {
    isolate_group->UpdateLastAllocationProfileAccumulatorResetTimestamp();
  }
  if (should_collect) {
    isolate_group->UpdateLastAllocationProfileGCTimestamp();
    isolate_group->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
  isolate_group->class_table()->AllocationProfilePrintJSON(js, internal);
}

GetAllocationProfilePublic()

static void dart::GetAllocationProfilePublic ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4546 of file service.cc.

                                                                       {
  GetAllocationProfileImpl(thread, js, false);
}

GetAllocationTraces()

static void dart::GetAllocationTraces ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4467 of file service.cc.

                                                                {
  int64_t time_origin_micros =
      Int64Parameter::Parse(js->LookupParam("timeOriginMicros"));
  int64_t time_extent_micros =
      Int64Parameter::Parse(js->LookupParam("timeExtentMicros"));
  Isolate* isolate = thread->isolate();
 
  // Return only allocations for objects with classId.
  if (js->HasParam("classId")) {
    const char* class_id = js->LookupParam("classId");
    intptr_t cid = -1;
    GetPrefixedIntegerId(class_id, "classes/", &cid);
    if (IsValidClassId(isolate, cid)) {
      if (CheckProfilerDisabled(thread, js)) {
        return;
      }
      const Class& cls = Class::Handle(GetClassForId(isolate, cid));
      ProfilerService::PrintAllocationJSON(js, cls, time_origin_micros,
                                           time_extent_micros);
    } else {
      PrintInvalidParamError(js, "classId");
    }
  } else {
    // Otherwise, return allocations for all traced class IDs.
    if (CheckProfilerDisabled(thread, js)) {
      return;
    }
    ProfilerService::PrintAllocationJSON(js, time_origin_micros,
                                         time_extent_micros);
  }
}

GetAndValidateThreadStackBounds()

static bool dart::GetAndValidateThreadStackBounds ( OSThread *  os_thread, Thread *  thread, uintptr_t  fp, uintptr_t  sp, uword *  stack_lower, uword *  stack_upper  )

static

Definition at line 368 of file profiler.cc.

                                                                {
  ASSERT(os_thread != nullptr);
  ASSERT(stack_lower != nullptr);
  ASSERT(stack_upper != nullptr);
 
#if defined(USING_SIMULATOR)
  const bool use_simulator_stack_bounds =
      thread != nullptr && thread->IsExecutingDartCode();
  if (use_simulator_stack_bounds) {
    Isolate* isolate = thread->isolate();
    ASSERT(isolate != nullptr);
    Simulator* simulator = isolate->simulator();
    *stack_lower = simulator->stack_limit();
    *stack_upper = simulator->stack_base();
  }
#else
  const bool use_simulator_stack_bounds = false;
#endif  // defined(USING_SIMULATOR)
 
  if (!use_simulator_stack_bounds) {
    *stack_lower = os_thread->stack_limit();
    *stack_upper = os_thread->stack_base();
  }
 
  if ((*stack_lower == 0) || (*stack_upper == 0)) {
    return false;
  }
 
  if (!use_simulator_stack_bounds && (sp > *stack_lower)) {
    // The stack pointer gives us a tighter lower bound.
    *stack_lower = sp;
  }
 
  return ValidateThreadStackBounds(fp, sp, *stack_lower, *stack_upper);
}

GetAssetLocation()

static ArrayPtr dart::GetAssetLocation ( Thread *const  thread, const String &  asset  )

static

Definition at line 332 of file ffi_dynamic_library.cc.

                                                                            {
  Zone* const zone = thread->zone();
  auto& result = Array::Handle(zone);
 
  const auto& native_assets_map =
      Array::Handle(zone, GetNativeAssetsMap(thread));
  if (!native_assets_map.IsNull()) {
    NativeAssetsMap map(native_assets_map.ptr());
    const auto& lookup = Object::Handle(zone, map.GetOrNull(asset));
    if (!lookup.IsNull()) {
      result = Array::Cast(lookup).ptr();
    }
    map.Release();
  }
  return result.ptr();
}

GetByteBufferConstructor()

static ObjectPtr dart::GetByteBufferConstructor ( Thread *  thread, const String &  class_name, const String &  constructor_name, intptr_t  num_args  )

static

Definition at line 3956 of file dart_api_impl.cc.

                                                             {
  const Library& lib = Library::Handle(
      thread->isolate_group()->object_store()->typed_data_library());
  ASSERT(!lib.IsNull());
  const Class& cls =
      Class::Handle(thread->zone(), lib.LookupClassAllowPrivate(class_name));
  ASSERT(!cls.IsNull());
  return ResolveConstructor(CURRENT_FUNC, cls, class_name, constructor_name,
                            num_args);
}

GetCallerLocation()

static TokenPosition dart::GetCallerLocation ( )

static

Definition at line 514 of file runtime_entry.cc.

                                         {
  DartFrameIterator iterator(Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame != nullptr);
  return caller_frame->GetTokenPos();
}

GetCaseIndependentLetters()

static intptr_t dart::GetCaseIndependentLetters ( uint16_t  character, bool  one_byte_subject, int32_t *  letters  )

static

Definition at line 861 of file regexp.cc.

                                                            {
  unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize;
  intptr_t length = jsregexp_uncanonicalize.get(character, '\0', letters);
  // Unibrow returns 0 or 1 for characters where case independence is
  // trivial.
  if (length == 0) {
    letters[0] = character;
    length = 1;
  }
  if (!one_byte_subject || character <= Symbols::kMaxOneCharCodeSymbol) {
    return length;
  }
 
  // The standard requires that non-ASCII characters cannot have ASCII
  // character codes in their equivalence class.
  // TODO(dcarney): issue 3550 this is not actually true for Latin1 anymore,
  // is it?  For example, \u00C5 is equivalent to \u212B.
  return 0;
}

GetClass()

static ClassPtr dart::GetClass	(	const Library &	lib,
		const char *	name
	)

Definition at line 64 of file il_test_helper.cc.

                                                        {
  Thread* thread = Thread::Current();
  const auto& cls = Class::Handle(
      lib.LookupClassAllowPrivate(String::Handle(Symbols::New(thread, name))));
  EXPECT(!cls.IsNull());
  return cls.ptr();
}

GetClassForId()

static ClassPtr dart::GetClassForId ( Isolate *  isolate, intptr_t  cid  )

static

Definition at line 674 of file service.cc.

                                                              {
  ASSERT(isolate == Isolate::Current());
  ASSERT(isolate != nullptr);
  ClassTable* class_table = isolate->group()->class_table();
  ASSERT(class_table != nullptr);
  return class_table->At(cid);
}

GetClassList()

static void dart::GetClassList ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5159 of file service.cc.

                                                         {
  ClassTable* table = thread->isolate_group()->class_table();
  JSONObject jsobj(js);
  table->PrintToJSONObject(&jsobj);
}

GetClassTypeParameter()

TypeParameterPtr dart::GetClassTypeParameter	(	const Class &	klass,
		intptr_t	index
	)

Definition at line 72 of file il_test_helper.cc.

                                                                           {
  const auto& param = TypeParameter::Handle(klass.TypeParameterAt(index));
  EXPECT(!param.IsNull());
  return param.ptr();
}

GetCodeAndEntryPointByIndex()

template<bool need_entry_point_for_non_discarded>

static DART_FORCE_INLINE CodePtr dart::GetCodeAndEntryPointByIndex ( const Deserializer *  d, intptr_t  code_index, uword *  entry_point  )

static

Definition at line 1799 of file app_snapshot.cc.

                        {
  code_index -= 1;  // 0 is reserved for LazyCompile stub.
 
  // In root unit and VM isolate snapshot code_indices are self-contained
  // they point into instruction table and/or into the code cluster.
  // In non-root units we might also refer to code objects from the
  // parent unit which means code_index is biased by num_base_objects_
  const intptr_t base = d->is_non_root_unit() ? d->num_base_objects() : 0;
  if (code_index < base) {
    CodePtr code = static_cast<CodePtr>(d->Ref(code_index));
    if (need_entry_point_for_non_discarded) {
      *entry_point = Code::EntryPointOf(code);
    }
    return code;
  }
  code_index -= base;
 
  // At this point code_index is referring to a code object which is either
  // discarded or exists in the Code cluster. Non-discarded Code objects
  // are associated with the tail of the instruction table and have the
  // same order there and in the Code cluster. This means that
  // subtracting first_entry_with_code yields index into the Code cluster.
  // This also works for deferred code objects in root unit's snapshot
  // due to the choice of encoding (see Serializer::GetCodeIndex).
  const intptr_t first_entry_with_code =
      d->instructions_table().rodata()->first_entry_with_code;
  if (code_index < first_entry_with_code) {
    *entry_point = d->instructions_table().EntryPointAt(code_index);
    return StubCode::UnknownDartCode().ptr();
  } else {
    const intptr_t cluster_index = code_index - first_entry_with_code;
    CodePtr code =
        static_cast<CodePtr>(d->Ref(d->code_start_index() + cluster_index));
    if (need_entry_point_for_non_discarded) {
      *entry_point = Code::EntryPointOf(code);
    }
    return code;
  }
}

GetCodeId()

static bool dart::GetCodeId ( const char *  s, int64_t *  timestamp, uword *  address  )

static

Definition at line 617 of file service.cc.

                                                                         {
  if ((s == nullptr) || (*s == '\0')) {
    // Empty string.
    return false;
  }
  if ((timestamp == nullptr) || (address == nullptr)) {
    // Bad arguments.
    return false;
  }
  // Extract the timestamp.
  if (!GetInteger64Id(s, timestamp, 16) || (*timestamp < 0)) {
    return false;
  }
  s = ScanUntilDash(s);
  if (s == nullptr) {
    return false;
  }
  // Skip the dash.
  s++;
  // Extract the PC.
  if (!GetUnsignedIntegerId(s, address, 16)) {
    return false;
  }
  return true;
}

GetCpuSamples()

static void dart::GetCpuSamples ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4455 of file service.cc.

                                                          {
  GetCpuSamplesCommon(TimelineOrSamplesResponseFormat::JSON, thread, js);
}

GetCpuSamplesCommon()

static void dart::GetCpuSamplesCommon ( TimelineOrSamplesResponseFormat  format, Thread *  thread, JSONStream *  js  )

static

Definition at line 4148 of file service.cc.

                                                {
  const int64_t time_origin_micros =
      Int64Parameter::Parse(js->LookupParam("timeOriginMicros"));
  const int64_t time_extent_micros =
      Int64Parameter::Parse(js->LookupParam("timeExtentMicros"));
  const bool include_code_samples =
      BoolParameter::Parse(js->LookupParam("_code"), false);
  if (CheckProfilerDisabled(thread, js)) {
    return;
  }
 
  if (format == TimelineOrSamplesResponseFormat::JSON) {
    ProfilerService::PrintJSON(js, time_origin_micros, time_extent_micros,
                               include_code_samples);
  } else if (format == TimelineOrSamplesResponseFormat::Perfetto) {
#if defined(SUPPORT_PERFETTO)
    // This branch will never be reached when SUPPORT_PERFETTO is not defined,
    // because |GetPerfettoCpuSamples| is not defined when SUPPORT_PERFETTO is
    // not defined.
    ProfilerService::PrintPerfetto(js, time_origin_micros, time_extent_micros);
#else
    UNREACHABLE();
#endif  // defined(SUPPORT_PERFETTO)
  }
}

GetCurrentStackTrace()

const StackTrace & dart::GetCurrentStackTrace

(

int

skip_frames

)

Definition at line 94 of file stacktrace.cc.

                                                        {
  Zone* zone = Thread::Current()->zone();
  const GrowableObjectArray& code_list =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  GrowableArray<uword> pc_offset_list;
  AppendFrames(code_list, &pc_offset_list, skip_frames);
 
  const StackTrace& stacktrace = StackTrace::Handle(
      zone, CreateStackTraceObject(zone, code_list, pc_offset_list));
  return stacktrace;
}

GetDefaultClassesAliases()

static void dart::GetDefaultClassesAliases ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5767 of file service.cc.

                                                                     {
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "ClassesAliasesMap");
 
  JSONObject map(&jsobj, "map");
 
#define DEFINE_ADD_VALUE_F(id)                                                 \
  internals.AddValueF("classes/%" Pd, static_cast<intptr_t>(id));
#define DEFINE_ADD_VALUE_F_CID(clazz) DEFINE_ADD_VALUE_F(k##clazz##Cid)
  {
    JSONArray internals(&map, "<VM Internals>");
    for (intptr_t id = kFirstInternalOnlyCid; id <= kLastInternalOnlyCid;
         ++id) {
      DEFINE_ADD_VALUE_F(id);
    }
    DEFINE_ADD_VALUE_F_CID(LibraryPrefix);
  }
  {
    JSONArray internals(&map, "Type");
    for (intptr_t id = kAbstractTypeCid; id <= kTypeParameterCid; ++id) {
      DEFINE_ADD_VALUE_F(id);
    }
  }
  {
    JSONArray internals(&map, "Object");
    DEFINE_ADD_VALUE_F_CID(Instance);
  }
  {
    JSONArray internals(&map, "Closure");
    DEFINE_ADD_VALUE_F_CID(Closure);
    DEFINE_ADD_VALUE_F_CID(Context);
  }
  {
    JSONArray internals(&map, "Int");
    for (intptr_t id = kIntegerCid; id <= kMintCid; ++id) {
      DEFINE_ADD_VALUE_F(id);
    }
  }
  {
    JSONArray internals(&map, "Double");
    DEFINE_ADD_VALUE_F_CID(Double);
  }
  {
    JSONArray internals(&map, "String");
    CLASS_LIST_STRINGS(DEFINE_ADD_VALUE_F_CID)
  }
  {
    JSONArray internals(&map, "List");
    CLASS_LIST_ARRAYS(DEFINE_ADD_VALUE_F_CID)
    DEFINE_ADD_VALUE_F_CID(ByteBuffer)
  }
  {
    JSONArray internals(&map, "Map");
    CLASS_LIST_MAPS(DEFINE_ADD_VALUE_F_CID)
  }
 
  {
    JSONArray internals(&map, "Set");
    CLASS_LIST_SETS(DEFINE_ADD_VALUE_F_CID)
  }
#define DEFINE_ADD_MAP_KEY(clazz)                                              \
  {JSONArray internals(&map, #clazz);                                          \
  DEFINE_ADD_VALUE_F_CID(TypedData##clazz)                                     \
  DEFINE_ADD_VALUE_F_CID(TypedData##clazz##View)                               \
  DEFINE_ADD_VALUE_F_CID(ExternalTypedData##clazz)                             \
  DEFINE_ADD_VALUE_F_CID(UnmodifiableTypedData##clazz##View)                   \
  }
  CLASS_LIST_TYPED_DATA(DEFINE_ADD_MAP_KEY)
#undef DEFINE_ADD_MAP_KEY
#define DEFINE_ADD_MAP_KEY(clazz)                                              \
  {JSONArray internals(&map, #clazz);                                          \
  DEFINE_ADD_VALUE_F_CID(Ffi##clazz)                                           \
  }
  CLASS_LIST_FFI(DEFINE_ADD_MAP_KEY)
#undef DEFINE_ADD_MAP_KEY
#undef DEFINE_ADD_VALUE_F_CID
#undef DEFINE_ADD_VALUE_F
}

GetDummyTarget()

static FunctionPtr dart::GetDummyTarget ( const char *  name )

static

Definition at line 3011 of file object_test.cc.

                                                    {
  const String& function_name =
      String::Handle(Symbols::New(Thread::Current(), name));
  const Class& cls =
      Class::Handle(CreateDummyClass(function_name, Script::Handle()));
  const bool is_static = false;
  const bool is_const = false;
  const bool is_abstract = false;
  const bool is_external = false;
  const bool is_native = false;
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  return Function::New(signature, function_name,
                       UntaggedFunction::kRegularFunction, is_static, is_const,
                       is_abstract, is_external, is_native, cls,
                       TokenPosition::kMinSource);
}

GetEdgeCount()

static intptr_t dart::GetEdgeCount ( const Array &  edge_counters, intptr_t  edge_id  )

static

Definition at line 14 of file block_scheduler.cc.

                                                                           {
  if (!FLAG_reorder_basic_blocks) {
    // Assume everything was visited once.
    return 1;
  }
  return Smi::Value(Smi::RawCast(edge_counters.At(edge_id)));
}

GetElementTypeFromArray()

static AbstractTypePtr dart::GetElementTypeFromArray ( Value *  array )

static

Definition at line 1850 of file type_propagator.cc.

                                                             {
  // Sometimes type of definition may contain a static type
  // which is useful to extract element type, but reaching type
  // only has a cid. So try out type of definition, if any.
  if (array->definition()->HasType()) {
    auto& elem_type = AbstractType::Handle(ExtractElementTypeFromArrayType(
        *(array->definition()->Type()->ToAbstractType())));
    if (!elem_type.IsDynamicType()) {
      return elem_type.ptr();
    }
  }
  return ExtractElementTypeFromArrayType(*(array->Type()->ToAbstractType()));
}

GetErrorString()

static const char * dart::GetErrorString ( Thread *  thread, const Object &  obj  )

static

Definition at line 335 of file dart_api_impl.cc.

                                                                     {
  // This function requires an API scope to be present.
  if (obj.IsError()) {
    ASSERT(thread->api_top_scope() != nullptr);
    const Error& error = Error::Cast(obj);
    const char* str = error.ToErrorCString();
    intptr_t len = strlen(str) + 1;
    char* str_copy = Api::TopScope(thread)->zone()->Alloc<char>(len);
    strncpy(str_copy, str, len);
    // Strip a possible trailing '\n'.
    if ((len > 1) && (str_copy[len - 2] == '\n')) {
      str_copy[len - 2] = '\0';
    }
    return str_copy;
  } else {
    return "";
  }
}

GetEscapedValue()

static int dart::GetEscapedValue ( const char *  str, intptr_t  pos, intptr_t  len  )

static

Definition at line 62 of file uri.cc.

                                                                        {
  if (pos + 2 >= len) {
    // Not enough room for a valid escape sequence.
    return -1;
  }
  if (str[pos] != '%') {
    // Escape sequences start with '%'.
    return -1;
  }
 
  char digit1 = str[pos + 1];
  char digit2 = str[pos + 2];
  if (!IsHexDigit(digit1) || !IsHexDigit(digit2)) {
    // Invalid escape sequence.  Ignore it.
    return -1;
  }
  return HexValue(digit1) * 16 + HexValue(digit2);
}

GetExperimentalFeatureDefault()

bool dart::GetExperimentalFeatureDefault

(

ExperimentalFeature

feature

)

Definition at line 17 of file experimental_features.cc.

                                                                {
  constexpr bool kFeatureValues[] = {
      true, true, true, true, true, true, true, true, true, true, true,
      true, true, true, true, true, true, true, true, true, true, true,
  };
  ASSERT(static_cast<size_t>(feature) < ARRAY_SIZE(kFeatureValues));
  return kFeatureValues[static_cast<int>(feature)];
}

GetExperimentalFeatureName()

const char * dart::GetExperimentalFeatureName

(

ExperimentalFeature

feature

)

Definition at line 26 of file experimental_features.cc.

                                                                    {
  constexpr const char* kFeatureNames[] = {
      "inference-update-3",
      "inline-class",
      "inference-update-2",
      "sealed-class",
      "class-modifiers",
      "records",
      "patterns",
      "unnamed-libraries",
      "inference-update-1",
      "enhanced-enums",
      "named-arguments-anywhere",
      "super-parameters",
      "constructor-tearoffs",
      "generic-metadata",
      "triple-shift",
      "nonfunction-type-aliases",
      "non-nullable",
      "extension-methods",
      "constant-update-2018",
      "control-flow-collections",
      "set-literals",
      "spread-collections",
  };
  ASSERT(static_cast<size_t>(feature) < ARRAY_SIZE(kFeatureNames));
  return kFeatureNames[static_cast<int>(feature)];
}

GetFfiNativeResolver()

static Dart_FfiNativeResolver dart::GetFfiNativeResolver ( Thread *const  thread, const String &  lib_url_str  )

static

Definition at line 257 of file ffi_dynamic_library.cc.

                                                                              {
  const Library& lib =
      Library::Handle(Library::LookupLibrary(thread, lib_url_str));
  if (lib.IsNull()) {
    // It is not an error to not have a native resolver installed.
    return nullptr;
  }
  return lib.ffi_native_resolver();
}

GetField()

static FieldPtr dart::GetField ( const Class &  cls, const char *  name  )

static

Definition at line 5310 of file object_test.cc.

                                                             {
  const Field& field =
      Field::Handle(cls.LookupField(String::Handle(String::New(name))));
  EXPECT(!field.IsNull());
  return field.ptr();
}

GetFlagList()

static void dart::GetFlagList ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5598 of file service.cc.

                                                        {
  Flags::PrintJSON(js);
}

GetForwardedObject()

static ObjectPtr dart::GetForwardedObject ( ObjectPtr  object )

static

Definition at line 54 of file become.cc.

                                                      {
  ASSERT(IsForwardingObject(object));
  uword addr = static_cast<uword>(object) - kHeapObjectTag;
  ForwardingCorpse* forwarder = reinterpret_cast<ForwardingCorpse*>(addr);
  return forwarder->target();
}

GetFunction() [1/3]

static FunctionPtr dart::GetFunction ( const Class &  cls, const char *  name  )

static

Definition at line 5291 of file object_test.cc.

                                                                   {
  Thread* thread = Thread::Current();
  const auto& error = cls.EnsureIsFinalized(thread);
  EXPECT(error == Error::null());
  const Function& result = Function::Handle(Resolver::ResolveDynamicFunction(
      Z, cls, String::Handle(String::New(name))));
  EXPECT(!result.IsNull());
  return result.ptr();
}

GetFunction() [2/3]

static FunctionPtr dart::GetFunction ( const Class &  cls, const char *  name  )

static

Definition at line 122 of file service_test.cc.

                                                                   {
  const Function& result = Function::Handle(Resolver::ResolveDynamicFunction(
      Thread::Current()->zone(), cls, String::Handle(String::New(name))));
  EXPECT(!result.IsNull());
  return result.ptr();
}

GetFunction() [3/3]

static FunctionPtr dart::GetFunction	(	const Library &	lib,
		const char *	name
	)

Definition at line 56 of file il_test_helper.cc.

                                                              {
  Thread* thread = Thread::Current();
  const auto& func = Function::Handle(lib.LookupFunctionAllowPrivate(
      String::Handle(Symbols::New(thread, name))));
  EXPECT(!func.IsNull());
  return func.ptr();
}

GetFunctionTypeParameter()

TypeParameterPtr dart::GetFunctionTypeParameter	(	const Function &	fun,
		intptr_t	index
	)

Definition at line 78 of file il_test_helper.cc.

                                                                               {
  const auto& param = TypeParameter::Handle(fun.TypeParameterAt(index));
  EXPECT(!param.IsNull());
  return param.ptr();
}

GetGlobalStruct()

DART_EXPORT Coord dart::GetGlobalStruct

(

)

Definition at line 63 of file ffi_test_functions.cc.

                                    {
  return globalStruct;
}

GetGlobalVar()

DART_EXPORT int32_t dart::GetGlobalVar

(

)

Definition at line 59 of file ffi_test_functions.cc.

                                   {
  return globalInt;
}

GetHash()

static intptr_t dart::GetHash ( Isolate *  isolate, const ObjectPtr  obj  )

static

Definition at line 37 of file object.cc.

                                                               {
#if defined(HASH_IN_OBJECT_HEADER)
  return Object::GetCachedHash(obj);
#else
  Heap* heap = isolate->group()->heap();
  ASSERT(obj->IsDartInstance());
  return heap->GetHash(obj);
#endif
}

GetHeapMap()

static void dart::GetHeapMap ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4570 of file service.cc.

                                                       {
  auto isolate_group = thread->isolate_group();
  if (js->HasParam("gc")) {
    if (js->ParamIs("gc", "scavenge")) {
      isolate_group->heap()->CollectGarbage(thread, GCType::kScavenge,
                                            GCReason::kDebugging);
    } else if (js->ParamIs("gc", "mark-sweep")) {
      isolate_group->heap()->CollectGarbage(thread, GCType::kMarkSweep,
                                            GCReason::kDebugging);
    } else if (js->ParamIs("gc", "mark-compact")) {
      isolate_group->heap()->CollectGarbage(thread, GCType::kMarkCompact,
                                            GCReason::kDebugging);
    } else {
      PrintInvalidParamError(js, "gc");
      return;
    }
  }
  isolate_group->heap()->PrintHeapMapToJSONStream(isolate_group, js);
}

GetHeapObjectCommon()

static bool dart::GetHeapObjectCommon ( Thread *  thread, JSONStream *  js, const char *  id, Object *  obj, ObjectIdRing::LookupResult *  lookup_result  )

static

Definition at line 5009 of file service.cc.

                                                                         {
  *obj = LookupHeapObject(thread, id, lookup_result);
  ASSERT(obj != nullptr);
  ASSERT(lookup_result != nullptr);
  if (obj->ptr() != Object::sentinel().ptr()) {
#if !defined(DART_PRECOMPILED_RUNTIME)
    // If obj is a script from dart:* and doesn't have source loaded, try and
    // load the source before sending the response.
    if (obj->IsScript()) {
      const Script& script = Script::Cast(*obj);
      if (!script.HasSource() && script.IsPartOfDartColonLibrary() &&
          Service::HasDartLibraryKernelForSources()) {
        const uint8_t* kernel_buffer = Service::dart_library_kernel();
        const intptr_t kernel_buffer_len =
            Service::dart_library_kernel_length();
        script.LoadSourceFromKernel(kernel_buffer, kernel_buffer_len);
      }
    }
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
    // We found a heap object for this id.
    return true;
  }
 
  return false;
}

GetHexCharacter()

static int32_t dart::GetHexCharacter ( int32_t  c )

static

Definition at line 23975 of file object.cc.

                                          {
  ASSERT(c >= 0);
  ASSERT(c < 16);
  const char* hex = "0123456789ABCDEF";
  return hex[c];
}

GetHexValue()

static int32_t dart::GetHexValue ( int32_t  c )

static

Definition at line 23982 of file object.cc.

                                      {
  if (c >= '0' && c <= '9') {
    return c - '0';
  }
  if (c >= 'A' && c <= 'F') {
    return c - 'A' + 10;
  }
  UNREACHABLE();
  return 0;
}

GetImplementationFields()

static void dart::GetImplementationFields ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5102 of file service.cc.

                                                                    {
  const char* id = js->LookupParam("objectId");
 
  // Handle heap objects.
  Object& obj = Object::Handle();
  ObjectIdRing::LookupResult lookup_result;
  if (GetHeapObjectCommon(thread, js, id, &obj, &lookup_result)) {
    obj.PrintImplementationFields(js);
    return;
  } else if (lookup_result == ObjectIdRing::kCollected) {
    PrintSentinel(js, kCollectedSentinel);
    return;
  } else if (lookup_result == ObjectIdRing::kExpired) {
    PrintSentinel(js, kExpiredSentinel);
    return;
  }
 
  // Handle non-heap objects.
  Breakpoint* bpt = LookupBreakpoint(thread->isolate(), id, &lookup_result);
  if (bpt != nullptr) {
    const JSONObject jsobj(js);
    jsobj.AddProperty("type", "ImplementationFields");
    JSONArray jsarr_fields(&jsobj, "fields");
    return;
  } else if (lookup_result == ObjectIdRing::kCollected) {
    PrintSentinel(js, kCollectedSentinel);
    return;
  }
 
  PrintInvalidParamError(js, "objectId");
}

GetInboundReferences()

static void dart::GetInboundReferences ( Thread *  thread, JSONStream *  js  )

static

Definition at line 2368 of file service.cc.

                                                                 {
  const char* target_id = js->LookupParam("targetId");
  if (target_id == nullptr) {
    PrintMissingParamError(js, "targetId");
    return;
  }
  const char* limit_cstr = js->LookupParam("limit");
  if (limit_cstr == nullptr) {
    PrintMissingParamError(js, "limit");
    return;
  }
  intptr_t limit;
  if (!GetIntegerId(limit_cstr, &limit)) {
    PrintInvalidParamError(js, "limit");
    return;
  }
 
  Object& obj = Object::Handle(thread->zone());
  ObjectIdRing::LookupResult lookup_result;
  {
    HANDLESCOPE(thread);
    obj = LookupHeapObject(thread, target_id, &lookup_result);
  }
  if (obj.ptr() == Object::sentinel().ptr()) {
    if (lookup_result == ObjectIdRing::kCollected) {
      PrintSentinel(js, kCollectedSentinel);
    } else if (lookup_result == ObjectIdRing::kExpired) {
      PrintSentinel(js, kExpiredSentinel);
    } else {
      PrintInvalidParamError(js, "targetId");
    }
    return;
  }
  PrintInboundReferences(thread, &obj, limit, js);
}

GetInputRange()

static const Range * dart::GetInputRange ( RangeAnalysis *  analysis, RangeBoundary::RangeSize  size, Value *  input  )

static

Definition at line 2760 of file range_analysis.cc.

                                                {
  switch (size) {
    case RangeBoundary::kRangeBoundarySmi:
      return analysis->GetSmiRange(input);
    case RangeBoundary::kRangeBoundaryInt8:
    case RangeBoundary::kRangeBoundaryInt16:
    case RangeBoundary::kRangeBoundaryInt32:
      return input->definition()->range();
    case RangeBoundary::kRangeBoundaryInt64:
      return analysis->GetIntRange(input);
    default:
      UNREACHABLE();
      return nullptr;
  }
}

GetInstances()

static void dart::GetInstances ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3541 of file service.cc.

                                                         {
  const char* object_id = js->LookupParam("objectId");
  const intptr_t limit = UIntParameter::Parse(js->LookupParam("limit"));
  const bool include_subclasses =
      BoolParameter::Parse(js->LookupParam("includeSubclasses"), false);
  const bool include_implementers =
      BoolParameter::Parse(js->LookupParam("includeImplementers"), false);
 
  const Object& obj =
      Object::Handle(LookupHeapObject(thread, object_id, nullptr));
  if (obj.ptr() == Object::sentinel().ptr() || !obj.IsClass()) {
    PrintInvalidParamError(js, "objectId");
    return;
  }
  const Class& cls = Class::Cast(obj);
 
  // Ensure the array and handles created below are promptly destroyed.
  StackZone zone(thread);
 
  ZoneGrowableHandlePtrArray<Object> storage(thread->zone(), limit);
  GetInstancesVisitor visitor(&storage, limit);
  {
    ObjectGraph graph(thread);
    HeapIterationScope iteration_scope(Thread::Current(), true);
    MarkClasses(cls, include_subclasses, include_implementers);
    graph.IterateObjects(&visitor);
    UnmarkClasses();
  }
  intptr_t count = visitor.count();
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "InstanceSet");
  jsobj.AddProperty("totalCount", count);
  {
    JSONArray samples(&jsobj, "instances");
    for (int i = 0; (i < limit) && (i < count); i++) {
      samples.AddValue(storage.At(i));
    }
  }
}

GetInstancesAsList()

static void dart::GetInstancesAsList ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3589 of file service.cc.

                                                               {
  const char* object_id = js->LookupParam("objectId");
  bool include_subclasses =
      BoolParameter::Parse(js->LookupParam("includeSubclasses"), false);
  bool include_implementers =
      BoolParameter::Parse(js->LookupParam("includeImplementers"), false);
 
  const Object& obj =
      Object::Handle(LookupHeapObject(thread, object_id, nullptr));
  if (obj.ptr() == Object::sentinel().ptr() || !obj.IsClass()) {
    PrintInvalidParamError(js, "objectId");
    return;
  }
  const Class& cls = Class::Cast(obj);
 
  Array& instances = Array::Handle();
  {
    // Ensure the |ZoneGrowableHandlePtrArray| and handles created below are
    // promptly destroyed.
    StackZone zone(thread);
 
    ZoneGrowableHandlePtrArray<Object> storage(thread->zone(), 1024);
    GetInstancesVisitor visitor(&storage, kSmiMax);
    {
      ObjectGraph graph(thread);
      HeapIterationScope iteration_scope(Thread::Current(), true);
      MarkClasses(cls, include_subclasses, include_implementers);
      graph.IterateObjects(&visitor);
      UnmarkClasses();
    }
    intptr_t count = visitor.count();
    instances = Array::New(count);
    for (intptr_t i = 0; i < count; i++) {
      instances.SetAt(i, storage.At(i));
    }
  }
  instances.PrintJSON(js, /*ref=*/true);
}

GetInteger64Id()

static bool dart::GetInteger64Id ( const char *  s, int64_t *  id, int  base = 10  )

static

Definition at line 581 of file service.cc.

                                                                      {
  if ((s == nullptr) || (*s == '\0')) {
    // Empty string.
    return false;
  }
  if (id == nullptr) {
    // No id pointer.
    return false;
  }
  int64_t r = 0;
  char* end_ptr = nullptr;
  r = strtoll(s, &end_ptr, base);
  if (end_ptr == s) {
    // String was not advanced at all, cannot be valid.
    return false;
  }
  *id = r;
  return true;
}

GetIntegerId()

static bool dart::GetIntegerId ( const char *  s, intptr_t *  id, int  base = 10  )

static

Definition at line 533 of file service.cc.

                                                                     {
  if ((s == nullptr) || (*s == '\0')) {
    // Empty string.
    return false;
  }
  if (id == nullptr) {
    // No id pointer.
    return false;
  }
  intptr_t r = 0;
  char* end_ptr = nullptr;
#if defined(ARCH_IS_32_BIT)
  r = strtol(s, &end_ptr, base);
#else
  r = strtoll(s, &end_ptr, base);
#endif
  if (end_ptr == s) {
    // String was not advanced at all, cannot be valid.
    return false;
  }
  *id = r;
  return true;
}

GetIsolate()

static void dart::GetIsolate ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1520 of file service.cc.

                                                       {
  thread->isolate()->PrintJSON(js, false);
}

GetIsolateGroup()

static void dart::GetIsolateGroup ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1601 of file service.cc.

                                                            {
  ActOnIsolateGroup(js, [&](IsolateGroup* isolate_group) {
    isolate_group->PrintJSON(js, false);
  });
}

GetIsolateGroupMemoryUsage()

static void dart::GetIsolateGroupMemoryUsage ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1621 of file service.cc.

                                                                       {
  ActOnIsolateGroup(js, [&](IsolateGroup* isolate_group) {
    isolate_group->PrintMemoryUsageJSON(js);
  });
}

GetIsolateMetric()

static void dart::GetIsolateMetric ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4128 of file service.cc.

                                                             {
  const char* metric_id = js->LookupParam("metricId");
  if (metric_id == nullptr) {
    PrintMissingParamError(js, "metricId");
    return;
  }
  // Verify id begins with "metrics/native/".
  static const char* const kNativeMetricIdPrefix = "metrics/native/";
  static intptr_t kNativeMetricIdPrefixLen = strlen(kNativeMetricIdPrefix);
  if (strncmp(metric_id, kNativeMetricIdPrefix, kNativeMetricIdPrefixLen) !=
      0) {
    PrintInvalidParamError(js, "metricId");
    return;
  }
  const char* id = metric_id + kNativeMetricIdPrefixLen;
  HandleNativeMetric(thread, js, id);
}

GetIsolateMetricList()

static void dart::GetIsolateMetricList ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4110 of file service.cc.

                                                                 {
  if (js->HasParam("type")) {
    if (!js->ParamIs("type", "Native")) {
      PrintInvalidParamError(js, "type");
      return;
    }
  } else {
    PrintMissingParamError(js, "type");
    return;
  }
  HandleNativeMetricsList(thread, js);
}

GetIsolateObjectStore()

static void dart::GetIsolateObjectStore ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5149 of file service.cc.

                                                                  {
  JSONObject jsobj(js);
  thread->isolate()->isolate_object_store()->PrintToJSONObject(&jsobj);
}

GetIsolatePauseEvent()

static void dart::GetIsolatePauseEvent ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1632 of file service.cc.

                                                                 {
  thread->isolate()->PrintPauseEventJSON(js);
}

GetJSONRpcErrorMessage()

static const char * dart::GetJSONRpcErrorMessage ( intptr_t  code )

static

Definition at line 106 of file json_stream.cc.

                                                         {
  switch (code) {
    case kParseError:
      return "Parse error";
    case kInvalidRequest:
      return "Invalid Request";
    case kMethodNotFound:
      return "Method not found";
    case kInvalidParams:
      return "Invalid params";
    case kInternalError:
      return "Internal error";
    case kFeatureDisabled:
      return "Feature is disabled";
    case kCannotAddBreakpoint:
      return "Cannot add breakpoint";
    case kStreamAlreadySubscribed:
      return "Stream already subscribed";
    case kStreamNotSubscribed:
      return "Stream not subscribed";
    case kIsolateMustBeRunnable:
      return "Isolate must be runnable";
    case kIsolateMustBePaused:
      return "Isolate must be paused";
    case kCannotResume:
      return "Cannot resume execution";
    case kIsolateIsReloading:
      return "Isolate is reloading";
    case kIsolateReloadBarred:
      return "Isolate cannot be reloaded";
    case kIsolateMustHaveReloaded:
      return "Isolate must have reloaded";
    case kFileSystemAlreadyExists:
      return "File system already exists";
    case kFileSystemDoesNotExist:
      return "File system does not exist";
    case kFileDoesNotExist:
      return "File does not exist";
    case kInvalidTimelineRequest:
      return "The timeline related request could not be completed due to the "
             "current configuration";
    default:
      return "Extension error";
  }
}

GetLastErrorAsString()

static void dart::GetLastErrorAsString ( char **  error )

static

Definition at line 261 of file utils.cc.

                                               {
  if (error == nullptr) return;  // Nothing to do.
 
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_MACOS) ||              \
    defined(DART_HOST_OS_ANDROID) || defined(DART_HOST_OS_FUCHSIA)
  const char* status = dlerror();
  *error = status != nullptr ? strdup(status) : nullptr;
#elif defined(DART_HOST_OS_WINDOWS)
  const int status = GetLastError();
  if (status != 0) {
    char* description = nullptr;
    int length = FormatMessageA(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
        nullptr, status, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
        reinterpret_cast<char*>(&description), 0, nullptr);
    if (length == 0) {
      // Seems like there is no message for this error code.
      *error = Utils::SCreate("error code %i", status);
    } else {
      *error = Utils::SCreate("%s (error code: %i)", description, status);
    }
 
    LocalFree(description);
  } else {
    *error = nullptr;
  }
#else
  *error = Utils::StrDup("loading dynamic libraries is not supported");
#endif
}

GetListInstance()

static InstancePtr dart::GetListInstance ( Zone *  zone, const Object &  obj  )

static

Definition at line 152 of file dart_api_impl.cc.

                                                                  {
  if (obj.IsInstance()) {
    ObjectStore* object_store = IsolateGroup::Current()->object_store();
    const Type& list_rare_type =
        Type::Handle(zone, object_store->non_nullable_list_rare_type());
    ASSERT(!list_rare_type.IsNull());
    const Instance& instance = Instance::Cast(obj);
    const Class& obj_class = Class::Handle(zone, obj.clazz());
    if (Class::IsSubtypeOf(obj_class, Object::null_type_arguments(),
                           Nullability::kNonNullable, list_rare_type,
                           Heap::kNew)) {
      return instance.ptr();
    }
  }
  return Instance::null();
}

GetListLength()

static intptr_t dart::GetListLength ( const Object &  value )

static

Definition at line 12526 of file object.cc.

                                                   {
  if (value.IsTypedDataBase()) {
    return TypedDataBase::Cast(value).Length();
  } else if (value.IsArray()) {
    return Array::Cast(value).Length();
  } else if (value.IsGrowableObjectArray()) {
    // List length is variable.
    return Field::kNoFixedLength;
  }
  return Field::kNoFixedLength;
}

GetListLengthOffset()

static intptr_t dart::GetListLengthOffset ( intptr_t  cid )

static

Definition at line 12538 of file object.cc.

                                                  {
  if (IsTypedDataClassId(cid) || IsTypedDataViewClassId(cid) ||
      IsUnmodifiableTypedDataViewClassId(cid) ||
      IsExternalTypedDataClassId(cid)) {
    return TypedData::length_offset();
  } else if (cid == kArrayCid || cid == kImmutableArrayCid) {
    return Array::length_offset();
  } else if (cid == kGrowableObjectArrayCid) {
    // List length is variable.
    return Field::kUnknownLengthOffset;
  }
  return Field::kUnknownLengthOffset;
}

GetMapInstance()

static InstancePtr dart::GetMapInstance ( Zone *  zone, const Object &  obj  )

static

Definition at line 169 of file dart_api_impl.cc.

                                                                 {
  if (obj.IsInstance()) {
    ObjectStore* object_store = IsolateGroup::Current()->object_store();
    const Type& map_rare_type =
        Type::Handle(zone, object_store->non_nullable_map_rare_type());
    ASSERT(!map_rare_type.IsNull());
    const Instance& instance = Instance::Cast(obj);
    const Class& obj_class = Class::Handle(zone, obj.clazz());
    if (Class::IsSubtypeOf(obj_class, Object::null_type_arguments(),
                           Nullability::kNonNullable, map_rare_type,
                           Heap::kNew)) {
      return instance.ptr();
    }
  }
  return Instance::null();
}

GetMemoryUsage()

static void dart::GetMemoryUsage ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1612 of file service.cc.

                                                           {
  thread->isolate()->PrintMemoryUsageJSON(js);
}

GetNativeAssetsMap()

ArrayPtr dart::GetNativeAssetsMap

(

Thread *

thread

)

Definition at line 13 of file native_assets.cc.

                                            {
  Zone* const zone = thread->zone();
  ObjectStore* const object_store = thread->isolate_group()->object_store();
  auto& native_assets_map =
      Array::Handle(zone, object_store->native_assets_map());
  if (!native_assets_map.IsNull()) {
    return native_assets_map.ptr();
  }
 
#if defined(DART_PRECOMPILED_RUNTIME)
  // For now not configuring native assets is supported.
  return Array::null();
#else  // defined(DART_PRECOMPILED_RUNTIME)
 
  const auto& native_assets_library =
      Library::Handle(zone, object_store->native_assets_library());
  if (native_assets_library.IsNull()) {
    // For now not configuring native assets is supported.
    return Array::null();
  }
 
  auto& pragma = Object::Handle(zone);
  const bool pragma_found = native_assets_library.FindPragma(
      thread, /*only_core=*/false, native_assets_library,
      Symbols::vm_ffi_native_assets(),
      /*multiple=*/false, &pragma);
  ASSERT(pragma_found);
 
  // This map is formatted as follows:
  //
  // '<target_string>': {
  //   '<asset_uri>': ['<path_type>', '<path (optional)>']
  // }
  //
  // It is generated by: pkg/vm/lib/native_assets/synthesizer.dart
  const auto& abi_map = Map::Cast(pragma);
  const auto& current_abi = String::Handle(
      zone, String::NewFormatted("%s_%s", kTargetOperatingSystemName,
                                 kTargetArchitectureName));
  Map::Iterator abi_iterator(abi_map);
  auto& abi = String::Handle(zone);
  auto& asset_map = Map::Handle(zone);
  while (abi_iterator.MoveNext()) {
    abi = String::RawCast(abi_iterator.CurrentKey());
    if (abi.Equals(current_abi)) {
      asset_map = Map::RawCast(abi_iterator.CurrentValue());
      break;
    }
  }
  const intptr_t asset_map_length = asset_map.IsNull() ? 0 : asset_map.Length();
  NativeAssetsMap map(
      HashTables::New<NativeAssetsMap>(asset_map_length, Heap::kOld));
  if (!asset_map.IsNull()) {
    String& asset = String::Handle(zone);
    Array& path = Array::Handle(zone);
    Map::Iterator iterator2(asset_map);
    bool duplicate_asset = false;
    while (iterator2.MoveNext()) {
      asset = String::RawCast(iterator2.CurrentKey());
      path = Array::RawCast(iterator2.CurrentValue());
      duplicate_asset = map.UpdateOrInsert(asset, path);
      ASSERT(!duplicate_asset);
    }
  }
  native_assets_map = map.Release().ptr();
  object_store->set_native_assets_map(native_assets_map);
  return native_assets_map.ptr();
 
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

GetNativeDoubleArgument()

static bool dart::GetNativeDoubleArgument ( NativeArguments *  arguments, int  arg_index, double *  value  )

static

Definition at line 246 of file dart_api_impl.cc.

                                                   {
  ASSERT(value != nullptr);
  return Api::GetNativeDoubleArgument(arguments, arg_index, value);
}

GetNativeFieldsOfArgument()

static Dart_Handle dart::GetNativeFieldsOfArgument ( NativeArguments *  arguments, int  arg_index, int  num_fields, intptr_t *  field_values, const char *  current_func  )

static

Definition at line 253 of file dart_api_impl.cc.

                                                                       {
  ASSERT(field_values != nullptr);
  if (Api::GetNativeFieldsOfArgument(arguments, arg_index, num_fields,
                                     field_values)) {
    return Api::Success();
  }
  Thread* thread = arguments->thread();
  ASSERT(thread == Thread::Current());
  REUSABLE_OBJECT_HANDLESCOPE(thread);
  Object& obj = thread->ObjectHandle();
  obj = arguments->NativeArgAt(arg_index);
  if (obj.IsNull()) {
    memset(field_values, 0, (num_fields * sizeof(field_values[0])));
    return Api::Success();
  }
  // We did not succeed in extracting the native fields report the
  // appropriate error.
  if (!obj.IsInstance()) {
    return Api::NewError(
        "%s expects argument at index '%d' to be of"
        " type Instance.",
        current_func, arg_index);
  }
  const Instance& instance = Instance::Cast(obj);
  int field_count = instance.NumNativeFields();
  ASSERT(num_fields != field_count);
  return Api::NewError("%s: expected %d 'num_fields' but was passed in %d.",
                       current_func, field_count, num_fields);
}

GetNativeIntegerArgument()

static bool dart::GetNativeIntegerArgument ( NativeArguments *  arguments, int  arg_index, int64_t *  value  )

static

Definition at line 227 of file dart_api_impl.cc.

                                                     {
  ASSERT(value != nullptr);
  return Api::GetNativeIntegerArgument(arguments, arg_index, value);
}

GetNativeStringArgument()

static bool dart::GetNativeStringArgument ( NativeArguments *  arguments, int  arg_index, Dart_Handle *  str, void **  peer  )

static

Definition at line 200 of file dart_api_impl.cc.

                                                 {
  ASSERT(peer != nullptr);
  if (Api::StringGetPeerHelper(arguments, arg_index, peer)) {
    *str = nullptr;
    return true;
  }
  Thread* thread = arguments->thread();
  ASSERT(thread == Thread::Current());
  *peer = nullptr;
  REUSABLE_OBJECT_HANDLESCOPE(thread);
  Object& obj = thread->ObjectHandle();
  obj = arguments->NativeArgAt(arg_index);
  if (IsStringClassId(obj.GetClassId())) {
    ASSERT(thread->api_top_scope() != nullptr);
    *str = Api::NewHandle(thread, obj.ptr());
    return true;
  }
  if (obj.IsNull()) {
    *str = Api::Null();
    return true;
  }
  return false;
}

GetNativeUnsignedIntegerArgument()

static bool dart::GetNativeUnsignedIntegerArgument ( NativeArguments *  arguments, int  arg_index, uint64_t *  value  )

static

Definition at line 234 of file dart_api_impl.cc.

                                                              {
  ASSERT(value != nullptr);
  int64_t arg_value = 0;
  if (Api::GetNativeIntegerArgument(arguments, arg_index, &arg_value)) {
    *value = static_cast<uint64_t>(arg_value);
    return true;
  }
  return false;
}

GetObject()

static void dart::GetObject ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5046 of file service.cc.

                                                      {
  const char* id = js->LookupParam("objectId");
  if (id == nullptr) {
    PrintMissingParamError(js, "objectId");
    return;
  }
  if (js->HasParam("offset")) {
    intptr_t value = UIntParameter::Parse(js->LookupParam("offset"));
    if (value < 0) {
      PrintInvalidParamError(js, "offset");
      return;
    }
    js->set_offset(value);
  }
  if (js->HasParam("count")) {
    intptr_t value = UIntParameter::Parse(js->LookupParam("count"));
    if (value < 0) {
      PrintInvalidParamError(js, "count");
      return;
    }
    js->set_count(value);
  }
 
  // Handle heap objects.
  Object& obj = Object::Handle();
  ObjectIdRing::LookupResult lookup_result;
  if (GetHeapObjectCommon(thread, js, id, &obj, &lookup_result)) {
    obj.PrintJSON(js, false);
    return;
  } else if (lookup_result == ObjectIdRing::kCollected) {
    PrintSentinel(js, kCollectedSentinel);
    return;
  } else if (lookup_result == ObjectIdRing::kExpired) {
    PrintSentinel(js, kExpiredSentinel);
    return;
  }
 
  // Handle non-heap objects.
  Breakpoint* bpt = LookupBreakpoint(thread->isolate(), id, &lookup_result);
  if (bpt != nullptr) {
    bpt->PrintJSON(js);
    return;
  } else if (lookup_result == ObjectIdRing::kCollected) {
    PrintSentinel(js, kCollectedSentinel);
    return;
  }
 
  PrintInvalidParamError(js, "objectId");
}

GetObjectStore()

static void dart::GetObjectStore ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5139 of file service.cc.

                                                           {
  JSONObject jsobj(js);
  thread->isolate_group()->object_store()->PrintToJSONObject(&jsobj);
}

GetPersistentHandles()

static void dart::GetPersistentHandles ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4945 of file service.cc.

                                                                 {
  Isolate* isolate = thread->isolate();
  ASSERT(isolate != nullptr);
 
  ApiState* api_state = isolate->group()->api_state();
  ASSERT(api_state != nullptr);
 
  {
    JSONObject obj(js);
    obj.AddProperty("type", "_PersistentHandles");
    // Persistent handles.
    {
      JSONArray persistent_handles(&obj, "persistentHandles");
      api_state->RunWithLockedPersistentHandles(
          [&](PersistentHandles& handles) {
            PersistentHandleVisitor<PersistentHandle> visitor(
                thread, &persistent_handles);
            handles.Visit(&visitor);
          });
    }
    // Weak persistent handles.
    {
      JSONArray weak_persistent_handles(&obj, "weakPersistentHandles");
      api_state->RunWithLockedWeakPersistentHandles(
          [&](FinalizablePersistentHandles& handles) {
            PersistentHandleVisitor<FinalizablePersistentHandle> visitor(
                thread, &weak_persistent_handles);
            handles.VisitHandles(&visitor);
          });
    }
  }
}

GetPlaceId()

static DART_FORCE_INLINE intptr_t dart::GetPlaceId ( const Instruction *  instr )

static

Definition at line 1364 of file redundancy_elimination.cc.

                                                                       {
  ASSERT(HasPlaceId(instr));
  return instr->GetPassSpecificId(CompilerPass::kCSE);
}

GetPlatformScriptPath()

static StringPtr dart::GetPlatformScriptPath ( Thread *  thread )

static

Definition at line 297 of file ffi_dynamic_library.cc.

                                                       {
  IsolateGroupSource* const source = thread->isolate_group()->source();
 
#if defined(DART_TARGET_OS_WINDOWS)
  // Isolate.spawnUri sets a `source` including the file schema.
  // And on Windows we get an extra forward slash in that case.
  const char* file_schema_slash = "file:///";
  const int file_schema_slash_length = 8;
  const char* path = source->script_uri;
  if (strlen(source->script_uri) > file_schema_slash_length &&
      strncmp(source->script_uri, file_schema_slash,
              file_schema_slash_length) == 0) {
    path = (source->script_uri + file_schema_slash_length);
  }
 
  // Replace backward slashes with forward slashes.
  const intptr_t len = strlen(path);
  char* path_copy = reinterpret_cast<char*>(malloc(len + 1));
  snprintf(path_copy, len + 1, "%s", path);
  ReplaceBackSlashes(path_copy);
  const auto& result = String::Handle(String::New(path_copy));
  free(path_copy);
  return result.ptr();
#else
  // Isolate.spawnUri sets a `source` including the file schema.
  if (strlen(source->script_uri) > file_schema_length &&
      strncmp(source->script_uri, file_schema, file_schema_length) == 0) {
    const char* path = (source->script_uri + file_schema_length);
    return String::New(path);
  }
  return String::New(source->script_uri);
#endif
}

GetPorts()

static void dart::GetPorts ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3690 of file service.cc.

                                                     {
  // Ensure the array and handles created below are promptly destroyed.
  StackZone zone(thread);
  const GrowableObjectArray& ports = GrowableObjectArray::Handle(
      GrowableObjectArray::RawCast(DartLibraryCalls::LookupOpenPorts()));
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "PortList");
  {
    ReceivePort& port = ReceivePort::Handle(zone.GetZone());
    JSONArray arr(&jsobj, "ports");
    for (int i = 0; i < ports.Length(); ++i) {
      port ^= ports.At(i);
      ASSERT(port.is_open());
      if (port.keep_isolate_alive()) {
        arr.AddValue(port);
      }
    }
  }
}

GetPortsPrivate()

static void dart::GetPortsPrivate ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4983 of file service.cc.

                                                            {
  MessageHandler* message_handler = thread->isolate()->message_handler();
  PortMap::PrintPortsForMessageHandler(message_handler, js);
}

GetPrefixedIntegerId()

static bool dart::GetPrefixedIntegerId ( const char *  s, const char *  prefix, intptr_t *  service_id  )

static

Definition at line 645 of file service.cc.

                                                       {
  if (s == nullptr) {
    return false;
  }
  ASSERT(prefix != nullptr);
  const intptr_t kInputLen = strlen(s);
  const intptr_t kPrefixLen = strlen(prefix);
  ASSERT(kPrefixLen > 0);
  if (kInputLen <= kPrefixLen) {
    return false;
  }
  if (strncmp(s, prefix, kPrefixLen) != 0) {
    return false;
  }
  // Prefix satisfied. Move forward.
  s += kPrefixLen;
  // Attempt to read integer id.
  return GetIntegerId(s, service_id);
}

GetProcessMemoryUsage()

static void dart::GetProcessMemoryUsage ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4825 of file service.cc.

                                                                  {
  GetProcessMemoryUsageHelper(js);
}

GetProcessMemoryUsageHelper()

static intptr_t dart::GetProcessMemoryUsageHelper ( JSONStream *  js )

static

Definition at line 4705 of file service.cc.

                                                            {
  JSONObject response(js);
  response.AddProperty("type", "ProcessMemoryUsage");
 
  JSONObject rss(&response, "root");
  rss.AddPropertyF("name", "Process %" Pd "", OS::ProcessId());
  rss.AddProperty("description", "Resident set size");
  rss.AddProperty64("size", Service::CurrentRSS());
  JSONArray rss_children(&rss, "children");
 
  intptr_t vm_size = 0;
  {
    JSONObject vm(&rss_children);
    {
      JSONArray vm_children(&vm, "children");
 
      {
        JSONObject profiler(&vm_children);
        profiler.AddProperty("name", "Profiler");
        profiler.AddProperty("description",
                             "Samples from the Dart VM's profiler");
        intptr_t size = Profiler::Size();
        vm_size += size;
        profiler.AddProperty64("size", size);
        JSONArray(&profiler, "children");
      }
 
      {
        JSONObject timeline(&vm_children);
        timeline.AddProperty("name", "Timeline");
        timeline.AddProperty(
            "description",
            "Timeline events from dart:developer and Dart_RecordTimelineEvent");
        intptr_t size = Timeline::recorder()->Size();
        vm_size += size;
        timeline.AddProperty64("size", size);
        JSONArray(&timeline, "children");
      }
 
      {
        JSONObject zone(&vm_children);
        zone.AddProperty("name", "Zone");
        zone.AddProperty("description", "Arena allocation in the Dart VM");
        intptr_t size = Zone::Size();
        vm_size += size;
        zone.AddProperty64("size", size);
        JSONArray(&zone, "children");
      }
 
      {
        JSONObject semi(&vm_children);
        semi.AddProperty("name", "Page Cache");
        semi.AddProperty("description", "Cached heap regions");
        intptr_t size = Page::CachedSize();
        vm_size += size;
        semi.AddProperty64("size", size);
        JSONArray(&semi, "children");
      }
 
      IsolateGroup::ForEach([&vm_children,
                             &vm_size](IsolateGroup* isolate_group) {
        int64_t capacity =
            (isolate_group->heap()->new_space()->CapacityInWords() +
             isolate_group->heap()->old_space()->CapacityInWords()) *
            kWordSize;
        // The more precise UsedInWords for new-space iterates pages and
        // potentially accesses Thread::top_/end_, which is not thread-safe
        // here. CapacityInWords is similar enough for purposes of service stats
        // for new-space, differing only up to the as-yet-unused portion of
        // active TLABs, unlike old-space where it can differ greatly in a
        // highly fragmented heap.
        int64_t used = (isolate_group->heap()->new_space()->CapacityInWords() +
                        isolate_group->heap()->old_space()->UsedInWords()) *
                       kWordSize;
 
        int64_t free = capacity - used;
 
        JSONObject group(&vm_children);
        group.AddPropertyF("name", "IsolateGroup %s",
                           isolate_group->source()->name);
        group.AddProperty("description", "Dart heap capacity");
        vm_size += capacity;
        group.AddProperty64("size", capacity);
        JSONArray group_children(&group, "children");
 
        {
          JSONObject jsused(&group_children);
          jsused.AddProperty("name", "Used");
          jsused.AddProperty("description", "");
          jsused.AddProperty64("size", used);
          JSONArray(&jsused, "children");
        }
 
        {
          JSONObject jsfree(&group_children);
          jsfree.AddProperty("name", "Free");
          jsfree.AddProperty("description", "");
          jsfree.AddProperty64("size", free);
          JSONArray(&jsfree, "children");
        }
      });
    }  // vm_children
 
    vm.AddProperty("name", "Dart VM");
    vm.AddProperty("description", "");
    vm.AddProperty64("size", vm_size);
  }
 
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_ANDROID)
  AddVMMappings(&rss_children);
#endif
  // TODO(46166): Implement for other operating systems.
 
  return vm_size;
}

GetReachableSize()

static void dart::GetReachableSize ( Thread *  thread, JSONStream *  js  )

static

Definition at line 2591 of file service.cc.

                                                             {
  const char* target_id = js->LookupParam("targetId");
  ASSERT(target_id != nullptr);
  ObjectIdRing::LookupResult lookup_result;
  Object& obj =
      Object::Handle(LookupHeapObject(thread, target_id, &lookup_result));
  if (obj.ptr() == Object::sentinel().ptr()) {
    if (lookup_result == ObjectIdRing::kCollected) {
      PrintSentinel(js, kCollectedSentinel);
    } else if (lookup_result == ObjectIdRing::kExpired) {
      PrintSentinel(js, kExpiredSentinel);
    } else {
      PrintInvalidParamError(js, "targetId");
    }
    return;
  }
  // TODO(rmacnak): There is no way to get the size retained by a class object.
  // SizeRetainedByClass should be a separate RPC.
  if (obj.IsClass()) {
    const Class& cls = Class::Cast(obj);
    ObjectGraph graph(thread);
    intptr_t retained_size = graph.SizeReachableByClass(cls.id());
    const Object& result = Object::Handle(Integer::New(retained_size));
    result.PrintJSON(js, true);
    return;
  }
 
  ObjectGraph graph(thread);
  intptr_t retained_size = graph.SizeReachableByInstance(obj);
  const Object& result = Object::Handle(Integer::New(retained_size));
  result.PrintJSON(js, true);
}

GetRelativeSourceIndex()

static intptr_t dart::GetRelativeSourceIndex ( const String &  src, intptr_t  line, intptr_t  line_offset = 0, intptr_t  column = 1, intptr_t  column_offset = 0, intptr_t  starting_index = 0  )

static

Definition at line 13410 of file object.cc.

                                                                    {
  if (starting_index < 0 || line < 1 || column < 1 || line <= line_offset ||
      (line == line_offset + 1 && column <= column_offset)) {
    return -1;
  }
  intptr_t len = src.Length();
  intptr_t current_line = line_offset + 1;
  intptr_t current_index = starting_index;
  for (; current_index < len; current_index++) {
    if (current_line == line) {
      break;
    }
    const uint16_t c = src.CharAt(current_index);
    if (c == '\n' || c == '\r') {
      current_line++;
    }
    if (c == '\r' && current_index + 1 < len &&
        src.CharAt(current_index + 1) == '\n') {
      // \r\n is treated as a single line terminator.
      current_index++;
    }
  }
  if (current_line != line) {
    return -1;
  }
  // Only adjust with column offset when still on the first line.
  intptr_t current_column = 1 + (line == line_offset + 1 ? column_offset : 0);
  for (; current_index < len; current_index++, current_column++) {
    if (current_column == column) {
      return current_index;
    }
    const uint16_t c = src.CharAt(current_index);
    if (c == '\n' || c == '\r') {
      break;
    }
  }
  // Check for a column value representing the source's end.
  if (current_column == column) {
    return current_index;
  }
  return -1;
}

GetResourceValue()

intptr_t dart::GetResourceValue

(

intptr_t *

resource

)

Definition at line 1171 of file ffi_test_functions_vmspecific.cc.

                                              {
  return *resource;
}

GetRetainedSize()

static void dart::GetRetainedSize ( Thread *  thread, JSONStream *  js  )

static

Definition at line 2552 of file service.cc.

                                                            {
  const char* target_id = js->LookupParam("targetId");
  ASSERT(target_id != nullptr);
  ObjectIdRing::LookupResult lookup_result;
  Object& obj =
      Object::Handle(LookupHeapObject(thread, target_id, &lookup_result));
  if (obj.ptr() == Object::sentinel().ptr()) {
    if (lookup_result == ObjectIdRing::kCollected) {
      PrintSentinel(js, kCollectedSentinel);
    } else if (lookup_result == ObjectIdRing::kExpired) {
      PrintSentinel(js, kExpiredSentinel);
    } else {
      PrintInvalidParamError(js, "targetId");
    }
    return;
  }
  // TODO(rmacnak): There is no way to get the size retained by a class object.
  // SizeRetainedByClass should be a separate RPC.
  if (obj.IsClass()) {
    const Class& cls = Class::Cast(obj);
    ObjectGraph graph(thread);
    intptr_t retained_size = graph.SizeRetainedByClass(cls.id());
    const Object& result = Object::Handle(Integer::New(retained_size));
    result.PrintJSON(js, true);
    return;
  }
 
  ObjectGraph graph(thread);
  intptr_t retained_size = graph.SizeRetainedByInstance(obj);
  const Object& result = Object::Handle(Integer::New(retained_size));
  result.PrintJSON(js, true);
}

GetRetainingPath()

static void dart::GetRetainingPath ( Thread *  thread, JSONStream *  js  )

static

Definition at line 2510 of file service.cc.

                                                             {
  const char* target_id = js->LookupParam("targetId");
  if (target_id == nullptr) {
    PrintMissingParamError(js, "targetId");
    return;
  }
  const char* limit_cstr = js->LookupParam("limit");
  if (limit_cstr == nullptr) {
    PrintMissingParamError(js, "limit");
    return;
  }
  intptr_t limit;
  if (!GetIntegerId(limit_cstr, &limit)) {
    PrintInvalidParamError(js, "limit");
    return;
  }
 
  Object& obj = Object::Handle(thread->zone());
  ObjectIdRing::LookupResult lookup_result;
  {
    HANDLESCOPE(thread);
    obj = LookupHeapObject(thread, target_id, &lookup_result);
  }
  if (obj.ptr() == Object::sentinel().ptr()) {
    if (lookup_result == ObjectIdRing::kCollected) {
      PrintSentinel(js, kCollectedSentinel);
    } else if (lookup_result == ObjectIdRing::kExpired) {
      PrintSentinel(js, kExpiredSentinel);
    } else {
      PrintInvalidParamError(js, "targetId");
    }
    return;
  }
  PrintRetainingPath(thread, &obj, limit, js);
}

GetRootLibraryUrl()

DART_EXPORT Dart_Handle dart::GetRootLibraryUrl

(

)

Definition at line 1134 of file ffi_test_functions_vmspecific.cc.

                                            {
  Dart_Handle root_lib = Dart_RootLibrary();
  Dart_Handle lib_url = Dart_LibraryUrl(root_lib);
  ENSURE(!Dart_IsError(lib_url));
  return lib_url;
}

GetScripts()

static void dart::GetScripts ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1641 of file service.cc.

                                                       {
  auto object_store = thread->isolate_group()->object_store();
  Zone* zone = thread->zone();
 
  const auto& libs =
      GrowableObjectArray::Handle(zone, object_store->libraries());
  intptr_t num_libs = libs.Length();
 
  Library& lib = Library::Handle(zone);
  Array& scripts = Array::Handle(zone);
  Script& script = Script::Handle(zone);
 
  JSONObject jsobj(js);
  {
    jsobj.AddProperty("type", "ScriptList");
    JSONArray script_array(&jsobj, "scripts");
    for (intptr_t i = 0; i < num_libs; i++) {
      lib ^= libs.At(i);
      ASSERT(!lib.IsNull());
      scripts = lib.LoadedScripts();
      for (intptr_t j = 0; j < scripts.Length(); j++) {
        script ^= scripts.At(j);
        ASSERT(!script.IsNull());
        script_array.AddValue(script);
      }
    }
  }
}

GetSerialized()

static std::unique_ptr< Message > dart::GetSerialized ( Dart_Handle  lib, const char *  dart_function  )

static

Definition at line 797 of file snapshot_test.cc.

                                                                         {
  Dart_Handle result;
  {
    TransitionVMToNative transition(Thread::Current());
    result = Dart_Invoke(lib, NewString(dart_function), 0, nullptr);
    EXPECT_VALID(result);
  }
  Object& obj = Object::Handle(Api::UnwrapHandle(result));
 
  // Serialize the object into a message.
  return WriteMessage(/* same_group */ false, obj, ILLEGAL_PORT,
                      Message::kNormalPriority);
}

GetSourceReport()

static void dart::GetSourceReport ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3730 of file service.cc.

                                                            {
#if defined(DART_PRECOMPILED_RUNTIME)
  js->PrintError(kFeatureDisabled, "disabled in AOT mode and PRODUCT.");
#else
  char* reports_str = Utils::StrDup(js->LookupParam("reports"));
  const EnumListParameter* reports_parameter =
      static_cast<const EnumListParameter*>(get_source_report_params[1]);
  const char** reports = reports_parameter->Parse(reports_str);
  const char** riter = reports;
  intptr_t report_set = 0;
  while (*riter != nullptr) {
    if (strcmp(*riter, SourceReport::kCallSitesStr) == 0) {
      report_set |= SourceReport::kCallSites;
    } else if (strcmp(*riter, SourceReport::kCoverageStr) == 0) {
      report_set |= SourceReport::kCoverage;
    } else if (strcmp(*riter, SourceReport::kPossibleBreakpointsStr) == 0) {
      report_set |= SourceReport::kPossibleBreakpoints;
    } else if (strcmp(*riter, SourceReport::kProfileStr) == 0) {
      report_set |= SourceReport::kProfile;
    } else if (strcmp(*riter, SourceReport::kBranchCoverageStr) == 0) {
      report_set |= SourceReport::kBranchCoverage;
    }
    riter++;
  }
  if (reports != nullptr) {
    delete[] reports;
  }
  free(reports_str);
 
  SourceReport::CompileMode compile_mode = SourceReport::kNoCompile;
  if (BoolParameter::Parse(js->LookupParam("forceCompile"), false)) {
    compile_mode = SourceReport::kForceCompile;
  }
 
  bool report_lines =
      BoolParameter::Parse(js->LookupParam("reportLines"), false);
 
  Script& script = Script::Handle();
  intptr_t start_pos = UIntParameter::Parse(js->LookupParam("tokenPos"));
  intptr_t end_pos = UIntParameter::Parse(js->LookupParam("endTokenPos"));
 
  if (js->HasParam("scriptId")) {
    // Get the target script.
    const char* script_id_param = js->LookupParam("scriptId");
    const Object& obj =
        Object::Handle(LookupHeapObject(thread, script_id_param, nullptr));
    if (obj.ptr() == Object::sentinel().ptr() || !obj.IsScript()) {
      PrintInvalidParamError(js, "scriptId");
      return;
    }
    script ^= obj.ptr();
  } else {
    if (js->HasParam("tokenPos")) {
      js->PrintError(
          kInvalidParams,
          "%s: the 'tokenPos' parameter requires the 'scriptId' parameter",
          js->method());
      return;
    }
    if (js->HasParam("endTokenPos")) {
      js->PrintError(
          kInvalidParams,
          "%s: the 'endTokenPos' parameter requires the 'scriptId' parameter",
          js->method());
      return;
    }
  }
 
  const char* library_filters_param = js->LookupParam("libraryFilters");
  GrowableObjectArray& library_filters = GrowableObjectArray::Handle();
  if (library_filters_param != nullptr) {
    library_filters = GrowableObjectArray::New();
    intptr_t library_filters_length =
        ParseJSONArray(thread, library_filters_param, library_filters);
    if (library_filters_length < 0) {
      PrintInvalidParamError(js, "library_filters");
      return;
    }
  }
 
  const char* libraries_already_compiled_param =
      js->LookupParam("librariesAlreadyCompiled");
  Zone* zone = thread->zone();
  ZoneCStringSet* libraries_already_compiled = nullptr;
  if (libraries_already_compiled_param != nullptr) {
    libraries_already_compiled = new (zone) ZoneCStringSet(zone);
    intptr_t libraries_already_compiled_length = ParseJSONSet(
        thread, libraries_already_compiled_param, libraries_already_compiled);
    if (libraries_already_compiled_length < 0) {
      PrintInvalidParamError(js, "libraries_already_compiled");
      return;
    }
  }
 
  SourceReport report(report_set, library_filters, libraries_already_compiled,
                      compile_mode, report_lines);
  report.PrintJSON(js, script, TokenPosition::Deserialize(start_pos),
                   TokenPosition::Deserialize(end_pos));
#endif  // !DART_PRECOMPILED_RUNTIME
}

GetStack()

static void dart::GetStack ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1676 of file service.cc.

                                                     {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
  intptr_t limit = 0;
  bool has_limit = js->HasParam("limit");
  if (has_limit) {
    limit = UIntParameter::Parse(js->LookupParam("limit"));
    if (limit < 0) {
      PrintInvalidParamError(js, "limit");
      return;
    }
  }
  Isolate* isolate = thread->isolate();
  DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
  DebuggerStackTrace* async_awaiter_stack =
      isolate->debugger()->AsyncAwaiterStackTrace();
 
  // Do we want the complete script object and complete local variable objects?
  // This is true for dump requests.
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "Stack");
  {
    JSONArray jsarr(&jsobj, "frames");
 
    intptr_t num_frames =
        has_limit ? Utils::Minimum(stack->Length(), limit) : stack->Length();
 
    for (intptr_t i = 0; i < num_frames; i++) {
      ActivationFrame* frame = stack->FrameAt(i);
      JSONObject jsobj(&jsarr);
      frame->PrintToJSONObject(&jsobj);
      jsobj.AddProperty("index", i);
    }
  }
 
  if (async_awaiter_stack != nullptr) {
    JSONArray jsarr(&jsobj, "asyncCausalFrames");
    intptr_t num_frames =
        has_limit ? Utils::Minimum(async_awaiter_stack->Length(), limit)
                  : async_awaiter_stack->Length();
    for (intptr_t i = 0; i < num_frames; i++) {
      ActivationFrame* frame = async_awaiter_stack->FrameAt(i);
      JSONObject jsobj(&jsarr);
      frame->PrintToJSONObject(&jsobj);
      jsobj.AddProperty("index", i);
    }
  }
 
  const bool truncated =
      (has_limit &&
       (limit < stack->Length() || (async_awaiter_stack != nullptr &&
                                    limit < async_awaiter_stack->Length())));
  jsobj.AddProperty("truncated", truncated);
 
  {
    MessageHandler::AcquiredQueues aq(isolate->message_handler());
    jsobj.AddProperty("messages", aq.queue());
  }
}

GetStackTraceForException()

StackTracePtr dart::GetStackTraceForException

(

)

Definition at line 56 of file stacktrace.cc.

                                          {
  Thread* thread = Thread::Current();
  return CurrentStackTrace(thread, 0);
}

GetStaticFunction()

static FunctionPtr dart::GetStaticFunction ( const Class &  cls, const char *  name  )

static

Definition at line 5301 of file object_test.cc.

                                                                         {
  const auto& error = cls.EnsureIsFinalized(Thread::Current());
  EXPECT(error == Error::null());
  const Function& result = Function::Handle(
      cls.LookupStaticFunction(String::Handle(String::New(name))));
  EXPECT(!result.IsNull());
  return result.ptr();
}

GetStoredValue()

static Definition * dart::GetStoredValue ( Instruction *  instr )

static

Definition at line 1287 of file redundancy_elimination.cc.

                                                      {
  if (instr->IsStoreIndexed()) {
    return instr->AsStoreIndexed()->value()->definition();
  }
 
  StoreFieldInstr* store_instance_field = instr->AsStoreField();
  if (store_instance_field != nullptr) {
    return store_instance_field->value()->definition();
  }
 
  StoreStaticFieldInstr* store_static_field = instr->AsStoreStaticField();
  if (store_static_field != nullptr) {
    return store_static_field->value()->definition();
  }
 
  UNREACHABLE();  // Should only be called for supported store instructions.
  return nullptr;
}

GetTagProfile()

static void dart::GetTagProfile ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4442 of file service.cc.

                                                          {
  JSONObject miniProfile(js);
  miniProfile.AddProperty("type", "TagProfile");
  thread->isolate()->vm_tag_counters()->PrintToJSONObject(&miniProfile);
}

GetType()

static Dart_TypedData_Type dart::GetType ( intptr_t  class_id )

static

Definition at line 3599 of file dart_api_impl.cc.

                                                      {
  Dart_TypedData_Type type;
  switch (class_id) {
    case kByteDataViewCid:
    case kUnmodifiableByteDataViewCid:
      type = Dart_TypedData_kByteData;
      break;
    case kTypedDataInt8ArrayCid:
    case kTypedDataInt8ArrayViewCid:
    case kUnmodifiableTypedDataInt8ArrayViewCid:
    case kExternalTypedDataInt8ArrayCid:
      type = Dart_TypedData_kInt8;
      break;
    case kTypedDataUint8ArrayCid:
    case kTypedDataUint8ArrayViewCid:
    case kUnmodifiableTypedDataUint8ArrayViewCid:
    case kExternalTypedDataUint8ArrayCid:
      type = Dart_TypedData_kUint8;
      break;
    case kTypedDataUint8ClampedArrayCid:
    case kTypedDataUint8ClampedArrayViewCid:
    case kUnmodifiableTypedDataUint8ClampedArrayViewCid:
    case kExternalTypedDataUint8ClampedArrayCid:
      type = Dart_TypedData_kUint8Clamped;
      break;
    case kTypedDataInt16ArrayCid:
    case kTypedDataInt16ArrayViewCid:
    case kUnmodifiableTypedDataInt16ArrayViewCid:
    case kExternalTypedDataInt16ArrayCid:
      type = Dart_TypedData_kInt16;
      break;
    case kTypedDataUint16ArrayCid:
    case kTypedDataUint16ArrayViewCid:
    case kUnmodifiableTypedDataUint16ArrayViewCid:
    case kExternalTypedDataUint16ArrayCid:
      type = Dart_TypedData_kUint16;
      break;
    case kTypedDataInt32ArrayCid:
    case kTypedDataInt32ArrayViewCid:
    case kUnmodifiableTypedDataInt32ArrayViewCid:
    case kExternalTypedDataInt32ArrayCid:
      type = Dart_TypedData_kInt32;
      break;
    case kTypedDataUint32ArrayCid:
    case kTypedDataUint32ArrayViewCid:
    case kUnmodifiableTypedDataUint32ArrayViewCid:
    case kExternalTypedDataUint32ArrayCid:
      type = Dart_TypedData_kUint32;
      break;
    case kTypedDataInt64ArrayCid:
    case kTypedDataInt64ArrayViewCid:
    case kUnmodifiableTypedDataInt64ArrayViewCid:
    case kExternalTypedDataInt64ArrayCid:
      type = Dart_TypedData_kInt64;
      break;
    case kTypedDataUint64ArrayCid:
    case kTypedDataUint64ArrayViewCid:
    case kUnmodifiableTypedDataUint64ArrayViewCid:
    case kExternalTypedDataUint64ArrayCid:
      type = Dart_TypedData_kUint64;
      break;
    case kTypedDataFloat32ArrayCid:
    case kTypedDataFloat32ArrayViewCid:
    case kUnmodifiableTypedDataFloat32ArrayViewCid:
    case kExternalTypedDataFloat32ArrayCid:
      type = Dart_TypedData_kFloat32;
      break;
    case kTypedDataFloat64ArrayCid:
    case kTypedDataFloat64ArrayViewCid:
    case kUnmodifiableTypedDataFloat64ArrayViewCid:
    case kExternalTypedDataFloat64ArrayCid:
      type = Dart_TypedData_kFloat64;
      break;
    case kTypedDataInt32x4ArrayCid:
    case kTypedDataInt32x4ArrayViewCid:
    case kUnmodifiableTypedDataInt32x4ArrayViewCid:
    case kExternalTypedDataInt32x4ArrayCid:
      type = Dart_TypedData_kInt32x4;
      break;
    case kTypedDataFloat32x4ArrayCid:
    case kTypedDataFloat32x4ArrayViewCid:
    case kUnmodifiableTypedDataFloat32x4ArrayViewCid:
    case kExternalTypedDataFloat32x4ArrayCid:
      type = Dart_TypedData_kFloat32x4;
      break;
    case kTypedDataFloat64x2ArrayCid:
    case kTypedDataFloat64x2ArrayViewCid:
    case kUnmodifiableTypedDataFloat64x2ArrayViewCid:
    case kExternalTypedDataFloat64x2ArrayCid:
      type = Dart_TypedData_kFloat64x2;
      break;
    default:
      type = Dart_TypedData_kInvalid;
      break;
  }
  return type;
}

GetTypeArgumentsList()

static void dart::GetTypeArgumentsList ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5170 of file service.cc.

                                                                 {
  bool only_with_instantiations = false;
  if (js->ParamIs("onlyWithInstantiations", "true")) {
    only_with_instantiations = true;
  }
  Zone* zone = thread->zone();
  ObjectStore* object_store = thread->isolate_group()->object_store();
  CanonicalTypeArgumentsSet typeargs_table(
      zone, object_store->canonical_type_arguments());
  const intptr_t table_size = typeargs_table.NumEntries();
  const intptr_t table_used = typeargs_table.NumOccupied();
  const Array& typeargs_array =
      Array::Handle(zone, HashTables::ToArray(typeargs_table, false));
  ASSERT(typeargs_array.Length() == table_used);
  TypeArguments& typeargs = TypeArguments::Handle(zone);
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "TypeArgumentsList");
  jsobj.AddProperty("canonicalTypeArgumentsTableSize", table_size);
  jsobj.AddProperty("canonicalTypeArgumentsTableUsed", table_used);
  JSONArray members(&jsobj, "typeArguments");
  for (intptr_t i = 0; i < table_used; i++) {
    typeargs ^= typeargs_array.At(i);
    if (!typeargs.IsNull()) {
      if (!only_with_instantiations || typeargs.HasInstantiations()) {
        members.AddValue(typeargs);
      }
    }
  }
  typeargs_table.Release();
}

GetTypeCommon()

static Dart_Handle dart::GetTypeCommon ( Dart_Handle  library, Dart_Handle  class_name, intptr_t  number_of_type_arguments, Dart_Handle *  type_arguments, Nullability  nullability  )

static

Definition at line 5523 of file dart_api_impl.cc.

                                                          {
  DARTSCOPE(Thread::Current());
  // Validate the input arguments.
  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
  if (lib.IsNull()) {
    RETURN_TYPE_ERROR(Z, library, Library);
  }
  if (!lib.Loaded()) {
    return Api::NewError("%s expects library argument 'library' to be loaded.",
                         CURRENT_FUNC);
  }
  const String& name_str = Api::UnwrapStringHandle(Z, class_name);
  if (name_str.IsNull()) {
    RETURN_TYPE_ERROR(Z, class_name, String);
  }
  const Class& cls = Class::Handle(Z, lib.LookupClassAllowPrivate(name_str));
  if (cls.IsNull()) {
    const String& lib_name = String::Handle(Z, lib.name());
    return Api::NewError("Type '%s' not found in library '%s'.",
                         name_str.ToCString(), lib_name.ToCString());
  }
  cls.EnsureDeclarationLoaded();
  CHECK_ERROR_HANDLE(cls.VerifyEntryPoint());
 
  Type& type = Type::Handle();
  if (cls.NumTypeArguments() == 0) {
    if (number_of_type_arguments != 0) {
      return Api::NewError(
          "Invalid number of type arguments specified, "
          "got %" Pd " expected 0",
          number_of_type_arguments);
    }
    type ^= Type::NewNonParameterizedType(cls);
    type ^= type.ToNullability(nullability, Heap::kOld);
  } else {
    intptr_t num_expected_type_arguments = cls.NumTypeParameters();
    TypeArguments& type_args_obj = TypeArguments::Handle();
    if (number_of_type_arguments > 0) {
      if (type_arguments == nullptr) {
        RETURN_NULL_ERROR(type_arguments);
      }
      if (num_expected_type_arguments != number_of_type_arguments) {
        return Api::NewError(
            "Invalid number of type arguments specified, "
            "got %" Pd " expected %" Pd,
            number_of_type_arguments, num_expected_type_arguments);
      }
      const Array& array = Api::UnwrapArrayHandle(Z, *type_arguments);
      if (array.IsNull()) {
        RETURN_TYPE_ERROR(Z, *type_arguments, Array);
      }
      if (array.Length() != num_expected_type_arguments) {
        return Api::NewError(
            "Invalid type arguments specified, expected an "
            "array of len %" Pd " but got an array of len %" Pd,
            number_of_type_arguments, array.Length());
      }
      // Set up the type arguments array.
      type_args_obj = TypeArguments::New(num_expected_type_arguments);
      AbstractType& type_arg = AbstractType::Handle();
      for (intptr_t i = 0; i < number_of_type_arguments; i++) {
        type_arg ^= array.At(i);
        type_args_obj.SetTypeAt(i, type_arg);
      }
    }
 
    // Construct the type object, canonicalize it and return.
    type ^= Type::New(cls, type_args_obj, nullability);
  }
  type ^= ClassFinalizer::FinalizeType(type);
  return Api::NewHandle(T, type.ptr());
}

GetTypedDataSizeOrThrow()

static intptr_t dart::GetTypedDataSizeOrThrow ( const Instance &  instance )

static

Definition at line 1117 of file isolate.cc.

                                                                  {
  // From the Dart side we are guaranteed that the type of [instance] is a
  // subtype of TypedData.
  if (instance.IsTypedDataBase()) {
    return TypedDataBase::Cast(instance).LengthInBytes();
  }
 
  // This can happen if [instance] is `null` or an instance of a 3rd party class
  // which implements [TypedData].
  Exceptions::ThrowArgumentError(instance);
}

GetUnsignedIntegerId()

static bool dart::GetUnsignedIntegerId ( const char *  s, uintptr_t *  id, int  base = 10  )

static

Definition at line 557 of file service.cc.

                                                                              {
  if ((s == nullptr) || (*s == '\0')) {
    // Empty string.
    return false;
  }
  if (id == nullptr) {
    // No id pointer.
    return false;
  }
  uintptr_t r = 0;
  char* end_ptr = nullptr;
#if defined(ARCH_IS_32_BIT)
  r = strtoul(s, &end_ptr, base);
#else
  r = strtoull(s, &end_ptr, base);
#endif
  if (end_ptr == s) {
    // String was not advanced at all, cannot be valid.
    return false;
  }
  *id = r;
  return true;
}

GetValue()

static int64_t dart::GetValue ( Dart_Handle  arg )

static

Definition at line 8653 of file dart_api_impl_test.cc.

GetVariableValue()

static DART_FORCE_INLINE ObjectPtr dart::GetVariableValue ( uword  addr )

static

Definition at line 833 of file debugger.cc.

                                                                {
  return *reinterpret_cast<ObjectPtr*>(addr);
}

GetVersion()

static void dart::GetVersion ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5206 of file service.cc.

                                                       {
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "Version");
  jsobj.AddProperty("major",
                    static_cast<intptr_t>(SERVICE_PROTOCOL_MAJOR_VERSION));
  jsobj.AddProperty("minor",
                    static_cast<intptr_t>(SERVICE_PROTOCOL_MINOR_VERSION));
  jsobj.AddProperty("_privateMajor", static_cast<intptr_t>(0));
  jsobj.AddProperty("_privateMinor", static_cast<intptr_t>(0));
}

GetVM()

static void dart::GetVM ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5337 of file service.cc.

                                                  {
  Service::PrintJSONForVM(js, false);
}

GetVMName()

static const char * dart::GetVMName ( )

static

Definition at line 358 of file service.cc.

                               {
  if (vm_name == nullptr) {
    return FLAG_vm_name;
  }
  return vm_name;
}

GetVMTimeline()

static void dart::GetVMTimeline ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4307 of file service.cc.

                                                          {
  GetVMTimelineCommon(TimelineOrSamplesResponseFormat::JSON, thread, js);
}

GetVMTimelineCommon()

void dart::GetVMTimelineCommon ( TimelineOrSamplesResponseFormat  format, Thread *  thread, JSONStream *  js  )

inline

Definition at line 4176 of file service.cc.

                                                {
  Isolate* isolate = thread->isolate();
  ASSERT(isolate != nullptr);
  StackZone zone(thread);
  TimelineEventRecorder* timeline_recorder = Timeline::recorder();
  ASSERT(timeline_recorder != nullptr);
  const char* name = timeline_recorder->name();
  if (strcmp(name, CALLBACK_RECORDER_NAME) == 0) {
    js->PrintError(kInvalidTimelineRequest,
                   "A recorder of type \"%s\" is currently in use. As a "
                   "result, timeline events are handled by the embedder rather "
                   "than the VM.",
                   timeline_recorder->name());
    return;
  } else if (strcmp(name, FUCHSIA_RECORDER_NAME) == 0 ||
             strcmp(name, SYSTRACE_RECORDER_NAME) == 0 ||
             strcmp(name, MACOS_RECORDER_NAME) == 0) {
    js->PrintError(
        kInvalidTimelineRequest,
        "A recorder of type \"%s\" is currently in use. As a result, timeline "
        "events are handled by the OS rather than the VM. See the VM service "
        "documentation for more details on where timeline events can be found "
        "for this recorder type.",
        timeline_recorder->name());
    return;
  } else if (strcmp(name, FILE_RECORDER_NAME) == 0 ||
             strcmp(name, PERFETTO_FILE_RECORDER_NAME) == 0) {
    js->PrintError(kInvalidTimelineRequest,
                   "A recorder of type \"%s\" is currently in use. As a "
                   "result, timeline events are written directly to a file and "
                   "thus cannot be retrieved through the VM Service.",
                   timeline_recorder->name());
    return;
  }
  int64_t time_origin_micros =
      Int64Parameter::Parse(js->LookupParam("timeOriginMicros"));
  int64_t time_extent_micros =
      Int64Parameter::Parse(js->LookupParam("timeExtentMicros"));
  TimelineEventFilter filter(time_origin_micros, time_extent_micros);
  if (format == TimelineOrSamplesResponseFormat::JSON) {
    timeline_recorder->PrintJSON(js, &filter);
  } else if (format == TimelineOrSamplesResponseFormat::Perfetto) {
#if defined(SUPPORT_PERFETTO)
    // This branch will never be reached when SUPPORT_PERFETTO is not defined,
    // because |GetPerfettoVMTimeline| is not defined when SUPPORT_PERFETTO is
    // not defined.
    timeline_recorder->PrintPerfettoTimeline(js, filter);
#else
    UNREACHABLE();
#endif  // defined(SUPPORT_PERFETTO)
  }
}

GetVMTimelineFlags()

static void dart::GetVMTimelineFlags ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4262 of file service.cc.

                                                               {
#if !defined(SUPPORT_TIMELINE)
  JSONObject obj(js);
  obj.AddProperty("type", "TimelineFlags");
#else
  Isolate* isolate = thread->isolate();
  ASSERT(isolate != nullptr);
  StackZone zone(thread);
  Timeline::PrintFlagsToJSON(js);
#endif
}

GetVMTimelineMicros()

static void dart::GetVMTimelineMicros ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4279 of file service.cc.

                                                                {
  JSONObject obj(js);
  obj.AddProperty("type", "Timestamp");
  obj.AddPropertyTimeMicros("timestamp", OS::GetCurrentMonotonicMicros());
}

GetYieldPointsFromCode()

static YieldPoints * dart::GetYieldPointsFromCode ( const Code &  code )

static

Definition at line 37 of file yield_position_test.cc.

                                                             {
  auto array = new YieldPoints();
  const auto& pc_descriptor = PcDescriptors::Handle(code.pc_descriptors());
  PcDescriptors::Iterator it(pc_descriptor, UntaggedPcDescriptors::kOther);
  while (it.MoveNext()) {
    if (it.YieldIndex() != UntaggedPcDescriptors::kInvalidYieldIndex) {
      array->Add(it.TokenPos());
    }
  }
  array->Sort(LowestFirst);
  return array;
}

GetYieldPointsFromGraph()

static YieldPoints * dart::GetYieldPointsFromGraph ( FlowGraph *  flow_graph )

static

Definition at line 21 of file yield_position_test.cc.

                                                                   {
  auto array = new (flow_graph->zone()) YieldPoints();
  const auto& blocks = flow_graph->reverse_postorder();
  for (auto block : blocks) {
    ForwardInstructionIterator it(block);
    while (!it.Done()) {
      if (auto suspend_instr = it.Current()->AsSuspend()) {
        array->Add(suspend_instr->token_pos());
      }
      it.Advance();
    }
  }
  array->Sort(LowestFirst);
  return array;
}

gnac_lookup()

static Dart_NativeFunction dart::gnac_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 7261 of file dart_api_impl_test.cc.

                                                               {
  ASSERT(auto_setup_scope != nullptr);

greatestFirst()

static int dart::greatestFirst ( const int *  a, const int *  b  )

static

Definition at line 76 of file growable_array_test.cc.

                                                     {
  if (*a > *b) {
    return -1;
  } else if (*a < *b) {
    return 1;
  } else {
    return 0;
  }
}

HandleCommonEcho()

static void dart::HandleCommonEcho ( JSONObject *  jsobj, JSONStream *  js  )

static

Definition at line 1737 of file service.cc.

                                                                {
  jsobj->AddProperty("type", "_EchoResponse");
  if (js->HasParam("text")) {
    jsobj->AddProperty("text", js->LookupParam("text"));
  }
}

HandleFromFinalizable()

static Dart_Handle dart::HandleFromFinalizable ( Dart_FinalizableHandle  object )

static

Definition at line 958 of file dart_api_impl.cc.

                                                                        {
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  CHECK_ISOLATE(isolate);
  ApiState* state = isolate->group()->api_state();
  ASSERT(state != nullptr);
  TransitionNativeToVM transition(thread);
  NoSafepointScope no_safepoint_scope;
  FinalizablePersistentHandle* weak_ref =
      FinalizablePersistentHandle::Cast(object);
  return Api::NewHandle(thread, weak_ref->ptr());
}

HandleInterrupts()

void dart::HandleInterrupts

(

Thread *

thread

)

Definition at line 10277 of file dart_api_impl_test.cc.

                                  {
  return x;
}
 

HandleIsolateMessage()

static void dart::HandleIsolateMessage ( Isolate *  isolate, const Array &  msg  )

static

Definition at line 136 of file service_test.cc.

                                                                     {
  Service::HandleIsolateMessage(isolate, msg);
}

HandleNativeMetric()

static void dart::HandleNativeMetric ( Thread *  thread, JSONStream *  js, const char *  id  )

static

Definition at line 4083 of file service.cc.

                                                                               {
  auto isolate = thread->isolate();
#define ADD_METRIC(type, variable, name, unit)                                 \
  if (strcmp(id, name) == 0) {                                                 \
    isolate->Get##variable##Metric()->PrintJSON(js);                           \
    return;                                                                    \
  }
  ISOLATE_METRIC_LIST(ADD_METRIC);
#undef ADD_METRIC
 
  auto isolate_group = thread->isolate_group();
#define ADD_METRIC(type, variable, name, unit)                                 \
  if (strcmp(id, name) == 0) {                                                 \
    isolate_group->Get##variable##Metric()->PrintJSON(js);                     \
    return;                                                                    \
  }
  ISOLATE_GROUP_METRIC_LIST(ADD_METRIC);
#undef ADD_METRIC
 
  PrintInvalidParamError(js, "metricId");
}

HandleNativeMetricsList()

static void dart::HandleNativeMetricsList ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4063 of file service.cc.

                                                                    {
  JSONObject obj(js);
  obj.AddProperty("type", "MetricList");
  {
    JSONArray metrics(&obj, "metrics");
 
    auto isolate = thread->isolate();
#define ADD_METRIC(type, variable, name, unit)                                 \
  metrics.AddValue(isolate->Get##variable##Metric());
    ISOLATE_METRIC_LIST(ADD_METRIC);
#undef ADD_METRIC
 
    auto isolate_group = thread->isolate_group();
#define ADD_METRIC(type, variable, name, unit)                                 \
  metrics.AddValue(isolate_group->Get##variable##Metric());
    ISOLATE_GROUP_METRIC_LIST(ADD_METRIC);
#undef ADD_METRIC
  }
}

HandleOSRRequest()

static void dart::HandleOSRRequest ( Thread *  thread )

static

Definition at line 3079 of file runtime_entry.cc.

                                             {
  auto isolate_group = thread->isolate_group();
  ASSERT(isolate_group->use_osr());
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = iterator.NextFrame();
  ASSERT(frame != nullptr);
  const Code& code = Code::ZoneHandle(frame->LookupDartCode());
  ASSERT(!code.IsNull());
  ASSERT(!code.is_optimized());
  const Function& function = Function::Handle(code.function());
  ASSERT(!function.IsNull());
 
  // If the code of the frame does not match the function's unoptimized code,
  // we bail out since the code was reset by an isolate reload.
  if (code.ptr() != function.unoptimized_code()) {
    return;
  }
 
  // Since the code is referenced from the frame and the ZoneHandle,
  // it cannot have been removed from the function.
  ASSERT(function.HasCode());
  // Don't do OSR on intrinsified functions: The intrinsic code expects to be
  // called like a regular function and can't be entered via OSR.
  if (!Compiler::CanOptimizeFunction(thread, function) ||
      function.is_intrinsic()) {
    return;
  }
 
  // The unoptimized code is on the stack and should never be detached from
  // the function at this point.
  ASSERT(function.unoptimized_code() != Object::null());
  intptr_t osr_id =
      Code::Handle(function.unoptimized_code()).GetDeoptIdForOsr(frame->pc());
  ASSERT(osr_id != Compiler::kNoOSRDeoptId);
  if (FLAG_trace_osr) {
    OS::PrintErr("Attempting OSR for %s at id=%" Pd ", count=%" Pd "\n",
                 function.ToFullyQualifiedCString(), osr_id,
                 function.usage_counter());
  }
 
  // Since the code is referenced from the frame and the ZoneHandle,
  // it cannot have been removed from the function.
  const Object& result = Object::Handle(
      Compiler::CompileOptimizedFunction(thread, function, osr_id));
  ThrowIfError(result);
 
  if (!result.IsNull()) {
    const Code& code = Code::Cast(result);
    uword optimized_entry = code.EntryPoint();
    frame->set_pc(optimized_entry);
    frame->set_pc_marker(code.ptr());
  }
}

HandleReadFieldValue()

DART_EXPORT int64_t dart::HandleReadFieldValue

(

Dart_Handle

handle

)

Definition at line 1039 of file ffi_test_functions_vmspecific.cc.

                                                             {
  printf("HandleReadFieldValue\n");
  Dart_Handle field_name = Dart_NewStringFromCString("a");
  if (Dart_IsError(field_name)) {
    printf("Dart_PropagateError(field_name)\n");
    Dart_PropagateError(field_name);
  }
  Dart_Handle field_value = Dart_GetField(handle, field_name);
  if (Dart_IsError(field_value)) {
    printf("Dart_PropagateError(field_value)\n");
    Dart_PropagateError(field_value);
  }
  int64_t value;
  Dart_Handle err = Dart_IntegerToInt64(field_value, &value);
  if (Dart_IsError(err)) {
    Dart_PropagateError(err);
  }
  return value;
}

HandleRecursion()

DART_EXPORT Dart_Handle dart::HandleRecursion	(	Dart_Handle	object,
		Dart_Handle(*)(int64_t)	callback,
		int64_t	i
	)

Definition at line 1002 of file ffi_test_functions_vmspecific.cc.

                                                   {
  printf("HandleRecursion %" Pd64 "\n", i);
  const bool do_invoke = i % 3 == 0;
  const bool do_gc = i % 7 == 3;
  if (do_gc) {
    Dart_ExecuteInternalCommand("gc-now", nullptr);
  }
  Dart_Handle result;
  if (do_invoke) {
    Dart_Handle method_name = Dart_NewStringFromCString("a");
    if (Dart_IsError(method_name)) {
      Dart_PropagateError(method_name);
    }
    Dart_Handle arg = Dart_NewInteger(i - 1);
    if (Dart_IsError(arg)) {
      Dart_PropagateError(arg);
    }
    printf("Dart_Invoke\n");
    result = Dart_Invoke(object, method_name, 1, &arg);
  } else {
    printf("callback\n");
    result = callback(i - 1);
  }
  if (do_gc) {
    Dart_ExecuteInternalCommand("gc-now", nullptr);
  }
  if (Dart_IsError(result)) {
    // Do C/C++ resource cleanup if needed, before propagating error.
    printf("Dart_PropagateError %" Pd64 "\n", i);
    Dart_PropagateError(result);
  }
  printf("return %" Pd64 "\n", i);
  return result;
}

HandleResponse()

static void dart::HandleResponse ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 9944 of file dart_api_impl_test.cc.

HandleRootMessage()

static void dart::HandleRootMessage ( const Array &  message )

static

Definition at line 140 of file service_test.cc.

                                                    {
  Service::HandleRootMessage(message);
}

HandleStackOverflowTestCases()

static void dart::HandleStackOverflowTestCases ( Thread *  thread )

static

Definition at line 2957 of file runtime_entry.cc.

                                                         {
  auto isolate = thread->isolate();
  auto isolate_group = thread->isolate_group();
 
  if (FLAG_shared_slow_path_triggers_gc) {
    isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
 
  bool do_deopt = false;
  bool do_stacktrace = false;
  bool do_reload = false;
  bool do_gc = false;
  const intptr_t isolate_reload_every =
      isolate->group()->reload_every_n_stack_overflow_checks();
  if ((FLAG_deoptimize_every > 0) || (FLAG_stacktrace_every > 0) ||
      (FLAG_gc_every > 0) || (isolate_reload_every > 0)) {
    if (!Isolate::IsSystemIsolate(isolate)) {
      // TODO(turnidge): To make --deoptimize_every and
      // --stacktrace-every faster we could move this increment/test to
      // the generated code.
      int32_t count = thread->IncrementAndGetStackOverflowCount();
      if (FLAG_deoptimize_every > 0 && (count % FLAG_deoptimize_every) == 0) {
        do_deopt = true;
      }
      if (FLAG_stacktrace_every > 0 && (count % FLAG_stacktrace_every) == 0) {
        do_stacktrace = true;
      }
      if (FLAG_gc_every > 0 && (count % FLAG_gc_every) == 0) {
        do_gc = true;
      }
      if ((isolate_reload_every > 0) && (count % isolate_reload_every) == 0) {
        do_reload = isolate->group()->CanReload();
      }
    }
  }
  if ((FLAG_deoptimize_filter != nullptr) ||
      (FLAG_stacktrace_filter != nullptr) || (FLAG_reload_every != 0)) {
    DartFrameIterator iterator(thread,
                               StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* frame = iterator.NextFrame();
    ASSERT(frame != nullptr);
    Code& code = Code::Handle();
    Function& function = Function::Handle();
    code = frame->LookupDartCode();
    ASSERT(!code.IsNull());
    function = code.function();
    ASSERT(!function.IsNull());
    const char* function_name = nullptr;
    if ((FLAG_deoptimize_filter != nullptr) ||
        (FLAG_stacktrace_filter != nullptr)) {
      function_name = function.ToFullyQualifiedCString();
      ASSERT(function_name != nullptr);
    }
    if (!code.IsNull()) {
      if (!code.is_optimized() && FLAG_reload_every_optimized) {
        // Don't do the reload if we aren't inside optimized code.
        do_reload = false;
      }
      if (code.is_optimized() && FLAG_deoptimize_filter != nullptr &&
          strstr(function_name, FLAG_deoptimize_filter) != nullptr &&
          !function.ForceOptimize()) {
        OS::PrintErr("*** Forcing deoptimization (%s)\n",
                     function.ToFullyQualifiedCString());
        do_deopt = true;
      }
    }
    if (FLAG_stacktrace_filter != nullptr &&
        strstr(function_name, FLAG_stacktrace_filter) != nullptr) {
      OS::PrintErr("*** Computing stacktrace (%s)\n",
                   function.ToFullyQualifiedCString());
      do_stacktrace = true;
    }
  }
  if (do_deopt) {
    // TODO(turnidge): Consider using DeoptimizeAt instead.
    DeoptimizeFunctionsOnStack();
  }
  if (do_reload) {
    // Maybe adjust the rate of future reloads.
    isolate_group->MaybeIncreaseReloadEveryNStackOverflowChecks();
 
    // Issue a reload.
    const char* script_uri = isolate_group->source()->script_uri;
    JSONStream js;
    const bool success =
        isolate_group->ReloadSources(&js, /*force_reload=*/true, script_uri);
    if (!success) {
      FATAL("*** Isolate reload failed:\n%s\n", js.ToCString());
    }
  }
  if (do_stacktrace) {
    String& var_name = String::Handle();
    Instance& var_value = Instance::Handle();
    DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
    intptr_t num_frames = stack->Length();
    for (intptr_t i = 0; i < num_frames; i++) {
      ActivationFrame* frame = stack->FrameAt(i);
      int num_vars = 0;
      // Variable locations and number are unknown when precompiling.
#if !defined(DART_PRECOMPILED_RUNTIME)
      if (!frame->function().ForceOptimize()) {
        // Ensure that we have unoptimized code.
        frame->function().EnsureHasCompiledUnoptimizedCode();
        num_vars = frame->NumLocalVariables();
      }
#endif
      TokenPosition unused = TokenPosition::kNoSource;
      for (intptr_t v = 0; v < num_vars; v++) {
        frame->VariableAt(v, &var_name, &unused, &unused, &unused, &var_value);
      }
    }
    if (FLAG_stress_async_stacks) {
      DebuggerStackTrace::CollectAsyncAwaiters();
    }
  }
  if (do_gc) {
    isolate->group()->heap()->CollectAllGarbage(GCReason::kDebugging);
  }
}

Hash()

static uint32_t dart::Hash ( uint32_t  key )

static

Definition at line 65 of file hashmap_test.cc.

                                   {
  return 23;
}

Hash64To32()

static uword dart::Hash64To32 ( uint64_t  v )

static

Definition at line 6517 of file object.cc.

                                    {
  v = ~v + (v << 18);
  v = v ^ (v >> 31);
  v = v * 21;
  v = v ^ (v >> 11);
  v = v + (v << 6);
  v = v ^ (v >> 22);
  return static_cast<uint32_t>(v);
}

HashBaseNonConstEqualsConst()

template<class LinkedHashBase , int kMutableCid, int kImmutableCid>

static void dart::HashBaseNonConstEqualsConst ( const char *  script, bool  check_data = true  )

static

Definition at line 6901 of file object_test.cc.

                                                   {
  return object.IsMap() || object.IsSet();
}
 
// Checks that the non-constant and constant HashMap and HashSets are equal.
//
// Expects a script with a methods named `nonConstValue`, `constValue`, and
// `init`.
template <class LinkedHashBase, int kMutableCid, int kImmutableCid>
static void HashBaseNonConstEqualsConst(const char* script,
                                        bool check_data = true) {
  Dart_Handle lib = TestCase::LoadTestScript(script, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle init_result = Dart_Invoke(lib, NewString("init"), 0, nullptr);
  EXPECT_VALID(init_result);
  Dart_Handle non_const_result =
      Dart_Invoke(lib, NewString("nonConstValue"), 0, nullptr);
  EXPECT_VALID(non_const_result);
  Dart_Handle const_result =
      Dart_Invoke(lib, NewString("constValue"), 0, nullptr);
  EXPECT_VALID(const_result);
 
  TransitionNativeToVM transition(Thread::Current());
  const auto& non_const_object =
      Object::Handle(Api::UnwrapHandle(non_const_result));
  const auto& const_object = Object::Handle(Api::UnwrapHandle(const_result));
  non_const_object.IsMap();
  EXPECT(IsLinkedHashBase(non_const_object));
  if (!IsLinkedHashBase(non_const_object)) return;

HashBytes()

uint32_t dart::HashBytes ( const uint8_t *  bytes, intptr_t  size  )

inline

Definition at line 31 of file hash.h.

                                                               {
  uint32_t hash = size;
  while (size > 0) {
    hash = CombineHashes(hash, *bytes);
    bytes++;
    size--;
  }
  return hash;
}

HashCodeEqualsCanonicalizeHash()

static bool dart::HashCodeEqualsCanonicalizeHash ( const char *  value_script, uint32_t  hashcode_canonicalize_vm = kCalculateCanonicalizeHash, bool  check_identity = true, bool  check_hashcode = true  )

static

Definition at line 6453 of file object_test.cc.

                                {
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "%s"
                  "\n"
                  "valueHashCode() {\n"
                  "  return value().hashCode;\n"
                  "}\n"
                  "\n"
                  "valueIdentityHashCode() {\n"
                  "  return identityHashCode(value());\n"
                  "}\n",
                  value_script),
      std::free);
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars.get(), nullptr);
  EXPECT_VALID(lib);
  Dart_Handle value_result = Dart_Invoke(lib, NewString("value"), 0, nullptr);
  EXPECT_VALID(value_result);
  Dart_Handle hashcode_result;
  if (check_hashcode) {
    hashcode_result = Dart_Invoke(lib, NewString("valueHashCode"), 0, nullptr);
    EXPECT_VALID(hashcode_result);
  }
  Dart_Handle identity_hashcode_result =
      Dart_Invoke(lib, NewString("valueIdentityHashCode"), 0, nullptr);
  EXPECT_VALID(identity_hashcode_result);
 
  TransitionNativeToVM transition(Thread::Current());
 
  const auto& value_dart = Instance::CheckedHandle(
      Thread::Current()->zone(), Api::UnwrapHandle(value_result));
  int64_t hashcode_dart;
  if (check_hashcode) {
    hashcode_dart =
        Integer::Cast(Object::Handle(Api::UnwrapHandle(hashcode_result)))
            .AsInt64Value();
  }
  const int64_t identity_hashcode_dart =
      Integer::Cast(Object::Handle(Api::UnwrapHandle(identity_hashcode_result)))
          .AsInt64Value();
  if (hashcode_canonicalize_vm == 0) {
    hashcode_canonicalize_vm = Instance::Cast(value_dart).CanonicalizeHash();
  }
 
  bool success = true;
 
  if (check_hashcode) {
    success &= hashcode_dart == hashcode_canonicalize_vm;
  }
  if (check_identity) {
    success &= identity_hashcode_dart == hashcode_canonicalize_vm;
  }
 
  if (!success) {
    LogBlock lb;
    THR_Print(
        "Dart hashCode or Dart identityHashCode does not equal VM "
        "CanonicalizeHash for %s\n",

HashMapNonConstEqualsConst()

static void dart::HashMapNonConstEqualsConst ( const char *  script, bool  check_data = true  )

static

Definition at line 6933 of file object_test.cc.

HashSetNonConstEqualsConst()

static void dart::HashSetNonConstEqualsConst ( const char *  script, bool  check_data = true  )

static

Definition at line 6938 of file object_test.cc.

HasNoTasks()

static bool dart::HasNoTasks ( Heap *  heap )

static

Definition at line 93 of file isolate_reload.cc.

                                   {
  MonitorLocker ml(heap->old_space()->tasks_lock());
  return heap->old_space()->tasks() == 0;
}

HasOnlyUnconstrainedUses()

static bool dart::HasOnlyUnconstrainedUses ( LiveRange *  range )

static

Definition at line 581 of file linearscan.cc.

                                                       {
  UsePosition* use = range->first_use();
  while (use != nullptr) {
    if (!use->location_slot()->Equals(Location::Any())) {
      return false;
    }
    use = use->next();
  }
  return true;
}

HasOnlyUnconstrainedUsesInLoop()

static bool dart::HasOnlyUnconstrainedUsesInLoop ( LiveRange *  range, intptr_t  boundary  )

static

Definition at line 568 of file linearscan.cc.

                                                              {
  UsePosition* use = range->first_use();
  while ((use != nullptr) && (use->pos() < boundary)) {
    if (!use->location_slot()->Equals(Location::Any())) {
      return false;
    }
    use = use->next();
  }
  return true;
}

HasPhis()

static bool dart::HasPhis ( BlockEntryInstr *  block )

static

Definition at line 1676 of file constant_propagator.cc.

                                            {
  if (auto* join = block->AsJoinEntry()) {
    return (join->phis() != nullptr) && !join->phis()->is_empty();
  }
  return false;
}

HasPlaceId()

static DART_FORCE_INLINE bool dart::HasPlaceId ( const Instruction *  instr )

static

Definition at line 1360 of file redundancy_elimination.cc.

                                                                   {
  return instr->HasPassSpecificId(CompilerPass::kCSE);
}

HasPragma()

static bool dart::HasPragma ( const Object &  declaration )

static

Definition at line 13760 of file object.cc.

                                                 {
  return (declaration.IsClass() && Class::Cast(declaration).has_pragma()) ||
         (declaration.IsFunction() &&
          Function::Cast(declaration).has_pragma()) ||
         (declaration.IsField() && Field::Cast(declaration).has_pragma());
}

HasRealUse()

static bool dart::HasRealUse ( Definition *  def )

static

Definition at line 4384 of file redundancy_elimination.cc.

                                        {
  // Environment uses are real (non-phi) uses.
  if (def->env_use_list() != nullptr) return true;
 
  for (Value::Iterator it(def->input_use_list()); !it.Done(); it.Advance()) {
    if (!it.Current()->instruction()->IsPhi()) return true;
  }
  return false;
}

HasStack()

bool dart::HasStack

(

)

Definition at line 106 of file stacktrace.cc.

                {
  Thread* thread = Thread::Current();
  StackFrameIterator frames(ValidationPolicy::kDontValidateFrames, thread,
                            StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = frames.NextFrame();
  return frame != nullptr;
}

HaveSameRuntimeTypeHelper()

static bool dart::HaveSameRuntimeTypeHelper ( Zone *  zone, const Instance &  left, const Instance &  right  )

static

Definition at line 101 of file object.cc.

                                                             {
  const intptr_t left_cid = left.GetClassId();
  const intptr_t right_cid = right.GetClassId();
 
  if (left_cid != right_cid) {
    if (IsIntegerClassId(left_cid)) {
      return IsIntegerClassId(right_cid);
    } else if (IsStringClassId(left_cid)) {
      return IsStringClassId(right_cid);
    } else if (IsTypeClassId(left_cid)) {
      return IsTypeClassId(right_cid);
    } else if (IsArrayClassId(left_cid)) {
      if (!IsArrayClassId(right_cid)) {
        return false;
      }
      // Still need to check type arguments.
    } else {
      return false;
    }
  }
 
  if (left_cid == kClosureCid) {
    const auto& left_closure = Closure::Cast(left);
    const auto& right_closure = Closure::Cast(right);
    // If all the components that make up the instantiated signature are equal,
    // then no need to instantiate.
    if (left_closure.function_type_arguments() ==
            right_closure.function_type_arguments() &&
        left_closure.delayed_type_arguments() ==
            right_closure.delayed_type_arguments() &&
        left_closure.instantiator_type_arguments() ==
            right_closure.instantiator_type_arguments()) {
      const auto& left_fun = Function::Handle(zone, left_closure.function());
      const auto& right_fun = Function::Handle(zone, right_closure.function());
      if (left_fun.signature() == right_fun.signature()) {
        return true;
      }
    }
    const AbstractType& left_type =
        AbstractType::Handle(zone, left.GetType(Heap::kNew));
    const AbstractType& right_type =
        AbstractType::Handle(zone, right.GetType(Heap::kNew));
    return left_type.IsEquivalent(right_type, TypeEquality::kSyntactical);
  }
 
  if (left_cid == kRecordCid) {
    const auto& left_record = Record::Cast(left);
    const auto& right_record = Record::Cast(right);
    if (left_record.shape() != right_record.shape()) {
      return false;
    }
    Instance& left_field = Instance::Handle(zone);
    Instance& right_field = Instance::Handle(zone);
    const intptr_t num_fields = left_record.num_fields();
    for (intptr_t i = 0; i < num_fields; ++i) {
      left_field ^= left_record.FieldAt(i);
      right_field ^= right_record.FieldAt(i);
      if (!HaveSameRuntimeTypeHelper(zone, left_field, right_field)) {
        return false;
      }
    }
    return true;
  }
 
  const Class& cls = Class::Handle(zone, left.clazz());
  if (!cls.IsGeneric()) {
    return true;
  }
 
  if (left.GetTypeArguments() == right.GetTypeArguments()) {
    return true;
  }
  const TypeArguments& left_type_arguments =
      TypeArguments::Handle(zone, left.GetTypeArguments());
  const TypeArguments& right_type_arguments =
      TypeArguments::Handle(zone, right.GetTypeArguments());
  const intptr_t num_type_args = cls.NumTypeArguments();
  const intptr_t num_type_params = cls.NumTypeParameters();
  return left_type_arguments.IsSubvectorEquivalent(
      right_type_arguments, num_type_args - num_type_params, num_type_params,
      TypeEquality::kSyntactical);
}

HeapSamplingCreate()

static void * dart::HeapSamplingCreate ( Dart_Isolate  isolate, Dart_IsolateGroup  isolate_group, const char *  cls_name, intptr_t  heap_size  )

static

Definition at line 10242 of file dart_api_impl_test.cc.

  {

HeapSamplingDelete()

static void dart::HeapSamplingDelete ( void *  data )

static

Definition at line 10250 of file dart_api_impl_test.cc.

HeapSamplingReport()

void dart::HeapSamplingReport	(	void *	context,
		void *	data
	)

Definition at line 10254 of file dart_api_impl_test.cc.

Helper()

void dart::Helper

(

uword

arg

)

Definition at line 1073 of file thread_test.cc.

                       {
  auto state = reinterpret_cast<ReaderThreadState*>(arg);
  state->reader_id = OSThread::GetCurrentThreadJoinId(OSThread::Current());
  // Notify other thread.
  {
    MonitorLocker ml(state->monitor);
    state->child_started = true;
    ml.Notify();
  }
  const bool kBypassSafepoint = false;
  Thread::EnterIsolateGroupAsHelper(state->isolate_group, Thread::kUnknownTask,
                                    kBypassSafepoint);
  {
    auto thread = Thread::Current();
    intptr_t observed_value = -1;
    {
      SafepointReadRwLocker reader(thread, state->rw_lock);
      observed_value = state->value;
    }
    state->observed_value = observed_value;
  }
  Thread::ExitIsolateGroupAsHelper(kBypassSafepoint);
}

Hex()

static uint8_t dart::Hex ( uint8_t  value )

static

Definition at line 167 of file text_buffer.cc.

                                  {
  return value < 10 ? '0' + value : 'A' + value - 10;
}

HexValue() [1/2]

static int dart::HexValue ( char  digit )

static

Definition at line 48 of file uri.cc.

                                {
  if ((digit >= '0' && digit <= '9')) {
    return digit - '0';
  }
  if ((digit >= 'A' && digit <= 'F')) {
    return digit - 'A' + 10;
  }
  if ((digit >= 'a' && digit <= 'f')) {
    return digit - 'a' + 10;
  }
  UNREACHABLE();
  return 0;
}

HexValue() [2/2]

static intptr_t dart::HexValue ( uint32_t  c )

inlinestatic

Definition at line 1400 of file regexp_parser.cc.

                                            {
  c -= '0';
  if (static_cast<unsigned>(c) <= 9) return c;
  c = (c | 0x20) - ('a' - '0');  // detect 0x11..0x16 and 0x31..0x36.
  if (static_cast<unsigned>(c) <= 5) return c + 10;
  return -1;
}

IGH_CreateIsolate()

DART_EXPORT Dart_Isolate dart::IGH_CreateIsolate	(	const char *	name,
		void *	peer
	)

Definition at line 337 of file ffi_test_functions_vmspecific.cc.

                                                                         {
  struct Helper {
    static void ShutdownCallback(void* ig_data, void* isolate_data) {
      char* string = reinterpret_cast<char*>(isolate_data);
      ENSURE(string[0] == 'a');
      string[0] = 'x';
    }
    static void CleanupCallback(void* ig_data, void* isolate_data) {
      char* string = reinterpret_cast<char*>(isolate_data);
      ENSURE(string[2] == 'c');
      string[2] = 'z';
    }
  };
 
  Dart_Isolate parent = Dart_CurrentIsolate();
  Dart_ExitIsolate();
 
  char* error = nullptr;
  Dart_Isolate child =
      Dart_CreateIsolateInGroup(parent, name, &Helper::ShutdownCallback,
                                &Helper::CleanupCallback, peer, &error);
  if (child == nullptr) {
    Dart_EnterIsolate(parent);
    Dart_Handle error_obj = Dart_NewStringFromCString(error);
    free(error);
    Dart_ThrowException(error_obj);
    return nullptr;
  }
  Dart_ExitIsolate();
  Dart_EnterIsolate(parent);
  return child;
}

IGH_MsanUnpoison()

DART_EXPORT void dart::IGH_MsanUnpoison	(	void *	start,
		intptr_t	length
	)

Definition at line 333 of file ffi_test_functions_vmspecific.cc.

                                                                {
  MSAN_UNPOISON(start, length);
}

IGH_StartIsolate()

DART_EXPORT void dart::IGH_StartIsolate	(	Dart_Isolate	child_isolate,
		int64_t	main_isolate_port,
		const char *	library_uri,
		const char *	function_name,
		bool	errors_are_fatal,
		Dart_Port	on_error_port,
		Dart_Port	on_exit_port
	)

Definition at line 370 of file ffi_test_functions_vmspecific.cc.

                                                          {
  Dart_Isolate parent = Dart_CurrentIsolate();
  Dart_ExitIsolate();
  Dart_EnterIsolate(child_isolate);
  {
    Dart_EnterScope();
 
    Dart_Handle library_name = Dart_NewStringFromCString(library_uri);
    ENSURE(!Dart_IsError(library_name));
 
    Dart_Handle library = Dart_LookupLibrary(library_name);
    ENSURE(!Dart_IsError(library));
 
    Dart_Handle fun = Dart_NewStringFromCString(function_name);
    ENSURE(!Dart_IsError(fun));
 
    Dart_Handle port = Dart_NewInteger(main_isolate_port);
    ENSURE(!Dart_IsError(port));
 
    Dart_Handle args[] = {
        port,
    };
 
    Dart_Handle result = Dart_Invoke(library, fun, 1, args);
    if (Dart_IsError(result)) {
      fprintf(stderr, "Failed to invoke %s/%s in child isolate: %s\n",
              library_uri, function_name, Dart_GetError(result));
    }
    ENSURE(!Dart_IsError(result));
 
    Dart_ExitScope();
  }
 
  char* error = nullptr;
  ENSURE(
      Dart_RunLoopAsync(errors_are_fatal, on_error_port, on_exit_port, &error));
 
  Dart_EnterIsolate(parent);
}

ImmHi()

intx_t dart::ImmHi ( intx_t  imm )

inline

Definition at line 1001 of file constants_riscv.h.

                                {
  return static_cast<intx_t>(
             (static_cast<uintx_t>(imm) - static_cast<uintx_t>(ImmLo(imm)))
             << (XLEN - 32)) >>
         (XLEN - 32);
}

ImmLo()

intx_t dart::ImmLo ( intx_t  imm )

inline

Definition at line 997 of file constants_riscv.h.

                                {
  return static_cast<intx_t>(static_cast<uintx_t>(imm) << (XLEN - 12)) >>
         (XLEN - 12);
}

ImplicitReferencesCallback()

static void dart::ImplicitReferencesCallback ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 4517 of file dart_api_impl_test.cc.

                                                   {
  if (peer == &weak1) {
    weak1 = nullptr;
  } else if (peer == &weak2) {
    weak2 = nullptr;
  } else if (peer == &weak3) {
    weak3 = nullptr;
  }
}

ImportModifiedCallback()

static bool dart::ImportModifiedCallback ( const char *  url, int64_t  since  )

static

Definition at line 4520 of file isolate_reload_test.cc.

IncreaseBy()

static intptr_t dart::IncreaseBy ( intptr_t  previous, intptr_t  increase  )

static

Definition at line 291 of file regexp_ast.cc.

                                                                 {
  if (RegExpTree::kInfinity - previous < increase) {
    return RegExpTree::kInfinity;
  } else {
    return previous + increase;
  }
}

IncreaseRefcount()

DART_EXPORT void dart::IncreaseRefcount

(

RefCountedResource *

peer

)

Definition at line 1345 of file ffi_test_functions_vmspecific.cc.

                                                            {
  ref_counted_resource_mutex.lock();
  peer->refcount++;
  ref_counted_resource_mutex.unlock();
}

IndentN()

static void dart::IndentN ( int  count )

static

Definition at line 18592 of file object.cc.

                               {
  for (int i = 0; i < count; i++) {
    THR_Print(" ");
  }
}

IndexFromPPLoadDisp32()

intptr_t dart::IndexFromPPLoadDisp32

(

uword

start

)

IndexFromPPLoadDisp8()

intptr_t dart::IndexFromPPLoadDisp8

(

uword

start

)

InduceACrash()

DART_EXPORT void dart::InduceACrash

(

)

Definition at line 51 of file ffi_test_functions.cc.

                                {
  *reinterpret_cast<int*>(InduceACrash) = 123;
}

InitDartApiDL()

DART_EXPORT intptr_t dart::InitDartApiDL

(

void *

data

)

Definition at line 418 of file ffi_test_functions_vmspecific.cc.

                                               {
  return Dart_InitializeApiDL(data);
}

InitHeapSampling()

void dart::InitHeapSampling	(	Thread *	thread,
		const char *	expected_cls
	)

Definition at line 10282 of file dart_api_impl_test.cc.

                                     {
  const char* kScriptChars = R"(
    import 'dart:ffi';

InitializeExternalTypedData()

void dart::InitializeExternalTypedData	(	intptr_t	cid,
		ExternalTypedDataPtr	from,
		ExternalTypedDataPtr	to
	)

Definition at line 301 of file object_graph_copy.cc.

                                                          {
  auto raw_from = from.untag();
  auto raw_to = to.untag();
  const intptr_t length =
      TypedData::ElementSizeInBytes(cid) * Smi::Value(raw_from->length_);
 
  auto buffer = static_cast<uint8_t*>(malloc(length));
  memmove(buffer, raw_from->data_, length);
  raw_to->length_ = raw_from->length_;
  raw_to->data_ = buffer;
}

InitializeExternalTypedDataWithSafepointChecks()

void dart::InitializeExternalTypedDataWithSafepointChecks	(	Thread *	thread,
		intptr_t	cid,
		const ExternalTypedData &	from,
		const ExternalTypedData &	to
	)

Definition at line 339 of file object_graph_copy.cc.

                                 {
  const intptr_t length_in_elements = from.Length();
  const intptr_t length_in_bytes =
      TypedData::ElementSizeInBytes(cid) * length_in_elements;
 
  uint8_t* to_data = static_cast<uint8_t*>(malloc(length_in_bytes));
  to.ptr().untag()->data_ = to_data;
  to.ptr().untag()->length_ = Smi::New(length_in_elements);
 
  CopyTypedDataBaseWithSafepointChecks(thread, from, to, length_in_bytes);
}

InitializeMemory()

static void dart::InitializeMemory ( uint8_t *  input, uint8_t *  output  )

static

Definition at line 48 of file memory_copy_test.cc.

                                                              {
  const bool use_same_buffer = input == output;
  for (intptr_t i = 0; i < kMemoryTestLength; i++) {
    input[i] = ExpectedValue(i);  // Initialized.
    if (!use_same_buffer) {
      output[i] = kUnInitialized;  // Empty.
    }
  }
}

InitializeTypedDataView()

void dart::InitializeTypedDataView

(

TypedDataViewPtr

obj

)

Definition at line 355 of file object_graph_copy.cc.

                                                   {
  obj.untag()->typed_data_ = TypedDataBase::null();
  obj.untag()->offset_in_bytes_ = Smi::New(0);
  obj.untag()->length_ = Smi::New(0);
}

InitIndex()

static intptr_t dart::InitIndex ( LoopInfo *  loop )

static

Definition at line 111 of file loops.cc.

                                          {
  BlockEntryInstr* header = loop->header();
  for (intptr_t i = 0; i < header->PredecessorCount(); ++i) {
    if (!loop->Contains(header->PredecessorAt(i))) {  // pick first
      return i;
    }
  }
  UNREACHABLE();
  return -1;
}

InitNativeFields()

static void dart::InitNativeFields ( Dart_NativeArguments  args )

static

Definition at line 112 of file benchmark_test.cc.

                                                        {
  int count = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(1, count);
 
  Dart_Handle recv = Dart_GetNativeArgument(args, 0);
  EXPECT_VALID(recv);
  Dart_Handle result = Dart_SetNativeInstanceField(recv, 0, 7);
  EXPECT_VALID(result);
}

InitNewReadOnlyApiHandle()

static Dart_Handle dart::InitNewReadOnlyApiHandle ( ObjectPtr  raw )

static

Definition at line 517 of file dart_api_impl.cc.

                                                           {
  ASSERT(raw->untag()->InVMIsolateHeap());
  LocalHandle* ref = Dart::AllocateReadOnlyApiHandle();
  ref->set_ptr(raw);
  return ref->apiHandle();
}

InlineCacheMissHandler()

static void dart::InlineCacheMissHandler ( Thread *  thread, Zone *  zone, const GrowableArray< const Instance * > &  args, const ICData &  ic_data, NativeArguments  native_arguments  )

static

Definition at line 2648 of file runtime_entry.cc.

                                                                     {
#if !defined(DART_PRECOMPILED_RUNTIME)
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* caller_frame = iterator.NextFrame();
  const auto& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
  const auto& caller_function =
      Function::Handle(zone, caller_frame->LookupDartFunction());
 
  PatchableCallHandler handler(thread, args, MissHandler::kInlineCacheMiss,
                               native_arguments, caller_frame, caller_code,
                               caller_function);
 
  handler.ResolveSwitchAndReturn(ic_data);
#else
  UNREACHABLE();
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
}

InlineCacheMissHelper()

FunctionPtr dart::InlineCacheMissHelper	(	const Class &	receiver_class,
		const Array &	args_descriptor,
		const String &	target_name
	)

Definition at line 1598 of file runtime_entry.cc.

                                                             {
  // Create a demangled version of the target_name, if necessary, This is used
  // for the field getter in ResolveCallThroughGetter and as the target name
  // for the NoSuchMethod dispatcher (if needed).
  const String* demangled = &target_name;
  if (Function::IsDynamicInvocationForwarderName(target_name)) {
    demangled = &String::Handle(
        Function::DemangleDynamicInvocationForwarderName(target_name));
  }
  const bool is_getter = Field::IsGetterName(*demangled);
  Function& result = Function::Handle();
  if (is_getter ||
      !ResolveCallThroughGetter(receiver_class, target_name, *demangled,
                                args_descriptor, &result)) {
    ArgumentsDescriptor desc(args_descriptor);
    const Function& target_function =
        Function::Handle(receiver_class.GetInvocationDispatcher(
            *demangled, args_descriptor,
            UntaggedFunction::kNoSuchMethodDispatcher, FLAG_lazy_dispatchers));
    if (FLAG_trace_ic) {
      OS::PrintErr(
          "NoSuchMethod IC miss: adding <%s> id:%" Pd " -> <%s>\n",
          receiver_class.ToCString(), receiver_class.id(),
          target_function.IsNull() ? "null" : target_function.ToCString());
    }
    result = target_function.ptr();
  }
  // May be null if --no-lazy-dispatchers, in which case dispatch will be
  // handled by NoSuchMethodFromCallStub.
  ASSERT(!result.IsNull() || !FLAG_lazy_dispatchers);
  return result.ptr();
}

InlineDoubleOp()

static bool dart::InlineDoubleOp ( FlowGraph *  flow_graph, Token::Kind  op_kind, Instruction *  call, Definition *  receiver, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 1963 of file call_specializer.cc.

                                                {
  if (!CanUnboxDouble()) {
    return false;
  }
  Definition* left = receiver;
  Definition* right = call->ArgumentAt(1);
 
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
  // Arguments are checked. No need for class check.
  BinaryDoubleOpInstr* double_bin_op = new (Z)
      BinaryDoubleOpInstr(op_kind, new (Z) Value(left), new (Z) Value(right),
                          call->deopt_id(), call->source());
  flow_graph->AppendTo(*entry, double_bin_op, call->env(), FlowGraph::kValue);
  *last = double_bin_op;
  *result = double_bin_op->AsDefinition();
 
  return true;
}

InlineDoubleTestOp()

static bool dart::InlineDoubleTestOp ( FlowGraph *  flow_graph, Instruction *  call, Definition *  receiver, MethodRecognizer::Kind  kind, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 1992 of file call_specializer.cc.

                                                    {
  if (!CanUnboxDouble()) {
    return false;
  }
 
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
  // Arguments are checked. No need for class check.
 
  DoubleTestOpInstr* double_test_op = new (Z) DoubleTestOpInstr(
      kind, new (Z) Value(receiver), call->deopt_id(), call->source());
  flow_graph->AppendTo(*entry, double_test_op, call->env(), FlowGraph::kValue);
  *last = double_test_op;
  *result = double_test_op->AsDefinition();
 
  return true;
}

InlineGetIndexed()

static bool dart::InlineGetIndexed ( FlowGraph *  flow_graph, bool  can_speculate, bool  is_dynamic_call, MethodRecognizer::Kind  kind, Definition *  call, Definition *  receiver, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 1789 of file call_specializer.cc.

                                                  {
  intptr_t array_cid = MethodRecognizer::MethodKindToReceiverCid(kind);
 
  Definition* array = receiver;
  Definition* index = call->ArgumentAt(1);
 
  if (!can_speculate && is_dynamic_call && !index->Type()->IsInt()) {
    return false;
  }
 
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
  *last = *entry;
 
  array_cid =
      PrepareInlineIndexedOp(flow_graph, call, array_cid, &array, &index, last);
 
  // Array load and return.
  intptr_t index_scale = compiler::target::Instance::ElementSizeFor(array_cid);
  *result = new (Z) LoadIndexedInstr(
      new (Z) Value(array), new (Z) Value(index),
      /*index_unboxed=*/false, index_scale, array_cid, kAlignedAccess,
      call->deopt_id(), call->source(), ResultType(call));
  *last = flow_graph->AppendTo(*last, *result, call->env(), FlowGraph::kValue);
 
  if (LoadIndexedInstr::ReturnRepresentation(array_cid) == kUnboxedFloat) {
    *result =
        new (Z) FloatToDoubleInstr(new (Z) Value(*result), call->deopt_id());
    *last =
        flow_graph->AppendTo(*last, *result, call->env(), FlowGraph::kValue);
  }
 
  return true;
}

InlineGrowableArraySetter()

static bool dart::InlineGrowableArraySetter ( FlowGraph *  flow_graph, const Slot &  field, StoreBarrierType  store_barrier_type, Instruction *  call, Definition *  receiver, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 2019 of file call_specializer.cc.

                                                           {
  Definition* array = receiver;
  Definition* value = call->ArgumentAt(1);
 
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
 
  // This is an internal method, no need to check argument types.
  StoreFieldInstr* store =
      new (Z) StoreFieldInstr(field, new (Z) Value(array), new (Z) Value(value),
                              store_barrier_type, call->source());
  flow_graph->AppendTo(*entry, store, call->env(), FlowGraph::kEffect);
  *last = store;
  // We need a return value to replace uses of the original definition. However,
  // the last instruction is a field setter, which returns void, so we use null.
  *result = flow_graph->constant_null();
 
  return true;
}

InlineLoadClassId()

static bool dart::InlineLoadClassId ( FlowGraph *  flow_graph, Instruction *  call, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 2049 of file call_specializer.cc.

                                                   {
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
  auto load_cid =
      new (Z) LoadClassIdInstr(call->ArgumentValueAt(0)->CopyWithType(Z));
  flow_graph->InsertBefore(call, load_cid, nullptr, FlowGraph::kValue);
  *last = load_cid;
  *result = load_cid->AsDefinition();
  return true;
}

InlineMathIntPow()

static bool dart::InlineMathIntPow ( FlowGraph *  flow_graph, Instruction *  call, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 3054 of file call_specializer.cc.

                                                  {
  // Invoking the _intPow(x, y) implies that both:
  // (1) x, y are int
  // (2) y >= 0.
  // Thus, try to inline some very obvious cases.
  // TODO(ajcbik): useful to generalize?
  intptr_t val = 0;
  Value* x = call->ArgumentValueAt(0);
  Value* y = call->ArgumentValueAt(1);
  // Use x^0 == 1, x^1 == x, and x^c == x * .. * x for small c.
  const intptr_t small_exponent = 5;
  if (IsSmiValue(y, &val)) {
    if (val == 0) {
      *last = flow_graph->GetConstant(Smi::ZoneHandle(Smi::New(1)));
      *result = (*last)->AsDefinition();
      return true;
    } else if (val == 1) {
      *last = x->definition();
      *result = (*last)->AsDefinition();
      return true;
    } else if (1 < val && val <= small_exponent) {
      // Lazily construct entry only in this case.
      *entry = new (Z)
          FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                             call->GetBlock()->try_index(), DeoptId::kNone);
      (*entry)->InheritDeoptTarget(Z, call);
      Definition* x_def = x->definition();
      Definition* square =
          InlineMul(flow_graph, *entry, x_def, x_def)->AsDefinition();
      *last = square;
      *result = square;
      switch (val) {
        case 2:
          return true;
        case 3:
          *last = InlineMul(flow_graph, *last, x_def, square);
          *result = (*last)->AsDefinition();
          return true;
        case 4:
          *last = InlineMul(flow_graph, *last, square, square);
          *result = (*last)->AsDefinition();
          return true;
        case 5:
          *last = InlineMul(flow_graph, *last, square, square);
          *last = InlineMul(flow_graph, *last, x_def, (*last)->AsDefinition());
          *result = (*last)->AsDefinition();
          return true;
      }
    }
  }
  // Use 0^y == 0 (only for y != 0) and 1^y == 1.
  if (IsSmiValue(x, &val)) {
    if (val == 1) {
      *last = x->definition();
      *result = x->definition();
      return true;
    }
  }
  return false;
}

InlineMul()

static Instruction * dart::InlineMul ( FlowGraph *  flow_graph, Instruction *  cursor, Definition *  x, Definition *  y  )

static

Definition at line 3044 of file call_specializer.cc.

                                             {
  BinaryInt64OpInstr* mul = new (Z)
      BinaryInt64OpInstr(Token::kMUL, new (Z) Value(x), new (Z) Value(y),
                         DeoptId::kNone, Instruction::kNotSpeculative);
  return flow_graph->AppendTo(cursor, mul, nullptr, FlowGraph::kValue);
}

InlineSetIndexed()

static bool dart::InlineSetIndexed ( FlowGraph *  flow_graph, MethodRecognizer::Kind  kind, const Function &  target, Instruction *  call, Definition *  receiver, const InstructionSource &  source, CallSpecializer::ExactnessInfo *  exactness, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 1835 of file call_specializer.cc.

                                                  {
  intptr_t array_cid = MethodRecognizer::MethodKindToReceiverCid(kind);
  auto const rep = StoreIndexedInstr::ValueRepresentation(array_cid);
 
  Definition* array = receiver;
  Definition* index = call->ArgumentAt(1);
  Definition* stored_value = call->ArgumentAt(2);
 
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
  *last = *entry;
 
  bool is_unchecked_call = false;
  if (StaticCallInstr* static_call = call->AsStaticCall()) {
    is_unchecked_call =
        static_call->entry_kind() == Code::EntryKind::kUnchecked;
  } else if (InstanceCallInstr* instance_call = call->AsInstanceCall()) {
    is_unchecked_call =
        instance_call->entry_kind() == Code::EntryKind::kUnchecked;
  } else if (PolymorphicInstanceCallInstr* instance_call =
                 call->AsPolymorphicInstanceCall()) {
    is_unchecked_call =
        instance_call->entry_kind() == Code::EntryKind::kUnchecked;
  }
 
  if (!is_unchecked_call &&
      (kind != MethodRecognizer::kObjectArraySetIndexedUnchecked &&
       kind != MethodRecognizer::kGrowableArraySetIndexedUnchecked)) {
    // Only type check for the value. A type check for the index is not
    // needed here because we insert a deoptimizing smi-check for the case
    // the index is not a smi.
    const AbstractType& value_type =
        AbstractType::ZoneHandle(Z, target.ParameterTypeAt(2));
    Definition* type_args = nullptr;
    if (rep == kTagged) {
      const Class& instantiator_class = Class::Handle(Z, target.Owner());
      LoadFieldInstr* load_type_args =
          new (Z) LoadFieldInstr(new (Z) Value(array),
                                 Slot::GetTypeArgumentsSlotFor(
                                     flow_graph->thread(), instantiator_class),
                                 call->source());
      *last = flow_graph->AppendTo(*last, load_type_args, call->env(),
                                   FlowGraph::kValue);
      type_args = load_type_args;
    } else if (!RepresentationUtils::IsUnboxed(rep)) {
      UNREACHABLE();
    } else {
      type_args = flow_graph->constant_null();
      ASSERT(value_type.IsInstantiated());
#if defined(DEBUG)
      if (rep == kUnboxedFloat || rep == kUnboxedDouble) {
        ASSERT(value_type.IsDoubleType());
      } else if (rep == kUnboxedFloat32x4) {
        ASSERT(value_type.IsFloat32x4Type());
      } else if (rep == kUnboxedInt32x4) {
        ASSERT(value_type.IsInt32x4Type());
      } else if (rep == kUnboxedFloat64x2) {
        ASSERT(value_type.IsFloat64x2Type());
      } else {
        ASSERT(RepresentationUtils::IsUnboxedInteger(rep));
        ASSERT(value_type.IsIntType());
      }
#endif
    }
 
    if (exactness != nullptr && exactness->is_exact) {
      exactness->emit_exactness_guard = true;
    } else {
      auto const function_type_args = flow_graph->constant_null();
      auto const dst_type = flow_graph->GetConstant(value_type);
      AssertAssignableInstr* assert_value = new (Z) AssertAssignableInstr(
          source, new (Z) Value(stored_value), new (Z) Value(dst_type),
          new (Z) Value(type_args), new (Z) Value(function_type_args),
          Symbols::Value(), call->deopt_id());
      *last = flow_graph->AppendSpeculativeTo(*last, assert_value, call->env(),
                                              FlowGraph::kValue);
    }
  }
 
  array_cid =
      PrepareInlineIndexedOp(flow_graph, call, array_cid, &array, &index, last);
 
  const bool is_typed_data_store = IsTypedDataBaseClassId(array_cid);
 
  // Check if store barrier is needed. Byte arrays don't need a store barrier.
  StoreBarrierType needs_store_barrier =
      is_typed_data_store ? kNoStoreBarrier : kEmitStoreBarrier;
 
  if (rep == kUnboxedFloat) {
    stored_value = new (Z)
        DoubleToFloatInstr(new (Z) Value(stored_value), call->deopt_id());
    *last = flow_graph->AppendTo(*last, stored_value, call->env(),
                                 FlowGraph::kValue);
  } else if (RepresentationUtils::IsUnboxedInteger(rep)) {
    // Insert explicit unboxing instructions with truncation to avoid relying
    // on [SelectRepresentations] which doesn't mark them as truncating.
    stored_value =
        UnboxInstr::Create(rep, new (Z) Value(stored_value), call->deopt_id(),
                           Instruction::kNotSpeculative);
    *last = flow_graph->AppendTo(*last, stored_value, call->env(),
                                 FlowGraph::kValue);
  }
 
  const intptr_t index_scale =
      compiler::target::Instance::ElementSizeFor(array_cid);
  auto* const store = new (Z) StoreIndexedInstr(
      new (Z) Value(array), new (Z) Value(index), new (Z) Value(stored_value),
      needs_store_barrier, /*index_unboxed=*/false, index_scale, array_cid,
      kAlignedAccess, call->deopt_id(), call->source());
  *last = flow_graph->AppendTo(*last, store, call->env(), FlowGraph::kEffect);
  // We need a return value to replace uses of the original definition. However,
  // the final instruction is a use of 'void operator[]=()', so we use null.
  *result = flow_graph->constant_null();
  return true;
}

InlineSimdOp()

static bool dart::InlineSimdOp ( FlowGraph *  flow_graph, bool  is_dynamic_call, Instruction *  call, Definition *  receiver, MethodRecognizer::Kind  kind, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 2921 of file call_specializer.cc.

                                              {
  if (is_dynamic_call && call->ArgumentCount() > 1) {
    // Issue(dartbug.com/37737): Dynamic invocation forwarders have the
    // same recognized kind as the method they are forwarding to.
    // That causes us to inline the recognized method and not the
    // dyn: forwarder itself.
    // This is only safe if all arguments are checked in the flow graph we
    // build.
    // For double/int arguments speculative unboxing instructions should ensure
    // to bailout in AOT (or deoptimize in JIT) if the incoming values are not
    // correct. Though for user-implementable types, like
    // operator+(Float32x4 other), this is not safe and we therefore bailout.
    return false;
  }
 
  if (!FLAG_enable_simd_inline) {
    return false;
  }
 
  if (!FlowGraphCompiler::SupportsUnboxedSimd128()) {
#if defined(TARGET_ARCH_RISCV32) || defined(TARGET_ARCH_RISCV64)
    SimdLowering lowering(flow_graph, call, graph_entry, entry, last, result);
    return lowering.TryInline(kind);
#else
    return false;
#endif
  }
 
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  Instruction* cursor = *entry;
  switch (kind) {
    case MethodRecognizer::kInt32x4Shuffle:
    case MethodRecognizer::kInt32x4ShuffleMix:
    case MethodRecognizer::kFloat32x4Shuffle:
    case MethodRecognizer::kFloat32x4ShuffleMix: {
      Definition* mask_definition = call->ArgumentAt(call->ArgumentCount() - 1);
      intptr_t mask = 0;
      if (!CheckMask(mask_definition, &mask)) {
        return false;
      }
      *last = SimdOpInstr::CreateFromCall(Z, kind, receiver, call, mask);
      break;
    }
 
    case MethodRecognizer::kFloat32x4WithX:
    case MethodRecognizer::kFloat32x4WithY:
    case MethodRecognizer::kFloat32x4WithZ:
    case MethodRecognizer::kFloat32x4WithW:
    case MethodRecognizer::kFloat32x4Scale: {
      Definition* left = receiver;
      Definition* right = call->ArgumentAt(1);
      // Note: left and right values are swapped when handed to the instruction,
      // this is done so that the double value is loaded into the output
      // register and can be destroyed.
      // TODO(dartbug.com/31035) this swapping is only needed because register
      // allocator has SameAsFirstInput policy and not SameAsNthInput(n).
      *last = SimdOpInstr::Create(kind, new (Z) Value(right),
                                  new (Z) Value(left), call->deopt_id());
      break;
    }
 
    case MethodRecognizer::kFloat32x4Zero:
    case MethodRecognizer::kFloat32x4ToFloat64x2:
    case MethodRecognizer::kFloat64x2ToFloat32x4:
    case MethodRecognizer::kFloat32x4ToInt32x4:
    case MethodRecognizer::kInt32x4ToFloat32x4:
    case MethodRecognizer::kFloat64x2Zero:
      *last = SimdOpInstr::CreateFromFactoryCall(Z, kind, call);
      break;
    case MethodRecognizer::kFloat32x4Mul:
    case MethodRecognizer::kFloat32x4Div:
    case MethodRecognizer::kFloat32x4Add:
    case MethodRecognizer::kFloat32x4Sub:
    case MethodRecognizer::kFloat64x2Mul:
    case MethodRecognizer::kFloat64x2Div:
    case MethodRecognizer::kFloat64x2Add:
    case MethodRecognizer::kFloat64x2Sub:
      *last = SimdOpInstr::CreateFromCall(Z, kind, receiver, call);
      if (CompilerState::Current().is_aot()) {
        // Add null-checks in case of the arguments are known to be compatible
        // but they are possibly nullable.
        // By inserting the null-check, we can allow the unbox instruction later
        // inserted to be non-speculative.
        CheckNullInstr* check1 =
            new (Z) CheckNullInstr(new (Z) Value(receiver), Symbols::FirstArg(),
                                   call->deopt_id(), call->source());
 
        CheckNullInstr* check2 = new (Z) CheckNullInstr(
            new (Z) Value(call->ArgumentAt(1)), Symbols::SecondArg(),
            call->deopt_id(), call->source(), CheckNullInstr::kArgumentError);
 
        (*last)->SetInputAt(0, new (Z) Value(check1));
        (*last)->SetInputAt(1, new (Z) Value(check2));
 
        flow_graph->InsertBefore(call, check1, call->env(), FlowGraph::kValue);
        flow_graph->InsertBefore(call, check2, call->env(), FlowGraph::kValue);
      }
      break;
    default:
      *last = SimdOpInstr::CreateFromCall(Z, kind, receiver, call);
      break;
  }
  // InheritDeoptTarget also inherits environment (which may add 'entry' into
  // env_use_list()), so InheritDeoptTarget should be done only after decided
  // to inline.
  (*entry)->InheritDeoptTarget(Z, call);
  flow_graph->AppendTo(
      cursor, *last, call->deopt_id() != DeoptId::kNone ? call->env() : nullptr,
      FlowGraph::kValue);
  *result = (*last)->AsDefinition();
  return true;
}

InlineStringBaseCharAt()

static bool dart::InlineStringBaseCharAt ( FlowGraph *  flow_graph, Instruction *  call, Definition *  receiver, intptr_t  cid, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 2106 of file call_specializer.cc.

                                                        {
  if (cid != kOneByteStringCid) {
    return false;
  }
  Definition* str = receiver;
  Definition* index = call->ArgumentAt(1);
 
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
 
  *last = PrepareInlineStringIndexOp(flow_graph, call, cid, str, index, *entry);
 
  OneByteStringFromCharCodeInstr* char_at = new (Z)
      OneByteStringFromCharCodeInstr(new (Z) Value((*last)->AsDefinition()));
 
  flow_graph->AppendTo(*last, char_at, nullptr, FlowGraph::kValue);
  *last = char_at;
  *result = char_at->AsDefinition();
 
  return true;
}

InlineStringBaseCodeUnitAt()

static bool dart::InlineStringBaseCodeUnitAt ( FlowGraph *  flow_graph, Instruction *  call, Definition *  receiver, intptr_t  cid, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result  )

static

Definition at line 2137 of file call_specializer.cc.

                                                            {
  if (cid == kDynamicCid) {
    ASSERT(call->IsStaticCall());
    return false;
  } else if ((cid != kOneByteStringCid) && (cid != kTwoByteStringCid)) {
    return false;
  }
  Definition* str = receiver;
  Definition* index = call->ArgumentAt(1);
 
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
 
  *last = PrepareInlineStringIndexOp(flow_graph, call, cid, str, index, *entry);
  *result = (*last)->AsDefinition();
 
  return true;
}

InlineTypedDataIndexCheck()

static bool dart::InlineTypedDataIndexCheck ( FlowGraph *  flow_graph, Instruction *  call, Definition *  receiver, GraphEntryInstr *  graph_entry, FunctionEntryInstr **  entry, Instruction **  last, Definition **  result, const String &  symbol  )

static

Definition at line 1717 of file call_specializer.cc.

                                                            {
  *entry =
      new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                 call->GetBlock()->try_index(), DeoptId::kNone);
  (*entry)->InheritDeoptTarget(Z, call);
  Instruction* cursor = *entry;
 
  Definition* index = call->ArgumentAt(1);
  Definition* length = call->ArgumentAt(2);
 
  if (CompilerState::Current().is_aot()) {
    // Add a null-check in case the index argument is known to be compatible
    // but possibly nullable. We don't need to do the same for length
    // because all callers in typed_data_patch.dart retrieve the length
    // from the typed data object.
    auto* const null_check =
        new (Z) CheckNullInstr(new (Z) Value(index), symbol, call->deopt_id(),
                               call->source(), CheckNullInstr::kArgumentError);
    cursor = flow_graph->AppendTo(cursor, null_check, call->env(),
                                  FlowGraph::kEffect);
  }
  index = flow_graph->CreateCheckBound(length, index, call->deopt_id());
  cursor = flow_graph->AppendTo(cursor, index, call->env(), FlowGraph::kValue);
 
  *last = cursor;
  *result = index;
  return true;
}

InSameGroup()

static bool dart::InSameGroup ( Isolate *  sender, const SendPort &  receiver  )

static

Definition at line 105 of file isolate.cc.

                                                                   {
  // Cannot determine whether sender is in same group (yet).
  if (sender->origin_id() == ILLEGAL_PORT) return false;
 
  // Only allow arbitrary messages between isolates of the same IG.
  return sender->origin_id() == receiver.origin_id();
}

InsertFakeSample()

static void dart::InsertFakeSample ( uword *  pc_offsets )

static

Definition at line 2167 of file profiler_test.cc.

                                                {
  Isolate* isolate = Isolate::Current();
  ASSERT(Profiler::sample_block_buffer() != nullptr);
  Sample* sample = Profiler::sample_block_buffer()->ReserveCPUSample(isolate);
  ASSERT(sample != nullptr);
  sample->Init(isolate->main_port(), OS::GetCurrentMonotonicMicros(),
               OSThread::Current()->trace_id());
  sample->set_thread_task(Thread::kMutatorTask);
 
  intptr_t i = 0;
  while (pc_offsets[i] != 0) {
    // When we collect a real stack trace, all PCs collected aside from the
    // executing one (i == 0) are actually return addresses. Return addresses
    // are one byte beyond the call instruction that is executing. The profiler
    // accounts for this and subtracts one from these addresses when querying
    // inline and token position ranges. To be consistent with real stack
    // traces, we add one byte to all PCs except the executing one.
    // See OffsetForPC in profiler_service.cc for more context.
    const intptr_t return_address_offset = i > 0 ? 1 : 0;
    sample->SetAt(i, pc_offsets[i] + return_address_offset);
    i++;
  }
  sample->SetAt(i, 0);
}

InsertRangeInCanonicalList()

static intptr_t dart::InsertRangeInCanonicalList ( ZoneGrowableArray< CharacterRange > *  list, intptr_t  count, CharacterRange  insert  )

static

Definition at line 4811 of file regexp.cc.

                           {
  // Inserts a range into list[0..count[, which must be sorted
  // by from value and non-overlapping and non-adjacent, using at most
  // list[0..count] for the result. Returns the number of resulting
  // canonicalized ranges. Inserting a range may collapse existing ranges into
  // fewer ranges, so the return value can be anything in the range 1..count+1.
  int32_t from = insert.from();
  int32_t to = insert.to();
  intptr_t start_pos = 0;
  intptr_t end_pos = count;
  for (intptr_t i = count - 1; i >= 0; i--) {
    CharacterRange current = list->At(i);
    if (current.from() > to + 1) {
      end_pos = i;
    } else if (current.to() + 1 < from) {
      start_pos = i + 1;
      break;
    }
  }
 
  // Inserted range overlaps, or is adjacent to, ranges at positions
  // [start_pos..end_pos[. Ranges before start_pos or at or after end_pos are
  // not affected by the insertion.
  // If start_pos == end_pos, the range must be inserted before start_pos.
  // if start_pos < end_pos, the entire range from start_pos to end_pos
  // must be merged with the insert range.
 
  if (start_pos == end_pos) {
    // Insert between existing ranges at position start_pos.
    if (start_pos < count) {
      MoveRanges(list, start_pos, start_pos + 1, count - start_pos);
    }
    (*list)[start_pos] = insert;
    return count + 1;
  }
  if (start_pos + 1 == end_pos) {
    // Replace single existing range at position start_pos.
    CharacterRange to_replace = list->At(start_pos);
    intptr_t new_from = Utils::Minimum(to_replace.from(), from);
    intptr_t new_to = Utils::Maximum(to_replace.to(), to);
    (*list)[start_pos] = CharacterRange(new_from, new_to);
    return count;
  }
  // Replace a number of existing ranges from start_pos to end_pos - 1.
  // Move the remaining ranges down.
 
  intptr_t new_from = Utils::Minimum(list->At(start_pos).from(), from);
  intptr_t new_to = Utils::Maximum(list->At(end_pos - 1).to(), to);
  if (end_pos < count) {
    MoveRanges(list, end_pos, start_pos + 1, count - end_pos);
  }
  (*list)[start_pos] = CharacterRange(new_from, new_to);
  return count - (end_pos - start_pos) + 1;
}

InsertRedefinition()

static RedefinitionInstr * dart::InsertRedefinition ( FlowGraph *  graph, BlockEntryInstr *  dom, Definition *  original, const Object &  constant_value  )

static

Definition at line 1584 of file constant_propagator.cc.

                                                                           {
  auto redef = new RedefinitionInstr(new Value(original),
                                     /*inserted_by_constant_propagation=*/true);
 
  graph->InsertAfter(dom, redef, nullptr, FlowGraph::kValue);
  graph->RenameDominatedUses(original, redef, redef);
 
  if (redef->input_use_list() == nullptr) {
    // There are no dominated uses, so the newly added Redefinition is useless.
    redef->RemoveFromGraph();
    return nullptr;
  }
 
  redef->constant_value() = constant_value.ptr();
  return redef;
}

InspectStack()

void dart::InspectStack

(

Dart_NativeArguments

args

)

Definition at line 463 of file inliner_test.cc.

                                             {
#ifndef PRODUCT
  Dart_EnterScope();
 
  Dart_StackTrace stacktrace;
  Dart_Handle result = Dart_GetStackTrace(&stacktrace);
  EXPECT_VALID(result);
 
  intptr_t frame_count = 0;
  result = Dart_StackTraceLength(stacktrace, &frame_count);
  EXPECT_VALID(result);
  EXPECT_EQ(3, frame_count);
  // Test something bigger than the preallocated size to verify nothing was
  // truncated.
  EXPECT(102 > StackTrace::kPreallocatedStackdepth);
 
  Dart_Handle function_name;
  Dart_Handle script_url;
  intptr_t line_number = 0;
  intptr_t column_number = 0;
  const char* cstr = "";
  const char* test_lib = "file:///test-lib";
 
  // Top frame is InspectStack().
  Dart_ActivationFrame frame;
  result = Dart_GetActivationFrame(stacktrace, 0, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("InspectStack", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_STREQ(test_lib, cstr);
  EXPECT_EQ(11, line_number);
  EXPECT_EQ(24, column_number);
 
  // Second frame is foo() positioned at call to InspectStack().
  result = Dart_GetActivationFrame(stacktrace, 1, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("foo", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_STREQ(test_lib, cstr);
 
  // Bottom frame positioned at main().
  result = Dart_GetActivationFrame(stacktrace, frame_count - 1, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("main", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_STREQ(test_lib, cstr);
 
  // Out-of-bounds frames.
  result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
  EXPECT(Dart_IsError(result));
  result = Dart_GetActivationFrame(stacktrace, -1, &frame);
  EXPECT(Dart_IsError(result));
 
  Dart_SetReturnValue(args, Dart_NewInteger(42));
  Dart_ExitScope();
#endif  // !PRODUCT
}

InstanceIsType()

static bool dart::InstanceIsType ( const Thread *  thread, const Instance &  instance, const Type &  type  )

static

Definition at line 2272 of file dart_api_impl.cc.

                                             {
  ASSERT(!type.IsNull());
  CHECK_CALLBACK_STATE(thread);
  return instance.IsInstanceOf(type, Object::null_type_arguments(),
                               Object::null_type_arguments());
}

InstantiateType()

static AbstractTypePtr dart::InstantiateType ( const AbstractType &  type, const AbstractType &  instantiator  )

static

Definition at line 614 of file mirrors.cc.

                                                                         {
  // Generic function type parameters are not reified, but mapped to dynamic,
  // i.e. all function type parameters are free with a null vector.
  ASSERT(type.IsFinalized());
  ASSERT(type.IsCanonical());
  Thread* thread = Thread::Current();
 
  if (type.IsInstantiated()) {
    return type.Canonicalize(thread);
  }
  TypeArguments& instantiator_type_args = TypeArguments::Handle();
  if (!instantiator.IsNull() && instantiator.IsType()) {
    ASSERT(instantiator.IsFinalized());
    if (instantiator.type_class_id() == kInstanceCid) {
      // Handle types created in ClosureMirror_function.
      instantiator_type_args = instantiator.arguments();
    } else {
      instantiator_type_args =
          Type::Cast(instantiator)
              .GetInstanceTypeArguments(thread, /*canonicalize=*/false);
    }
  }
  AbstractType& result = AbstractType::Handle(type.InstantiateFrom(
      instantiator_type_args, Object::null_type_arguments(), kAllFree,
      Heap::kOld));
  ASSERT(result.IsFinalized());
  return result.Canonicalize(thread);
}

INSTRUCTION_TEST() [1/8]

dart::INSTRUCTION_TEST	(	Binary1	,
		2	,
		(Register out, Register in0, FpuRegister in1)	,
		ReqReg	,
		(ReqReg, Location::RequiresFpuRegister())	,
		()	,
		RegLoc(0)	,
		(RegLoc(1), FpuLoc(2))	,
		()
	)

Definition at line 131 of file locations_helpers_test.cc.

                     {
  EXPECT_EQ(Reg(0), out);
  EXPECT_EQ(Reg(1), in0);
  EXPECT_EQ(Fpu(2), in1);
}

INSTRUCTION_TEST() [2/8]

dart::INSTRUCTION_TEST	(	Binary2	,
		2	,
		(Register out, FpuRegister in0, Register in1)	,
		ReqReg	,
		(ReqFpu, ReqReg)	,
		()	,
		RegLoc(0)	,
		(FpuLoc(1), RegLoc(2))	,
		()
	)

Definition at line 146 of file locations_helpers_test.cc.

                     {
  EXPECT_EQ(Reg(0), out);
  EXPECT_EQ(Fpu(1), in0);
  EXPECT_EQ(Reg(2), in1);
}

INSTRUCTION_TEST() [3/8]

dart::INSTRUCTION_TEST	(	FixedInput	,
		1	,
		(FpuRegister out, Fixed< FpuRegister, Fpu(3)> in)	,
		ReqFpu	,
		(FpuLoc(3))	,
		()	,
		FpuLoc(0)	,
		(FpuLoc(3))	,
		()
	)

Definition at line 174 of file locations_helpers_test.cc.

                     {
  EXPECT_EQ(Fpu(0), out);
  EXPECT_EQ(Fpu(3), Fpu(in));
}

INSTRUCTION_TEST() [4/8]

dart::INSTRUCTION_TEST	(	FixedOutput	,
		0	,
		(Fixed< Register, Reg(3)> out)	,
		RegLoc(3)	,
		()	,
		()	,
		RegLoc(3)	,
		()	,
		()
	)

Definition at line 161 of file locations_helpers_test.cc.

                     {
  EXPECT_EQ(Reg(3), Reg(out));
}

INSTRUCTION_TEST() [5/8]

dart::INSTRUCTION_TEST	(	FixedTemp	,
		0	,
		(FpuRegister out, Temp< Fixed< FpuRegister, Fpu(3)> > temp)	,
		ReqFpu	,
		()	,
		(FpuLoc(3))	,
		FpuLoc(4)	,
		()	,
		(FpuLoc(3))
	)

Definition at line 223 of file locations_helpers_test.cc.

                              {
  EXPECT_EQ(Fpu(4), out);
  EXPECT_EQ(Fpu(3), Fpu(temp));
}

INSTRUCTION_TEST() [6/8]

dart::INSTRUCTION_TEST	(	SameAsFirstInput	,
		2	,
		(SameAsFirstInput, Register in0, Register in1)	,
		Location::SameAsFirstInput()	,
		(ReqReg, ReqReg)	,
		()	,
		RegLoc(0)	,
		(RegLoc(0), RegLoc(1))	,
		()
	)

Definition at line 188 of file locations_helpers_test.cc.

                     {
  EXPECT_EQ(Reg(0), in0);
  EXPECT_EQ(Reg(1), in1);
}

INSTRUCTION_TEST() [7/8]

dart::INSTRUCTION_TEST	(	Temps	,
		2	,
		(Register out, Register in0, FpuRegister in1, Temp< FpuRegister > temp0, Temp< Register > temp1)	,
		ReqReg	,
		(ReqReg, ReqFpu)	,
		(ReqFpu, ReqReg)	,
		RegLoc(0)	,
		(RegLoc(1), FpuLoc(2))	,
		(FpuLoc(3), RegLoc(4))
	)

Definition at line 202 of file locations_helpers_test.cc.

                                         {
  EXPECT_EQ(Reg(0), out);
  EXPECT_EQ(Reg(1), in0);
  EXPECT_EQ(Fpu(2), in1);
  EXPECT_EQ(Fpu(3), Fpu(temp0));
  EXPECT_EQ(Reg(4), Reg(temp1));
}

INSTRUCTION_TEST() [8/8]

dart::INSTRUCTION_TEST	(	Unary	,
		1	,
		(Register out, Register in)	,
		ReqReg	,
		(ReqReg)	,
		()	,
		RegLoc(0)	,
		(RegLoc(1))	,
		()
	)

Definition at line 117 of file locations_helpers_test.cc.

                     {
  EXPECT_EQ(Reg(0), out);
  EXPECT_EQ(Reg(1), in);
}

IntComputation()

DART_EXPORT int64_t dart::IntComputation	(	int8_t	a,
		int16_t	b,
		int32_t	c,
		int64_t	d
	)

Definition at line 198 of file ffi_test_functions.cc.

                                                                              {
  std::cout << "IntComputation(" << static_cast<int>(a) << ", " << b << ", "
            << c << ", " << d << ")\n";
  const int64_t retval = d - c + b - a;
  std::cout << "returning " << retval << "\n";
  return retval;
}

IntptrAdditionClosure()

DART_EXPORT IntptrBinOp dart::IntptrAdditionClosure

(

)

Definition at line 593 of file ffi_test_functions.cc.

                                                {
  std::cout << "IntptrAdditionClosure()\n";
  IntptrBinOp retval = [](intptr_t a, intptr_t b) { return a + b; };
  std::cout << "returning " << &retval << "\n";
  return retval;
}

InvalidForwarding()

DART_NOINLINE static DART_NORETURN void dart::InvalidForwarding ( ObjectPtr  before, ObjectPtr  after, const char *  message  )

static

Definition at line 255 of file become.cc.

                                                   {
  // Separate prints so we can at least get partial information if header
  // dereference or ToCString crashes.
  OS::PrintErr("become: %s\n", message);
  OS::PrintErr("before: %" Px "\n", static_cast<uword>(before));
  OS::PrintErr("after: %" Px "\n", static_cast<uword>(after));
  OS::PrintErr("before header: %" Px "\n",
               before->IsHeapObject() ? before->untag()->tags() : 0);
  OS::PrintErr("after header: %" Px "\n",
               after->IsHeapObject() ? after->untag()->tags() : 0);
  // Create both handles before either ToCString.
  Object& before_handle = Object::Handle(before);
  Object& after_handle = Object::Handle(after);
  OS::PrintErr("before: %s\n", before_handle.ToCString());
  OS::PrintErr("after: %s\n", after_handle.ToCString());
  FATAL("become: %s", message);
}

InventFloatValue()

DART_EXPORT float dart::InventFloatValue

(

)

Definition at line 830 of file ffi_test_functions.cc.

                                     {
  std::cout << "InventFloatValue()\n";
  const float retval = 1337.0f;
  std::cout << "returning " << retval << "\n";
  return retval;
}

InvertCondition() [1/4]

static Condition dart::InvertCondition ( Condition  c )

inlinestatic

Definition at line 804 of file constants_arm.h.

                                                     {
  COMPILE_ASSERT((EQ ^ NE) == 1);
  COMPILE_ASSERT((CS ^ CC) == 1);
  COMPILE_ASSERT((MI ^ PL) == 1);
  COMPILE_ASSERT((VS ^ VC) == 1);
  COMPILE_ASSERT((HI ^ LS) == 1);
  COMPILE_ASSERT((GE ^ LT) == 1);
  COMPILE_ASSERT((GT ^ LE) == 1);
  ASSERT(c != AL);
  ASSERT(c != kSpecialCondition);
  ASSERT(c != kInvalidCondition);
  return static_cast<Condition>(c ^ 1);
}

InvertCondition() [2/4]

static Condition dart::InvertCondition ( Condition  c )

inlinestatic

Definition at line 680 of file constants_arm64.h.

                                                     {
  COMPILE_ASSERT((EQ ^ NE) == 1);
  COMPILE_ASSERT((CS ^ CC) == 1);
  COMPILE_ASSERT((MI ^ PL) == 1);
  COMPILE_ASSERT((VS ^ VC) == 1);
  COMPILE_ASSERT((HI ^ LS) == 1);
  COMPILE_ASSERT((GE ^ LT) == 1);
  COMPILE_ASSERT((GT ^ LE) == 1);
  COMPILE_ASSERT((AL ^ NV) == 1);
  ASSERT(c != AL);
  ASSERT(c != kInvalidCondition);
  return static_cast<Condition>(c ^ 1);
}

InvertCondition() [3/4]

static Condition dart::InvertCondition ( Condition  c )

inlinestatic

Definition at line 642 of file constants_riscv.h.

                                                     {
  COMPILE_ASSERT((EQ ^ NE) == 1);
  COMPILE_ASSERT((CS ^ CC) == 1);
  COMPILE_ASSERT((MI ^ PL) == 1);
  COMPILE_ASSERT((VS ^ VC) == 1);
  COMPILE_ASSERT((HI ^ LS) == 1);
  COMPILE_ASSERT((GE ^ LT) == 1);
  COMPILE_ASSERT((GT ^ LE) == 1);
  COMPILE_ASSERT((AL ^ NV) == 1);
  ASSERT(c != AL);
  ASSERT(c != kInvalidCondition);
  return static_cast<Condition>(c ^ 1);
}

InvertCondition() [4/4]

static Condition dart::InvertCondition ( Condition  c )

inlinestatic

Definition at line 52 of file constants_x86.h.

                                                     {
  COMPILE_ASSERT((OVERFLOW ^ NO_OVERFLOW) == 1);
  COMPILE_ASSERT((BELOW ^ ABOVE_EQUAL) == 1);
  COMPILE_ASSERT((EQUAL ^ NOT_EQUAL) == 1);
  COMPILE_ASSERT((BELOW_EQUAL ^ ABOVE) == 1);
  COMPILE_ASSERT((SIGN ^ NOT_SIGN) == 1);
  COMPILE_ASSERT((PARITY_EVEN ^ PARITY_ODD) == 1);
  COMPILE_ASSERT((LESS ^ GREATER_EQUAL) == 1);
  COMPILE_ASSERT((LESS_EQUAL ^ GREATER) == 1);
  ASSERT(c != kInvalidCondition);
  return static_cast<Condition>(c ^ 1);
}

InVmTests()

static bool dart::InVmTests ( const Function &  function )

static

Definition at line 9061 of file object.cc.

                                                {
#if defined(TESTING)
  return true;
#else
  auto* zone = Thread::Current()->zone();
  const auto& cls = Class::Handle(zone, function.Owner());
  const auto& lib = Library::Handle(zone, cls.library());
  const auto& url = String::Handle(zone, lib.url());
  const bool in_vm_tests =
      strstr(url.ToCString(), "runtime/tests/vm/") != nullptr;
  return in_vm_tests;
#endif
}

Invoke() [1/3]

ObjectPtr dart::Invoke	(	const Library &	lib,
		const char *	name
	)

Definition at line 84 of file il_test_helper.cc.

                                                       {
  Thread* thread = Thread::Current();
  Dart_Handle api_lib = Api::NewHandle(thread, lib.ptr());
  Dart_Handle result;
  {
    TransitionVMToNative transition(thread);
    result =
        Dart_Invoke(api_lib, NewString(name), /*argc=*/0, /*argv=*/nullptr);
    EXPECT_VALID(result);
  }
  return Api::UnwrapHandle(result);
}

Invoke() [2/3]

static void dart::Invoke ( const Library &  lib, const char *  name, intptr_t  argc = 0, Dart_Handle *  argv = nullptr  )

static

Definition at line 238 of file profiler_test.cc.

                                                {
  Thread* thread = Thread::Current();
  Dart_Handle api_lib = Api::NewHandle(thread, lib.ptr());
  TransitionVMToNative transition(thread);
  Dart_Handle result = Dart_Invoke(api_lib, NewString(name), argc, argv);
  EXPECT_VALID(result);
}

Invoke() [3/3]

static void dart::Invoke ( Thread *  thread, JSONStream *  js  )

static

Definition at line 2629 of file service.cc.

                                                   {
  const char* receiver_id = js->LookupParam("targetId");
  if (receiver_id == nullptr) {
    PrintMissingParamError(js, "targetId");
    return;
  }
  const char* selector_cstr = js->LookupParam("selector");
  if (selector_cstr == nullptr) {
    PrintMissingParamError(js, "selector");
    return;
  }
  const char* argument_ids = js->LookupParam("argumentIds");
  if (argument_ids == nullptr) {
    PrintMissingParamError(js, "argumentIds");
    return;
  }
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  bool disable_breakpoints =
      BoolParameter::Parse(js->LookupParam("disableBreakpoints"), false);
  DisableBreakpointsScope db(thread->isolate()->debugger(),
                             disable_breakpoints);
#endif
 
  Zone* zone = thread->zone();
  ObjectIdRing::LookupResult lookup_result;
  Object& receiver = Object::Handle(
      zone, LookupHeapObject(thread, receiver_id, &lookup_result));
  if (receiver.ptr() == Object::sentinel().ptr()) {
    if (lookup_result == ObjectIdRing::kCollected) {
      PrintSentinel(js, kCollectedSentinel);
    } else if (lookup_result == ObjectIdRing::kExpired) {
      PrintSentinel(js, kExpiredSentinel);
    } else {
      PrintInvalidParamError(js, "targetId");
    }
    return;
  }
 
  const GrowableObjectArray& growable_args =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
 
  bool is_instance = (receiver.IsInstance() || receiver.IsNull()) &&
                     !ContainsNonInstance(receiver);
  if (is_instance) {
    growable_args.Add(receiver);
  }
 
  intptr_t n = strlen(argument_ids);
  if ((n < 2) || (argument_ids[0] != '[') || (argument_ids[n - 1] != ']')) {
    PrintInvalidParamError(js, "argumentIds");
    return;
  }
  if (n > 2) {
    intptr_t start = 1;
    while (start < n) {
      intptr_t end = start;
      while ((argument_ids[end + 1] != ',') && (argument_ids[end + 1] != ']')) {
        end++;
      }
      if (end == start) {
        // Empty element.
        PrintInvalidParamError(js, "argumentIds");
        return;
      }
 
      const char* argument_id =
          zone->MakeCopyOfStringN(&argument_ids[start], end - start + 1);
 
      ObjectIdRing::LookupResult lookup_result;
      Object& argument = Object::Handle(
          zone, LookupHeapObject(thread, argument_id, &lookup_result));
      // Invoke only accepts Instance arguments.
      if (!(argument.IsInstance() || argument.IsNull()) ||
          ContainsNonInstance(argument)) {
        PrintInvalidParamError(js, "argumentIds");
        return;
      }
      if (argument.ptr() == Object::sentinel().ptr()) {
        if (lookup_result == ObjectIdRing::kCollected) {
          PrintSentinel(js, kCollectedSentinel);
        } else if (lookup_result == ObjectIdRing::kExpired) {
          PrintSentinel(js, kExpiredSentinel);
        } else {
          PrintInvalidParamError(js, "argumentIds");
        }
        return;
      }
      growable_args.Add(argument);
 
      start = end + 3;
    }
  }
 
  const String& selector = String::Handle(zone, String::New(selector_cstr));
  const Array& args =
      Array::Handle(zone, Array::MakeFixedLength(growable_args));
  const Array& arg_names = Object::empty_array();
 
  if (receiver.IsLibrary()) {
    const Library& lib = Library::Cast(receiver);
    const Object& result =
        Object::Handle(zone, lib.Invoke(selector, args, arg_names));
    result.PrintJSON(js, true);
    return;
  }
  if (receiver.IsClass()) {
    const Class& cls = Class::Cast(receiver);
    const Object& result =
        Object::Handle(zone, cls.Invoke(selector, args, arg_names));
    result.PrintJSON(js, true);
    return;
  }
  if (is_instance) {
    // We don't use Instance::Cast here because it doesn't allow null.
    Instance& instance = Instance::Handle(zone);
    instance ^= receiver.ptr();
    const Object& result =
        Object::Handle(zone, instance.Invoke(selector, args, arg_names));
    result.PrintJSON(js, true);
    return;
  }
  js->PrintError(kInvalidParams,
                 "%s: invalid 'targetId' parameter: "
                 "Cannot invoke against a VM-internal object",
                 js->method());
}

InvokeCallThroughGetterOrNoSuchMethod()

static ObjectPtr dart::InvokeCallThroughGetterOrNoSuchMethod ( Thread *  thread, Zone *  zone, const Instance &  receiver, const String &  target_name, const Array &  orig_arguments, const Array &  orig_arguments_desc  )

static

Definition at line 2744 of file runtime_entry.cc.

                                      {
  ASSERT(!FLAG_lazy_dispatchers);
  const bool is_dynamic_call =
      Function::IsDynamicInvocationForwarderName(target_name);
  String& demangled_target_name = String::Handle(zone, target_name.ptr());
  if (is_dynamic_call) {
    demangled_target_name =
        Function::DemangleDynamicInvocationForwarderName(target_name);
  }
 
  Class& cls = Class::Handle(zone, receiver.clazz());
  Function& function = Function::Handle(zone);
 
  // Dart distinguishes getters and regular methods and allows their calls
  // to mix with conversions, and its selectors are independent of arity. So do
  // a zigzagged lookup to see if this call failed because of an arity mismatch,
  // need for conversion, or there really is no such method.
 
  const bool is_getter = Field::IsGetterName(demangled_target_name);
  if (is_getter) {
    // Tear-off of a method
    // o.foo (o.get:foo) failed, closurize o.foo() if it exists.
    const auto& function_name =
        String::Handle(zone, Field::NameFromGetter(demangled_target_name));
    while (!cls.IsNull()) {
      // We don't generate dyn:* forwarders for method extractors so there is no
      // need to try to find a dyn:get:foo first (see assertion below)
      if (function.IsNull()) {
        if (cls.EnsureIsFinalized(thread) == Error::null()) {
          function = Resolver::ResolveDynamicFunction(zone, cls, function_name);
        }
      }
      if (!function.IsNull()) {
#if !defined(DART_PRECOMPILED_RUNTIME)
        ASSERT(!kernel::NeedsDynamicInvocationForwarder(Function::Handle(
            function.GetMethodExtractor(demangled_target_name))));
#endif
        const Function& closure_function =
            Function::Handle(zone, function.ImplicitClosureFunction());
        const Object& result = Object::Handle(
            zone, closure_function.ImplicitInstanceClosure(receiver));
        return result.ptr();
      }
      cls = cls.SuperClass();
    }
 
    if (receiver.IsRecord()) {
      const Record& record = Record::Cast(receiver);
      const intptr_t field_index =
          record.GetFieldIndexByName(thread, function_name);
      if (field_index >= 0) {
        return record.FieldAt(field_index);
      }
    }
 
    // Fall through for noSuchMethod
  } else {
    // Call through field.
    // o.foo(...) failed, invoke noSuchMethod is foo exists but has the wrong
    // number of arguments, or try (o.foo).call(...)
 
    if ((target_name.ptr() == Symbols::call().ptr()) && receiver.IsClosure()) {
      // Special case: closures are implemented with a call getter instead of a
      // call method and with lazy dispatchers the field-invocation-dispatcher
      // would perform the closure call.
      return DartEntry::InvokeClosure(thread, orig_arguments,
                                      orig_arguments_desc);
    }
 
    // Dynamic call sites have to use the dynamic getter as well (if it was
    // created).
    const auto& getter_name =
        String::Handle(zone, Field::GetterName(demangled_target_name));
    const auto& dyn_getter_name = String::Handle(
        zone, is_dynamic_call
                  ? Function::CreateDynamicInvocationForwarderName(getter_name)
                  : getter_name.ptr());
    ArgumentsDescriptor args_desc(orig_arguments_desc);
    while (!cls.IsNull()) {
      // If there is a function with the target name but mismatched arguments
      // we need to call `receiver.noSuchMethod()`.
      if (cls.EnsureIsFinalized(thread) == Error::null()) {
        function = Resolver::ResolveDynamicFunction(zone, cls, target_name);
      }
      if (!function.IsNull()) {
        ASSERT(!function.AreValidArguments(args_desc, nullptr));
        break;  // mismatch, invoke noSuchMethod
      }
      if (is_dynamic_call) {
        function =
            Resolver::ResolveDynamicFunction(zone, cls, demangled_target_name);
        if (!function.IsNull()) {
          ASSERT(!function.AreValidArguments(args_desc, nullptr));
          break;  // mismatch, invoke noSuchMethod
        }
      }
 
      // If there is a getter we need to call-through-getter.
      if (is_dynamic_call) {
        function = Resolver::ResolveDynamicFunction(zone, cls, dyn_getter_name);
      }
      if (function.IsNull()) {
        function = Resolver::ResolveDynamicFunction(zone, cls, getter_name);
      }
      if (!function.IsNull()) {
        const Array& getter_arguments = Array::Handle(Array::New(1));
        getter_arguments.SetAt(0, receiver);
        const Object& getter_result = Object::Handle(
            zone, DartEntry::InvokeFunction(function, getter_arguments));
        if (getter_result.IsError()) {
          return getter_result.ptr();
        }
        ASSERT(getter_result.IsNull() || getter_result.IsInstance());
 
        orig_arguments.SetAt(args_desc.FirstArgIndex(), getter_result);
        return DartEntry::InvokeClosure(thread, orig_arguments,
                                        orig_arguments_desc);
      }
      cls = cls.SuperClass();
    }
 
    if (receiver.IsRecord()) {
      const Record& record = Record::Cast(receiver);
      const intptr_t field_index =
          record.GetFieldIndexByName(thread, demangled_target_name);
      if (field_index >= 0) {
        const Object& getter_result =
            Object::Handle(zone, record.FieldAt(field_index));
        ASSERT(getter_result.IsNull() || getter_result.IsInstance());
        orig_arguments.SetAt(args_desc.FirstArgIndex(), getter_result);
        return DartEntry::InvokeClosure(thread, orig_arguments,
                                        orig_arguments_desc);
      }
    }
  }
 
  const Object& result = Object::Handle(
      zone,
      DartEntry::InvokeNoSuchMethod(thread, receiver, demangled_target_name,
                                    orig_arguments, orig_arguments_desc));
  return result.ptr();
}

InvokeClosureCallback()

DART_EXPORT void dart::InvokeClosureCallback

(

)

Definition at line 1114 of file ffi_test_functions_vmspecific.cc.

                                         {
  Dart_Handle closure_handle =
      Dart_HandleFromPersistent_DL(closure_to_callback_);
  callback_(closure_handle);
}

InvokeEmitter() [1/6]

template<typename Instr , typename Out >

void dart::InvokeEmitter	(	FlowGraphCompiler *	compiler,
		Instr *	instr,
		void(*)(FlowGraphCompiler *, Instr *, Out)	Emit
	)

Definition at line 340 of file locations_helpers.h.

                                                                  {
  typedef SIGNATURE_TRAIT(0, ()) S;
  ASSERT(instr->InputCount() == S::kInputCount);
  LocationSummary* locs = instr->locs();
  Emit(compiler, instr, LocationTrait<Out>::Unwrap(locs->out(0)));
}

InvokeEmitter() [2/6]

template<typename Instr , typename Out , typename T0 >

void dart::InvokeEmitter	(	FlowGraphCompiler *	compiler,
		Instr *	instr,
		void(*)(FlowGraphCompiler *, Instr *, Out, T0)	Emit
	)

Definition at line 350 of file locations_helpers.h.

                                                                      {
  typedef SIGNATURE_TRAIT(1, (T0)) S;
  ASSERT(instr->InputCount() == S::kInputCount);
  LocationSummary* locs = instr->locs();
  Emit(compiler, instr, LocationTrait<Out>::Unwrap(locs->out(0)),
       LocationTrait<T0>::template UnwrapInput<S::kInputCount, 0>(locs));
}

InvokeEmitter() [3/6]

template<typename Instr , typename Out , typename T0 , typename T1 >

void dart::InvokeEmitter	(	FlowGraphCompiler *	compiler,
		Instr *	instr,
		void(*)(FlowGraphCompiler *, Instr *, Out, T0, T1)	Emit
	)

Definition at line 361 of file locations_helpers.h.

                                                                          {
  typedef SIGNATURE_TRAIT(2, (T0, T1)) S;
  ASSERT(instr->InputCount() == S::kInputCount);
  LocationSummary* locs = instr->locs();
  Emit(compiler, instr, LocationTrait<Out>::Unwrap(locs->out(0)),
       LocationTrait<T0>::template UnwrapInput<S::kInputCount, 0>(locs),
       LocationTrait<T1>::template UnwrapInput<S::kInputCount, 1>(locs));
}

InvokeEmitter() [4/6]

template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 >

void dart::InvokeEmitter	(	FlowGraphCompiler *	compiler,
		Instr *	instr,
		void(*)(FlowGraphCompiler *, Instr *, Out, T0, T1, T2)	Emit
	)

Definition at line 373 of file locations_helpers.h.

                                                                              {
  typedef SIGNATURE_TRAIT(3, (T0, T1, T2)) S;
  ASSERT(instr->InputCount() == S::kInputCount);
  LocationSummary* locs = instr->locs();
  Emit(compiler, instr, LocationTrait<Out>::Unwrap(locs->out(0)),
       LocationTrait<T0>::template UnwrapInput<S::kInputCount, 0>(locs),
       LocationTrait<T1>::template UnwrapInput<S::kInputCount, 1>(locs),
       LocationTrait<T2>::template UnwrapInput<S::kInputCount, 2>(locs));
}

InvokeEmitter() [5/6]

template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 , typename T3 >

void dart::InvokeEmitter	(	FlowGraphCompiler *	compiler,
		Instr *	instr,
		void(*)(FlowGraphCompiler *, Instr *, Out, T0, T1, T2, T3)	Emit
	)

Definition at line 391 of file locations_helpers.h.

                                                                   {
  typedef SIGNATURE_TRAIT(4, (T0, T1, T2, T3)) S;
  ASSERT(instr->InputCount() == S::kInputCount);
  LocationSummary* locs = instr->locs();
  Emit(compiler, instr, LocationTrait<Out>::Unwrap(locs->out(0)),
       LocationTrait<T0>::template UnwrapInput<S::kInputCount, 0>(locs),
       LocationTrait<T1>::template UnwrapInput<S::kInputCount, 1>(locs),
       LocationTrait<T2>::template UnwrapInput<S::kInputCount, 2>(locs),
       LocationTrait<T3>::template UnwrapInput<S::kInputCount, 3>(locs));
}

InvokeEmitter() [6/6]

template<typename Instr , typename Out , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >

void dart::InvokeEmitter	(	FlowGraphCompiler *	compiler,
		Instr *	instr,
		void(*)(FlowGraphCompiler *, Instr *, Out, T0, T1, T2, T3, T4)	Emit
	)

Definition at line 412 of file locations_helpers.h.

                                                                       {
  typedef SIGNATURE_TRAIT(5, (T0, T1, T2, T3, T4)) S;
  ASSERT(instr->InputCount() == S::kInputCount);
  LocationSummary* locs = instr->locs();
  Emit(compiler, instr, LocationTrait<Out>::Unwrap(locs->out(0)),
       LocationTrait<T0>::template UnwrapInput<S::kInputCount, 0>(locs),
       LocationTrait<T1>::template UnwrapInput<S::kInputCount, 1>(locs),
       LocationTrait<T2>::template UnwrapInput<S::kInputCount, 2>(locs),
       LocationTrait<T3>::template UnwrapInput<S::kInputCount, 3>(locs),
       LocationTrait<T4>::template UnwrapInput<S::kInputCount, 4>(locs));
}

InvokeEventHandler()

static void dart::InvokeEventHandler ( ServiceEvent *  event )

static

Definition at line 284 of file debugger.cc.

                                                    {
  ASSERT(!event->IsPause());  // For pause events, call Pause instead.
  Service::HandleEvent(event, /*enter_safepoint*/ false);
}

InvokeInstanceFunction()

static ObjectPtr dart::InvokeInstanceFunction ( Thread *  thread, const Instance &  receiver, const Function &  function, const String &  target_name, const Array &  args, const Array &  args_descriptor_array, bool  respect_reflectable, const TypeArguments &  instantiator_type_args  )

static

Definition at line 14363 of file object.cc.

                                                 {
  // Note "args" is already the internal arguments with the receiver as the
  // first element.
  ArgumentsDescriptor args_descriptor(args_descriptor_array);
  if (function.IsNull() ||
      !function.AreValidArguments(args_descriptor, nullptr) ||
      (respect_reflectable && !function.is_reflectable())) {
    return DartEntry::InvokeNoSuchMethod(thread, receiver, target_name, args,
                                         args_descriptor_array);
  }
  ObjectPtr type_error = function.DoArgumentTypesMatch(args, args_descriptor,
                                                       instantiator_type_args);
  if (type_error != Error::null()) {
    return type_error;
  }
  return DartEntry::InvokeFunction(function, args, args_descriptor_array);
}

InvokeServiceMessages()

static void dart::InvokeServiceMessages ( uword  param )

static

Definition at line 9903 of file dart_api_impl_test.cc.

                                                      {
    return SetPerformanceModeDefault;
  } else if (strcmp(cstr, "SetPerformanceModeLatency") == 0) {
    return SetPerformanceModeLatency;
  }
  return nullptr;
}
 
TEST_CASE(DartAPI_SetPerformanceMode) {
  const char* kScriptChars = R"(
import "dart:typed_data";
@pragma("vm:external-name", "SetPerformanceModeDefault")
external void setPerformanceModeDefault();
@pragma("vm:external-name", "SetPerformanceModeLatency")
external void setPerformanceModeLatency();
void main() {
  for (var i = 0; i < 10; i++) {
    setPerformanceModeLatency();
    var t = [];
    for (var j = 0; j < 32; j++) {
      t.add(Uint8List(1000000));
    }
    setPerformanceModeDefault();
  }
}
)";
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, &SetMode_native_lookup);

IrregexpRegExpTooBig()

static RegExpEngine::CompilationResult dart::IrregexpRegExpTooBig ( )

static

Definition at line 384 of file regexp.cc.

                                                            {
  return RegExpEngine::CompilationResult("RegExp too big");
}

IsAbiPreservedRegister()

constexpr bool dart::IsAbiPreservedRegister ( Register  reg )

constexpr

Definition at line 90 of file constants.h.

                                                    {
  return (kAbiPreservedCpuRegs & (1 << reg)) != 0;
}

IsAllocatableInNewSpace()

bool dart::IsAllocatableInNewSpace ( intptr_t  size )

inline

Definition at line 57 of file spaces.h.

                                                   {
  return size <= kNewAllocatableSize;
}

IsAllocatableViaFreeLists()

bool dart::IsAllocatableViaFreeLists ( intptr_t  size )

inline

Definition at line 60 of file spaces.h.

                                                     {
  return size < kAllocatablePageSize;
}

IsAllocatedReference()

static constexpr bool dart::IsAllocatedReference ( intptr_t  ref )

staticconstexpr

Definition at line 292 of file app_snapshot.cc.

                                                         {
  return ref > kUnreachableReference;
}

IsAlpha()

static bool dart::IsAlpha ( char  c )

static

Definition at line 2762 of file service.cc.

                            {
  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}

IsAlphaNum()

static bool dart::IsAlphaNum ( char  c )

static

Definition at line 2768 of file service.cc.

                               {
  return (c >= '0' && c <= '9') || IsAlpha(c);
}

IsAlphaNumOrDollar()

static bool dart::IsAlphaNumOrDollar ( char  c )

static

Definition at line 2771 of file service.cc.

                                       {
  return (c >= '0' && c <= '9') || IsAlphaOrDollar(c);
}

IsAlphaOrDollar()

static bool dart::IsAlphaOrDollar ( char  c )

static

Definition at line 2765 of file service.cc.

                                    {
  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '$');
}

IsArgumentRegister()

static constexpr bool dart::IsArgumentRegister ( Register  reg )

staticconstexpr

Definition at line 77 of file constants.h.

                                                       {
  return ((1 << reg) & CallingConventions::kArgumentRegisters) != 0;
}

IsArrayClassId()

bool dart::IsArrayClassId ( intptr_t  index )

inline

Definition at line 358 of file class_id.h.

                                           {
  COMPILE_ASSERT(kImmutableArrayCid == kArrayCid + 1);
  COMPILE_ASSERT(kGrowableObjectArrayCid == kArrayCid + 2);
  return (index >= kArrayCid && index <= kGrowableObjectArrayCid);
}

IsArtificialReference()

static constexpr bool dart::IsArtificialReference ( intptr_t  ref )

staticconstexpr

Definition at line 296 of file app_snapshot.cc.

                                                          {
  return ref < kUnallocatedReference;
}

IsAsciiNonprintable()

static bool dart::IsAsciiNonprintable ( int32_t  c )

inlinestatic

Definition at line 516 of file object.cc.

                                                  {
  return ((0 <= c) && (c < 32)) || (c == 127);
}

IsAtAsyncJump()

static bool dart::IsAtAsyncJump ( ActivationFrame *  top_frame )

static

Definition at line 3502 of file debugger.cc.

                                                      {
  Zone* zone = Thread::Current()->zone();
  if (!top_frame->function().IsAsyncFunction() &&
      !top_frame->function().IsAsyncGenerator()) {
    return false;
  }
  const auto& pc_descriptors =
      PcDescriptors::Handle(zone, top_frame->code().pc_descriptors());
  if (pc_descriptors.IsNull()) {
    return false;
  }
  const TokenPosition looking_for = top_frame->TokenPos();
  PcDescriptors::Iterator it(pc_descriptors, UntaggedPcDescriptors::kOther);
  while (it.MoveNext()) {
    if (it.TokenPos() == looking_for &&
        it.YieldIndex() != UntaggedPcDescriptors::kInvalidYieldIndex) {
      return true;
    }
  }
  return false;
}

IsAThisCallThroughAnUncheckedEntryPoint()

static bool dart::IsAThisCallThroughAnUncheckedEntryPoint ( Definition *  call )

static

Definition at line 776 of file inliner.cc.

                                                                      {
  if (auto instance_call = call->AsInstanceCallBase()) {
    return (instance_call->entry_kind() == Code::EntryKind::kUnchecked) &&
           instance_call->is_call_on_this();
  }
  return false;
}

IsBTypeImm()

bool dart::IsBTypeImm ( intptr_t  imm )

inline

Definition at line 1008 of file constants_riscv.h.

                                     {
  return Utils::IsInt(12, imm) && Utils::IsAligned(imm, 2);
}

IsBuiltinListClassId()

bool dart::IsBuiltinListClassId ( intptr_t  index )

inline

Definition at line 364 of file class_id.h.

                                                 {
  // Make sure this function is updated when new builtin List types are added.
  return (IsArrayClassId(index) || IsTypedDataBaseClassId(index) ||
          (index == kByteBufferCid));
}

IsCalleeFrameOf()

static DART_FORCE_INLINE bool dart::IsCalleeFrameOf ( uword  fp, uword  other_fp  )

static

Definition at line 422 of file stack_frame.h.

                                                                        {
  return other_fp < fp;
}

IsCalleeSavedRegister()

static constexpr bool dart::IsCalleeSavedRegister ( Register  reg )

staticconstexpr

Definition at line 85 of file constants.h.

                                                          {
  return ((1 << reg) & CallingConventions::kCalleeSaveCpuRegisters) != 0;
}

IsCallRecursive()

static bool dart::IsCallRecursive ( const Function &  function, Definition *  call  )

static

Definition at line 104 of file inliner.cc.

                                                                        {
  Environment* env = call->env();
  while (env != nullptr) {
    if (function.ptr() == env->function().ptr()) {
      return true;
    }
    env = env->outer();
  }
  return false;
}

IsCBImm()

bool dart::IsCBImm ( intptr_t  imm )

inline

Definition at line 1323 of file constants_riscv.h.

                                  {
  return Utils::IsInt(8, imm) && Utils::IsAligned(imm, 2);
}

IsCensoredLibrary()

static bool dart::IsCensoredLibrary ( const String &  url )

static

Definition at line 328 of file mirrors.cc.

                                                 {
  static const char* const censored_libraries[] = {
      "dart:_builtin",
      "dart:_vmservice",
      "dart:vmservice_io",
  };
  for (const char* censored_library : censored_libraries) {
    if (url.Equals(censored_library)) {
      return true;
    }
  }
  if (!Api::IsFfiEnabled() && url.Equals(Symbols::DartFfi())) {
    return true;
  }
  return false;
}

IsCI16Imm()

bool dart::IsCI16Imm ( intptr_t  imm )

inline

Definition at line 1380 of file constants_riscv.h.

                                    {
  return Utils::IsInt(10, imm) && Utils::IsAligned(imm, 16);
}

IsCI4SPNImm()

bool dart::IsCI4SPNImm ( intptr_t  imm )

inline

Definition at line 1403 of file constants_riscv.h.

                                      {
  return Utils::IsUint(9, imm) && Utils::IsAligned(imm, 4);
}

IsCIImm()

bool dart::IsCIImm ( intptr_t  imm )

inline

Definition at line 1346 of file constants_riscv.h.

                                  {
  return Utils::IsInt(6, imm) && Utils::IsAligned(imm, 1);
}

IsCInstruction()

bool dart::IsCInstruction ( uint16_t  parcel )

inline

Definition at line 1089 of file constants_riscv.h.

                                            {
  return (parcel & 3) != 3;
}

IsCJImm()

bool dart::IsCJImm ( intptr_t  imm )

inline

Definition at line 1294 of file constants_riscv.h.

                                  {
  return Utils::IsInt(11, imm) && Utils::IsAligned(imm, 2);
}

IsClampedTypedDataBaseClassId()

bool dart::IsClampedTypedDataBaseClassId ( intptr_t  index )

inline

Definition at line 461 of file class_id.h.

                                                          {
  if (!IsTypedDataBaseClassId(index)) return false;
  const intptr_t internal_cid =
      index - ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) +
      kTypedDataCidRemainderInternal;
  // Currently, the only clamped typed data arrays are Uint8.
  return internal_cid == kTypedDataUint8ClampedArrayCid;
}

IsCMem4Imm()

bool dart::IsCMem4Imm ( intptr_t  imm )

inline

Definition at line 1258 of file constants_riscv.h.

                                     {
  return Utils::IsUint(7, imm) && Utils::IsAligned(imm, 4);
}

IsCMem8Imm()

bool dart::IsCMem8Imm ( intptr_t  imm )

inline

Definition at line 1277 of file constants_riscv.h.

                                     {
  return Utils::IsUint(8, imm) && Utils::IsAligned(imm, 8);
}

IsCommutative()

static bool dart::IsCommutative ( Token::Kind  op )

static

Definition at line 2231 of file il.cc.

                                        {
  switch (op) {
    case Token::kMUL:
      FALL_THROUGH;
    case Token::kADD:
      FALL_THROUGH;
    case Token::kBIT_AND:
      FALL_THROUGH;
    case Token::kBIT_OR:
      FALL_THROUGH;
    case Token::kBIT_XOR:
      return true;
    default:
      return false;
  }
}

IsCompiletimeErrorObject()

static bool dart::IsCompiletimeErrorObject ( Zone *  zone, const Object &  obj  )

static

Definition at line 186 of file dart_api_impl.cc.

                                                                    {
#if defined(DART_PRECOMPILED_RUNTIME)
  // All compile-time errors were handled at snapshot generation time and
  // compiletime_error_class was removed.
  return false;
#else
  auto isolate_group = Thread::Current()->isolate_group();
  const Class& error_class = Class::Handle(
      zone, isolate_group->object_store()->compiletime_error_class());
  ASSERT(!error_class.IsNull());
  return (obj.GetClassId() == error_class.id());
#endif
}

IsConcreteTypeClassId()

bool dart::IsConcreteTypeClassId ( intptr_t  index )

inline

Definition at line 325 of file class_id.h.

                                                  {
  // Make sure to update when new AbstractType subclasses are added.
  COMPILE_ASSERT(kFunctionTypeCid == kTypeCid + 1 &&
                 kRecordTypeCid == kTypeCid + 2 &&
                 kTypeParameterCid == kTypeCid + 3);
  return (index >= kTypeCid && index <= kTypeParameterCid);
}

IsConstant()

static bool dart::IsConstant ( Definition *  def, int64_t *  val  )

static

Definition at line 123 of file loops.cc.

                                                      {
  if (def->IsConstant()) {
    const Object& value = def->AsConstant()->value();
    if (value.IsInteger()) {
      *val = Integer::Cast(value).AsInt64Value();  // smi and mint
      return true;
    }
  }
  return false;
}

IsCreateLargeArray()

static bool dart::IsCreateLargeArray ( Definition *  defn )

static

Definition at line 192 of file write_barrier_elimination.cc.

                                                 {
  if (auto create_array = defn->AsCreateArray()) {
    static_assert(!Array::UseCardMarkingForAllocation(
                      Array::kMaxLengthForWriteBarrierElimination),
                  "Invariant restoration code does not handle card marking.");
    // Note: IsUsable would reject CreateArray instructions with non-constant
    // number of elements.
    return create_array->GetConstantNumElements() >
           Array::kMaxLengthForWriteBarrierElimination;
  }
  return false;
}

IsCSPLoad4Imm()

bool dart::IsCSPLoad4Imm ( intptr_t  imm )

inline

Definition at line 1186 of file constants_riscv.h.

                                        {
  return Utils::IsUint(8, imm) && Utils::IsAligned(imm, 4);
}

IsCSPLoad8Imm()

bool dart::IsCSPLoad8Imm ( intptr_t  imm )

inline

Definition at line 1205 of file constants_riscv.h.

                                        {
  return Utils::IsUint(9, imm) && Utils::IsAligned(imm, 8);
}

IsCSPStore4Imm()

bool dart::IsCSPStore4Imm ( intptr_t  imm )

inline

Definition at line 1224 of file constants_riscv.h.

                                         {
  return Utils::IsUint(8, imm) && Utils::IsAligned(imm, 4);
}

IsCSPStore8Imm()

bool dart::IsCSPStore8Imm ( intptr_t  imm )

inline

Definition at line 1241 of file constants_riscv.h.

                                         {
  return Utils::IsUint(9, imm) && Utils::IsAligned(imm, 8);
}

IsCUImm()

bool dart::IsCUImm ( intptr_t  imm )

inline

Definition at line 1363 of file constants_riscv.h.

                                  {
  return Utils::IsInt(17, imm) && Utils::IsAligned(imm, 1 << 12);
}

IsDataFieldOfTypedDataView()

static bool dart::IsDataFieldOfTypedDataView ( Definition *  alloc, const Slot &  slot  )

static

Definition at line 3978 of file redundancy_elimination.cc.

                                                                            {
  if (!slot.IsIdentical(Slot::PointerBase_data())) return false;
  // Internal typed data objects use AllocateTypedData.
  if (!alloc->IsAllocateObject()) return false;
  auto const cid = alloc->AsAllocateObject()->cls().id();
  return IsTypedDataViewClassId(cid) || IsUnmodifiableTypedDataViewClassId(cid);
}

IsDecimalDigit()

static bool dart::IsDecimalDigit ( int32_t  c )

static

Definition at line 13317 of file object.cc.

                                      {
  return '0' <= c && c <= '9';
}

IsDeeplyImmutableCid()

bool dart::IsDeeplyImmutableCid ( intptr_t  predefined_cid )

inline

Definition at line 485 of file class_id.h.

                                                          {
  ASSERT(predefined_cid < kNumPredefinedCids);
  return IsStringClassId(predefined_cid) || predefined_cid == kNumberCid ||
         predefined_cid == kIntegerCid || predefined_cid == kSmiCid ||
         predefined_cid == kMintCid || predefined_cid == kNeverCid ||
         predefined_cid == kSentinelCid || predefined_cid == kStackTraceCid ||
         predefined_cid == kDoubleCid || predefined_cid == kFloat32x4Cid ||
         predefined_cid == kFloat64x2Cid || predefined_cid == kInt32x4Cid ||
         predefined_cid == kSendPortCid || predefined_cid == kCapabilityCid ||
         predefined_cid == kRegExpCid || predefined_cid == kBoolCid ||
         predefined_cid == kNullCid || predefined_cid == kPointerCid ||
         predefined_cid == kTypeCid || predefined_cid == kRecordTypeCid ||
         predefined_cid == kFunctionTypeCid;
}

IsDelimiter()

static bool dart::IsDelimiter ( intptr_t  value )

static

Definition at line 17 of file uri.cc.

                                        {
  switch (value) {
    case ':':
    case '/':
    case '?':
    case '#':
    case '[':
    case ']':
    case '@':
    case '!':
    case '$':
    case '&':
    case '\'':
    case '(':
    case ')':
    case '*':
    case '+':
    case ',':
    case ';':
    case '=':
      return true;
    default:
      return false;
  }
}

IsDominatedUse()

static bool dart::IsDominatedUse ( Instruction *  dom, Value *  use  )

static

Definition at line 2848 of file flow_graph.cc.

                                                         {
  BlockEntryInstr* dom_block = dom->GetBlock();
 
  Instruction* instr = use->instruction();
 
  PhiInstr* phi = instr->AsPhi();
  if (phi != nullptr) {
    return dom_block->Dominates(phi->block()->PredecessorAt(use->use_index()));
  }
 
  BlockEntryInstr* use_block = instr->GetBlock();
  if (use_block == dom_block) {
    // Fast path for the case of block entry.
    if (dom_block == dom) return true;
 
    for (Instruction* curr = dom->next(); curr != nullptr;
         curr = curr->next()) {
      if (curr == instr) return true;
    }
 
    return false;
  }
 
  return dom_block->Dominates(use_block);
}

IsDummyObject()

static bool dart::IsDummyObject ( ObjectPtr  object )

static

Definition at line 248 of file become.cc.

                                            {
  if (!object->IsForwardingCorpse()) return false;
  return GetForwardedObject(object) == object;
}

IsEmptyBlock()

static bool dart::IsEmptyBlock ( BlockEntryInstr *  block )

static

Definition at line 1683 of file constant_propagator.cc.

                                                 {
  // A block containing a goto to itself forms an infinite loop.
  // We don't consider this an empty block to handle the edge-case where code
  // reduces to an infinite loop.
  return block->next()->IsGoto() &&
         block->next()->AsGoto()->successor() != block && !HasPhis(block) &&
         !block->IsIndirectEntry();
}

IsErrorClassId()

bool dart::IsErrorClassId ( intptr_t  index )

inline

Definition at line 321 of file class_id.h.

                                           {
  return (index >= kFirstErrorCid && index <= kLastErrorCid);
}

IsExternalPayloadClassId()

bool dart::IsExternalPayloadClassId ( classid_t  cid )

inline

Definition at line 472 of file class_id.h.

                                                    {
  return cid == kPointerCid || IsExternalTypedDataClassId(cid);
}

IsExternalTypedDataClassId()

bool dart::IsExternalTypedDataClassId ( intptr_t  index )

inline

Definition at line 447 of file class_id.h.

                                                       {
  return IsTypedDataBaseClassId(index) &&
         ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) ==
             kTypedDataCidRemainderExternal;
}

IsFfiCompound()

static bool dart::IsFfiCompound ( Thread *  T, const Object &  obj  )

static

Definition at line 994 of file dart_api_impl.cc.

                                                        {
  if (obj.IsNull()) {
    return false;
  }
 
  // CFE guarantees we can only have direct subclasses of `Struct` and `Union`
  // (no implementations or indirect subclasses are allowed).
  const auto& klass = Class::Handle(Z, obj.clazz());
  const auto& super_klass = Class::Handle(Z, klass.SuperClass());
  if (super_klass.IsNull()) {
    // This means klass is Object.
    return false;
  }
  if (super_klass.Name() != Symbols::Struct().ptr() &&
      super_klass.Name() != Symbols::Union().ptr()) {
    return false;
  }
  const auto& library = Library::Handle(Z, super_klass.library());
  return library.url() == Symbols::DartFfi().ptr();
}

IsFfiDynamicLibraryClassId()

bool dart::IsFfiDynamicLibraryClassId ( intptr_t  index )

inline

Definition at line 545 of file class_id.h.

                                                       {
  return index == kDynamicLibraryCid;
}

IsFfiPointerClassId()

bool dart::IsFfiPointerClassId ( intptr_t  index )

inline

Definition at line 541 of file class_id.h.

                                                {
  return index == kPointerCid;
}

IsFfiPredefinedClassId()

bool dart::IsFfiPredefinedClassId ( classid_t  class_id )

inline

Definition at line 527 of file class_id.h.

                                                       {
  switch (class_id) {
    case kPointerCid:
    case kDynamicLibraryCid:
#define CASE_FFI_CID(name) case kFfi##name##Cid:
      CLASS_LIST_FFI(CASE_FFI_CID)
#undef CASE_FFI_CID
      return true;
    default:
      return false;
  }
  UNREACHABLE();
}

IsFfiTypeClassId()

bool dart::IsFfiTypeClassId ( intptr_t  index )

inline

Definition at line 513 of file class_id.h.

                                             {
  switch (index) {
    case kPointerCid:
    case kFfiNativeFunctionCid:
#define CASE_FFI_CID(name) case kFfi##name##Cid:
      CLASS_LIST_FFI_TYPE_MARKER(CASE_FFI_CID)
#undef CASE_FFI_CID
      return true;
    default:
      return false;
  }
  UNREACHABLE();
}

IsForwarding()

static DART_FORCE_INLINE bool dart::IsForwarding ( uword  header )

static

Definition at line 66 of file scavenger.cc.

                                       {
  uword bits = header & kForwardingMask;
  ASSERT((bits == kNotForwarded) || (bits == kForwarded));
  return bits == kForwarded;
}

IsForwardingObject()

static bool dart::IsForwardingObject ( ObjectPtr  object )

static

Definition at line 50 of file become.cc.

                                                 {
  return object->IsHeapObject() && object->IsForwardingCorpse();
}

IsFpCompare()

static bool dart::IsFpCompare ( ComparisonInstr *  comp )

static

Definition at line 3513 of file il.cc.

                                               {
  if (comp->IsRelationalOp()) {
    return comp->operation_cid() == kDoubleCid;
  }
  return false;
}

IsFpuArgumentRegister()

static constexpr bool dart::IsFpuArgumentRegister ( FpuRegister  reg )

staticconstexpr

Definition at line 81 of file constants.h.

                                                             {
  return ((1 << reg) & CallingConventions::kFpuArgumentRegisters) != 0;
}

IsFunctionVisible()

static bool dart::IsFunctionVisible ( const Function &  function )

static

Definition at line 1286 of file debugger.cc.

                                                        {
  return FLAG_show_invisible_frames || function.is_visible();
}

IsHexCharacter()

static bool dart::IsHexCharacter ( int32_t  c )

static

Definition at line 23952 of file object.cc.

                                      {
  if (c >= '0' && c <= '9') {
    return true;
  }
  if (c >= 'A' && c <= 'F') {
    return true;
  }
  return false;
}

IsHexDigit()

static bool dart::IsHexDigit ( char  value )

static

Definition at line 43 of file uri.cc.

                                   {
  return ((value >= '0' && value <= '9') || (value >= 'A' && value <= 'F') ||
          (value >= 'a' && value <= 'f'));
}

IsIdentChar()

static bool dart::IsIdentChar ( int32_t  c )

static

Definition at line 13325 of file object.cc.

                                   {
  return IsLetter(c) || IsDecimalDigit(c) || (c == '_') || (c == '$');
}

IsIdenticalConstants()

static bool dart::IsIdenticalConstants ( const Object &  left, const Object &  right  )

static

Definition at line 83 of file constant_propagator.cc.

                                                                          {
  // This should be kept in line with Identical_comparison (identical.cc)
  // (=> Instance::IsIdenticalTo in object.cc).
 
  if (left.ptr() == right.ptr()) return true;
  if (left.GetClassId() != right.GetClassId()) return false;
  if (left.IsInteger()) {
    return Integer::Cast(left).Equals(Integer::Cast(right));
  }
  if (left.IsDouble()) {
    return Double::Cast(left).BitwiseEqualsToDouble(
        Double::Cast(right).value());
  }
  return false;
}

IsIdentStartChar()

static bool dart::IsIdentStartChar ( int32_t  c )

static

Definition at line 13321 of file object.cc.

                                        {
  return IsLetter(c) || (c == '_') || (c == '$');
}

IsImplicitFieldClassId()

bool dart::IsImplicitFieldClassId ( intptr_t  index )

inline

Definition at line 556 of file class_id.h.

                                                   {
  return index == kByteBufferCid;
}

IsImplicitFunction()

static bool dart::IsImplicitFunction ( const Function &  func )

static

Definition at line 393 of file debugger.cc.

                                                     {
  switch (func.kind()) {
    case UntaggedFunction::kImplicitGetter:
    case UntaggedFunction::kImplicitSetter:
    case UntaggedFunction::kImplicitStaticGetter:
    case UntaggedFunction::kFieldInitializer:
    case UntaggedFunction::kMethodExtractor:
    case UntaggedFunction::kNoSuchMethodDispatcher:
    case UntaggedFunction::kInvokeFieldDispatcher:
    case UntaggedFunction::kIrregexpFunction:
    case UntaggedFunction::kRecordFieldGetter:
      return true;
    default:
      if (func.token_pos() == func.end_token_pos()) {
        // |func| could be an implicit constructor for example.
        return true;
      }
  }
  return false;
}

IsInlineableOperator()

static bool dart::IsInlineableOperator ( const Function &  function )

static

Definition at line 2468 of file inliner.cc.

                                                           {
  return (function.name() == Symbols::IndexToken().ptr()) ||
         (function.name() == Symbols::AssignIndexToken().ptr()) ||
         (function.name() == Symbols::Plus().ptr()) ||
         (function.name() == Symbols::Minus().ptr());
}

IsInstructionEndPosition()

static bool dart::IsInstructionEndPosition ( intptr_t  pos )

static

Definition at line 46 of file linearscan.cc.

                                                   {
  return (pos & 1) == 1;
}

IsInstructionStartPosition()

static bool dart::IsInstructionStartPosition ( intptr_t  pos )

static

Definition at line 42 of file linearscan.cc.

                                                     {
  return (pos & 1) == 0;
}

IsIntegerClassId()

bool dart::IsIntegerClassId ( intptr_t  index )

inline

Definition at line 340 of file class_id.h.

                                             {
  // Make sure this function is updated when new Integer types are added.
  COMPILE_ASSERT(kSmiCid == kIntegerCid + 1 && kMintCid == kIntegerCid + 2);
  return (index >= kIntegerCid && index <= kMintCid);
}

IsIntegerOrDouble()

static bool dart::IsIntegerOrDouble ( const Object &  value )

static

Definition at line 1284 of file constant_propagator.cc.

                                                   {
  return value.IsInteger() || value.IsDouble();
}

IsInternalOnlyClassId()

bool dart::IsInternalOnlyClassId ( intptr_t  index )

inline

Definition at line 299 of file class_id.h.

                                                  {
  // Fix the condition below if these become non-contiguous.
  COMPILE_ASSERT(kIllegalCid + 1 == kNativePointer &&
                 kIllegalCid + 2 == kFreeListElement &&
                 kIllegalCid + 3 == kForwardingCorpse &&
                 kIllegalCid + 4 == kObjectCid &&
                 kIllegalCid + 5 == kFirstInternalOnlyCid);
  return index <= kLastInternalOnlyCid;
}

IsInternalVMdefinedClassId()

bool dart::IsInternalVMdefinedClassId ( intptr_t  index )

inline

Definition at line 549 of file class_id.h.

                                                       {
  return ((index < kNumPredefinedCids) && !IsImplicitFieldClassId(index));
}

IsInterruptLimit()

static bool dart::IsInterruptLimit ( uword  limit )

static

Definition at line 700 of file thread.cc.

                                          {
  return (limit & ~Thread::kInterruptsMask) ==
         (kInterruptStackLimit & ~Thread::kInterruptsMask);
}

IsITypeImm()

bool dart::IsITypeImm ( intptr_t  imm )

inline

Definition at line 1050 of file constants_riscv.h.

                                     {
  return Utils::IsInt(12, imm);
}

IsJTypeImm()

bool dart::IsJTypeImm ( intptr_t  imm )

inline

Definition at line 1029 of file constants_riscv.h.

                                     {
  return Utils::IsInt(20, imm) && Utils::IsAligned(imm, 2);
}

IsLengthOneString()

static bool dart::IsLengthOneString ( Definition *  d )

static

Definition at line 277 of file call_specializer.cc.

                                             {
  if (d->IsConstant()) {
    const Object& obj = d->AsConstant()->value();
    if (obj.IsString()) {
      return String::Cast(obj).Length() == 1;
    } else {
      return false;
    }
  } else {
    return d->IsOneByteStringFromCharCode();
  }
}

IsLetter()

static bool dart::IsLetter ( int32_t  c )

static

Definition at line 13313 of file object.cc.

                                {
  return (('A' <= c) && (c <= 'Z')) || (('a' <= c) && (c <= 'z'));
}

IsLinkedHashBase()

static bool dart::IsLinkedHashBase ( const Object &  object )

static

Definition at line 6892 of file object_test.cc.

IsLoadEliminationCandidate()

static bool dart::IsLoadEliminationCandidate ( Instruction *  instr )

static

Definition at line 1425 of file redundancy_elimination.cc.

                                                           {
  if (instr->IsDefinition() &&
      instr->AsDefinition()->MayCreateUnsafeUntaggedPointer()) {
    return false;
  }
  if (auto* load = instr->AsLoadField()) {
    if (load->slot().is_weak()) {
      return false;
    }
  }
  return instr->IsLoadField() || instr->IsLoadIndexed() ||
         instr->IsLoadStaticField();
}

IsLoopInvariantLoad()

static bool dart::IsLoopInvariantLoad ( ZoneGrowableArray< BitVector * > *  sets, intptr_t  loop_header_index, Instruction *  instr  )

static

Definition at line 1439 of file redundancy_elimination.cc.

                                                    {
  return IsLoadEliminationCandidate(instr) && (sets != nullptr) &&
         HasPlaceId(instr) &&
         (*sets)[loop_header_index]->Contains(GetPlaceId(instr));
}

IsMarked()

static bool dart::IsMarked ( BlockEntryInstr *  block, GrowableArray< BlockEntryInstr * > *  preorder  )

static

Definition at line 1679 of file il.cc.

                                                                {
  // Detect that a block has been visited as part of the current
  // DiscoverBlocks (we can call DiscoverBlocks multiple times).  The block
  // will be 'marked' by (1) having a preorder number in the range of the
  // preorder array and (2) being in the preorder array at that index.
  intptr_t i = block->preorder_number();
  return (i >= 0) && (i < preorder->length()) && ((*preorder)[i] == block);
}

IsMarkedWithNoBoundsChecks()

static bool dart::IsMarkedWithNoBoundsChecks ( const Function &  function )

static

Definition at line 43 of file flow_graph.cc.

                                                                 {
  Object& options = Object::Handle();
  return Library::FindPragma(dart::Thread::Current(),
                             /*only_core=*/false, function,
                             Symbols::vm_unsafe_no_bounds_checks(),
                             /*multiple=*/false, &options);
}

IsMarkedWithNoInterrupts()

static bool dart::IsMarkedWithNoInterrupts ( const Function &  function )

static

Definition at line 4547 of file redundancy_elimination.cc.

                                                               {
  Object& options = Object::Handle();
  return Library::FindPragma(dart::Thread::Current(),
                             /*only_core=*/false, function,
                             Symbols::vm_unsafe_no_interrupts(),
                             /*multiple=*/false, &options);
}

IsNull()

DART_EXPORT bool dart::IsNull

(

Dart_Handle

object

)

Definition at line 1321 of file ffi_test_functions_vmspecific.cc.

                                            {
  return Dart_IsNull(object);
}

IsNumberCid()

static bool dart::IsNumberCid ( intptr_t  cid )

static

Definition at line 41 of file call_specializer.cc.

                                      {
  return (cid == kSmiCid) || (cid == kDoubleCid);
}

IsNumberClassId()

bool dart::IsNumberClassId ( intptr_t  index )

inline

Definition at line 333 of file class_id.h.

                                            {
  // Make sure this function is updated when new Number types are added.
  COMPILE_ASSERT(kIntegerCid == kNumberCid + 1 && kSmiCid == kNumberCid + 2 &&
                 kMintCid == kNumberCid + 3 && kDoubleCid == kNumberCid + 4);
  return (index >= kNumberCid && index <= kDoubleCid);
}

IsObjectIdChar()

static bool dart::IsObjectIdChar ( char  c )

static

Definition at line 2777 of file service.cc.

                                   {
  return IsAlphaNum(c) || c == '/' || c == '-' || c == '@' || c == '%';
}

IsObjectInstruction()

static bool dart::IsObjectInstruction ( DeoptInstr::Kind  kind )

static

Definition at line 224 of file deopt_instructions.cc.

                                                     {
  switch (kind) {
    case DeoptInstr::kConstant:
    case DeoptInstr::kPp:
    case DeoptInstr::kCallerPp:
    case DeoptInstr::kMaterializedObjectRef:
    case DeoptInstr::kFloat32x4:
    case DeoptInstr::kInt32x4:
    case DeoptInstr::kFloat64x2:
    case DeoptInstr::kWord:
    case DeoptInstr::kFloat:
    case DeoptInstr::kDouble:
    case DeoptInstr::kMint:
    case DeoptInstr::kMintPair:
    case DeoptInstr::kInt32:
    case DeoptInstr::kUint32:
      return true;
 
    case DeoptInstr::kRetAddress:
    case DeoptInstr::kPcMarker:
    case DeoptInstr::kCallerFp:
    case DeoptInstr::kCallerPc:
      return false;
 
    case DeoptInstr::kMaterializeObject:
    default:
      // We should not encounter these instructions when filling stack slots.
      UNREACHABLE();
      return false;
  }
  UNREACHABLE();
  return false;
}

IsOfTypeNullabilityHelper()

static Dart_Handle dart::IsOfTypeNullabilityHelper ( Dart_Handle  type, Nullability  nullability, bool *  result  )

static

Definition at line 5646 of file dart_api_impl.cc.

                                                           {
  DARTSCOPE(Thread::Current());
  const Type& ty = Api::UnwrapTypeHandle(Z, type);
  if (ty.IsNull()) {
    *result = false;
    RETURN_TYPE_ERROR(Z, type, Type);
  }
  *result = (ty.nullability() == nullability);
  return Api::Success();
}

ISOLATE_UNIT_TEST_CASE() [1/463]

dart::ISOLATE_UNIT_TEST_CASE

(

AbstractType_NormalizeFutureOrType

)

Definition at line 7643 of file object_test.cc.

                                                         {
  ObjectStore* const object_store = IsolateGroup::Current()->object_store();
  const auto& future_class = Class::Handle(object_store->future_class());
  const auto& tav = TypeArguments::Handle(TypeArguments::New(1));
  tav.SetTypeAt(0, param);
  const auto& type = Type::Handle(Type::New(future_class, tav, nullability));
  return Type::RawCast(
      ClassFinalizer::FinalizeType(type, ClassFinalizer::kFinalize));
}
 
ISOLATE_UNIT_TEST_CASE(AbstractType_NormalizeFutureOrType) {
  // This should be kept up to date with any changes in
  // https://github.com/dart-lang/language/blob/master/resources/type-system/normalization.md
 
  ObjectStore* const object_store = IsolateGroup::Current()->object_store();
 
  auto normalized_future_or = [&](const AbstractType& param,
                                  Nullability nullability) -> AbstractTypePtr {
    const auto& type = Type::Handle(CreateFutureOrType(param, nullability));
    return type.NormalizeFutureOrType(Heap::kNew);
  };
 
  // NORM(FutureOr<T>) =
  //   let S be NORM(T)
  //   if S is a top type then S
  {
    const auto& type = AbstractType::Handle(normalized_future_or(
        Object::dynamic_type(), Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::dynamic_type(), type);
  }
 
  {
    const auto& type = AbstractType::Handle(
        normalized_future_or(Object::void_type(), Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::void_type(), type);
  }
 
  {
    const auto& type_nullable_object =
        Type::Handle(object_store->nullable_object_type());
    const auto& type = AbstractType::Handle(
        normalized_future_or(type_nullable_object, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, type);
  }
 
  //   if S is Object then S
 
  {
    const auto& type_non_nullable_object =
        Type::Handle(object_store->non_nullable_object_type());
    const auto& type = AbstractType::Handle(normalized_future_or(
        type_non_nullable_object, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_non_nullable_object, type);
  }
 
  //   if S is Object* then S
 
  {
    const auto& type_legacy_object =
        Type::Handle(object_store->legacy_object_type());
    const auto& type = AbstractType::Handle(
        normalized_future_or(type_legacy_object, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_legacy_object, type);
  }
 
  //   if S is Never then Future<Never>
 
  {
    const auto& type_never = Type::Handle(object_store->never_type());
    const auto& expected =
        Type::Handle(CreateFutureType(type_never, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        normalized_future_or(type_never, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
 
  //   if S is Null then Future<Null>?
 
  {
    const auto& type_null = Type::Handle(object_store->null_type());
    const auto& expected =
        Type::Handle(CreateFutureType(type_null, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        normalized_future_or(type_null, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
 
  //   else FutureOr<S>
 
  // NORM(T?) =
  //   let S be NORM(T)
  //   ...
  //   if S is FutureOr<R> and R is nullable then S

ISOLATE_UNIT_TEST_CASE() [2/463]

dart::ISOLATE_UNIT_TEST_CASE

(

AllocateScopeHandle

)

Definition at line 40 of file handles_test.cc.

                                            {
#if defined(DEBUG)
  FLAG_trace_handles = true;
#endif
  int32_t handle_count = VMHandles::ScopedHandleCount();
  const int kNumHandles = 65;
  // Create some scoped handles.
  {
    Thread* thread = Thread::Current();
    HANDLESCOPE(thread);
    for (int i = 0; i < kNumHandles; i++) {
      const Smi& handle = Smi::Handle(Smi::New(i));
      EXPECT(handle.IsSmi());
      EXPECT_EQ(i, handle.Value());
    }
    EXPECT_EQ((handle_count + kNumHandles), VMHandles::ScopedHandleCount());
    // Create lots of scoped handles in a loop with a nested scope.
    for (int loop = 0; loop < 1000; loop++) {
      HANDLESCOPE(thread);
      for (int i = 0; i < 2; i++) {
        const Smi& handle = Smi::Handle(Smi::New(i + loop));
        EXPECT(handle.IsSmi());
        EXPECT_EQ(i + loop, handle.Value());
      }
      EXPECT_EQ((handle_count + kNumHandles + 2),
                VMHandles::ScopedHandleCount());
    }
    EXPECT_EQ((handle_count + kNumHandles), VMHandles::ScopedHandleCount());
    for (int i = 0; i < kNumHandles; i++) {
      const Smi& handle = Smi::Handle(Smi::New(i));
      EXPECT(handle.IsSmi());
      EXPECT_EQ(i, handle.Value());
    }
    EXPECT_EQ((handle_count + (2 * kNumHandles)),
              VMHandles::ScopedHandleCount());
  }
  EXPECT_EQ(handle_count, VMHandles::ScopedHandleCount());
}

ISOLATE_UNIT_TEST_CASE() [3/463]

dart::ISOLATE_UNIT_TEST_CASE

(

AllocateZoneHandle

)

Definition at line 16 of file handles_test.cc.

                                           {
#if defined(DEBUG)
  FLAG_trace_handles = true;
#endif
  // The previously run stub code generation may have created zone handles.
  int initial_count = VMHandles::ZoneHandleCount();
  const int kNumHandles = 65;
  // Create some zone handles.
  for (int i = 0; i < kNumHandles; i++) {
    const Smi& handle = Smi::ZoneHandle(Smi::New(i));
    EXPECT(handle.IsSmi());
    EXPECT_EQ(i, handle.Value());
  }
  EXPECT_EQ(kNumHandles + initial_count, VMHandles::ZoneHandleCount());
  // Create some more zone handles.
  for (int i = kNumHandles; i < (2 * kNumHandles); i++) {
    const Smi& handle = Smi::ZoneHandle(Smi::New(i));
    EXPECT(handle.IsSmi());
    EXPECT_EQ(i, handle.Value());
  }
  EXPECT_EQ((2 * kNumHandles) + initial_count, VMHandles::ZoneHandleCount());
}

ISOLATE_UNIT_TEST_CASE() [4/463]

dart::ISOLATE_UNIT_TEST_CASE

(

AllocationSinking_Arrays

)

Definition at line 1208 of file redundancy_elimination_test.cc.

                                                 {
  const char* kScript = R"(
import 'dart:typed_data';
 
class Vector2 {
  final Float64List _v2storage;
 
  @pragma('vm:prefer-inline')
  Vector2.zero() : _v2storage = Float64List(2);
 
  @pragma('vm:prefer-inline')
  factory Vector2(double x, double y) => Vector2.zero()..setValues(x, y);
 
  @pragma('vm:prefer-inline')
  factory Vector2.copy(Vector2 other) => Vector2.zero()..setFrom(other);
 
  @pragma('vm:prefer-inline')
  Vector2 clone() => Vector2.copy(this);
 
  @pragma('vm:prefer-inline')
  void setValues(double x_, double y_) {
    _v2storage[0] = x_;
    _v2storage[1] = y_;
  }
 
  @pragma('vm:prefer-inline')
  void setFrom(Vector2 other) {
    final otherStorage = other._v2storage;
    _v2storage[1] = otherStorage[1];
    _v2storage[0] = otherStorage[0];
  }
 
  @pragma('vm:prefer-inline')
  Vector2 operator +(Vector2 other) => clone()..add(other);
 
  @pragma('vm:prefer-inline')
  void add(Vector2 arg) {
    final argStorage = arg._v2storage;
    _v2storage[0] = _v2storage[0] + argStorage[0];
    _v2storage[1] = _v2storage[1] + argStorage[1];
  }
 
  @pragma('vm:prefer-inline')
  double get x => _v2storage[0];
 
  @pragma('vm:prefer-inline')
  double get y => _v2storage[1];
}
 
@pragma('vm:never-inline')
String foo(double x) {
  // All allocations in this function are eliminated by the compiler,
  // except array allocation for string interpolation at the end.
  List v1 = List.filled(2, null);
  v1[0] = 1;
  v1[1] = 'hi';
  Vector2 v2 = new Vector2(1.0, 2.0);
  Vector2 v3 = v2 + Vector2(x, x);
  double sum = v3.x + v3.y;
  return "v1: [${v1[0]},${v1[1]}], v2: [${v2.x},${v2.y}], v3: [${v3.x},${v3.y}], sum: $sum";
}
 
main() {
  foo(42.0);
}
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  ASSERT(flow_graph != nullptr);
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  /* Flow graph to match:
 
  4:     CheckStackOverflow:8(stack=0, loop=0)
  5:     ParallelMove rax <- S+2
  6:     CheckClass:14(v2 Cids[1: _Double@0150898 etc.  cid 62] nullcheck)
  8:     v312 <- Unbox:14(v2 T{_Double}) T{_Double}
 10:     ParallelMove xmm1 <- C
 10:     v221 <- BinaryDoubleOp:22(+, v341, v312) T{_Double}
 11:     ParallelMove DS-7 <- xmm1
 12:     ParallelMove xmm2 <- C
 12:     v227 <- BinaryDoubleOp:34(+, v342, v312) T{_Double}
 13:     ParallelMove DS-6 <- xmm2
 14:     v333 <- Box(v221) T{_Double}
 15:     ParallelMove S-4 <- rax
 16:     v334 <- Box(v227) T{_Double}
 17:     ParallelMove S-3 <- rcx
 18:     ParallelMove xmm0 <- xmm1
 18:     v15 <- BinaryDoubleOp:28(+, v221, v227) T{_Double}
 19:     ParallelMove rbx <- C, r10 <- C, DS-5 <- xmm0
 20:     v17 <- CreateArray:30(v0, v16) T{_List}
 21:     ParallelMove rcx <- rax
 22:     StoreIndexed(v17, v5, v18, NoStoreBarrier)
 24:     StoreIndexed(v17, v6, v6, NoStoreBarrier)
 26:     StoreIndexed(v17, v3, v20, NoStoreBarrier)
 28:     StoreIndexed(v17, v21, v7, NoStoreBarrier)
 30:     StoreIndexed(v17, v23, v24, NoStoreBarrier)
 32:     StoreIndexed(v17, v25, v8, NoStoreBarrier)
 34:     StoreIndexed(v17, v27, v20, NoStoreBarrier)
 36:     StoreIndexed(v17, v28, v9, NoStoreBarrier)
 38:     StoreIndexed(v17, v30, v31, NoStoreBarrier)
 39:     ParallelMove rax <- S-4
 40:     StoreIndexed(v17, v32, v333, NoStoreBarrier)
 42:     StoreIndexed(v17, v34, v20, NoStoreBarrier)
 43:     ParallelMove rax <- S-3
 44:     StoreIndexed(v17, v35, v334, NoStoreBarrier)
 46:     StoreIndexed(v17, v37, v38, NoStoreBarrier)
 47:     ParallelMove xmm0 <- DS-5
 48:     v335 <- Box(v15) T{_Double}
 49:     ParallelMove rdx <- rcx, rax <- rax
 50:     StoreIndexed(v17, v39, v335)
 52:     MoveArgument(v17)
 54:     v40 <- StaticCall:44( _interpolate@0150898<0> v17,
            recognized_kind = StringBaseInterpolate) T{String?}
 56:     Return:48(v40)
*/
 
  CreateArrayInstr* create_array = nullptr;
  StaticCallInstr* string_interpolate = nullptr;
 
  ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                   ParallelMovesHandling::kSkip);
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveFunctionEntry,
      kMatchAndMoveCheckStackOverflow,
  }));
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveUnbox,
      kMatchAndMoveBinaryDoubleOp,
      kMatchAndMoveBinaryDoubleOp,
      kMatchAndMoveBox,
      kMatchAndMoveBox,
      kMatchAndMoveBinaryDoubleOp,
      {kMatchAndMoveCreateArray, &create_array},
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveBox,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveMoveArgument,
      {kMatchAndMoveStaticCall, &string_interpolate},
      kMatchDartReturn,
  }));
 
  EXPECT(string_interpolate->ArgumentAt(0) == create_array);
}

ISOLATE_UNIT_TEST_CASE() [5/463]

dart::ISOLATE_UNIT_TEST_CASE

(

AllocationSinking_NoViewDataMaterialization

)

Definition at line 1743 of file redundancy_elimination_test.cc.

                                                                    {
  auto* const kFunctionName = "unalignedUint16";
  auto* const kInvokeNoDeoptName = "no_deopt";
  auto* const kInvokeDeoptName = "deopt";
  auto kScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr, R"(
        import 'dart:_internal';
        import 'dart:typed_data';
 
        @pragma("vm:never-inline")
        void check(int x, int y) {
          if (x != y) {
            throw "Doesn't match";
          }
        }
 
        @pragma("vm:never-inline")
        bool %s(num x) {
          var bytes = new ByteData(64);
          if (x is int) {
            for (var i = 2; i < 4; i++) {
              bytes.setUint16(i, x + 1, Endian.host);
              check(x + 1, bytes.getUint16(i, Endian.host));
            }
          } else {
            // Force a garbage collection after deoptimization. In DEBUG mode,
            // the scavenger tests that the view's data field was set correctly
            // during deoptimization before recomputing it.
            VMInternalsForTesting.collectAllGarbage();
          }
          // Make sure the array is also used on the non-int path.
          check(0, bytes.getUint16(0, Endian.host));
          return x is int;
        }
 
        bool %s() {
          return %s(0xABCC);
        }
 
        bool %s() {
          return %s(1.0);
        }
            )",
                  kFunctionName, kInvokeNoDeoptName, kFunctionName,
                  kInvokeDeoptName, kFunctionName),
      std::free);
 
  const auto& lib =
      Library::Handle(LoadTestScript(kScript.get(), NoopNativeLookup));
  EXPECT(!lib.IsNull());
  if (lib.IsNull()) return;
 
  const auto& function = Function::ZoneHandle(GetFunction(lib, kFunctionName));
  EXPECT(!function.IsNull());
  if (function.IsNull()) return;
 
  // Run the unoptimized code.
  auto& result = Object::Handle(Invoke(lib, kInvokeNoDeoptName));
  EXPECT(Bool::Cast(result).value());
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
      CompilerPass::kApplyICData,
      CompilerPass::kTryOptimizePatterns,
      CompilerPass::kSetOuterInliningId,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyClassIds,
      CompilerPass::kInlining,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyClassIds,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyICData,
      CompilerPass::kCanonicalize,
      CompilerPass::kBranchSimplify,
      CompilerPass::kIfConvert,
      CompilerPass::kCanonicalize,
      CompilerPass::kConstantPropagation,
      CompilerPass::kOptimisticallySpecializeSmiPhis,
      CompilerPass::kTypePropagation,
      CompilerPass::kWidenSmiToInt32,
      CompilerPass::kSelectRepresentations,
      CompilerPass::kCSE,
      CompilerPass::kCanonicalize,
      CompilerPass::kLICM,
      CompilerPass::kTryOptimizePatterns,
      CompilerPass::kSelectRepresentations,
      CompilerPass::kDSE,
      CompilerPass::kTypePropagation,
      CompilerPass::kSelectRepresentations,
      CompilerPass::kEliminateEnvironments,
      CompilerPass::kEliminateDeadPhis,
      CompilerPass::kDCE,
      CompilerPass::kCanonicalize,
      CompilerPass::kOptimizeBranches,
  });
 
  // Check for the soon-to-be-sunk ByteDataView allocation.
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  AllocateTypedDataInstr* alloc_typed_data = nullptr;
  AllocateObjectInstr* alloc_view = nullptr;
  StoreFieldInstr* store_view_typed_data = nullptr;
  StoreFieldInstr* store_view_offset_in_bytes = nullptr;
  StoreFieldInstr* store_view_length = nullptr;
  LoadFieldInstr* load_typed_data_payload = nullptr;
  StoreFieldInstr* store_view_payload = nullptr;
 
  ILMatcher cursor(flow_graph, entry, true, ParallelMovesHandling::kSkip);
  EXPECT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveAllocateTypedData, &alloc_typed_data},
      {kMatchAndMoveAllocateObject, &alloc_view},
      {kMatchAndMoveStoreField, &store_view_typed_data},
      {kMatchAndMoveStoreField, &store_view_offset_in_bytes},
      {kMatchAndMoveStoreField, &store_view_length},
      {kMatchAndMoveLoadField, &load_typed_data_payload},
      {kMatchAndMoveStoreField, &store_view_payload},
  }));
  if (store_view_payload == nullptr) return;
 
  EXPECT_EQ(alloc_view, store_view_typed_data->instance()->definition());
  EXPECT(Slot::TypedDataView_typed_data().IsIdentical(
      store_view_typed_data->slot()));
  EXPECT_EQ(alloc_typed_data, store_view_typed_data->value()->definition());
 
  EXPECT_EQ(alloc_view, store_view_length->instance()->definition());
  EXPECT(Slot::TypedDataBase_length().IsIdentical(store_view_length->slot()));
  EXPECT_EQ(alloc_typed_data->num_elements()->definition(),
            store_view_length->value()->definition());
 
  EXPECT_EQ(alloc_view, store_view_offset_in_bytes->instance()->definition());
  EXPECT(Slot::TypedDataView_offset_in_bytes().IsIdentical(
      store_view_offset_in_bytes->slot()));
  EXPECT(store_view_offset_in_bytes->value()->BindsToSmiConstant());
  EXPECT_EQ(0, store_view_offset_in_bytes->value()->BoundSmiConstant());
 
  EXPECT_EQ(alloc_typed_data,
            load_typed_data_payload->instance()->definition());
  EXPECT(Slot::PointerBase_data().IsIdentical(load_typed_data_payload->slot()));
 
  EXPECT_EQ(alloc_view, store_view_payload->instance()->definition());
  EXPECT(Slot::PointerBase_data().IsIdentical(store_view_payload->slot()));
  EXPECT_EQ(load_typed_data_payload, store_view_payload->value()->definition());
 
  // Setting the view data field is the only use of the unsafe payload load.
  EXPECT(load_typed_data_payload->HasOnlyUse(store_view_payload->value()));
 
  pipeline.RunAdditionalPasses({
      CompilerPass::kAllocationSinking_Sink,
  });
 
  // After sinking, the view allocation has been removed from the flow graph.
  EXPECT_EQ(nullptr, alloc_view->previous());
  EXPECT_EQ(nullptr, alloc_view->next());
  // There is at least one MaterializeObject instruction created for the view.
  intptr_t mat_count = 0;
  for (auto block_it = flow_graph->reverse_postorder_iterator();
       !block_it.Done(); block_it.Advance()) {
    for (ForwardInstructionIterator it(block_it.Current()); !it.Done();
         it.Advance()) {
      auto* const mat = it.Current()->AsMaterializeObject();
      if (mat == nullptr) continue;
      if (mat->allocation() == alloc_view) {
        ++mat_count;
        for (intptr_t i = 0; i < mat->InputCount(); i++) {
          // No slot of the materialization should correspond to the data field.
          EXPECT(mat->FieldOffsetAt(i) !=
                 Slot::PointerBase_data().offset_in_bytes());
          // No input of the materialization should be a load of the typed
          // data object's payload.
          if (auto* const load = mat->InputAt(i)->definition()->AsLoadField()) {
            if (load->instance()->definition() == alloc_typed_data) {
              EXPECT(!load->slot().IsIdentical(Slot::PointerBase_data()));
            }
          }
        }
      }
    }
  }
  EXPECT(mat_count > 0);
  // There are no uses of the original unsafe payload load. In particular, no
  // MaterializeObject instructions use it.
  EXPECT(!load_typed_data_payload->HasUses());
 
  pipeline.RunAdditionalPasses({
      CompilerPass::kEliminateDeadPhis,
      CompilerPass::kDCE,
      CompilerPass::kCanonicalize,
      CompilerPass::kTypePropagation,
      CompilerPass::kSelectRepresentations_Final,
      CompilerPass::kUseTableDispatch,
      CompilerPass::kEliminateStackOverflowChecks,
      CompilerPass::kCanonicalize,
      CompilerPass::kAllocationSinking_DetachMaterializations,
      CompilerPass::kEliminateWriteBarriers,
      CompilerPass::kLoweringAfterCodeMotionDisabled,
      CompilerPass::kFinalizeGraph,
      CompilerPass::kCanonicalize,
      CompilerPass::kReorderBlocks,
      CompilerPass::kAllocateRegisters,
      CompilerPass::kTestILSerialization,
  });
 
  // Finish the compilation and attach code so we can run it.
  pipeline.CompileGraphAndAttachFunction();
 
  // Can run optimized code fine without deoptimization.
  result = Invoke(lib, kInvokeNoDeoptName);
  EXPECT(function.HasOptimizedCode());
  EXPECT(Bool::Cast(result).value());
 
  // Can run code fine with deoptimization.
  result = Invoke(lib, kInvokeDeoptName);
  // Deoptimization has put us back to unoptimized code.
  EXPECT(!function.HasOptimizedCode());
  EXPECT(!Bool::Cast(result).value());
}

ISOLATE_UNIT_TEST_CASE() [6/463]

dart::ISOLATE_UNIT_TEST_CASE

(

AllocationSinking_Records

)

Definition at line 1371 of file redundancy_elimination_test.cc.

                                                  {
  const char* kScript = R"(
 
@pragma('vm:prefer-inline')
({int field1, String field2}) getRecord(int x, String y) =>
    (field1: x, field2: y);
 
@pragma('vm:never-inline')
String foo(int x, String y) {
  // All allocations in this function are eliminated by the compiler,
  // except array allocation for string interpolation at the end.
  (int, bool) r1 = (x, true);
  final r2 = getRecord(x, y);
  int sum = r1.$1 + r2.field1;
  return "r1: (${r1.$1}, ${r1.$2}), "
    "r2: (field1: ${r2.field1}, field2: ${r2.field2}), sum: $sum";
}
 
int count = 0;
main() {
  // Deoptimize on the 2nd run.
  return foo(count++ == 0 ? 42 : 9223372036854775807, 'hey');
}
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& result1 = Object::Handle(Invoke(root_library, "main"));
  EXPECT(result1.IsString());
  EXPECT_STREQ(result1.ToCString(),
               "r1: (42, true), r2: (field1: 42, field2: hey), sum: 84");
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  ASSERT(flow_graph != nullptr);
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  /* Flow graph to match:
 
  2: B1[function entry]:2 {
      v2 <- Parameter(0) [-9223372036854775808, 9223372036854775807] T{int}
      v3 <- Parameter(1) T{String}
}
  4:     CheckStackOverflow:8(stack=0, loop=0)
  5:     ParallelMove rax <- S+3
  6:     CheckSmi:16(v2)
  8:     ParallelMove rcx <- rax
  8:     v9 <- BinarySmiOp:16(+, v2 T{_Smi}, v2 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
  9:     ParallelMove rbx <- C, r10 <- C, S-3 <- rcx
 10:     v11 <- CreateArray:18(v0, v10) T{_List}
 11:     ParallelMove rax <- rax
 12:     StoreIndexed(v11, v12, v13, NoStoreBarrier)
 13:     ParallelMove rcx <- S+3
 14:     StoreIndexed(v11, v14, v2 T{_Smi}, NoStoreBarrier)
 16:     StoreIndexed(v11, v16, v17, NoStoreBarrier)
 18:     StoreIndexed(v11, v18, v5, NoStoreBarrier)
 20:     StoreIndexed(v11, v20, v21, NoStoreBarrier)
 22:     StoreIndexed(v11, v22, v2 T{_Smi}, NoStoreBarrier)
 24:     StoreIndexed(v11, v24, v25, NoStoreBarrier)
 25:     ParallelMove rcx <- S+2
 26:     StoreIndexed(v11, v26, v3, NoStoreBarrier)
 28:     StoreIndexed(v11, v28, v29, NoStoreBarrier)
 29:     ParallelMove rcx <- S-3
 30:     StoreIndexed(v11, v30, v9, NoStoreBarrier)
 32:     MoveArgument(v11)
 34:     v31 <- StaticCall:20( _interpolate@0150898<0> v11, recognized_kind = StringBaseInterpolate) T{String}
 35:     ParallelMove rax <- rax
 36:     Return:24(v31)
*/
 
  ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                   ParallelMovesHandling::kSkip);
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveFunctionEntry,
      kMatchAndMoveCheckStackOverflow,
      kMatchAndMoveCheckSmi,
      kMatchAndMoveBinarySmiOp,
      kMatchAndMoveCreateArray,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveStoreIndexed,
      kMatchAndMoveMoveArgument,
      kMatchAndMoveStaticCall,
      kMatchDartReturn,
  }));
 
  Compiler::CompileOptimizedFunction(thread, function);
  const auto& result2 = Object::Handle(Invoke(root_library, "main"));
  EXPECT(result2.IsString());
  EXPECT_STREQ(result2.ToCString(),
               "r1: (9223372036854775807, true), r2: (field1: "
               "9223372036854775807, field2: hey), sum: -2");
}

ISOLATE_UNIT_TEST_CASE() [7/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Array

)

Definition at line 1776 of file object_test.cc.

                              {
  const int kArrayLen = 5;
  const Array& array = Array::Handle(Array::New(kArrayLen));
  EXPECT_EQ(kArrayLen, array.Length());
  Object& element = Object::Handle(array.At(0));
  EXPECT(element.IsNull());
  element = array.At(kArrayLen - 1);
  EXPECT(element.IsNull());
  array.SetAt(0, array);
  array.SetAt(2, array);
  element = array.At(0);
  EXPECT_EQ(array.ptr(), element.ptr());
  element = array.At(1);
  EXPECT(element.IsNull());
  element = array.At(2);
  EXPECT_EQ(array.ptr(), element.ptr());
 
  Array& other_array = Array::Handle(Array::New(kArrayLen));
  other_array.SetAt(0, array);
  other_array.SetAt(2, array);
 
  EXPECT(array.CanonicalizeEquals(array));
  EXPECT(array.CanonicalizeEquals(other_array));
 
  other_array.SetAt(1, other_array);
  EXPECT(!array.CanonicalizeEquals(other_array));
 
  other_array = Array::New(kArrayLen - 1);
  other_array.SetAt(0, array);
  other_array.SetAt(2, array);
  EXPECT(!array.CanonicalizeEquals(other_array));
 
  EXPECT_EQ(0, Object::empty_array().Length());
 
  array.MakeImmutable();
  Object& obj = Object::Handle(array.ptr());
  EXPECT(obj.IsArray());
}

ISOLATE_UNIT_TEST_CASE() [8/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Array_Grow

)

Definition at line 1815 of file object_test.cc.

                                   {
  const intptr_t kSmallSize = 100;
  EXPECT(!Array::UseCardMarkingForAllocation(kSmallSize));
  const intptr_t kMediumSize = 1000;
  EXPECT(!Array::UseCardMarkingForAllocation(kMediumSize));
  const intptr_t kLargeSize = 100000;
  EXPECT(Array::UseCardMarkingForAllocation(kLargeSize));
 
  const Array& small = Array::Handle(Array::New(kSmallSize));
  for (intptr_t i = 0; i < kSmallSize; i++) {
    small.SetAt(i, Smi::Handle(Smi::New(i)));
  }
 
  const Array& medium = Array::Handle(Array::Grow(small, kMediumSize));
  EXPECT_EQ(kMediumSize, medium.Length());
  for (intptr_t i = 0; i < kSmallSize; i++) {
    EXPECT_EQ(Smi::New(i), medium.At(i));
  }
  for (intptr_t i = kSmallSize; i < kMediumSize; i++) {
    EXPECT_EQ(Object::null(), medium.At(i));
  }
 
  const Array& large = Array::Handle(Array::Grow(small, kLargeSize));
  EXPECT_EQ(kLargeSize, large.Length());
  for (intptr_t i = 0; i < kSmallSize; i++) {
    EXPECT_EQ(large.At(i), Smi::New(i));
  }
  for (intptr_t i = kSmallSize; i < kLargeSize; i++) {
    EXPECT_EQ(large.At(i), Object::null());
  }
}

ISOLATE_UNIT_TEST_CASE() [9/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ArrayTruncationPadding

)

Definition at line 755 of file heap_test.cc.

                                               {
  GrowableObjectArray& retain =
      GrowableObjectArray::Handle(GrowableObjectArray::New());
  Array& array = Array::Handle();
 
  for (intptr_t big = 0; big < 256; big++) {
    for (intptr_t small = 0; small < big; small++) {
      array = Array::New(big);
 
      // Fill the alignment gap with invalid pointers.
      uword addr = UntaggedObject::ToAddr(array.ptr());
      for (intptr_t offset = Array::UnroundedSize(big);
           offset < Array::InstanceSize(big); offset += sizeof(uword)) {
        *reinterpret_cast<uword*>(addr + offset) = kHeapObjectTag;
      }
 
      array.Truncate(small);
      retain.Add(array);
    }
  }
 
  IsolateGroup::Current()->heap()->Verify("truncation padding");
}

ISOLATE_UNIT_TEST_CASE() [10/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ArrayTruncationRaces

)

Definition at line 709 of file heap_test.cc.

                                             {
  // Alternate between allocating new lists and truncating.
  // For each list, the life cycle is
  // 1) the list is allocated and filled with some elements
  // 2) kNumLists other lists are allocated
  // 3) the list's backing store is truncated; the list becomes unreachable
  // 4) kNumLists other lists are allocated
  // 5) the backing store becomes unreachable
  // The goal is to cause truncation *during* concurrent mark or sweep, by
  // truncating an array that had been alive for a while and will be visited by
  // a GC triggering by the allocations in step 2.
 
  intptr_t kMaxListLength = 100;
  intptr_t kNumLists = 1000;
  Array& lists = Array::Handle(Array::New(kNumLists));
  Array& arrays = Array::Handle(Array::New(kNumLists));
 
  GrowableObjectArray& list = GrowableObjectArray::Handle();
  Array& array = Array::Handle();
  Object& element = Object::Handle();
 
  for (intptr_t i = 0; i < kNumLists; i++) {
    list = GrowableObjectArray::New(Heap::kNew);
    intptr_t length = i % kMaxListLength;
    for (intptr_t j = 0; j < length; j++) {
      list.Add(element, Heap::kNew);
    }
    lists.SetAt(i, list);
  }
 
  intptr_t kTruncations = 100000;
  for (intptr_t i = 0; i < kTruncations; i++) {
    list ^= lists.At(i % kNumLists);
    array = Array::MakeFixedLength(list);
    arrays.SetAt(i % kNumLists, array);
 
    list = GrowableObjectArray::New(Heap::kOld);
    intptr_t length = i % kMaxListLength;
    for (intptr_t j = 0; j < length; j++) {
      list.Add(element, Heap::kOld);
    }
    lists.SetAt(i % kNumLists, list);
  }
}

ISOLATE_UNIT_TEST_CASE() [11/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BasicInductionDown

)

Definition at line 110 of file loops_test.cc.

                                           {
  const char* script_chars =

ISOLATE_UNIT_TEST_CASE() [12/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BasicInductionLoopNest

)

Definition at line 143 of file loops_test.cc.

             {
        foo();
      }
    )";
  const char* expected =
      "  [0\n"
      "  LIN(10 + 2 * i)\n"  // phi
      "  LIN(12 + 2 * i)\n"  // add
      "  ]\n";
  EXPECT_STREQ(expected, ComputeInduction(thread, script_chars));
}
 
ISOLATE_UNIT_TEST_CASE(BasicInductionStepDown) {
  const char* script_chars =
      R"(
      foo() {
        for (int i = 100; i >= 0; i -= 7) {

ISOLATE_UNIT_TEST_CASE() [13/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BasicInductionStepDown

)

Definition at line 132 of file loops_test.cc.

                                             {
  const char* script_chars =
      R"(
      foo() {
        for (int i = 10; i < 100; i += 2) {

ISOLATE_UNIT_TEST_CASE() [14/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BasicInductionStepUp

)

Definition at line 121 of file loops_test.cc.

            {
        for (int i = 100; i > 0; i--) {
        }
      }
      main() {
        foo();
      }
    )";
  const char* expected =
      "  [0\n"

ISOLATE_UNIT_TEST_CASE() [15/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BasicInductionUp

)

Definition at line 99 of file loops_test.cc.

                                         {
  const char* script_chars =
      R"(
      foo() {
        for (int i = 0; i < 100; i++) {
        }
      }
      main() {
        foo();
      }

ISOLATE_UNIT_TEST_CASE() [16/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCEArithmeticWrapAround

)

Definition at line 138 of file bce_test.cc.

ISOLATE_UNIT_TEST_CASE() [17/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCEBubbleSort

)

Definition at line 132 of file bce_test.cc.

                                                 {
          l[i] = 1;
        }
      }

ISOLATE_UNIT_TEST_CASE() [18/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCECannotRemove

)

Definition at line 78 of file bce_test.cc.

                                        {
  const char* kScriptChars =
      R"(
      import 'dart:typed_data';
      foo(Float64List l) {

ISOLATE_UNIT_TEST_CASE() [19/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCEListNamedAndPlainLength

)

Definition at line 144 of file bce_test.cc.

                                  {
  const char* kScriptChars =
      R"(
      foo(int i) {
        var l = List<int>.filled(3, 0);

ISOLATE_UNIT_TEST_CASE() [20/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCELowerTriangular

)

Definition at line 108 of file bce_test.cc.

                  :typed_data';
      foo(Float64List l) {
        for (int i = 0; i < l.length; i++) {
          l[i] = 0;

ISOLATE_UNIT_TEST_CASE() [21/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCEModulo

)

Definition at line 102 of file bce_test.cc.

                                       {

ISOLATE_UNIT_TEST_CASE() [22/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCENamedLength

)

Definition at line 126 of file bce_test.cc.

                  :typed_data';
      foo(Float64List l) {
        for (int i = l.length - 1; i >= 0; i--) {

ISOLATE_UNIT_TEST_CASE() [23/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCERemoveOne

)

Definition at line 84 of file bce_test.cc.

             {
        foo(new Float64List(1));
      }
    )";

ISOLATE_UNIT_TEST_CASE() [24/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCESimpleLoops

)

Definition at line 90 of file bce_test.cc.

                                     {
  const char* kScriptChars =
      R"(

ISOLATE_UNIT_TEST_CASE() [25/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCESimpleLoopsDown

)

Definition at line 96 of file bce_test.cc.

                         {
        return l[1] + l[0];
      }
      main() {
        foo(new Float64List(2));

ISOLATE_UNIT_TEST_CASE() [26/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCETriangularDown

)

Definition at line 120 of file bce_test.cc.

ISOLATE_UNIT_TEST_CASE() [27/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BCEUpperTriangular

)

Definition at line 114 of file bce_test.cc.

                                                 {
          l[i] = 1;
        }
      }
      main() {

ISOLATE_UNIT_TEST_CASE() [28/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardMessageId

)

Definition at line 97 of file become_test.cc.

                                               {
  Isolate* isolate = Isolate::Current();
  isolate->set_forward_table_new(new WeakTable());
  isolate->set_forward_table_old(new WeakTable());
 
  const Array& before_obj = Array::Handle(Array::New(0, Heap::kOld));
  const Array& after_obj = Array::Handle(Array::New(0, Heap::kOld));
  EXPECT(before_obj.ptr() != after_obj.ptr());
 
  intptr_t id = 42;
  intptr_t no_id = 0;
  isolate->forward_table_old()->SetValueExclusive(before_obj.ptr(), id);
  EXPECT_EQ(id,
            isolate->forward_table_old()->GetValueExclusive(before_obj.ptr()));
  EXPECT_EQ(no_id,
            isolate->forward_table_old()->GetValueExclusive(after_obj.ptr()));
 
  Become become;
  become.Add(before_obj, after_obj);
  become.Forward();
 
  EXPECT(before_obj.ptr() == after_obj.ptr());
  EXPECT_EQ(id,
            isolate->forward_table_old()->GetValueExclusive(before_obj.ptr()));
  EXPECT_EQ(id,
            isolate->forward_table_old()->GetValueExclusive(after_obj.ptr()));
 
  isolate->set_forward_table_new(nullptr);
  isolate->set_forward_table_old(nullptr);
}

ISOLATE_UNIT_TEST_CASE() [29/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardNewToNew

)

Definition at line 41 of file become_test.cc.

                                              {
  TestBecomeForward(Heap::kNew, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE() [30/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardNewToOld

)

Definition at line 49 of file become_test.cc.

                                              {
  TestBecomeForward(Heap::kNew, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE() [31/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardObjectId

)

Definition at line 75 of file become_test.cc.

                                              {
  Heap* heap = IsolateGroup::Current()->heap();
 
  const Array& before_obj = Array::Handle(Array::New(0, Heap::kOld));
  const Array& after_obj = Array::Handle(Array::New(0, Heap::kOld));
  EXPECT(before_obj.ptr() != after_obj.ptr());
 
  intptr_t id = 42;
  intptr_t no_id = 0;
  heap->SetObjectId(before_obj.ptr(), id);
  EXPECT_EQ(id, heap->GetObjectId(before_obj.ptr()));
  EXPECT_EQ(no_id, heap->GetObjectId(after_obj.ptr()));
 
  Become become;
  become.Add(before_obj, after_obj);
  become.Forward();
 
  EXPECT(before_obj.ptr() == after_obj.ptr());
  EXPECT_EQ(id, heap->GetObjectId(before_obj.ptr()));
  EXPECT_EQ(id, heap->GetObjectId(after_obj.ptr()));
}

ISOLATE_UNIT_TEST_CASE() [32/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardOldToNew

)

Definition at line 45 of file become_test.cc.

                                              {
  TestBecomeForward(Heap::kOld, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE() [33/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardOldToOld

)

Definition at line 37 of file become_test.cc.

                                              {
  TestBecomeForward(Heap::kOld, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE() [34/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardPeer

)

Definition at line 53 of file become_test.cc.

                                          {
  Heap* heap = IsolateGroup::Current()->heap();
 
  const Array& before_obj = Array::Handle(Array::New(0, Heap::kOld));
  const Array& after_obj = Array::Handle(Array::New(0, Heap::kOld));
  EXPECT(before_obj.ptr() != after_obj.ptr());
 
  void* peer = reinterpret_cast<void*>(42);
  void* no_peer = reinterpret_cast<void*>(0);
  heap->SetPeer(before_obj.ptr(), peer);
  EXPECT_EQ(peer, heap->GetPeer(before_obj.ptr()));
  EXPECT_EQ(no_peer, heap->GetPeer(after_obj.ptr()));
 
  Become become;
  become.Add(before_obj, after_obj);
  become.Forward();
 
  EXPECT(before_obj.ptr() == after_obj.ptr());
  EXPECT_EQ(peer, heap->GetPeer(before_obj.ptr()));
  EXPECT_EQ(peer, heap->GetPeer(after_obj.ptr()));
}

ISOLATE_UNIT_TEST_CASE() [35/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardRememberedCards

)

Definition at line 152 of file become_test.cc.

                                                     {
  const intptr_t length = kNewAllocatableSize / Array::kBytesPerElement;
  ASSERT(Array::UseCardMarkingForAllocation(length));
  const Array& card_remembered_array = Array::Handle(Array::New(length));
  EXPECT(card_remembered_array.ptr()->untag()->IsCardRemembered());
  EXPECT(!card_remembered_array.ptr()->untag()->IsRemembered());
 
  const String& old_element = String::Handle(String::New("old", Heap::kOld));
  const String& new_element = String::Handle(String::New("new", Heap::kNew));
  card_remembered_array.SetAt(0, old_element);
 
  {
    HANDLESCOPE(thread);
    EXPECT_STREQ("old",
                 Object::Handle(card_remembered_array.At(0)).ToCString());
  }
 
  Become become;
  become.Add(old_element, new_element);
  become.Forward();
 
  EXPECT(old_element.ptr() == new_element.ptr());
  EXPECT(old_element.ptr()->IsNewObject());
  EXPECT(card_remembered_array.ptr()->untag()->IsCardRemembered());
  EXPECT(!card_remembered_array.ptr()->untag()->IsRemembered());
 
  {
    HANDLESCOPE(thread);
    EXPECT_STREQ("new",
                 Object::Handle(card_remembered_array.At(0)).ToCString());
  }
 
  GCTestHelper::CollectAllGarbage();
 
  EXPECT(old_element.ptr() == new_element.ptr());
  EXPECT(card_remembered_array.ptr()->untag()->IsCardRemembered());
  EXPECT(!card_remembered_array.ptr()->untag()->IsRemembered());
 
  {
    HANDLESCOPE(thread);
    EXPECT_STREQ("new",
                 Object::Handle(card_remembered_array.At(0)).ToCString());
  }
}

ISOLATE_UNIT_TEST_CASE() [36/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BecomeForwardRememberedObject

)

Definition at line 128 of file become_test.cc.

                                                      {
  const String& new_element = String::Handle(String::New("new", Heap::kNew));
  const String& old_element = String::Handle(String::New("old", Heap::kOld));
  const Array& before_obj = Array::Handle(Array::New(1, Heap::kOld));
  const Array& after_obj = Array::Handle(Array::New(1, Heap::kOld));
  before_obj.SetAt(0, new_element);
  after_obj.SetAt(0, old_element);
  EXPECT(before_obj.ptr()->untag()->IsRemembered());
  EXPECT(!after_obj.ptr()->untag()->IsRemembered());
 
  EXPECT(before_obj.ptr() != after_obj.ptr());
 
  Become become;
  become.Add(before_obj, after_obj);
  become.Forward();
 
  EXPECT(before_obj.ptr() == after_obj.ptr());
  EXPECT(!after_obj.ptr()->untag()->IsRemembered());
 
  GCTestHelper::CollectAllGarbage();
 
  EXPECT(before_obj.ptr() == after_obj.ptr());
}

ISOLATE_UNIT_TEST_CASE() [37/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BitmapBuilder

)

Definition at line 25 of file bitmap_test.cc.

                                      {
  // Test basic bit map builder operations.
  BitmapBuilder* builder1 = new BitmapBuilder();
  EXPECT_EQ(0, builder1->Length());
 
  bool value = true;
  for (int32_t i = 0; i < 128; i++) {
    builder1->Set(i, value);
    value = !value;
  }
  EXPECT_EQ(128, builder1->Length());
  value = true;
  for (int32_t i = 0; i < 128; i++) {
    EXPECT_EQ(value, builder1->Get(i));
    value = !value;
  }
  value = true;
  for (int32_t i = 0; i < 1024; i++) {
    builder1->Set(i, value);
    value = !value;
  }
  EXPECT_EQ(1024, builder1->Length());
  value = true;
  for (int32_t i = 0; i < 1024; i++) {
    EXPECT_EQ(value, builder1->Get(i));
    value = !value;
  }
 
  // Create a CompressedStackMaps object and verify its contents.
  const auto& maps1 = CompressedStackMaps::Handle(
      thread->zone(), MapsFromBuilder(thread->zone(), builder1));
  auto it1 = maps1.iterator(thread);
  EXPECT(it1.MoveNext());
 
  EXPECT_EQ(kTestPcOffset, it1.pc_offset());
  EXPECT_EQ(kTestSpillSlotBitCount, it1.SpillSlotBitCount());
  EXPECT_EQ(1024, it1.Length());
  value = true;
  for (int32_t i = 0; i < 1024; i++) {
    EXPECT_EQ(value, it1.IsObject(i));
    value = !value;
  }
 
  EXPECT(!it1.MoveNext());
 
  // Test the SetRange function in the builder.
  builder1->SetRange(0, 256, false);
  EXPECT_EQ(1024, builder1->Length());
  builder1->SetRange(257, 1024, true);
  EXPECT_EQ(1025, builder1->Length());
  builder1->SetRange(1025, 2048, false);
  EXPECT_EQ(2049, builder1->Length());
  for (int32_t i = 0; i <= 256; i++) {
    EXPECT(!builder1->Get(i));
  }
  for (int32_t i = 257; i <= 1024; i++) {
    EXPECT(builder1->Get(i));
  }
  for (int32_t i = 1025; i <= 2048; i++) {
    EXPECT(!builder1->Get(i));
  }
 
  const auto& maps2 = CompressedStackMaps::Handle(
      thread->zone(), MapsFromBuilder(thread->zone(), builder1));
  auto it2 = maps2.iterator(thread);
  EXPECT(it2.MoveNext());
 
  EXPECT_EQ(kTestPcOffset, it2.pc_offset());
  EXPECT_EQ(kTestSpillSlotBitCount, it2.SpillSlotBitCount());
  EXPECT_EQ(2049, it2.Length());
  for (int32_t i = 0; i <= 256; i++) {
    EXPECT(!it2.IsObject(i));
  }
  for (int32_t i = 257; i <= 1024; i++) {
    EXPECT(it2.IsObject(i));
  }
  for (int32_t i = 1025; i <= 2048; i++) {
    EXPECT(!it2.IsObject(i));
  }
 
  EXPECT(!it2.MoveNext());
 
  // Test using SetLength to shorten the builder, followed by lengthening.
  builder1->SetLength(747);
  EXPECT_EQ(747, builder1->Length());
  for (int32_t i = 257; i < 747; ++i) {
    EXPECT(builder1->Get(i));
  }
 
  builder1->Set(800, false);
  EXPECT_EQ(801, builder1->Length());
  for (int32_t i = 257; i < 747; ++i) {
    EXPECT(builder1->Get(i));
  }
  for (int32_t i = 747; i < 801; ++i) {
    EXPECT(!builder1->Get(i));
  }
 
  builder1->Set(900, true);
  EXPECT_EQ(901, builder1->Length());
  for (int32_t i = 257; i < 747; ++i) {
    EXPECT(builder1->Get(i));
  }
  for (int32_t i = 747; i < 900; ++i) {
    EXPECT(!builder1->Get(i));
  }
  EXPECT(builder1->Get(900));
}

ISOLATE_UNIT_TEST_CASE() [38/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BitmapBuilder_Regress44946

)

Definition at line 134 of file bitmap_test.cc.

                                                   {
  BitmapBuilder* builder1 = new BitmapBuilder();
  EXPECT_EQ(0, builder1->Length());
 
  builder1->Set(10000, false);
  EXPECT_EQ(10001, builder1->Length());
  builder1->Set(9999, true);
  EXPECT(builder1->Get(9999));
}

ISOLATE_UNIT_TEST_CASE() [39/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Bool

)

Definition at line 1771 of file object_test.cc.

                             {
  EXPECT(Bool::True().value());
  EXPECT(!Bool::False().value());
}

ISOLATE_UNIT_TEST_CASE() [40/463]

dart::ISOLATE_UNIT_TEST_CASE

(

BoundsCheckElimination_Pragma

)

Definition at line 1606 of file redundancy_elimination_test.cc.

                                                      {
  const char* kScript = R"(
    import 'dart:typed_data';
 
    @pragma('vm:unsafe:no-bounds-checks')
    int test(Uint8List list) {
      int result = 0;
      for (int i = 0; i < 10; i++) {
        result = list[i];
      }
      return result;
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  TestPipeline pipeline(function, CompilerPass::kAOT);
  auto flow_graph = pipeline.RunPasses({});
  for (auto block : flow_graph->postorder()) {
    for (auto instr : block->instructions()) {
      EXPECT_PROPERTY(instr, !it.IsCheckBoundBase());
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [41/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CardRememberedArray

)

Definition at line 1355 of file heap_test.cc.

                                            {
  TestCardRememberedArray(true, true);
  TestCardRememberedArray(true, false);
}

ISOLATE_UNIT_TEST_CASE() [42/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CardRememberedImmutableArray

)

Definition at line 1360 of file heap_test.cc.

                                                     {
  TestCardRememberedArray(false, true);
  TestCardRememberedArray(false, false);
}

ISOLATE_UNIT_TEST_CASE() [43/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CardRememberedWeakArray

)

Definition at line 1365 of file heap_test.cc.

                                                {
  TestCardRememberedWeakArray(true);
  TestCardRememberedWeakArray(false);
}

ISOLATE_UNIT_TEST_CASE() [44/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CatchEntryMoves

)

Definition at line 95 of file catch_entry_moves_test.cc.

                                        {
  // Common prefix.
  const TestCaseMoves test1[] = {
      TestCaseMoves{
          abcde,
          ARRAY_SIZE(abcde),
      },
      TestCaseMoves{
          abcdx,
          ARRAY_SIZE(abcdx),
      },
  };
  RunTestCase(test1, ARRAY_SIZE(test1));
 
  // Common suffix.
  const TestCaseMoves test2[] = {
      TestCaseMoves{
          abcde,
          ARRAY_SIZE(abcde),
      },
      TestCaseMoves{
          xbcde,
          ARRAY_SIZE(xbcde),
      },
  };
  RunTestCase(test2, ARRAY_SIZE(test2));
 
  // Common prefix and suffix.
  const TestCaseMoves test3[] = {
      TestCaseMoves{
          abcde,
          ARRAY_SIZE(abcde),
      },
      TestCaseMoves{
          abxde,
          ARRAY_SIZE(abxde),
      },
  };
  RunTestCase(test3, ARRAY_SIZE(test3));
 
  // Subset of suffix.
  const TestCaseMoves test4[] = {
      TestCaseMoves{
          abcde,
          ARRAY_SIZE(abcde),
      },
      TestCaseMoves{
          de,
          ARRAY_SIZE(de),
      },
  };
  RunTestCase(test4, ARRAY_SIZE(test4));
 
  // Subset of prefix.
  const TestCaseMoves test5[] = {
      TestCaseMoves{
          abcde,
          ARRAY_SIZE(abcde),
      },
      TestCaseMoves{
          ab,
          ARRAY_SIZE(ab),
      },
  };
  RunTestCase(test5, ARRAY_SIZE(test5));
 
  // All moves (with duplicates).
  const TestCaseMoves test6[] = {
      TestCaseMoves{
          abcde,
          ARRAY_SIZE(abcde),
      },
      TestCaseMoves{
          abcde,
          ARRAY_SIZE(abcde),
      },
      TestCaseMoves{
          abcdx,
          ARRAY_SIZE(abcdx),
      },
      TestCaseMoves{
          xbcde,
          ARRAY_SIZE(xbcde),
      },
      TestCaseMoves{
          abxde,
          ARRAY_SIZE(abxde),
      },
      TestCaseMoves{
          ab,
          ARRAY_SIZE(ab),
      },
      TestCaseMoves{
          de,
          ARRAY_SIZE(de),
      },
      TestCaseMoves{
          de,
          ARRAY_SIZE(de),
      },
  };
  RunTestCase(test6, ARRAY_SIZE(test6));
}

ISOLATE_UNIT_TEST_CASE() [45/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ChainInduction

)

Definition at line 162 of file loops_test.cc.

             {
        foo();
      }
    )";
  const char* expected =
      "  [0\n"
      "  LIN(100 + -7 * i)\n"  // phi
      "  LIN(93 + -7 * i)\n"   // sub
      "  ]\n";
  EXPECT_STREQ(expected, ComputeInduction(thread, script_chars));
}
 

ISOLATE_UNIT_TEST_CASE() [46/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CheckedHandle

)

Definition at line 2615 of file object_test.cc.

                                      {
  // Ensure that null handles have the correct C++ vtable setup.
  Zone* zone = Thread::Current()->zone();
  const String& str1 = String::Handle(zone);
  EXPECT(str1.IsString());
  EXPECT(str1.IsNull());
  const String& str2 = String::CheckedHandle(zone, Object::null());
  EXPECT(str2.IsString());
  EXPECT(str2.IsNull());
  String& str3 = String::Handle(zone);
  str3 ^= Object::null();
  EXPECT(str3.IsString());
  EXPECT(str3.IsNull());
  EXPECT(!str3.IsOneByteString());
  str3 = String::New("Steep and Deep!");
  EXPECT(str3.IsString());
  EXPECT(str3.IsOneByteString());
  str3 = OneByteString::null();
  EXPECT(str3.IsString());
  EXPECT(!str3.IsOneByteString());
}

ISOLATE_UNIT_TEST_CASE() [47/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CheckStackOverflowElimination_NoInterruptsPragma

)

Definition at line 1572 of file redundancy_elimination_test.cc.

                                                                         {
  const char* kScript = R"(
    @pragma('vm:prefer-inline')
    int bar(int n) {
      print(''); // Side-effectful operation
      var sum = 0;
      for (int i = 0; i < n; i++) {
        sum += i;
      }
      return sum;
    }
 
    @pragma('vm:unsafe:no-interrupts')
    int test() {
      int result = 0;
      for (int i = 0; i < 10; i++) {
        result ^= bar(i);
      }
      return result;
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  TestPipeline pipeline(function, CompilerPass::kAOT);
  auto flow_graph = pipeline.RunPasses({});
  for (auto block : flow_graph->postorder()) {
    for (auto instr : block->instructions()) {
      EXPECT_PROPERTY(instr, !it.IsCheckStackOverflow());
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [48/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Class

)

Definition at line 53 of file object_test.cc.

                              {
  // Allocate the class first.
  const String& class_name = String::Handle(Symbols::New(thread, "MyClass"));
  const Script& script = Script::Handle();
  const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
 
  // Class has no fields and no functions yet.
  EXPECT_EQ(Array::Handle(cls.fields()).Length(), 0);
  EXPECT_EQ(Array::Handle(cls.current_functions()).Length(), 0);
 
  // Setup the interfaces in the class.
  // Normally the class finalizer is resolving super types and interfaces
  // before finalizing the types in a class. A side-effect of this is setting
  // the is_implemented() bit on a class. We do that manually here.
  const Array& interfaces = Array::Handle(Array::New(2));
  Class& interface = Class::Handle();
  String& interface_name = String::Handle();
  interface_name = Symbols::New(thread, "Harley");
  interface = CreateDummyClass(interface_name, script);
  interfaces.SetAt(0, Type::Handle(Type::NewNonParameterizedType(interface)));
  interface.set_is_implemented_unsafe();
  interface_name = Symbols::New(thread, "Norton");
  interface = CreateDummyClass(interface_name, script);
  interfaces.SetAt(1, Type::Handle(Type::NewNonParameterizedType(interface)));
  interface.set_is_implemented_unsafe();
  cls.set_interfaces(interfaces);
 
  // Finalization of types happens before the fields and functions have been
  // parsed.
  ClassFinalizer::FinalizeTypesInClass(cls);
 
  // Create and populate the function arrays.
  const Array& functions = Array::Handle(Array::New(6));
  FunctionType& signature = FunctionType::Handle();
  Function& function = Function::Handle();
  String& function_name = String::Handle();
  function_name = Symbols::New(thread, "foo");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, false, false,
                           false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(0, function);
  function_name = Symbols::New(thread, "bar");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, false, false,
                           false, false, false, cls, TokenPosition::kMinSource);
 
  const int kNumFixedParameters = 2;
  const int kNumOptionalParameters = 3;
  const bool kAreOptionalPositional = true;
  signature.set_num_fixed_parameters(kNumFixedParameters);
  signature.SetNumOptionalParameters(kNumOptionalParameters,
                                     kAreOptionalPositional);
  functions.SetAt(1, function);
 
  function_name = Symbols::New(thread, "baz");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, false, false,
                           false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(2, function);
 
  function_name = Symbols::New(thread, "Foo");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, true, false,
                           false, false, false, cls, TokenPosition::kMinSource);
 
  functions.SetAt(3, function);
  function_name = Symbols::New(thread, "Bar");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, true, false,
                           false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(4, function);
  function_name = Symbols::New(thread, "BaZ");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, true, false,
                           false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(5, function);
 
  // Setup the functions in the class.
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    cls.SetFunctions(functions);
    // The class can now be finalized.
    cls.Finalize();
  }
 
  function_name = String::New("Foo");
  function = Resolver::ResolveDynamicFunction(Z, cls, function_name);
  EXPECT(function.IsNull());
  function = cls.LookupStaticFunction(function_name);
  EXPECT(!function.IsNull());
  EXPECT(function_name.Equals(String::Handle(function.name())));
  EXPECT_EQ(cls.ptr(), function.Owner());
  EXPECT(function.is_static());
  function_name = String::New("baz");
  function = Resolver::ResolveDynamicFunction(Z, cls, function_name);
  EXPECT(!function.IsNull());
  EXPECT(function_name.Equals(String::Handle(function.name())));
  EXPECT_EQ(cls.ptr(), function.Owner());
  EXPECT(!function.is_static());
  function = cls.LookupStaticFunction(function_name);
  EXPECT(function.IsNull());
 
  function_name = String::New("foo");
  function = Resolver::ResolveDynamicFunction(Z, cls, function_name);
  EXPECT(!function.IsNull());
  EXPECT_EQ(0, function.num_fixed_parameters());
  EXPECT(!function.HasOptionalParameters());
 
  function_name = String::New("bar");
  function = Resolver::ResolveDynamicFunction(Z, cls, function_name);
  EXPECT(!function.IsNull());
  EXPECT_EQ(kNumFixedParameters, function.num_fixed_parameters());
  EXPECT_EQ(kNumOptionalParameters, function.NumOptionalParameters());
}

ISOLATE_UNIT_TEST_CASE() [49/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ClassDictionaryIterator

)

Definition at line 2989 of file object_test.cc.

                                                {
  Class& ae66 = Class::ZoneHandle(CreateTestClass("Ae6/6"));
  Class& re44 = Class::ZoneHandle(CreateTestClass("Re4/4"));
  Field& ce68 = Field::ZoneHandle(CreateTestField("Ce6/8"));
  Field& tee = Field::ZoneHandle(CreateTestField("TEE"));
  String& url = String::ZoneHandle(String::New("SBB"));
  Library& lib = Library::Handle(Library::New(url));
  lib.AddClass(ae66);
  lib.AddObject(ce68, String::ZoneHandle(ce68.name()));
  lib.AddClass(re44);
  lib.AddObject(tee, String::ZoneHandle(tee.name()));
  ClassDictionaryIterator iterator(lib);
  int count = 0;
  Class& cls = Class::Handle();
  while (iterator.HasNext()) {
    cls = iterator.GetNextClass();
    EXPECT((cls.ptr() == ae66.ptr()) || (cls.ptr() == re44.ptr()));
    count++;
  }
  EXPECT(count == 2);
}

ISOLATE_UNIT_TEST_CASE() [50/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ClassFinalizer

)

Definition at line 26 of file class_finalizer_test.cc.

                                       {
  Zone* zone = thread->zone();
  auto isolate_group = thread->isolate_group();
  ObjectStore* object_store = isolate_group->object_store();
  const auto& pending_classes =
      GrowableObjectArray::Handle(zone, object_store->pending_classes());
  GrowableArray<const Class*> classes_1;
  classes_1.Add(&Class::Handle(CreateTestClass("BMW")));
  pending_classes.Add(*classes_1[0]);
  classes_1.Add(&Class::Handle(CreateTestClass("Porsche")));
  pending_classes.Add(*classes_1[1]);
 
  GrowableArray<const Class*> classes_2;
  classes_2.Add(&Class::ZoneHandle(CreateTestClass("Ferrari")));
  pending_classes.Add(*classes_2[0]);
  classes_2.Add(&Class::ZoneHandle(CreateTestClass("Fiat")));
  pending_classes.Add(*classes_2[1]);
  classes_2.Add(&Class::ZoneHandle(CreateTestClass("Alfa")));
  pending_classes.Add(*classes_2[2]);
  EXPECT(ClassFinalizer::ProcessPendingClasses());
  for (int i = 0; i < classes_1.length(); i++) {
    EXPECT(classes_1[i]->is_type_finalized());
  }
  for (int i = 0; i < classes_2.length(); i++) {
    EXPECT(classes_2[i]->is_type_finalized());
  }
  EXPECT(ClassFinalizer::AllClassesFinalized());
  EXPECT(ClassFinalizer::ProcessPendingClasses());
}

ISOLATE_UNIT_TEST_CASE() [51/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Closure

)

Definition at line 2558 of file object_test.cc.

                                {
  // Allocate the class first.
  const String& class_name = String::Handle(Symbols::New(thread, "MyClass"));
  const Script& script = Script::Handle();
  const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
  const Array& functions = Array::Handle(Array::New(1));
 
  const Context& context = Context::Handle(Context::New(0));
  Function& parent = Function::Handle();
  const String& parent_name = String::Handle(Symbols::New(thread, "foo_papa"));
  FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  parent = Function::New(signature, parent_name,
                         UntaggedFunction::kRegularFunction, false, false,
                         false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(0, parent);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    cls.SetFunctions(functions);
    cls.Finalize();
  }
 
  Function& function = Function::Handle();
  const String& function_name = String::Handle(Symbols::New(thread, "foo"));
  function = Function::NewClosureFunction(function_name, parent,
                                          TokenPosition::kMinSource);
  signature = function.signature();
  signature.set_result_type(Object::dynamic_type());
  signature ^= ClassFinalizer::FinalizeType(signature);
  function.SetSignature(signature);
  const Closure& closure = Closure::Handle(
      Closure::New(Object::null_type_arguments(), Object::null_type_arguments(),
                   function, context));
  const Class& closure_class = Class::Handle(closure.clazz());
  EXPECT_EQ(closure_class.id(), kClosureCid);
  const Function& closure_function = Function::Handle(closure.function());
  EXPECT_EQ(closure_function.ptr(), function.ptr());
  const Context& closure_context = Context::Handle(closure.GetContext());
  EXPECT_EQ(closure_context.ptr(), context.ptr());
}

ISOLATE_UNIT_TEST_CASE() [52/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ClosureType_SubtypeOfFunctionType

)

Definition at line 7422 of file object_test.cc.

                                                            : "not be");
    super.PrintName(Object::kScrubbedName, &buffer);
    expect.Fail("%s", buffer.buffer());
  }
}
 
#define EXPECT_SUBTYPE(sub, super)                                             \
  CheckSubtypeRelation(Expect(__FILE__, __LINE__), sub, super, true);
#define EXPECT_NOT_SUBTYPE(sub, super)                                         \
  CheckSubtypeRelation(Expect(__FILE__, __LINE__), sub, super, false);
 
ISOLATE_UNIT_TEST_CASE(ClosureType_SubtypeOfFunctionType) {
  const auto& closure_class =
      Class::Handle(IsolateGroup::Current()->object_store()->closure_class());
  const auto& closure_type = Type::Handle(closure_class.DeclarationType());
  auto& closure_type_nullable = Type::Handle(
      closure_type.ToNullability(Nullability::kNullable, Heap::kNew));
  FinalizeAndCanonicalize(&closure_type_nullable);
  auto& closure_type_legacy = Type::Handle(
      closure_type.ToNullability(Nullability::kLegacy, Heap::kNew));
  FinalizeAndCanonicalize(&closure_type_legacy);
  auto& closure_type_nonnullable = Type::Handle(
      closure_type.ToNullability(Nullability::kNonNullable, Heap::kNew));
  FinalizeAndCanonicalize(&closure_type_nonnullable);
 
  const auto& function_type =
      Type::Handle(IsolateGroup::Current()->object_store()->function_type());
  auto& function_type_nullable = Type::Handle(
      function_type.ToNullability(Nullability::kNullable, Heap::kNew));
  FinalizeAndCanonicalize(&function_type_nullable);
  auto& function_type_legacy = Type::Handle(
      function_type.ToNullability(Nullability::kLegacy, Heap::kNew));
  FinalizeAndCanonicalize(&function_type_legacy);
  auto& function_type_nonnullable = Type::Handle(
      function_type.ToNullability(Nullability::kNonNullable, Heap::kNew));
  FinalizeAndCanonicalize(&function_type_nonnullable);
 
  EXPECT_SUBTYPE(closure_type_nonnullable, function_type_nullable);
  EXPECT_SUBTYPE(closure_type_nonnullable, function_type_legacy);
  EXPECT_SUBTYPE(closure_type_nonnullable, function_type_nonnullable);
  EXPECT_SUBTYPE(closure_type_legacy, function_type_nullable);
  EXPECT_SUBTYPE(closure_type_legacy, function_type_legacy);
  EXPECT_SUBTYPE(closure_type_legacy, function_type_nonnullable);
  EXPECT_SUBTYPE(closure_type_nullable, function_type_nullable);
  EXPECT_SUBTYPE(closure_type_nullable, function_type_legacy);
  EXPECT_NOT_SUBTYPE(closure_type_nullable, function_type_nonnullable);
 
  const auto& async_lib = Library::Handle(Library::AsyncLibrary());
  const auto& future_or_class =
      Class::Handle(async_lib.LookupClass(Symbols::FutureOr()));
  auto& tav_function_nullable = TypeArguments::Handle(TypeArguments::New(1));
  tav_function_nullable.SetTypeAt(0, function_type_nullable);
  tav_function_nullable = tav_function_nullable.Canonicalize(thread);
  auto& tav_function_legacy = TypeArguments::Handle(TypeArguments::New(1));
  tav_function_legacy.SetTypeAt(0, function_type_legacy);
  tav_function_legacy = tav_function_legacy.Canonicalize(thread);
  auto& tav_function_nonnullable = TypeArguments::Handle(TypeArguments::New(1));
  tav_function_nonnullable.SetTypeAt(0, function_type_nonnullable);
  tav_function_nonnullable = tav_function_nonnullable.Canonicalize(thread);
 
  auto& future_or_function_type_nullable =
      Type::Handle(Type::New(future_or_class, tav_function_nullable));
  FinalizeAndCanonicalize(&future_or_function_type_nullable);
  auto& future_or_function_type_legacy =
      Type::Handle(Type::New(future_or_class, tav_function_legacy));
  FinalizeAndCanonicalize(&future_or_function_type_legacy);
  auto& future_or_function_type_nonnullable =
      Type::Handle(Type::New(future_or_class, tav_function_nonnullable));
  FinalizeAndCanonicalize(&future_or_function_type_nonnullable);
 

ISOLATE_UNIT_TEST_CASE() [53/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Code

)

Definition at line 2658 of file object_test.cc.

                             {
  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  const Function& function = Function::Handle(CreateFunction("Test_Code"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  function.AttachCode(code);
  const Instructions& instructions = Instructions::Handle(code.instructions());
  uword payload_start = instructions.PayloadStart();
  EXPECT_EQ(instructions.ptr(), Instructions::FromPayloadStart(payload_start));
  const Object& result =
      Object::Handle(DartEntry::InvokeFunction(function, Array::empty_array()));
  EXPECT_EQ(1, Smi::Cast(result).Value());
}

ISOLATE_UNIT_TEST_CASE() [54/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_DeadGenCycle

)

Definition at line 278 of file heap_test.cc.

                                                       {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  neu.SetAt(0, old);
  old.SetAt(0, neu);
  old = Array::null();
  neu = Array::null();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT_EQ(size_before, size_after);
}

ISOLATE_UNIT_TEST_CASE() [55/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_DeadNewToOld

)

Definition at line 255 of file heap_test.cc.

                                                       {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  neu.SetAt(0, old);
  old = Array::null();
  neu = Array::null();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT_EQ(size_before, size_after);
}

ISOLATE_UNIT_TEST_CASE() [56/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_DeadOldToNew

)

Definition at line 232 of file heap_test.cc.

                                                       {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  old.SetAt(0, neu);
  old = Array::null();
  neu = Array::null();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT_EQ(size_before, size_after);
}

ISOLATE_UNIT_TEST_CASE() [57/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_LiveNewDeadOld

)

Definition at line 368 of file heap_test.cc.

                                                         {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  old = Array::null();
  neu.SetAt(0, neu);
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT(size_before < size_after);
}

ISOLATE_UNIT_TEST_CASE() [58/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_LiveNewToOld

)

Definition at line 302 of file heap_test.cc.

                                                       {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  neu.SetAt(0, old);
  old = Array::null();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT(size_before < size_after);
}

ISOLATE_UNIT_TEST_CASE() [59/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_LiveNewToOldChain

)

Definition at line 390 of file heap_test.cc.

                                                            {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& old2 = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  old.SetAt(0, old2);
  neu.SetAt(0, old);
  old = Array::null();
  old2 = Array::null();
 
  heap->CollectAllGarbage();
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT(size_before < size_after);
}

ISOLATE_UNIT_TEST_CASE() [60/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_LiveOldDeadNew

)

Definition at line 346 of file heap_test.cc.

                                                         {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  neu = Array::null();
  old.SetAt(0, old);
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT(size_before < size_after);
}

ISOLATE_UNIT_TEST_CASE() [61/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_LiveOldToNew

)

Definition at line 324 of file heap_test.cc.

                                                       {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  old.SetAt(0, neu);
  neu = Array::null();
 
  heap->CollectAllGarbage();
  heap->WaitForMarkerTasks(thread);  // Finalize marking to get live size.
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT(size_before < size_after);
}

ISOLATE_UNIT_TEST_CASE() [62/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CollectAllGarbage_LiveOldToNewChain

)

Definition at line 413 of file heap_test.cc.

                                                            {
  Heap* heap = IsolateGroup::Current()->heap();
 
  heap->CollectAllGarbage();
  intptr_t size_before =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  Array& old = Array::Handle(Array::New(1, Heap::kOld));
  Array& neu = Array::Handle(Array::New(1, Heap::kNew));
  Array& neu2 = Array::Handle(Array::New(1, Heap::kOld));
  neu.SetAt(0, neu2);
  old.SetAt(0, neu);
  neu = Array::null();
  neu2 = Array::null();
 
  heap->CollectAllGarbage();
 
  intptr_t size_after =
      heap->new_space()->UsedInWords() + heap->old_space()->UsedInWords();
 
  EXPECT(size_before < size_after);
}

ISOLATE_UNIT_TEST_CASE() [63/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CompileFunction

)

Definition at line 19 of file compiler_test.cc.

                                        {
  const char* kScriptChars =
      "class A {\n"
      "  static foo() { return 42; }\n"
      "  static moo() {\n"
      "    // A.foo();\n"
      "  }\n"
      "}\n";
  Dart_Handle library;
  {
    TransitionVMToNative transition(thread);
    library = TestCase::LoadTestScript(kScriptChars, nullptr);
  }
  const Library& lib =
      Library::Handle(Library::RawCast(Api::UnwrapHandle(library)));
  EXPECT(ClassFinalizer::ProcessPendingClasses());
  Class& cls =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
  EXPECT(!cls.IsNull());
  const auto& error = cls.EnsureIsFinalized(thread);
  EXPECT(error == Error::null());
  String& function_foo_name = String::Handle(String::New("foo"));
  Function& function_foo =
      Function::Handle(cls.LookupStaticFunction(function_foo_name));
  EXPECT(!function_foo.IsNull());
  String& function_source = String::Handle(function_foo.GetSource());
  EXPECT_STREQ("static foo() { return 42; }", function_source.ToCString());
  EXPECT(CompilerTest::TestCompileFunction(function_foo));
  EXPECT(function_foo.HasCode());
 
  String& function_moo_name = String::Handle(String::New("moo"));
  Function& function_moo =
      Function::Handle(cls.LookupStaticFunction(function_moo_name));
  EXPECT(!function_moo.IsNull());
 
  EXPECT(CompilerTest::TestCompileFunction(function_moo));
  EXPECT(function_moo.HasCode());
  function_source = function_moo.GetSource();
  EXPECT_STREQ("static moo() {\n    // A.foo();\n  }",
               function_source.ToCString());
}

ISOLATE_UNIT_TEST_CASE() [64/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CompileFunctionOnHelperThread

)

Definition at line 103 of file compiler_test.cc.

                                                      {
  // Create a simple function and compile it without optimization.
  const char* kScriptChars =
      "class A {\n"
      "  static foo() { return 42; }\n"
      "}\n";
  Dart_Handle library;
  {
    TransitionVMToNative transition(thread);
    library = TestCase::LoadTestScript(kScriptChars, nullptr);
  }
  const Library& lib =
      Library::Handle(Library::RawCast(Api::UnwrapHandle(library)));
  EXPECT(ClassFinalizer::ProcessPendingClasses());
  Class& cls =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
  EXPECT(!cls.IsNull());
  const auto& error = cls.EnsureIsFinalized(thread);
  EXPECT(error == Error::null());
  String& function_foo_name = String::Handle(String::New("foo"));
  Function& func =
      Function::Handle(cls.LookupStaticFunction(function_foo_name));
  EXPECT(!func.HasCode());
  CompilerTest::TestCompileFunction(func);
  EXPECT(func.HasCode());
}

ISOLATE_UNIT_TEST_CASE() [65/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CompileType_CanBeSmi

)

Definition at line 400 of file type_propagator_test.cc.

                                             {
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
 
  const char* late_tag = TestCase::LateTag();
  auto script_chars = Utils::CStringUniquePtr(
      OS::SCreate(nullptr, R"(
import 'dart:async';
 
class G<T> {}
 
class C<NoBound,
        NumBound extends num,
        ComparableBound extends Comparable,
        StringBound extends String> {
  // Simple instantiated types.
  @pragma('vm-test:can-be-smi') %s int t1;
  @pragma('vm-test:can-be-smi') %s num t2;
  @pragma('vm-test:can-be-smi') %s Object t3;
  %s String t4;
 
  // Type parameters.
  @pragma('vm-test:can-be-smi') %s NoBound tp1;
  @pragma('vm-test:can-be-smi') %s NumBound tp2;
  @pragma('vm-test:can-be-smi') %s ComparableBound tp3;
  %s StringBound tp4;
 
  // Comparable<T> instantiations.
  @pragma('vm-test:can-be-smi') %s Comparable c1;
  %s Comparable<String> c2;
  @pragma('vm-test:can-be-smi') %s Comparable<num> c3;
  %s Comparable<int> c4;  // int is not a subtype of Comparable<int>.
  @pragma('vm-test:can-be-smi') %s Comparable<NoBound> c5;
  @pragma('vm-test:can-be-smi') %s Comparable<NumBound> c6;
  @pragma('vm-test:can-be-smi') %s Comparable<ComparableBound> c7;
  %s Comparable<StringBound> c8;
 
  // FutureOr<T> instantiations.
  @pragma('vm-test:can-be-smi') %s FutureOr fo1;
  %s FutureOr<String> fo2;
  @pragma('vm-test:can-be-smi') %s FutureOr<num> fo3;
  @pragma('vm-test:can-be-smi') %s FutureOr<int> fo4;
  @pragma('vm-test:can-be-smi') %s FutureOr<NoBound> fo5;
  @pragma('vm-test:can-be-smi') %s FutureOr<NumBound> fo6;
  @pragma('vm-test:can-be-smi') %s FutureOr<ComparableBound> fo7;
  %s FutureOr<StringBound> fo8;
 
  // Other generic classes.
  %s G<int> g1;
  %s G<NoBound> g2;
}
)",
                  late_tag, late_tag, late_tag, late_tag, late_tag, late_tag,
                  late_tag, late_tag, late_tag, late_tag, late_tag, late_tag,
                  late_tag, late_tag, late_tag, late_tag, late_tag, late_tag,
                  late_tag, late_tag, late_tag, late_tag, late_tag, late_tag,
                  late_tag, late_tag),
      std::free);
 
  const auto& lib = Library::Handle(LoadTestScript(script_chars.get()));
 
  const auto& pragma_can_be_smi =
      String::Handle(Symbols::New(thread, "vm-test:can-be-smi"));
  auto expected_can_be_smi = [&](const Field& f) {
    auto& options = Object::Handle();
    return lib.FindPragma(thread, /*only_core=*/false, f, pragma_can_be_smi,
                          /*multiple=*/false, &options);
  };
 
  const auto& cls = Class::Handle(GetClass(lib, "C"));
  const auto& err = Error::Handle(cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
  const auto& fields = Array::Handle(cls.fields());
 
  auto& field = Field::Handle();
  auto& type = AbstractType::Handle();
  for (intptr_t i = 0; i < fields.Length(); i++) {
    field ^= fields.At(i);
    type = field.type();
 
    auto compile_type = CompileType::FromAbstractType(
        type, CompileType::kCanBeNull, CompileType::kCannotBeSentinel);
    if (compile_type.CanBeSmi() != expected_can_be_smi(field)) {
      dart::Expect(__FILE__, __LINE__)
          .Fail("expected that CanBeSmi() returns %s for compile type %s\n",
                expected_can_be_smi(field) ? "true" : "false",
                compile_type.ToCString());
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [66/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ConcurrentForceGrowthScope

)

Definition at line 826 of file heap_test.cc.

                                                   {
  intptr_t task_count = 8;
  Monitor monitor;
  intptr_t done_count = 0;
 
  for (intptr_t i = 0; i < task_count; i++) {
    Dart::thread_pool()->Run<ConcurrentForceGrowthScopeTask>(
        thread->isolate_group(), &monitor, &done_count);
  }
 
  {
    MonitorLocker ml(&monitor);
    while (done_count < task_count) {
      ml.WaitWithSafepointCheck(thread);
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [67/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ConstantFold_bitLength

)

Definition at line 1132 of file il_test.cc.

                                               {
  // clang-format off
  auto kScript = R"(
      b0() => 0. bitLength;  // 0...00000
      b1() => 1. bitLength;  // 0...00001
      b100() => 100. bitLength;
      b200() => 200. bitLength;
      bffff() => 0xffff. bitLength;
      m1() => (-1).bitLength;  // 1...11111
      m2() => (-2).bitLength;  // 1...11110
 
      main() {
        b0();
        b1();
        b100();
        b200();
        bffff();
        m1();
        m2();
      }
    )";
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
 
  auto test = [&](const char* function, intptr_t expected) {
    TestConstantFoldToSmi(root_library, function, CompilerPass::kJIT, expected);
    TestConstantFoldToSmi(root_library, function, CompilerPass::kAOT, expected);
  };
 
  test("b0", 0);
  test("b1", 1);
  test("b100", 7);
  test("b200", 8);
  test("bffff", 16);
  test("m1", 0);
  test("m2", 1);
}

ISOLATE_UNIT_TEST_CASE() [68/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ConstantPropagation_PhiUnwrappingAndConvergence

)

Definition at line 21 of file constant_propagator_test.cc.

                                                                        {
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  // We are going to build the following graph:
  //
  // B0[graph_entry]
  // B1[function_entry]:
  //   v0 <- Constant(0)
  //   goto B2
  // B2:
  //   v1 <- phi(v0, v1)
  //   v2 <- EqualityCompare(v1 == v0)
  //   if v2 == true then B4 else B3
  // B3:
  //   goto B2
  // B4:
  //   Return(v1)
 
  PhiInstr* v1;
  ConstantInstr* v0 = H.IntConstant(0);
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
  auto b2 = H.JoinEntry();
  auto b3 = H.TargetEntry();
  auto b4 = H.TargetEntry();
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    builder.AddInstruction(new GotoInstr(b2, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b2);
    v1 = H.Phi(b2, {{b1, v0}, {b3, &v1}});
    builder.AddPhi(v1);
    auto v2 = builder.AddDefinition(
        new EqualityCompareInstr(InstructionSource(), Token::kEQ, new Value(v1),
                                 new Value(v0), kSmiCid, S.GetNextDeoptId()));
    builder.AddBranch(new StrictCompareInstr(
                          InstructionSource(), Token::kEQ_STRICT, new Value(v2),
                          new Value(H.flow_graph()->GetConstant(Bool::True())),
                          /*needs_number_check=*/false, S.GetNextDeoptId()),
                      b4, b3);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b3);
    builder.AddInstruction(new GotoInstr(b2, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b4);
    builder.AddReturn(new Value(v1));
  }
 
  H.FinishGraph();
 
  // Graph transformations will attempt to copy deopt information from
  // branches and block entries which we did not assign.
  // To disable copying we mark graph to disable LICM.
  H.flow_graph()->disallow_licm();
 
  FlowGraphPrinter::PrintGraph("Before ConstantPropagator", H.flow_graph());
  ConstantPropagator::Optimize(H.flow_graph());
  FlowGraphPrinter::PrintGraph("After ConstantPropagator", H.flow_graph());
 
  auto& blocks = H.flow_graph()->reverse_postorder();
  EXPECT_EQ(2, blocks.length());
  EXPECT_PROPERTY(blocks[0], it.IsGraphEntry());
  EXPECT_PROPERTY(blocks[1], it.IsFunctionEntry());
  EXPECT_PROPERTY(blocks[1]->next(), it.IsDartReturn());
  EXPECT_PROPERTY(blocks[1]->next()->AsDartReturn(),
                  it.value()->definition() == v0);
}

ISOLATE_UNIT_TEST_CASE() [69/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ConstantPropagator_StrictCompareEqualsSentinelLeft

)

Definition at line 350 of file constant_propagator_test.cc.

                                                                           {
  StrictCompareSentinel(thread, /*negate=*/false,
                        /*non_sentinel_on_left=*/true);
}

ISOLATE_UNIT_TEST_CASE() [70/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ConstantPropagator_StrictCompareEqualsSentinelRightt

)

Definition at line 355 of file constant_propagator_test.cc.

                                                                             {
  StrictCompareSentinel(thread, /*negate=*/false,
                        /*non_sentinel_on_left=*/false);
}

ISOLATE_UNIT_TEST_CASE() [71/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ConstantPropagator_StrictCompareNotEqualsSentinelLeft

)

Definition at line 360 of file constant_propagator_test.cc.

                                                                              {
  StrictCompareSentinel(thread, /*negate=*/true,
                        /*non_sentinel_on_left=*/true);
}

ISOLATE_UNIT_TEST_CASE() [72/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ConstantPropagator_StrictCompareNotEqualsSentinelRight

)

Definition at line 365 of file constant_propagator_test.cc.

                                                                               {
  StrictCompareSentinel(thread, /*negate=*/true,
                        /*non_sentinel_on_left=*/false);
}

ISOLATE_UNIT_TEST_CASE() [73/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Context

)

Definition at line 2417 of file object_test.cc.

                                {
  const int kNumVariables = 5;
  const Context& parent_context = Context::Handle(Context::New(0));
  const Context& context = Context::Handle(Context::New(kNumVariables));
  context.set_parent(parent_context);
  EXPECT_EQ(kNumVariables, context.num_variables());
  EXPECT(Context::Handle(context.parent()).ptr() == parent_context.ptr());
  EXPECT_EQ(0, Context::Handle(context.parent()).num_variables());
  EXPECT(Context::Handle(Context::Handle(context.parent()).parent()).IsNull());
  Object& variable = Object::Handle(context.At(0));
  EXPECT(variable.IsNull());
  variable = context.At(kNumVariables - 1);
  EXPECT(variable.IsNull());
  context.SetAt(0, Smi::Handle(Smi::New(2)));
  context.SetAt(2, Smi::Handle(Smi::New(3)));
  Smi& smi = Smi::Handle();
  smi ^= context.At(0);
  EXPECT_EQ(2, smi.Value());
  smi ^= context.At(2);
  EXPECT_EQ(3, smi.Value());
}

ISOLATE_UNIT_TEST_CASE() [74/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ContextScope

)

Definition at line 2439 of file object_test.cc.

                                     {
  // We need an active compiler context to manipulate scopes, since local
  // variables and slots can be canonicalized in the compiler state.
  CompilerState compiler_state(Thread::Current(), /*is_aot=*/false,
                               /*is_optimizing=*/false);
 
  const intptr_t parent_scope_function_level = 0;
  LocalScope* parent_scope =
      new LocalScope(nullptr, parent_scope_function_level, 0);
 
  const intptr_t local_scope_function_level = 1;
  LocalScope* local_scope =
      new LocalScope(parent_scope, local_scope_function_level, 0);
 
  const Type& dynamic_type = Type::ZoneHandle(Type::DynamicType());
  const String& ta = Symbols::FunctionTypeArgumentsVar();
  LocalVariable* var_ta = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, ta, dynamic_type);
  parent_scope->AddVariable(var_ta);
 
  const String& a = String::ZoneHandle(Symbols::New(thread, "a"));
  LocalVariable* var_a = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, a, dynamic_type);
  parent_scope->AddVariable(var_a);
 
  const String& b = String::ZoneHandle(Symbols::New(thread, "b"));
  LocalVariable* var_b = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, b, dynamic_type);
  local_scope->AddVariable(var_b);
 
  const String& c = String::ZoneHandle(Symbols::New(thread, "c"));
  LocalVariable* var_c = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, c, dynamic_type);
  parent_scope->AddVariable(var_c);
 
  bool test_only = false;  // Please, insert alias.
  var_ta = local_scope->LookupVariable(ta, LocalVariable::kNoKernelOffset,
                                       test_only);
  EXPECT(var_ta->is_captured());
  EXPECT_EQ(parent_scope_function_level, var_ta->owner()->function_level());
  EXPECT(local_scope->LocalLookupVariable(ta, LocalVariable::kNoKernelOffset) ==
         var_ta);  // Alias.
 
  var_a =
      local_scope->LookupVariable(a, LocalVariable::kNoKernelOffset, test_only);
  EXPECT(var_a->is_captured());
  EXPECT_EQ(parent_scope_function_level, var_a->owner()->function_level());
  EXPECT(local_scope->LocalLookupVariable(a, LocalVariable::kNoKernelOffset) ==
         var_a);  // Alias.
 
  var_b =
      local_scope->LookupVariable(b, LocalVariable::kNoKernelOffset, test_only);
  EXPECT(!var_b->is_captured());
  EXPECT_EQ(local_scope_function_level, var_b->owner()->function_level());
  EXPECT(local_scope->LocalLookupVariable(b, LocalVariable::kNoKernelOffset) ==
         var_b);
 
  test_only = true;  // Please, do not insert alias.
  var_c =
      local_scope->LookupVariable(c, LocalVariable::kNoKernelOffset, test_only);
  EXPECT(!var_c->is_captured());
  EXPECT_EQ(parent_scope_function_level, var_c->owner()->function_level());
  // c is not in local_scope.
  EXPECT(local_scope->LocalLookupVariable(c, LocalVariable::kNoKernelOffset) ==
         nullptr);
 
  test_only = false;  // Please, insert alias.
  var_c =
      local_scope->LookupVariable(c, LocalVariable::kNoKernelOffset, test_only);
  EXPECT(var_c->is_captured());
 
  EXPECT_EQ(4, local_scope->num_variables());         // ta, a, b, c.
  EXPECT_EQ(3, local_scope->NumCapturedVariables());  // ta, a, c.
 
  const VariableIndex first_parameter_index(0);
  const int num_parameters = 0;
  const VariableIndex first_local_index(-1);
  bool found_captured_vars = false;
  VariableIndex next_index = parent_scope->AllocateVariables(
      Function::null_function(), first_parameter_index, num_parameters,
      first_local_index, nullptr, &found_captured_vars);
  // Variables a, c and var_ta are captured, therefore are not allocated in
  // frame.
  EXPECT_EQ(0, next_index.value() -
                   first_local_index.value());  // Indices in frame < 0.
  const intptr_t parent_scope_context_level = 1;
  EXPECT_EQ(parent_scope_context_level, parent_scope->context_level());
  EXPECT(found_captured_vars);
 
  const intptr_t local_scope_context_level = 5;
  const ContextScope& context_scope =
      ContextScope::Handle(local_scope->PreserveOuterScope(
          Function::null_function(), local_scope_context_level));
  LocalScope* outer_scope = LocalScope::RestoreOuterScope(context_scope);
  EXPECT_EQ(3, outer_scope->num_variables());
 
  var_ta = outer_scope->LocalLookupVariable(ta, LocalVariable::kNoKernelOffset);
  EXPECT(var_ta->is_captured());
  EXPECT_EQ(0, var_ta->index().value());  // First index.
  EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
            var_ta->owner()->context_level());  // Adjusted context level.
 
  var_a = outer_scope->LocalLookupVariable(a, LocalVariable::kNoKernelOffset);
  EXPECT(var_a->is_captured());
  EXPECT_EQ(1, var_a->index().value());  // First index.
  EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
            var_a->owner()->context_level());  // Adjusted context level.
 
  // var b was not captured.
  EXPECT(outer_scope->LocalLookupVariable(b, LocalVariable::kNoKernelOffset) ==
         nullptr);
 
  var_c = outer_scope->LocalLookupVariable(c, LocalVariable::kNoKernelOffset);
  EXPECT(var_c->is_captured());
  EXPECT_EQ(2, var_c->index().value());
  EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
            var_c->owner()->context_level());  // Adjusted context level.
}

ISOLATE_UNIT_TEST_CASE() [75/463]

dart::ISOLATE_UNIT_TEST_CASE

(

CSE_Redefinitions

)

Definition at line 1634 of file redundancy_elimination_test.cc.

                                          {
  const char* script_chars = R"(
    @pragma("vm:external-name", "BlackholeNative")
    external dynamic blackhole([a, b, c, d, e, f]);
    class K<T> {
      final T field;
      K(this.field);
    }
  )";
  const Library& lib =
      Library::Handle(LoadTestScript(script_chars, NoopNativeLookup));
 
  const Class& cls = Class::ZoneHandle(
      lib.LookupClass(String::Handle(Symbols::New(thread, "K"))));
  const Error& err = Error::Handle(cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
 
  const Field& original_field = Field::Handle(
      cls.LookupField(String::Handle(Symbols::New(thread, "field"))));
  EXPECT(!original_field.IsNull());
  const Field& field = Field::Handle(original_field.CloneFromOriginal());
 
  const Function& blackhole =
      Function::ZoneHandle(GetFunction(lib, "blackhole"));
 
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H(/*num_parameters=*/2);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::DynamicType()));
  H.AddVariable("v1", AbstractType::ZoneHandle(Type::DynamicType()));
 
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
 
  BoxInstr* box0;
  BoxInstr* box1;
  LoadFieldInstr* load0;
  LoadFieldInstr* load1;
  LoadFieldInstr* load2;
  StaticCallInstr* call;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    auto& slot = Slot::Get(field, &H.flow_graph()->parsed_function());
    auto param0 = builder.AddParameter(0, kUnboxedDouble);
    auto param1 = builder.AddParameter(1, kTagged);
    auto redef0 =
        builder.AddDefinition(new RedefinitionInstr(new Value(param0)));
    auto redef1 =
        builder.AddDefinition(new RedefinitionInstr(new Value(param0)));
    box0 = builder.AddDefinition(
        BoxInstr::Create(kUnboxedDouble, new Value(redef0)));
    box1 = builder.AddDefinition(
        BoxInstr::Create(kUnboxedDouble, new Value(redef1)));
 
    auto redef2 =
        builder.AddDefinition(new RedefinitionInstr(new Value(param1)));
    auto redef3 =
        builder.AddDefinition(new RedefinitionInstr(new Value(param1)));
    load0 = builder.AddDefinition(
        new LoadFieldInstr(new Value(redef2), slot, InstructionSource()));
    load1 = builder.AddDefinition(
        new LoadFieldInstr(new Value(redef3), slot, InstructionSource()));
    load2 = builder.AddDefinition(
        new LoadFieldInstr(new Value(redef3), slot, InstructionSource()));
 
    InputsArray args(3);
    args.Add(new Value(load0));
    args.Add(new Value(load1));
    args.Add(new Value(load2));
    call = builder.AddInstruction(new StaticCallInstr(
        InstructionSource(), blackhole, 0, Array::empty_array(),
        std::move(args), S.GetNextDeoptId(), 0, ICData::RebindRule::kStatic));
 
    ret = builder.AddReturn(new Value(box1));
  }
  H.FinishGraph();
 
  // Running CSE without load optimization should eliminate redundant boxing
  // but keep loads intact if they don't  have exactly matching inputs.
  DominatorBasedCSE::Optimize(H.flow_graph(), /*run_load_optimization=*/false);
 
  EXPECT_PROPERTY(box1, it.WasEliminated());
  EXPECT_PROPERTY(ret, it.value()->definition() == box0);
 
  EXPECT_PROPERTY(load0, !it.WasEliminated());
  EXPECT_PROPERTY(load1, !it.WasEliminated());
  EXPECT_PROPERTY(load2, it.WasEliminated());
 
  EXPECT_PROPERTY(call, it.ArgumentAt(0) == load0);
  EXPECT_PROPERTY(call, it.ArgumentAt(1) == load1);
  EXPECT_PROPERTY(call, it.ArgumentAt(2) == load1);
 
  // Running load optimization pass should remove the second load but
  // insert a redefinition to prevent code motion because the field
  // has a generic type.
  DominatorBasedCSE::Optimize(H.flow_graph(), /*run_load_optimization=*/true);
 
  EXPECT_PROPERTY(load0, !it.WasEliminated());
  EXPECT_PROPERTY(load1, it.WasEliminated());
  EXPECT_PROPERTY(load2, it.WasEliminated());
 
  EXPECT_PROPERTY(call, it.ArgumentAt(0) == load0);
  EXPECT_PROPERTY(call, it.ArgumentAt(1)->IsRedefinition() &&
                            it.ArgumentAt(1)->OriginalDefinition() == load0);
  EXPECT_PROPERTY(call, it.ArgumentAt(2)->IsRedefinition() &&
                            it.ArgumentAt(2)->OriginalDefinition() == load0);
}

ISOLATE_UNIT_TEST_CASE() [76/463]

dart::ISOLATE_UNIT_TEST_CASE

(

DelayAllocations_DelayAcrossCalls

)

Definition at line 1475 of file redundancy_elimination_test.cc.

                                                          {
  const char* kScript = R"(
    class A {
      dynamic x, y;
      A(this.x, this.y);
    }
 
    int count = 0;
 
    @pragma("vm:never-inline")
    dynamic foo(int i) => count++ < 2 ? i : '$i';
 
    @pragma("vm:never-inline")
    dynamic use(v) {}
 
    void test() {
      A a = new A(foo(1), foo(2));
      use(a);
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  // Get fields to kDynamicCid guard
  Invoke(root_library, "test");
  Invoke(root_library, "test");
 
  TestPipeline pipeline(function, CompilerPass::kAOT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  auto entry = flow_graph->graph_entry()->normal_entry();
 
  StaticCallInstr* call1;
  StaticCallInstr* call2;
  AllocateObjectInstr* allocate;
  StoreFieldInstr* store1;
  StoreFieldInstr* store2;
 
  ILMatcher cursor(flow_graph, entry, true, ParallelMovesHandling::kSkip);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveStaticCall, &call1},
      kMoveGlob,
      {kMatchAndMoveStaticCall, &call2},
      kMoveGlob,
      {kMatchAndMoveAllocateObject, &allocate},
      {kMatchAndMoveStoreField, &store1},
      {kMatchAndMoveStoreField, &store2},
  }));
 
  EXPECT(strcmp(call1->function().UserVisibleNameCString(), "foo") == 0);
  EXPECT(strcmp(call2->function().UserVisibleNameCString(), "foo") == 0);
  EXPECT(store1->instance()->definition() == allocate);
  EXPECT(!store1->ShouldEmitStoreBarrier());
  EXPECT(store2->instance()->definition() == allocate);
  EXPECT(!store2->ShouldEmitStoreBarrier());
}

ISOLATE_UNIT_TEST_CASE() [77/463]

dart::ISOLATE_UNIT_TEST_CASE

(

DelayAllocations_DontDelayIntoLoop

)

Definition at line 1533 of file redundancy_elimination_test.cc.

                                                           {
  const char* kScript = R"(
    void test() {
      Object o = new Object();
      for (int i = 0; i < 10; i++) {
        use(o);
      }
    }
 
    @pragma('vm:never-inline')
    void use(Object o) {
      print(o.hashCode);
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  TestPipeline pipeline(function, CompilerPass::kAOT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  auto entry = flow_graph->graph_entry()->normal_entry();
 
  AllocateObjectInstr* allocate;
  StaticCallInstr* call;
 
  ILMatcher cursor(flow_graph, entry, true, ParallelMovesHandling::kSkip);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveAllocateObject, &allocate},
      kMoveGlob,
      kMatchAndMoveBranchTrue,
      kMoveGlob,
      {kMatchAndMoveStaticCall, &call},
  }));
 
  EXPECT(strcmp(call->function().UserVisibleNameCString(), "use") == 0);
  EXPECT(call->Receiver()->definition() == allocate);
}

ISOLATE_UNIT_TEST_CASE() [78/463]

dart::ISOLATE_UNIT_TEST_CASE

(

DerivedInduction

)

Definition at line 191 of file loops_test.cc.

ISOLATE_UNIT_TEST_CASE() [79/463]

dart::ISOLATE_UNIT_TEST_CASE

(

DescriptorList_TokenPositions

)

Definition at line 124 of file code_descriptors_test.cc.

                                                      {
  DescriptorList* descriptors = new DescriptorList(thread->zone());
  ASSERT(descriptors != nullptr);
  const int32_t token_positions[] = {
      kMinInt32,
      5,
      13,
      13,
      13,
      13,
      31,
      23,
      23,
      23,
      33,
      33,
      5,
      5,
      TokenPosition::kMinSourcePos,
      TokenPosition::kMaxSourcePos,
  };
  const intptr_t num_token_positions = ARRAY_SIZE(token_positions);
 
  for (intptr_t i = 0; i < num_token_positions; i++) {
    const TokenPosition& tp = TokenPosition::Deserialize(token_positions[i]);
    descriptors->AddDescriptor(UntaggedPcDescriptors::kRuntimeCall, 0, 0, tp, 0,
                               1);
  }
 
  const PcDescriptors& finalized_descriptors =
      PcDescriptors::Handle(descriptors->FinalizePcDescriptors(0));
 
  ASSERT(!finalized_descriptors.IsNull());
  PcDescriptors::Iterator it(finalized_descriptors,
                             UntaggedPcDescriptors::kRuntimeCall);
 
  intptr_t i = 0;
  while (it.MoveNext()) {
    const TokenPosition& tp = TokenPosition::Deserialize(token_positions[i]);
    if (tp != it.TokenPos()) {
      OS::PrintErr("[%" Pd "]: Expected: %s != %s\n", i, tp.ToCString(),
                   it.TokenPos().ToCString());
    }
    EXPECT(tp == it.TokenPos());
    i++;
  }
}

ISOLATE_UNIT_TEST_CASE() [80/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Disassembler

)

Definition at line 14 of file disassembler_test.cc.

                                     {
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler assembler(&object_pool_builder);
 
  // The used instructions work on all platforms.
  Register reg = static_cast<Register>(0);
  assembler.PopRegister(reg);
  assembler.Stop("testing disassembler");
 
  // Only verify that the disassembler does not crash.
  AssemblerTest test("Disassembler", &assembler, Thread::Current()->zone());
  test.Assemble();
  Disassembler::Disassemble(test.entry(), test.entry() + assembler.CodeSize());
}

ISOLATE_UNIT_TEST_CASE() [81/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Disassembler_InvalidInput

)

Definition at line 29 of file disassembler_test.cc.

                                                  {
  // Test that Disassembler doesn't crash even if the input is nonsense.
  uint32_t bad_input[] = {
      0x00000000, 0xFFFFFFFF, 0x12345678, 0x9ABCDEF0, 0x01110001,
      0xDEADC0DE, 0xBAADF00D, 0xDABADEEE, 0xDABAD111, 0xB000DEAD,
      0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
  };
  Disassembler::Disassemble(
      reinterpret_cast<uword>(&bad_input[0]),
      reinterpret_cast<uword>(ARRAY_SIZE(bad_input) + &bad_input[0]));
}

ISOLATE_UNIT_TEST_CASE() [82/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Double

)

Definition at line 577 of file object_test.cc.

                               {
  {
    const double dbl_const = 5.0;
    const Double& dbl = Double::Handle(Double::New(dbl_const));
    Object& dbl_object = Object::Handle(dbl.ptr());
    EXPECT(dbl.IsDouble());
    EXPECT(dbl_object.IsDouble());
    EXPECT_EQ(dbl_const, dbl.value());
  }
 
  {
    const double dbl_const = -5.0;
    const Double& dbl = Double::Handle(Double::New(dbl_const));
    Object& dbl_object = Object::Handle(dbl.ptr());
    EXPECT(dbl.IsDouble());
    EXPECT(dbl_object.IsDouble());
    EXPECT_EQ(dbl_const, dbl.value());
  }
 
  {
    const double dbl_const = 0.0;
    const Double& dbl = Double::Handle(Double::New(dbl_const));
    Object& dbl_object = Object::Handle(dbl.ptr());
    EXPECT(dbl.IsDouble());
    EXPECT(dbl_object.IsDouble());
    EXPECT_EQ(dbl_const, dbl.value());
  }
 
  {
    const double dbl_const = 5.0;
    const String& dbl_str = String::Handle(String::New("5.0"));
    const Double& dbl1 = Double::Handle(Double::NewCanonical(dbl_const));
    const Double& dbl2 = Double::Handle(Double::NewCanonical(dbl_const));
    const Double& dbl3 = Double::Handle(Double::NewCanonical(dbl_str));
    EXPECT_EQ(dbl_const, dbl1.value());
    EXPECT_EQ(dbl_const, dbl2.value());
    EXPECT_EQ(dbl_const, dbl3.value());
    EXPECT_EQ(dbl1.ptr(), dbl2.ptr());
    EXPECT_EQ(dbl1.ptr(), dbl3.ptr());
  }
 
  {
    const double dbl_const = 2.0;
    const Double& dbl1 = Double::Handle(Double::New(dbl_const));
    const Double& dbl2 = Double::Handle(Double::New(dbl_const));
    EXPECT(dbl1.OperatorEquals(dbl2));
    EXPECT(dbl1.IsIdenticalTo(dbl2));
    EXPECT(dbl1.CanonicalizeEquals(dbl2));
    const Double& dbl3 = Double::Handle(Double::New(3.3));
    EXPECT(!dbl1.OperatorEquals(dbl3));
    EXPECT(!dbl1.OperatorEquals(Smi::Handle(Smi::New(3))));
    EXPECT(!dbl1.OperatorEquals(Double::Handle()));
    const Double& nan0 = Double::Handle(Double::New(NAN));
    EXPECT(isnan(nan0.value()));
    EXPECT(nan0.IsIdenticalTo(nan0));
    EXPECT(nan0.CanonicalizeEquals(nan0));
    EXPECT(!nan0.OperatorEquals(nan0));
    const Double& nan1 =
        Double::Handle(Double::New(bit_cast<double>(kMaxUint64 - 0)));
    const Double& nan2 =
        Double::Handle(Double::New(bit_cast<double>(kMaxUint64 - 1)));
    EXPECT(isnan(nan1.value()));
    EXPECT(isnan(nan2.value()));
    EXPECT(!nan1.IsIdenticalTo(nan2));
    EXPECT(!nan1.CanonicalizeEquals(nan2));
    EXPECT(!nan1.OperatorEquals(nan2));
  }
  {
    const String& dbl_str0 = String::Handle(String::New("bla"));
    const Double& dbl0 = Double::Handle(Double::New(dbl_str0));
    EXPECT(dbl0.IsNull());
 
    const String& dbl_str1 = String::Handle(String::New("2.0"));
    const Double& dbl1 = Double::Handle(Double::New(dbl_str1));
    EXPECT_EQ(2.0, dbl1.value());
 
    // Disallow legacy form.
    const String& dbl_str2 = String::Handle(String::New("2.0d"));
    const Double& dbl2 = Double::Handle(Double::New(dbl_str2));
    EXPECT(dbl2.IsNull());
  }
}

ISOLATE_UNIT_TEST_CASE() [83/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EmbedSmiInCode

)

Definition at line 2740 of file object_test.cc.

                                       {
  extern void GenerateEmbedSmiInCode(compiler::Assembler * assembler,
                                     intptr_t value);
  const intptr_t kSmiTestValue = 5;
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
  const Function& function =
      Function::Handle(CreateFunction("Test_EmbedSmiInCode"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  function.AttachCode(code);
  const Object& result =
      Object::Handle(DartEntry::InvokeFunction(function, Array::empty_array()));
  EXPECT(Smi::Cast(result).Value() == kSmiTestValue);
}

ISOLATE_UNIT_TEST_CASE() [84/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EmbedStringInCode

)

Definition at line 2713 of file object_test.cc.

                                          {
  extern void GenerateEmbedStringInCode(compiler::Assembler * assembler,
                                        const char* str);
  const char* kHello = "Hello World!";
  word expected_length = static_cast<word>(strlen(kHello));
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateEmbedStringInCode(&_assembler_, kHello);
  const Function& function =
      Function::Handle(CreateFunction("Test_EmbedStringInCode"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  function.AttachCode(code);
  const Object& result =
      Object::Handle(DartEntry::InvokeFunction(function, Array::empty_array()));
  EXPECT(result.ptr()->IsHeapObject());
  String& string_object = String::Handle();
  string_object ^= result.ptr();
  EXPECT(string_object.Length() == expected_length);
  for (int i = 0; i < expected_length; i++) {
    EXPECT(string_object.CharAt(i) == kHello[i]);
  }
}

ISOLATE_UNIT_TEST_CASE() [85/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EmptyDartStackFrameIteration

)

Definition at line 30 of file stack_frame_test.cc.

                                                     {
  DartFrameIterator iterator(Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
  EXPECT(iterator.NextFrame() == nullptr);
  VerifyPointersVisitor::VerifyPointers("EmptyDartStackFrameIterationTest");
}

ISOLATE_UNIT_TEST_CASE() [86/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EmptyInstantiationsCacheArray

)

Definition at line 1847 of file object_test.cc.

                                                      {
  SafepointMutexLocker ml(
      thread->isolate_group()->type_arguments_canonicalization_mutex());
  const Array& empty_cache = Object::empty_instantiations_cache_array();
  DEBUG_ONLY(EXPECT(TypeArguments::Cache::IsValidStorageLocked(empty_cache));)
  const TypeArguments::Cache cache(thread->zone(), empty_cache);
  EXPECT(cache.IsLinear());
  EXPECT(!cache.IsHash());
  EXPECT_EQ(0, cache.NumOccupied());
  const InstantiationsCacheTable table(empty_cache);
  EXPECT_EQ(1, table.Length());
  for (const auto& tuple : table) {
    EXPECT(tuple.Get<TypeArguments::Cache::kSentinelIndex>() ==
           TypeArguments::Cache::Sentinel());
  }
}

ISOLATE_UNIT_TEST_CASE() [87/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EmptyStackFrameIteration

)

Definition at line 20 of file stack_frame_test.cc.

                                                 {
  StackFrameIterator iterator(ValidationPolicy::kValidateFrames,
                              Thread::Current(),
                              StackFrameIterator::kNoCrossThreadIteration);
  EXPECT(!iterator.HasNextFrame());
  EXPECT(iterator.NextFrame() == nullptr);
  VerifyPointersVisitor::VerifyPointers("EmptyStackFrameIterationTest");
}

ISOLATE_UNIT_TEST_CASE() [88/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EqualsIgnoringPrivate

)

Definition at line 3219 of file object_test.cc.

                                              {
  String& mangled_name = String::Handle();
  String& bare_name = String::Handle();
 
  // Simple matches.
  mangled_name = OneByteString::New("foo");
  bare_name = OneByteString::New("foo");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  mangled_name = OneByteString::New("foo.");
  bare_name = OneByteString::New("foo.");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  mangled_name = OneByteString::New("foo.named");
  bare_name = OneByteString::New("foo.named");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Simple mismatches.
  mangled_name = OneByteString::New("bar");
  bare_name = OneByteString::New("foo");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  mangled_name = OneByteString::New("foo.");
  bare_name = OneByteString::New("foo");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  mangled_name = OneByteString::New("foo");
  bare_name = OneByteString::New("foo.");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  mangled_name = OneByteString::New("foo.name");
  bare_name = OneByteString::New("foo.named");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  mangled_name = OneByteString::New("foo.named");
  bare_name = OneByteString::New("foo.name");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Private match.
  mangled_name = OneByteString::New("foo@12345");
  bare_name = OneByteString::New("foo");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Private mismatch.
  mangled_name = OneByteString::New("food@12345");
  bare_name = OneByteString::New("foo");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Private mismatch 2.
  mangled_name = OneByteString::New("foo@12345");
  bare_name = OneByteString::New("food");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Private mixin application match.
  mangled_name = OneByteString::New("_M1@12345&_M2@12345&_M3@12345");
  bare_name = OneByteString::New("_M1&_M2&_M3");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Private mixin application mismatch.
  mangled_name = OneByteString::New("_M1@12345&_M2@12345&_M3@12345");
  bare_name = OneByteString::New("_M1&_M2&_M4");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Private constructor match.
  mangled_name = OneByteString::New("foo@12345.");
  bare_name = OneByteString::New("foo.");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Private constructor mismatch.
  mangled_name = OneByteString::New("foo@12345.");
  bare_name = OneByteString::New("foo");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Private constructor mismatch 2.
  mangled_name = OneByteString::New("foo@12345");
  bare_name = OneByteString::New("foo.");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Named private constructor match.
  mangled_name = OneByteString::New("foo@12345.named");
  bare_name = OneByteString::New("foo.named");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Named private constructor mismatch.
  mangled_name = OneByteString::New("foo@12345.name");
  bare_name = OneByteString::New("foo.named");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Named private constructor mismatch 2.
  mangled_name = OneByteString::New("foo@12345.named");
  bare_name = OneByteString::New("foo.name");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Named double-private constructor match.  Yes, this happens.
  mangled_name = OneByteString::New("foo@12345.named@12345");
  bare_name = OneByteString::New("foo.named");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Named double-private constructor match where the caller knows the private
  // key.  Yes, this also happens.
  mangled_name = OneByteString::New("foo@12345.named@12345");
  bare_name = OneByteString::New("foo@12345.named");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Named double-private constructor mismatch.
  mangled_name = OneByteString::New("foo@12345.name@12345");
  bare_name = OneByteString::New("foo.named");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
  // Named double-private constructor mismatch.
  mangled_name = OneByteString::New("foo@12345.named@12345");
  bare_name = OneByteString::New("foo.name");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
}

ISOLATE_UNIT_TEST_CASE() [89/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EscapeSpecialCharactersOneByteString

)

Definition at line 1645 of file object_test.cc.

                                                             {
  uint8_t characters[] = {'a',  '\n', '\f', '\b', '\t',
                          '\v', '\r', '\\', '$',  'z'};
  intptr_t len = ARRAY_SIZE(characters);
 
  const String& str =
      String::Handle(OneByteString::New(characters, len, Heap::kNew));
  EXPECT(str.IsOneByteString());
  EXPECT_EQ(str.Length(), len);
  EXPECT(str.Equals("a\n\f\b\t\v\r\\$z"));
  const String& escaped_str =
      String::Handle(String::EscapeSpecialCharacters(str));
  EXPECT(escaped_str.Equals("a\\n\\f\\b\\t\\v\\r\\\\\\$z"));
 
  const String& escaped_empty_str =
      String::Handle(String::EscapeSpecialCharacters(Symbols::Empty()));
  EXPECT_EQ(escaped_empty_str.Length(), 0);
}

ISOLATE_UNIT_TEST_CASE() [90/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EscapeSpecialCharactersTwoByteString

)

Definition at line 1664 of file object_test.cc.

                                                             {
  uint16_t characters[] = {'a',  '\n', '\f', '\b', '\t',
                           '\v', '\r', '\\', '$',  'z'};
  intptr_t len = ARRAY_SIZE(characters);
 
  const String& str =
      String::Handle(TwoByteString::New(characters, len, Heap::kNew));
  EXPECT(str.IsTwoByteString());
  EXPECT_EQ(str.Length(), len);
  EXPECT(str.Equals("a\n\f\b\t\v\r\\$z"));
  const String& escaped_str =
      String::Handle(String::EscapeSpecialCharacters(str));
  EXPECT(escaped_str.Equals("a\\n\\f\\b\\t\\v\\r\\\\\\$z"));
 
  const String& empty_str =
      String::Handle(TwoByteString::New(static_cast<intptr_t>(0), Heap::kNew));
  const String& escaped_empty_str =
      String::Handle(String::EscapeSpecialCharacters(empty_str));
  EXPECT_EQ(empty_str.Length(), 0);
  EXPECT_EQ(escaped_empty_str.Length(), 0);
}

ISOLATE_UNIT_TEST_CASE() [91/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EvalExpressionExhaustCIDs

)

Definition at line 254 of file compiler_test.cc.

                                                  {
  {  // Initialize an incremental compiler in DFE mode.
    TransitionVMToNative transition(thread);
    TestCase::LoadTestScript("", nullptr);
  }
  Library& lib = Library::Handle(Library::CoreLibrary());
  const String& expression = String::Handle(String::New("3 + 4"));
  Object& val = Object::Handle();
  val = Api::UnwrapHandle(
      TestCase::EvaluateExpression(lib, expression,
                                   /* param_names= */ Array::empty_array(),
                                   /* param_values= */ Array::empty_array()));
 
  EXPECT(!val.IsNull());
  EXPECT(!val.IsError());
  EXPECT(val.IsInteger());
  EXPECT_EQ(7, Integer::Cast(val).AsInt64Value());
 
  auto class_table = IsolateGroup::Current()->class_table();
 
  intptr_t initial_class_table_size = class_table->NumCids();
 
  val = Api::UnwrapHandle(
      TestCase::EvaluateExpression(lib, expression,
                                   /* param_names= */ Array::empty_array(),
                                   /* param_values= */ Array::empty_array()));
  EXPECT(!val.IsNull());
  EXPECT(!val.IsError());
  EXPECT(val.IsInteger());
  EXPECT_EQ(7, Integer::Cast(val).AsInt64Value());
 
  intptr_t final_class_table_size = class_table->NumCids();
  // Eval should not eat into this non-renewable resource.
  EXPECT_EQ(initial_class_table_size, final_class_table_size);
}

ISOLATE_UNIT_TEST_CASE() [92/463]

dart::ISOLATE_UNIT_TEST_CASE

(

EvalExpressionWithLazyCompile

)

Definition at line 234 of file compiler_test.cc.

                                                      {
  {  // Initialize an incremental compiler in DFE mode.
    TransitionVMToNative transition(thread);
    TestCase::LoadTestScript("", nullptr);
  }
  Library& lib = Library::Handle(Library::CoreLibrary());
  const String& expression = String::Handle(
      String::New("(){ return (){ return (){ return 3 + 4; }(); }(); }()"));
  Object& val = Object::Handle();
  val = Api::UnwrapHandle(
      TestCase::EvaluateExpression(lib, expression,
                                   /* param_names= */ Array::empty_array(),
                                   /* param_values= */ Array::empty_array()));
 
  EXPECT(!val.IsNull());
  EXPECT(!val.IsError());
  EXPECT(val.IsInteger());
  EXPECT_EQ(7, Integer::Cast(val).AsInt64Value());
}

ISOLATE_UNIT_TEST_CASE() [93/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ExceptionHandlers

)

Definition at line 2781 of file object_test.cc.

                                          {
  const int kNumEntries = 4;
  // Add an exception handler table to the code.
  ExceptionHandlers& exception_handlers = ExceptionHandlers::Handle();
  exception_handlers ^= ExceptionHandlers::New(kNumEntries);
  const bool kNeedsStackTrace = true;
  const bool kNoStackTrace = false;
  exception_handlers.SetHandlerInfo(0, -1, 20u, kNeedsStackTrace, false, true);
  exception_handlers.SetHandlerInfo(1, 0, 30u, kNeedsStackTrace, false, true);
  exception_handlers.SetHandlerInfo(2, -1, 40u, kNoStackTrace, true, true);
  exception_handlers.SetHandlerInfo(3, 1, 150u, kNoStackTrace, true, true);
 
  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
      Code::PoolAttachment::kAttachPool));
  code.set_exception_handlers(exception_handlers);
 
  // Verify the exception handler table entries by accessing them.
  const ExceptionHandlers& handlers =
      ExceptionHandlers::Handle(code.exception_handlers());
  EXPECT_EQ(kNumEntries, handlers.num_entries());
  ExceptionHandlerInfo info;
  handlers.GetHandlerInfo(0, &info);
  EXPECT_EQ(-1, handlers.OuterTryIndex(0));
  EXPECT_EQ(-1, info.outer_try_index);
  EXPECT_EQ(20u, handlers.HandlerPCOffset(0));
  EXPECT(handlers.NeedsStackTrace(0));
  EXPECT(!handlers.HasCatchAll(0));
  EXPECT_EQ(20u, info.handler_pc_offset);
  EXPECT_EQ(1, handlers.OuterTryIndex(3));
  EXPECT_EQ(150u, handlers.HandlerPCOffset(3));
  EXPECT(!handlers.NeedsStackTrace(3));
  EXPECT(handlers.HasCatchAll(3));
}

ISOLATE_UNIT_TEST_CASE() [94/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ExerciseTLABs

)

Definition at line 942 of file thread_test.cc.

                                      {
  const int NUMBER_TEST_THREADS = 10;
  Monitor done_monitor[NUMBER_TEST_THREADS];
  bool done[NUMBER_TEST_THREADS];
  auto isolate_group = thread->isolate_group();
  for (int i = 0; i < NUMBER_TEST_THREADS; i++) {
    done[i] = false;
    Dart::thread_pool()->Run<AllocateGlobsOfMemoryTask>(
        isolate_group, &done_monitor[i], &done[i]);
  }
 
  for (int i = 0; i < NUMBER_TEST_THREADS; i++) {
    MonitorLocker ml(&done_monitor[i]);
    while (!done[i]) {
      ml.WaitWithSafepointCheck(thread);
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [95/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ExternalAllocationStats

)

Definition at line 607 of file heap_test.cc.

                                                {
  auto isolate_group = thread->isolate_group();
  Heap* heap = isolate_group->heap();
 
  Array& old = Array::Handle(Array::New(100, Heap::kOld));
  Array& neu = Array::Handle();
  for (intptr_t i = 0; i < 100; i++) {
    neu = Array::New(1, Heap::kNew);
    FinalizablePersistentHandle::New(isolate_group, neu, nullptr, NoopFinalizer,
                                     1 * MB,
                                     /*auto_delete=*/true);
    old.SetAt(i, neu);
 
    if ((i % 4) == 0) {
      HeapTestHelper::MarkSweep(thread);
    } else {
      HeapTestHelper::Scavenge(thread);
    }
 
    CountObjectsVisitor visitor(thread,
                                isolate_group->class_table()->NumCids());
    HeapIterationScope iter(thread);
    iter.IterateObjects(&visitor);
    isolate_group->VisitWeakPersistentHandles(&visitor);
    EXPECT_LE(visitor.old_external_size_[kArrayCid],
              heap->old_space()->ExternalInWords() * kWordSize);
    EXPECT_LE(visitor.new_external_size_[kArrayCid],
              heap->new_space()->ExternalInWords() * kWordSize);
  }
}

ISOLATE_UNIT_TEST_CASE() [96/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ExternalPromotion

)

Definition at line 438 of file heap_test.cc.

                                          {
  auto isolate_group = IsolateGroup::Current();
  Heap* heap = isolate_group->heap();
 
  heap->CollectAllGarbage();
  intptr_t size_before = kWordSize * (heap->new_space()->ExternalInWords() +
                                      heap->old_space()->ExternalInWords());
 
  Array& old = Array::Handle(Array::New(100, Heap::kOld));
  Array& neu = Array::Handle();
  for (intptr_t i = 0; i < 100; i++) {
    neu = Array::New(1, Heap::kNew);
    FinalizablePersistentHandle::New(isolate_group, neu, nullptr, NoopFinalizer,
                                     1 * MB,
                                     /*auto_delete=*/true);
    old.SetAt(i, neu);
  }
 
  intptr_t size_middle = kWordSize * (heap->new_space()->ExternalInWords() +
                                      heap->old_space()->ExternalInWords());
  EXPECT_EQ(size_before + 100 * MB, size_middle);
 
  old = Array::null();
  neu = Array::null();
 
  heap->CollectAllGarbage();
 
  intptr_t size_after = kWordSize * (heap->new_space()->ExternalInWords() +
                                     heap->old_space()->ExternalInWords());
 
  EXPECT_EQ(size_before, size_after);
}

ISOLATE_UNIT_TEST_CASE() [97/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ExternalSizeLimit

)

Definition at line 638 of file heap_test.cc.

                                          {
  // This test checks that the tracked total size of external data never exceeds
  // the amount of memory on the system. To accomplish this, the test performs
  // five calls to FinalizablePersistentHandle::New(), all supplying a size
  // argument that is barely (16 bytes) less than a quarter of kMaxAddrSpaceMB.
  // So, we expect the first four calls to succeed, and the fifth one to return
  // nullptr.
 
  auto isolate_group = thread->isolate_group();
  Heap* heap = isolate_group->heap();
 
  // We declare an array of only length 1 here to get around the limit of
  // ExternalTypedData::MaxElements(kExternalTypedDataUint8ArrayCid). Below, we
  // pretend that the length is longer when calling
  // FinalizablePersistentHandle::New(), which is what updates the external size
  // tracker.
  const intptr_t data_length = 1;
  uint8_t data[data_length] = {0};
  const ExternalTypedData& external_typed_data_1 =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataUint8ArrayCid, data, data_length, Heap::kOld));
  const ExternalTypedData& external_typed_data_2 =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataUint8ArrayCid, data, data_length, Heap::kOld));
  const ExternalTypedData& external_typed_data_3 =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataUint8ArrayCid, data, data_length, Heap::kOld));
  const ExternalTypedData& external_typed_data_4 =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataUint8ArrayCid, data, data_length, Heap::kOld));
  const ExternalTypedData& external_typed_data_5 =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataUint8ArrayCid, data, data_length, Heap::kOld));
 
  // A size that is less than a quarter of kMaxAddrSpaceMB is used because it
  // needs to be less than or equal to std::numeric_limits<intptr_t>::max().
  const intptr_t external_allocation_size =
      (intptr_t{kMaxAddrSpaceMB / 4} << MBLog2) - 16;
  EXPECT_NOTNULL(FinalizablePersistentHandle::New(
      isolate_group, external_typed_data_1, nullptr, NoopFinalizer,
      external_allocation_size,
      /*auto_delete=*/true));
  EXPECT_LT(heap->old_space()->ExternalInWords(), kMaxAddrSpaceInWords);
 
  EXPECT_NOTNULL(FinalizablePersistentHandle::New(
      isolate_group, external_typed_data_2, nullptr, NoopFinalizer,
      external_allocation_size,
      /*auto_delete=*/true));
  EXPECT_LT(heap->old_space()->ExternalInWords(), kMaxAddrSpaceInWords);
 
  EXPECT_NOTNULL(FinalizablePersistentHandle::New(
      isolate_group, external_typed_data_3, nullptr, NoopFinalizer,
      external_allocation_size,
      /*auto_delete=*/true));
  EXPECT_LT(heap->old_space()->ExternalInWords(), kMaxAddrSpaceInWords);
 
  EXPECT_NOTNULL(FinalizablePersistentHandle::New(
      isolate_group, external_typed_data_4, nullptr, NoopFinalizer,
      external_allocation_size,
      /*auto_delete=*/true));
  EXPECT_LT(heap->old_space()->ExternalInWords(), kMaxAddrSpaceInWords);
 
  EXPECT_NULLPTR(FinalizablePersistentHandle::New(
      isolate_group, external_typed_data_5, nullptr, NoopFinalizer,
      external_allocation_size,
      /*auto_delete=*/true));
  // Check that the external size is indeed protected from overflowing.
  EXPECT_LT(heap->old_space()->ExternalInWords(), kMaxAddrSpaceInWords);
}

ISOLATE_UNIT_TEST_CASE() [98/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ExternalTypedData

)

Definition at line 2292 of file object_test.cc.

                                          {
  uint8_t data[] = {253, 254, 255, 0, 1, 2, 3, 4};
  intptr_t data_length = ARRAY_SIZE(data);
 
  const ExternalTypedData& int8_array =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataInt8ArrayCid, data, data_length));
  EXPECT(!int8_array.IsNull());
  EXPECT_EQ(data_length, int8_array.Length());
 
  const ExternalTypedData& uint8_array =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataUint8ArrayCid, data, data_length));
  EXPECT(!uint8_array.IsNull());
  EXPECT_EQ(data_length, uint8_array.Length());
 
  const ExternalTypedData& uint8_clamped_array =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataUint8ClampedArrayCid, data, data_length));
  EXPECT(!uint8_clamped_array.IsNull());
  EXPECT_EQ(data_length, uint8_clamped_array.Length());
 
  EXPECT_EQ(-3, int8_array.GetInt8(0));
  EXPECT_EQ(253, uint8_array.GetUint8(0));
  EXPECT_EQ(253, uint8_clamped_array.GetUint8(0));
 
  EXPECT_EQ(-2, int8_array.GetInt8(1));
  EXPECT_EQ(254, uint8_array.GetUint8(1));
  EXPECT_EQ(254, uint8_clamped_array.GetUint8(1));
 
  EXPECT_EQ(-1, int8_array.GetInt8(2));
  EXPECT_EQ(255, uint8_array.GetUint8(2));
  EXPECT_EQ(255, uint8_clamped_array.GetUint8(2));
 
  EXPECT_EQ(0, int8_array.GetInt8(3));
  EXPECT_EQ(0, uint8_array.GetUint8(3));
  EXPECT_EQ(0, uint8_clamped_array.GetUint8(3));
 
  EXPECT_EQ(1, int8_array.GetInt8(4));
  EXPECT_EQ(1, uint8_array.GetUint8(4));
  EXPECT_EQ(1, uint8_clamped_array.GetUint8(4));
 
  EXPECT_EQ(2, int8_array.GetInt8(5));
  EXPECT_EQ(2, uint8_array.GetUint8(5));
  EXPECT_EQ(2, uint8_clamped_array.GetUint8(5));
 
  for (intptr_t i = 0; i < int8_array.Length(); ++i) {
    EXPECT_EQ(int8_array.GetUint8(i), uint8_array.GetUint8(i));
  }
 
  int8_array.SetInt8(2, -123);
  uint8_array.SetUint8(0, 123);
  for (intptr_t i = 0; i < int8_array.Length(); ++i) {
    EXPECT_EQ(int8_array.GetInt8(i), uint8_array.GetInt8(i));
  }
 
  uint8_clamped_array.SetUint8(0, 123);
  for (intptr_t i = 0; i < int8_array.Length(); ++i) {
    EXPECT_EQ(int8_array.GetUint8(i), uint8_clamped_array.GetUint8(i));
  }
}

ISOLATE_UNIT_TEST_CASE() [99/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FfiCallbackMetadata_BigRandomMultithreadedTest

)

Definition at line 606 of file ffi_callback_metadata_test.cc.

                                                                       {
  static constexpr int kThreads = 5;
 
  std::vector<std::thread> threads;
 
  Random random;
  for (int i = 0; i < kThreads; ++i) {
    threads.push_back(
        std::thread(RunBigRandomMultithreadedTest, random.NextUInt64()));
  }
 
  for (auto& thread : threads) {

ISOLATE_UNIT_TEST_CASE() [100/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FfiCallbackMetadata_TrampolineRecycling

)

Definition at line 367 of file ffi_callback_metadata_test.cc.

                                                                {
  Isolate* isolate = thread->isolate();
  auto* zone = thread->zone();
  auto* fcm = FfiCallbackMetadata::Instance();
 
  const Function& func =
      Function::Handle(CreateTestFunction(FfiCallbackKind::kAsyncCallback));
  const Code& code = Code::Handle(func.EnsureHasCode());
  EXPECT(!code.IsNull());
 
  auto port = PortMap::CreatePort(new FakeMessageHandler());
  FfiCallbackMetadata::Metadata* list_head = nullptr;
 
  // Allocate and free one callback at a time, and verify that we don't reuse
  // them. Allocate enough that the whole page fills up with dead trampolines.
  std::vector<FfiCallbackMetadata::Trampoline> allocation_order;
  std::unordered_set<FfiCallbackMetadata::Trampoline> allocated;
  const intptr_t trampolines_per_page =
      FfiCallbackMetadata::NumCallbackTrampolinesPerPage();
  for (intptr_t i = 0; i < trampolines_per_page; ++i) {
    auto tramp =
        fcm->CreateAsyncFfiCallback(isolate, zone, func, port, &list_head);
    EXPECT_EQ(allocated.count(tramp), 0u);
    allocation_order.push_back(tramp);
    allocated.insert(tramp);
    fcm->DeleteCallback(tramp, &list_head);
  }
 
  // Now  as we continue allocating and freeing, we start reusing them, in the
  // same allocation order as before.
  for (intptr_t i = 0; i < trampolines_per_page; ++i) {
    auto tramp =
        fcm->CreateAsyncFfiCallback(isolate, zone, func, port, &list_head);
    EXPECT_EQ(allocated.count(tramp), 1u);
    EXPECT_EQ(allocation_order[i], tramp);
    fcm->DeleteCallback(tramp, &list_head);
  }
 
  // Now allocate enough to fill the page without freeing them. Again they
  // should come out in the same order.
  for (intptr_t i = 0; i < trampolines_per_page; ++i) {
    auto tramp =
        fcm->CreateAsyncFfiCallback(isolate, zone, func, port, &list_head);
    EXPECT_EQ(allocated.count(tramp), 1u);
    EXPECT_EQ(allocation_order[i], tramp);
  }
 
  // Now that the page is full, we should allocate a new page and see new
  // trampolines we haven't seen before.
  for (intptr_t i = 0; i < 3 * trampolines_per_page; ++i) {
    auto tramp =
        fcm->CreateAsyncFfiCallback(isolate, zone, func, port, &list_head);

ISOLATE_UNIT_TEST_CASE() [101/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FieldTests

)

Definition at line 3200 of file object_test.cc.

                                   {
  const String& f = String::Handle(String::New("oneField"));
  const String& getter_f = String::Handle(Field::GetterName(f));
  const String& setter_f = String::Handle(Field::SetterName(f));
  EXPECT(!Field::IsGetterName(f));
  EXPECT(!Field::IsSetterName(f));
  EXPECT(Field::IsGetterName(getter_f));
  EXPECT(!Field::IsSetterName(getter_f));
  EXPECT(!Field::IsGetterName(setter_f));
  EXPECT(Field::IsSetterName(setter_f));
  EXPECT_STREQ(f.ToCString(),
               String::Handle(Field::NameFromGetter(getter_f)).ToCString());
  EXPECT_STREQ(f.ToCString(),
               String::Handle(Field::NameFromSetter(setter_f)).ToCString());
}

ISOLATE_UNIT_TEST_CASE() [102/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearDetachOne_NewSpace

)

Definition at line 3967 of file object_test.cc.

                                                          {
  Finalizer_ClearDetachOne(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE() [103/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearDetachOne_OldSpace

)

Definition at line 3971 of file object_test.cc.

                                                          {
  Finalizer_ClearDetachOne(thread, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE() [104/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearDetachTwo_NewSpace

)

Definition at line 4321 of file object_test.cc.

                                                          {
  Finalizer_TwoEntries(thread, Heap::kNew, false, false, true, true);
}

ISOLATE_UNIT_TEST_CASE() [105/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearDetachTwo_OldSpace

)

Definition at line 4325 of file object_test.cc.

                                                          {
  Finalizer_TwoEntries(thread, Heap::kOld, false, false, true, true);
}

ISOLATE_UNIT_TEST_CASE() [106/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearFirstValue_NewSpace

)

Definition at line 4297 of file object_test.cc.

                                                           {
  Finalizer_TwoEntries(thread, Heap::kNew, true, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [107/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearFirstValue_OldSpace

)

Definition at line 4301 of file object_test.cc.

                                                           {
  Finalizer_TwoEntries(thread, Heap::kOld, true, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [108/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearSecondValue_NewSpace

)

Definition at line 4305 of file object_test.cc.

                                                            {
  Finalizer_TwoEntries(thread, Heap::kNew, false, true, false, false);
}

ISOLATE_UNIT_TEST_CASE() [109/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearSecondValue_OldSpace

)

Definition at line 4309 of file object_test.cc.

                                                            {
  Finalizer_TwoEntries(thread, Heap::kOld, false, true, false, false);
}

ISOLATE_UNIT_TEST_CASE() [110/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearValueNullTokenOne_NewSpace

)

Definition at line 4039 of file object_test.cc.

                                                                  {
  Finalizer_ClearValueOne(thread, Heap::kNew, true);
}

ISOLATE_UNIT_TEST_CASE() [111/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearValueNullTokenOne_OldSpace

)

Definition at line 4043 of file object_test.cc.

                                                                  {
  Finalizer_ClearValueOne(thread, Heap::kOld, true);
}

ISOLATE_UNIT_TEST_CASE() [112/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearValueOne_NewSpace

)

Definition at line 4031 of file object_test.cc.

                                                         {
  Finalizer_ClearValueOne(thread, Heap::kNew, false);
}

ISOLATE_UNIT_TEST_CASE() [113/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearValueOne_OldSpace

)

Definition at line 4035 of file object_test.cc.

                                                         {
  Finalizer_ClearValueOne(thread, Heap::kOld, false);
}

ISOLATE_UNIT_TEST_CASE() [114/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearValueTwo_NewSpace

)

Definition at line 4289 of file object_test.cc.

                                                         {
  Finalizer_TwoEntries(thread, Heap::kNew, true, true, false, false);
}

ISOLATE_UNIT_TEST_CASE() [115/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_ClearValueTwo_OldSpace

)

Definition at line 4293 of file object_test.cc.

                                                         {
  Finalizer_TwoEntries(thread, Heap::kOld, true, true, false, false);
}

ISOLATE_UNIT_TEST_CASE() [116/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_DetachAndClearValueOne_NewSpace

)

Definition at line 4111 of file object_test.cc.

                                                                  {
  Finalizer_DetachOne(thread, Heap::kNew, true);
}

ISOLATE_UNIT_TEST_CASE() [117/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_DetachAndClearValueOne_OldSpace

)

Definition at line 4115 of file object_test.cc.

                                                                  {
  Finalizer_DetachOne(thread, Heap::kOld, true);
}

ISOLATE_UNIT_TEST_CASE() [118/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_DetachOne_NewSpace

)

Definition at line 4103 of file object_test.cc.

                                                     {
  Finalizer_DetachOne(thread, Heap::kNew, false);
}

ISOLATE_UNIT_TEST_CASE() [119/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_DetachOne_OldSpace

)

Definition at line 4107 of file object_test.cc.

                                                     {
  Finalizer_DetachOne(thread, Heap::kOld, false);
}

ISOLATE_UNIT_TEST_CASE() [120/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_GcFinalizer_NewSpace

)

Definition at line 4159 of file object_test.cc.

                                                       {
  Finalizer_GcFinalizer(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE() [121/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_GcFinalizer_OldSpace

)

Definition at line 4163 of file object_test.cc.

                                                       {
  Finalizer_GcFinalizer(thread, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE() [122/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_PreserveNoDetachOne_NewSpace

)

Definition at line 3902 of file object_test.cc.

                                                               {
  Finalizer_PreserveOne(thread, Heap::kNew, false);
}

ISOLATE_UNIT_TEST_CASE() [123/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_PreserveNoDetachOne_OldSpace

)

Definition at line 3906 of file object_test.cc.

                                                               {
  Finalizer_PreserveOne(thread, Heap::kOld, false);
}

ISOLATE_UNIT_TEST_CASE() [124/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_PreserveTwo_NewSpace

)

Definition at line 4313 of file object_test.cc.

                                                       {
  Finalizer_TwoEntries(thread, Heap::kNew, false, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [125/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_PreserveTwo_OldSpace

)

Definition at line 4317 of file object_test.cc.

                                                       {
  Finalizer_TwoEntries(thread, Heap::kOld, false, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [126/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_PreserveWithDetachOne_NewSpace

)

Definition at line 3910 of file object_test.cc.

                                                                 {
  Finalizer_PreserveOne(thread, Heap::kNew, true);
}

ISOLATE_UNIT_TEST_CASE() [127/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_PreserveWithDetachOne_OldSpace

)

Definition at line 3914 of file object_test.cc.

                                                                 {
  Finalizer_PreserveOne(thread, Heap::kOld, true);
}

ISOLATE_UNIT_TEST_CASE() [128/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Finalizer_Regress_48843

)

Definition at line 4895 of file object_test.cc.

                                                {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
  SetFlagScope<bool> sfs2(&FLAG_verify_store_buffer, true);
#endif
  SetFlagScope<bool> sfs3(&FLAG_use_compactor, true);
 
  const auto& finalizer = Finalizer::Handle(Finalizer::New(Heap::kOld));
  finalizer.set_isolate(thread->isolate());
 
  const auto& detach1 =
      String::Handle(OneByteString::New("detach1", Heap::kNew));
  const auto& token1 = String::Handle(OneByteString::New("token1", Heap::kNew));
  const auto& detach2 =
      String::Handle(OneByteString::New("detach2", Heap::kOld));
  const auto& token2 = String::Handle(OneByteString::New("token2", Heap::kOld));
 
  {
    HANDLESCOPE(thread);
    const auto& entry1 =
        FinalizerEntry::Handle(FinalizerEntry::New(finalizer, Heap::kNew));
    entry1.set_detach(detach1);
    entry1.set_token(token1);
 
    const auto& entry2 =
        FinalizerEntry::Handle(FinalizerEntry::New(finalizer, Heap::kOld));
    entry2.set_detach(detach2);
    entry2.set_token(token2);
 
    {
      HANDLESCOPE(thread);
      const auto& value1 =
          String::Handle(OneByteString::New("value1", Heap::kNew));
      entry1.set_value(value1);
      const auto& value2 =
          String::Handle(OneByteString::New("value2", Heap::kOld));
      entry2.set_value(value2);
      // Lose both values.
    }
 
    // First collect new space.
    GCTestHelper::CollectNewSpace();
    // Then old space, this will make the old space entry point to the new
    // space entry.
    // Also, this must be a mark compact, not a mark sweep, to move the entry.
    GCTestHelper::CollectOldSpace();
  }
 
  // Imagine callbacks running.
  // Entries themselves become unreachable.
  finalizer.set_entries_collected(
      FinalizerEntry::Handle(FinalizerEntry::null()));
 
  // There should be a single entry in the store buffer.
  // And it should crash when seeing the address in the buffer.
  GCTestHelper::CollectNewSpace();
 
  // We should no longer be processing the entries.
  GCTestHelper::CollectOldSpace();
  GCTestHelper::CollectNewSpace();
}

ISOLATE_UNIT_TEST_CASE() [129/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FinalizerEntry_Generations

)

Definition at line 1216 of file heap_test.cc.

                                                   {
  FLAG_early_tenuring_threshold = 100;  // I.e., off.
 
  FinalizerEntry_Generations(kNew, kNew, true, true, true);
  FinalizerEntry_Generations(kNew, kOld, false, true, true);
  FinalizerEntry_Generations(kNew, kImm, false, false, false);
  FinalizerEntry_Generations(kOld, kNew, true, true, true);
  FinalizerEntry_Generations(kOld, kOld, false, true, true);
  FinalizerEntry_Generations(kOld, kImm, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [130/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FindClosureIndex

)

Definition at line 5317 of file object_test.cc.

                                         {
  // Allocate the class first.
  const String& class_name = String::Handle(Symbols::New(thread, "MyClass"));
  const Script& script = Script::Handle();
  const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
  const Array& functions = Array::Handle(Array::New(1));
 
  Function& parent = Function::Handle();
  const String& parent_name = String::Handle(Symbols::New(thread, "foo_papa"));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  parent = Function::New(signature, parent_name,
                         UntaggedFunction::kRegularFunction, false, false,
                         false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(0, parent);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    cls.SetFunctions(functions);
  }
 
  Function& function = Function::Handle();
  const String& function_name = String::Handle(Symbols::New(thread, "foo"));
  function = Function::NewClosureFunction(function_name, parent,
                                          TokenPosition::kMinSource);
  function.set_kernel_offset(42);
  // Add closure function to class.
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    ClosureFunctionsCache::AddClosureFunctionLocked(function);
  }
 
  // The closure should return a valid index.
  intptr_t good_closure_index =
      ClosureFunctionsCache::FindClosureIndex(function);
  EXPECT_GE(good_closure_index, 0);
  // The parent function should return an invalid index.
  intptr_t bad_closure_index = ClosureFunctionsCache::FindClosureIndex(parent);
  EXPECT_EQ(bad_closure_index, -1);
 
  // Retrieve closure function via index.
  Function& func_from_index = Function::Handle();
  func_from_index ^=
      ClosureFunctionsCache::ClosureFunctionFromIndex(good_closure_index);
  // Same closure function.
  EXPECT_EQ(func_from_index.ptr(), function.ptr());
}

ISOLATE_UNIT_TEST_CASE() [131/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FindInvocationDispatcherFunctionIndex

)

Definition at line 5363 of file object_test.cc.

                                                              {
  const String& class_name = String::Handle(Symbols::New(thread, "MyClass"));
  const Script& script = Script::Handle();
  const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
  ClassFinalizer::FinalizeTypesInClass(cls);
 
  const Array& functions = Array::Handle(Array::New(1));
  Function& parent = Function::Handle();
  const String& parent_name = String::Handle(Symbols::New(thread, "foo_papa"));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  parent = Function::New(signature, parent_name,
                         UntaggedFunction::kRegularFunction, false, false,
                         false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(0, parent);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    cls.SetFunctions(functions);
    cls.Finalize();
  }
 
  // Add invocation dispatcher.
  const String& invocation_dispatcher_name =
      String::Handle(Symbols::New(thread, "myMethod"));
  const Array& args_desc = Array::Handle(ArgumentsDescriptor::NewBoxed(0, 1));
  Function& invocation_dispatcher = Function::Handle();
  invocation_dispatcher ^= cls.GetInvocationDispatcher(
      invocation_dispatcher_name, args_desc,
      UntaggedFunction::kNoSuchMethodDispatcher, true /* create_if_absent */);
  EXPECT(!invocation_dispatcher.IsNull());
  // Get index to function.
  intptr_t invocation_dispatcher_index =
      cls.FindInvocationDispatcherFunctionIndex(invocation_dispatcher);
  // Expect a valid index.
  EXPECT_GE(invocation_dispatcher_index, 0);
  // Retrieve function through index.
  Function& invocation_dispatcher_from_index = Function::Handle();
  invocation_dispatcher_from_index ^=
      cls.InvocationDispatcherFunctionFromIndex(invocation_dispatcher_index);
  // Same function.
  EXPECT_EQ(invocation_dispatcher.ptr(),
            invocation_dispatcher_from_index.ptr());
  // Test function not found case.
  const Function& bad_function = Function::Handle(Function::null());
  intptr_t bad_invocation_dispatcher_index =
      cls.FindInvocationDispatcherFunctionIndex(bad_function);
  EXPECT_EQ(bad_invocation_dispatcher_index, -1);
}

ISOLATE_UNIT_TEST_CASE() [132/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_LargeFrame_Double

)

Definition at line 246 of file flow_graph_test.cc.

                                                    {
  TestLargeFrame("double", "0.0", "1.0",
                 "main() {\n"
                 "  for (var i = 0; i < 100; i++) {\n"
                 "    var r = largeFrame(1);\n"
                 "    if (r != 2000.0) throw r;\n"
                 "  }\n"
                 "  return 'Okay';\n"
                 "}\n");
}

ISOLATE_UNIT_TEST_CASE() [133/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_LargeFrame_Float32x4

)

Definition at line 271 of file flow_graph_test.cc.

                                                       {
  TestLargeFrame("Float32x4", "Float32x4(0.0, 0.0, 0.0, 0.0)",
                 "Float32x4(1.0, 2.0, 3.0, 4.0)",
                 "main() {\n"
                 "  for (var i = 0; i < 100; i++) {\n"
                 "    var r = largeFrame(1);\n"
                 "    if (r.x != 2000.0) throw r;\n"
                 "    if (r.y != 4000.0) throw r;\n"
                 "    if (r.z != 6000.0) throw r;\n"
                 "    if (r.w != 8000.0) throw r;\n"
                 "  }\n"
                 "  return 'Okay';\n"
                 "}\n");
}

ISOLATE_UNIT_TEST_CASE() [134/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_LargeFrame_Float64x2

)

Definition at line 286 of file flow_graph_test.cc.

                                                       {
  TestLargeFrame("Float64x2", "Float64x2(0.0, 0.0)", "Float64x2(1.0, 2.0)",
                 "main() {\n"
                 "  for (var i = 0; i < 100; i++) {\n"
                 "    var r = largeFrame(1);\n"
                 "    if (r.x != 2000.0) throw r;\n"
                 "    if (r.y != 4000.0) throw r;\n"
                 "  }\n"
                 "  return 'Okay';\n"
                 "}\n");
}

ISOLATE_UNIT_TEST_CASE() [135/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_LargeFrame_Int

)

Definition at line 235 of file flow_graph_test.cc.

                                                 {
  TestLargeFrame("int", "0", "1",
                 "main() {\n"
                 "  for (var i = 0; i < 100; i++) {\n"
                 "    var r = largeFrame(1);\n"
                 "    if (r != 2000) throw r;\n"
                 "  }\n"
                 "  return 'Okay';\n"
                 "}\n");
}

ISOLATE_UNIT_TEST_CASE() [136/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_LargeFrame_Int32x4

)

Definition at line 257 of file flow_graph_test.cc.

                                                     {
  TestLargeFrame("Int32x4", "Int32x4(0, 0, 0, 0)", "Int32x4(1, 2, 3, 4)",
                 "main() {\n"
                 "  for (var i = 0; i < 100; i++) {\n"
                 "    var r = largeFrame(1);\n"
                 "    if (r.x != 2000) throw r;\n"
                 "    if (r.y != 4000) throw r;\n"
                 "    if (r.z != 6000) throw r;\n"
                 "    if (r.w != 8000) throw r;\n"
                 "  }\n"
                 "  return 'Okay';\n"
                 "}\n");
}

ISOLATE_UNIT_TEST_CASE() [137/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_LateVariablePhiUnboxing

)

Definition at line 78 of file flow_graph_test.cc.

                                                          {
  using compiler::BlockBuilder;
 
  CompilerState S(thread, /*is_aot=*/true, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
  auto loop_header = H.JoinEntry();
  auto loop_body = H.TargetEntry();
  auto loop_exit = H.TargetEntry();
 
  ConstantInstr* sentinel = H.flow_graph()->GetConstant(Object::sentinel());
 
  PhiInstr* loop_var;
  PhiInstr* late_var;
  Definition* add1;
 
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), loop_header);
    loop_var = H.Phi(loop_header,
                     {{normal_entry, H.IntConstant(0)}, {loop_body, &add1}});
    builder.AddPhi(loop_var);
    loop_var->UpdateType(CompileType::Int());
    loop_var->UpdateType(CompileType::FromAbstractType(
        Type::ZoneHandle(Type::IntType()), CompileType::kCannotBeNull,
        CompileType::kCanBeSentinel));
    late_var =
        H.Phi(loop_header, {{normal_entry, sentinel}, {loop_body, &add1}});
    builder.AddPhi(late_var);
    builder.AddBranch(new RelationalOpInstr(
                          InstructionSource(), Token::kLT, new Value(loop_var),
                          new Value(H.IntConstant(10)), kMintCid,
                          S.GetNextDeoptId(), Instruction::kNotSpeculative),
                      loop_body, loop_exit);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), loop_body);
    add1 = builder.AddDefinition(new BinaryInt64OpInstr(
        Token::kADD, new Value(loop_var), new Value(H.IntConstant(1)),
        S.GetNextDeoptId(), Instruction::kNotSpeculative));
    builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), loop_exit);
    builder.AddReturn(new Value(late_var));
  }
 
  H.FinishGraph();
 
  FlowGraphTypePropagator::Propagate(H.flow_graph());
  H.flow_graph()->SelectRepresentations();
 
#if defined(TARGET_ARCH_IS_64_BIT)
  EXPECT_PROPERTY(loop_var, it.representation() == kUnboxedInt64);
#endif
  EXPECT_PROPERTY(late_var, it.representation() == kTagged);
}

ISOLATE_UNIT_TEST_CASE() [138/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_PhiUnboxingHeuristic_Double

)

Definition at line 298 of file flow_graph_test.cc.

                                                              {
  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {
    return;
  }
 
  const char* kScript = R"(
    double foo(double sum, int n) {
       if (sum == null) return 0.0;
       for (int i = 0; i < n; i++) {
          sum += 1.0;
       }
       return sum;
    }
    main() {
      foo(0.0, 10);
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
 
  Invoke(root_library, "main");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                   ParallelMovesHandling::kSkip);
 
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveFunctionEntry,
  }));
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveUnbox,  // outside of loop
      kMatchAndMoveCheckSmi,
      kMoveGlob,
 
      // Loop header
      kMatchAndMoveJoinEntry,
      kMatchAndMoveCheckStackOverflow,
      kMatchAndMoveBranchTrue,
 
      // Loop body
      kMatchAndMoveTargetEntry,
      kMatchAndMoveBinaryDoubleOp,
      kMatchAndMoveBinarySmiOp,
      kMatchAndMoveGoto,
 
      // Loop header, again
      kMatchAndMoveJoinEntry,
      kMatchAndMoveCheckStackOverflow,
      kMatchAndMoveBranchFalse,
 
      // After loop
      kMatchAndMoveTargetEntry,
      kMatchAndMoveBox,
      kMatchDartReturn,
  }));
}

ISOLATE_UNIT_TEST_CASE() [139/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_PhiUnboxingHeuristic_Float32x4

)

Definition at line 407 of file flow_graph_test.cc.

                                                                 {
  const char* kScript = R"(
    import 'dart:typed_data';
    Float32x4 foo(Float32x4 sum, int n) {
       if (sum == null) return Float32x4(0.0, 0.0, 0.0, 0.0);
       for (int i = 0; i < n; i++) {
          sum += Float32x4(1.0, 2.0, 3.0, 4.0);
       }
       return sum;
    }
    main() {
      foo(Float32x4(0.0, 0.0, 0.0, 0.0), 10);
    }
  )";
  TestPhiUnboxingHeuristicSimd(kScript);
}

ISOLATE_UNIT_TEST_CASE() [140/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_PhiUnboxingHeuristic_Float64x2

)

Definition at line 424 of file flow_graph_test.cc.

                                                                 {
  const char* kScript = R"(
    import 'dart:typed_data';
    Float64x2 foo(Float64x2 sum, int n) {
       if (sum == null) return Float64x2(0.0, 0.0);
       for (int i = 0; i < n; i++) {
          sum += Float64x2(1.0, 2.0);
       }
       return sum;
    }
    main() {
      foo(Float64x2(0.0, 0.0), 10);
    }
  )";
  TestPhiUnboxingHeuristicSimd(kScript);
}

ISOLATE_UNIT_TEST_CASE() [141/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_PhiUnboxingHeuristic_Int32x4

)

Definition at line 441 of file flow_graph_test.cc.

                                                               {
  const char* kScript = R"(
    import 'dart:typed_data';
    Int32x4 foo(Int32x4 sum, int n) {
       if (sum == null) return Int32x4(0, 0, 0, 0);
       for (int i = 0; i < n; i++) {
          sum += Int32x4(1, 2, 3, 4);
       }
       return sum;
    }
    main() {
      foo(Int32x4(0, 0, 0, 0), 10);
    }
  )";
  TestPhiUnboxingHeuristicSimd(kScript);
}

ISOLATE_UNIT_TEST_CASE() [142/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FlowGraph_UnboxedFloatPhi

)

Definition at line 143 of file flow_graph_test.cc.

                                                  {
  using compiler::BlockBuilder;
 
  CompilerState S(thread, /*is_aot=*/true, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
  auto then_body = H.TargetEntry();
  auto else_body = H.TargetEntry();
  auto join_exit = H.JoinEntry();
 
  PhiInstr* phi;
  Definition* double_to_float_1;
  Definition* double_to_float_2;
 
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    builder.AddBranch(
        new StrictCompareInstr(
            InstructionSource(), Token::kEQ_STRICT, new Value(H.IntConstant(1)),
            new Value(H.IntConstant(1)),
            /*needs_number_check=*/false, S.GetNextDeoptId()),
        then_body, else_body);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), then_body);
    double_to_float_1 = builder.AddDefinition(new DoubleToFloatInstr(
        new Value(H.DoubleConstant(1)), S.GetNextDeoptId(),
        Instruction::kNotSpeculative));
    builder.AddInstruction(new GotoInstr(join_exit, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), else_body);
    double_to_float_2 = builder.AddDefinition(new DoubleToFloatInstr(
        new Value(H.DoubleConstant(2)), S.GetNextDeoptId(),
        Instruction::kNotSpeculative));
    builder.AddInstruction(new GotoInstr(join_exit, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), join_exit);
    phi = new PhiInstr(join_exit, 3);
    phi->SetInputAt(0, new Value(double_to_float_1));
    phi->SetInputAt(1, new Value(double_to_float_2));
    phi->SetInputAt(2, new Value(phi));
    builder.AddPhi(phi);
    builder.AddReturn(new Value(phi));
  }
  H.FinishGraph();
 
  FlowGraphTypePropagator::Propagate(H.flow_graph());
  H.flow_graph()->SelectRepresentations();
 
  EXPECT_PROPERTY(phi, it.representation() == kUnboxedFloat);
}

ISOLATE_UNIT_TEST_CASE() [143/463]

dart::ISOLATE_UNIT_TEST_CASE

(

FunctionType_IsSubtypeOfNonNullableObject

)

Definition at line 7493 of file object_test.cc.

                                                                  {
  const auto& type_object = Type::Handle(
      IsolateGroup::Current()->object_store()->non_nullable_object_type());
 
  auto& type_function_int_nullary =
      FunctionType::Handle(FunctionType::New(0, Nullability::kNonNullable));

ISOLATE_UNIT_TEST_CASE() [144/463]

dart::ISOLATE_UNIT_TEST_CASE

(

GrowableHandlePtr

)

Definition at line 97 of file growable_array_test.cc.

                                          {
  Zone* zone = Thread::Current()->zone();
  GrowableHandlePtrArray<const String> test1(zone, 1);
  EXPECT_EQ(0, test1.length());
  test1.Add(Symbols::Int());
  EXPECT(test1[0].ptr() == Symbols::Int().ptr());
  EXPECT_EQ(1, test1.length());
 
  ZoneGrowableHandlePtrArray<const String>* test2 =
      new ZoneGrowableHandlePtrArray<const String>(zone, 1);
  test2->Add(Symbols::GetterPrefix());
  EXPECT((*test2)[0].ptr() == Symbols::GetterPrefix().ptr());
  EXPECT_EQ(1, test2->length());
}

ISOLATE_UNIT_TEST_CASE() [145/463]

dart::ISOLATE_UNIT_TEST_CASE

(

GrowableObjectArray

)

Definition at line 2065 of file object_test.cc.

                                            {
  const int kArrayLen = 5;
  Smi& value = Smi::Handle();
  Smi& expected_value = Smi::Handle();
  GrowableObjectArray& array = GrowableObjectArray::Handle();
 
  // Test basic growing functionality.
  array = GrowableObjectArray::New(kArrayLen);
  EXPECT_EQ(kArrayLen, array.Capacity());
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 10; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  EXPECT_EQ(10, array.Length());
  for (intptr_t i = 0; i < 10; i++) {
    expected_value = Smi::New(i);
    value ^= array.At(i);
    EXPECT(value.Equals(expected_value));
  }
  for (intptr_t i = 0; i < 10; i++) {
    value = Smi::New(i * 10);
    array.SetAt(i, value);
  }
  EXPECT_EQ(10, array.Length());
  for (intptr_t i = 0; i < 10; i++) {
    expected_value = Smi::New(i * 10);
    value ^= array.At(i);
    EXPECT(value.Equals(expected_value));
  }
 
  // Test the MakeFixedLength functionality to make sure the resulting array
  // object is properly setup.
  // 1. Should produce an array of length 2 and a left over int8 array.
  Array& new_array = Array::Handle();
  TypedData& left_over_array = TypedData::Handle();
  Object& obj = Object::Handle();
  uword addr = 0;
  intptr_t used_size = 0;
 
  array = GrowableObjectArray::New(kArrayLen + 1);
  EXPECT_EQ(kArrayLen + 1, array.Capacity());
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 2; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  used_size = Array::InstanceSize(array.Length());
  new_array = Array::MakeFixedLength(array);
  addr = UntaggedObject::ToAddr(new_array.ptr());
  obj = UntaggedObject::FromAddr(addr);
  EXPECT(obj.IsArray());
  new_array ^= obj.ptr();
  EXPECT_EQ(2, new_array.Length());
  addr += used_size;
  obj = UntaggedObject::FromAddr(addr);
#if defined(DART_COMPRESSED_POINTERS)
  // In compressed pointer mode, the TypedData doesn't fit.
  EXPECT(obj.IsInstance());
#else
  EXPECT(obj.IsTypedData());
  left_over_array ^= obj.ptr();
  EXPECT_EQ(4 * kWordSize - TypedData::InstanceSize(0),
            left_over_array.Length());
#endif
 
  // 2. Should produce an array of length 3 and a left over int8 array or
  // instance.
  array = GrowableObjectArray::New(kArrayLen);
  EXPECT_EQ(kArrayLen, array.Capacity());
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 3; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  used_size = Array::InstanceSize(array.Length());
  new_array = Array::MakeFixedLength(array);
  addr = UntaggedObject::ToAddr(new_array.ptr());
  obj = UntaggedObject::FromAddr(addr);
  EXPECT(obj.IsArray());
  new_array ^= obj.ptr();
  EXPECT_EQ(3, new_array.Length());
  addr += used_size;
  obj = UntaggedObject::FromAddr(addr);
  if (TypedData::InstanceSize(0) <= 2 * kCompressedWordSize) {
    EXPECT(obj.IsTypedData());
    left_over_array ^= obj.ptr();
    EXPECT_EQ(2 * kCompressedWordSize - TypedData::InstanceSize(0),
              left_over_array.Length());
  } else {
    EXPECT(obj.IsInstance());
  }
 
  // 3. Should produce an array of length 1 and a left over int8 array.
  array = GrowableObjectArray::New(kArrayLen + 3);
  EXPECT_EQ((kArrayLen + 3), array.Capacity());
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 1; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  used_size = Array::InstanceSize(array.Length());
  new_array = Array::MakeFixedLength(array);
  addr = UntaggedObject::ToAddr(new_array.ptr());
  obj = UntaggedObject::FromAddr(addr);
  EXPECT(obj.IsArray());
  new_array ^= obj.ptr();
  EXPECT_EQ(1, new_array.Length());
  addr += used_size;
  obj = UntaggedObject::FromAddr(addr);
#if defined(DART_COMPRESSED_POINTERS)
  // In compressed pointer mode, the TypedData doesn't fit.
  EXPECT(obj.IsInstance());
#else
  EXPECT(obj.IsTypedData());
  left_over_array ^= obj.ptr();
  EXPECT_EQ(8 * kWordSize - TypedData::InstanceSize(0),
            left_over_array.Length());
#endif
 
  // 4. Verify that GC can handle the filler object for a large array.
  array = GrowableObjectArray::New((1 * MB) >> kWordSizeLog2);
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 1; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  Heap* heap = IsolateGroup::Current()->heap();
  GCTestHelper::CollectAllGarbage();
  GCTestHelper::WaitForGCTasks();  // Sweeper must finish for accurate capacity.
  intptr_t capacity_before = heap->CapacityInWords(Heap::kOld);
  new_array = Array::MakeFixedLength(array);
  EXPECT_EQ(1, new_array.Length());
  GCTestHelper::CollectAllGarbage();
  GCTestHelper::WaitForGCTasks();  // Sweeper must finish for accurate capacity.
  intptr_t capacity_after = heap->CapacityInWords(Heap::kOld);
  // Page should shrink.
  EXPECT_LT(capacity_after, capacity_before);
  EXPECT_EQ(1, new_array.Length());
}

ISOLATE_UNIT_TEST_CASE() [146/463]

dart::ISOLATE_UNIT_TEST_CASE

(

HashTable

)

Definition at line 56 of file hash_table_test.cc.

                                  {
  typedef HashTable<TestTraits, 2, 1> Table;
  Table table(Thread::Current()->zone(), HashTables::New<Table>(5));
  // Ensure that we did get at least 5 entries.
  EXPECT_LE(5, table.NumEntries());
  EXPECT_EQ(0, table.NumOccupied());
  Validate(table);
  EXPECT_EQ(-1, table.FindKey("a"));
 
  // Insertion and lookup.
  intptr_t a_entry = -1;
  EXPECT(!table.FindKeyOrDeletedOrUnused("a", &a_entry));
  EXPECT_NE(-1, a_entry);
  String& a = String::Handle(String::New("a"));
  table.InsertKey(a_entry, a);
  EXPECT_EQ(1, table.NumOccupied());
  Validate(table);
  EXPECT_EQ(a_entry, table.FindKey("a"));
  EXPECT_EQ(-1, table.FindKey("b"));
  intptr_t a_entry_again = -1;
  EXPECT(table.FindKeyOrDeletedOrUnused("a", &a_entry_again));
  EXPECT_EQ(a_entry, a_entry_again);
  intptr_t b_entry = -1;
  EXPECT(!table.FindKeyOrDeletedOrUnused("b", &b_entry));
  String& b = String::Handle(String::New("b"));
  table.InsertKey(b_entry, b);
  EXPECT_EQ(2, table.NumOccupied());
  Validate(table);
 
  // Deletion.
  table.DeleteEntry(a_entry);
  EXPECT_EQ(1, table.NumOccupied());
  Validate(table);
  EXPECT_EQ(-1, table.FindKey("a"));
  EXPECT_EQ(b_entry, table.FindKey("b"));
  intptr_t c_entry = -1;
  EXPECT(!table.FindKeyOrDeletedOrUnused("c", &c_entry));
  String& c = String::Handle(String::New("c"));
  table.InsertKey(c_entry, c);
  EXPECT_EQ(2, table.NumOccupied());
  Validate(table);
  EXPECT_EQ(c_entry, table.FindKey("c"));
 
  // Ensure we can actually reach 5 occupied entries (without expansion).
  {
    intptr_t entry = -1;
    EXPECT(!table.FindKeyOrDeletedOrUnused("d", &entry));
    String& k = String::Handle(String::New("d"));
    table.InsertKey(entry, k);
    EXPECT(!table.FindKeyOrDeletedOrUnused("e", &entry));
    k = String::New("e");
    table.InsertKey(entry, k);
    EXPECT(!table.FindKeyOrDeletedOrUnused("f", &entry));
    k = String::New("f");
    table.InsertKey(entry, k);
    EXPECT_EQ(5, table.NumOccupied());
  }
  table.Release();
}

ISOLATE_UNIT_TEST_CASE() [147/463]

dart::ISOLATE_UNIT_TEST_CASE

(

HelperAllocAndGC

)

Definition at line 888 of file thread_test.cc.

                                         {
  Monitor done_monitor;
  bool done = false;
  auto isolate_group = thread->isolate_group();
  Dart::thread_pool()->Run<AllocAndGCTask>(isolate_group, &done_monitor, &done);
  {
    while (true) {
      TransitionVMToBlocked transition(thread);
      MonitorLocker ml(&done_monitor);
      if (done) {
        break;
      }
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [148/463]

dart::ISOLATE_UNIT_TEST_CASE

(

HierarchyInfo_Function_Subtype

)

Definition at line 547 of file il_test.cc.

                                                       {
  HierarchyInfo hi(thread);
  const auto& type =
      Type::Handle(IsolateGroup::Current()->object_store()->function_type());
  EXPECT(hi.CanUseSubtypeRangeCheckFor(type));
  const auto& cls = Class::Handle(type.type_class());
 
  GrowableArray<intptr_t> expected_concrete_cids;
  expected_concrete_cids.Add(kClosureCid);
 
  GrowableArray<intptr_t> expected_abstract_cids;
  expected_abstract_cids.Add(type.type_class_id());
 
  const CidRangeVector& concrete_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/false, /*exclude_null=*/true);
  RANGES_CONTAIN_EXPECTED_CIDS(concrete_range, expected_concrete_cids);
 
  GrowableArray<intptr_t> expected_cids;
  expected_cids.AddArray(expected_concrete_cids);
  expected_cids.AddArray(expected_abstract_cids);
  const CidRangeVector& abstract_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/true, /*exclude_null=*/true);
  RANGES_CONTAIN_EXPECTED_CIDS(abstract_range, expected_cids);
}

ISOLATE_UNIT_TEST_CASE() [149/463]

dart::ISOLATE_UNIT_TEST_CASE

(

HierarchyInfo_Int_Subtype

)

Definition at line 602 of file il_test.cc.

                                                  {
  HierarchyInfo hi(thread);
  const auto& type = Type::Handle(Type::IntType());
  EXPECT(hi.CanUseSubtypeRangeCheckFor(type));
  const auto& cls = Class::Handle(type.type_class());
 
  GrowableArray<intptr_t> expected_concrete_cids;
  expected_concrete_cids.Add(kSmiCid);
  expected_concrete_cids.Add(kMintCid);
 
  GrowableArray<intptr_t> expected_abstract_cids;
  expected_abstract_cids.Add(type.type_class_id());
 
  const CidRangeVector& concrete_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/false, /*exclude_null=*/true);
  RANGES_CONTAIN_EXPECTED_CIDS(concrete_range, expected_concrete_cids);
 
  GrowableArray<intptr_t> expected_cids;
  expected_cids.AddArray(expected_concrete_cids);
  expected_cids.AddArray(expected_abstract_cids);
  const CidRangeVector& abstract_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/true, /*exclude_null=*/true);
  RANGES_CONTAIN_EXPECTED_CIDS(abstract_range, expected_cids);
}

ISOLATE_UNIT_TEST_CASE() [150/463]

dart::ISOLATE_UNIT_TEST_CASE

(

HierarchyInfo_Num_Subtype

)

Definition at line 572 of file il_test.cc.

                                                  {
  HierarchyInfo hi(thread);
  const auto& num_type = Type::Handle(Type::Number());
  const auto& int_type = Type::Handle(Type::IntType());
  const auto& double_type = Type::Handle(Type::Double());
  EXPECT(hi.CanUseSubtypeRangeCheckFor(num_type));
  const auto& cls = Class::Handle(num_type.type_class());
 
  GrowableArray<intptr_t> expected_concrete_cids;
  expected_concrete_cids.Add(kSmiCid);
  expected_concrete_cids.Add(kMintCid);
  expected_concrete_cids.Add(kDoubleCid);
 
  GrowableArray<intptr_t> expected_abstract_cids;
  expected_abstract_cids.Add(num_type.type_class_id());
  expected_abstract_cids.Add(int_type.type_class_id());
  expected_abstract_cids.Add(double_type.type_class_id());
 
  const CidRangeVector& concrete_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/false, /*exclude_null=*/true);
  RANGES_CONTAIN_EXPECTED_CIDS(concrete_range, expected_concrete_cids);
 
  GrowableArray<intptr_t> expected_cids;
  expected_cids.AddArray(expected_concrete_cids);
  expected_cids.AddArray(expected_abstract_cids);
  const CidRangeVector& abstract_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/true, /*exclude_null=*/true);
  RANGES_CONTAIN_EXPECTED_CIDS(abstract_range, expected_cids);
}

ISOLATE_UNIT_TEST_CASE() [151/463]

dart::ISOLATE_UNIT_TEST_CASE

(

HierarchyInfo_Object_Subtype

)

Definition at line 501 of file il_test.cc.

                                                     {
  HierarchyInfo hi(thread);
  const auto& type =
      Type::Handle(IsolateGroup::Current()->object_store()->object_type());
  const bool is_nullable = Instance::NullIsAssignableTo(type);
  EXPECT(hi.CanUseSubtypeRangeCheckFor(type));
  const auto& cls = Class::Handle(type.type_class());
 
  ClassTable* const class_table = thread->isolate_group()->class_table();
  const intptr_t num_cids = class_table->NumCids();
  auto& to_check = Class::Handle(thread->zone());
  auto& rare_type = AbstractType::Handle(thread->zone());
 
  GrowableArray<intptr_t> expected_concrete_cids;
  GrowableArray<intptr_t> expected_abstract_cids;
  for (intptr_t cid = kInstanceCid; cid < num_cids; cid++) {
    if (!class_table->HasValidClassAt(cid)) continue;
    if (cid == kNullCid) continue;
    if (cid == kNeverCid) continue;
    if (cid == kDynamicCid && !is_nullable) continue;
    if (cid == kVoidCid && !is_nullable) continue;
    to_check = class_table->At(cid);
    // Only add concrete classes.
    if (to_check.is_abstract()) {
      expected_abstract_cids.Add(cid);
    } else {
      expected_concrete_cids.Add(cid);
    }
    if (cid != kTypeArgumentsCid) {  // Cannot call RareType() on this.
      rare_type = to_check.RareType();
      EXPECT(rare_type.IsSubtypeOf(type, Heap::kNew));
    }
  }
 
  const CidRangeVector& concrete_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/false, /*exclude_null=*/!is_nullable);
  RANGES_CONTAIN_EXPECTED_CIDS(concrete_range, expected_concrete_cids);
 
  GrowableArray<intptr_t> expected_cids;
  expected_cids.AddArray(expected_concrete_cids);
  expected_cids.AddArray(expected_abstract_cids);
  const CidRangeVector& abstract_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/true, /*exclude_null=*/!is_nullable);
  RANGES_CONTAIN_EXPECTED_CIDS(abstract_range, expected_cids);
}

ISOLATE_UNIT_TEST_CASE() [152/463]

dart::ISOLATE_UNIT_TEST_CASE

(

HierarchyInfo_String_Subtype

)

Definition at line 627 of file il_test.cc.

                                                     {
  HierarchyInfo hi(thread);
  const auto& type = Type::Handle(Type::StringType());
  EXPECT(hi.CanUseSubtypeRangeCheckFor(type));
  const auto& cls = Class::Handle(type.type_class());
 
  GrowableArray<intptr_t> expected_concrete_cids;
  expected_concrete_cids.Add(kOneByteStringCid);
  expected_concrete_cids.Add(kTwoByteStringCid);
 
  GrowableArray<intptr_t> expected_abstract_cids;
  expected_abstract_cids.Add(type.type_class_id());
 
  const CidRangeVector& concrete_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/false, /*exclude_null=*/true);
  THR_Print("Checking concrete subtype ranges for String\n");
  RANGES_CONTAIN_EXPECTED_CIDS(concrete_range, expected_concrete_cids);
 
  GrowableArray<intptr_t> expected_cids;
  expected_cids.AddArray(expected_concrete_cids);
  expected_cids.AddArray(expected_abstract_cids);
  const CidRangeVector& abstract_range = hi.SubtypeRangesForClass(
      cls, /*include_abstract=*/true, /*exclude_null=*/true);
  THR_Print("Checking concrete and abstract subtype ranges for String\n");
  RANGES_CONTAIN_EXPECTED_CIDS(abstract_range, expected_cids);
}

ISOLATE_UNIT_TEST_CASE() [153/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ICData

)

Definition at line 3028 of file object_test.cc.

                               {
  Function& function = Function::Handle(GetDummyTarget("Bern"));
  const intptr_t id = 12;
  const intptr_t num_args_tested = 1;
  const String& target_name = String::Handle(Symbols::New(thread, "Thun"));
  const intptr_t kTypeArgsLen = 0;
  const intptr_t kNumArgs = 1;
  const Array& args_descriptor = Array::Handle(ArgumentsDescriptor::NewBoxed(
      kTypeArgsLen, kNumArgs, Object::null_array()));
  ICData& o1 = ICData::Handle();
  o1 = ICData::New(function, target_name, args_descriptor, id, num_args_tested,
                   ICData::kInstance);
  EXPECT_EQ(1, o1.NumArgsTested());
  EXPECT_EQ(id, o1.deopt_id());
  EXPECT_EQ(function.ptr(), o1.Owner());
  EXPECT_EQ(0, o1.NumberOfChecks());
  EXPECT_EQ(target_name.ptr(), o1.target_name());
  EXPECT_EQ(args_descriptor.ptr(), o1.arguments_descriptor());
 
  const Function& target1 = Function::Handle(GetDummyTarget("Thun"));
  o1.AddReceiverCheck(kSmiCid, target1);
  EXPECT_EQ(1, o1.NumberOfChecks());
  EXPECT_EQ(1, o1.NumberOfUsedChecks());
  intptr_t test_class_id = -1;
  Function& test_target = Function::Handle();
  o1.GetOneClassCheckAt(0, &test_class_id, &test_target);
  EXPECT_EQ(kSmiCid, test_class_id);
  EXPECT_EQ(target1.ptr(), test_target.ptr());
  EXPECT_EQ(kSmiCid, o1.GetCidAt(0));
  GrowableArray<intptr_t> test_class_ids;
  o1.GetCheckAt(0, &test_class_ids, &test_target);
  EXPECT_EQ(1, test_class_ids.length());
  EXPECT_EQ(kSmiCid, test_class_ids[0]);
  EXPECT_EQ(target1.ptr(), test_target.ptr());
 
  const Function& target2 = Function::Handle(GetDummyTarget("Thun"));
  o1.AddReceiverCheck(kDoubleCid, target2);
  EXPECT_EQ(2, o1.NumberOfChecks());
  EXPECT_EQ(2, o1.NumberOfUsedChecks());
  o1.GetOneClassCheckAt(1, &test_class_id, &test_target);
  EXPECT_EQ(kDoubleCid, test_class_id);
  EXPECT_EQ(target2.ptr(), test_target.ptr());
  EXPECT_EQ(kDoubleCid, o1.GetCidAt(1));
 
  o1.AddReceiverCheck(kMintCid, target2);
  EXPECT_EQ(3, o1.NumberOfUsedChecks());
  o1.SetCountAt(o1.NumberOfChecks() - 1, 0);
  EXPECT_EQ(2, o1.NumberOfUsedChecks());
 
  ICData& o2 = ICData::Handle();
  o2 = ICData::New(function, target_name, args_descriptor, 57, 2,
                   ICData::kInstance);
  EXPECT_EQ(2, o2.NumArgsTested());
  EXPECT_EQ(57, o2.deopt_id());
  EXPECT_EQ(function.ptr(), o2.Owner());
  EXPECT_EQ(0, o2.NumberOfChecks());
  GrowableArray<intptr_t> classes;
  classes.Add(kSmiCid);
  classes.Add(kSmiCid);
  o2.AddCheck(classes, target1);
  EXPECT_EQ(1, o2.NumberOfChecks());
  o2.GetCheckAt(0, &test_class_ids, &test_target);
  EXPECT_EQ(2, test_class_ids.length());
  EXPECT_EQ(kSmiCid, test_class_ids[0]);
  EXPECT_EQ(kSmiCid, test_class_ids[1]);
  EXPECT_EQ(target1.ptr(), test_target.ptr());
 
  // Check ICData for unoptimized static calls.
  const intptr_t kNumArgsChecked = 0;
  const ICData& scall_icdata = ICData::Handle(
      ICData::NewForStaticCall(function, target1, args_descriptor, 57,
                               kNumArgsChecked, ICData::kInstance));
  EXPECT_EQ(target1.ptr(), scall_icdata.GetTargetAt(0));
}

ISOLATE_UNIT_TEST_CASE() [154/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ICDataTest

)

Definition at line 465 of file thread_test.cc.

                                   {
  auto isolate_group = thread->isolate_group();
  USE(isolate_group);
  Monitor monitor;
  intptr_t exited = 0;
  std::atomic<bool> done = {false};
 
  const intptr_t kNumICData = 0x10;
 
  const Array& ic_datas = Array::Handle(Array::New(kNumICData));
  ICData& ic_data = ICData::Handle();
  Function& owner = *CreateFunction("DummyFunction");
  String& name = String::Handle(Symbols::New(thread, "foo"));
  const Array& args_desc =
      Array::Handle(ArgumentsDescriptor::NewBoxed(0, 0, Object::empty_array()));
  for (intptr_t i = 0; i < kNumICData; i++) {
    ic_data = ICData::New(owner, name, args_desc, /*deopt_id=*/0,
                          /*num_args_tested=*/1, ICData::kInstance,
                          Object::null_abstract_type());
    ic_datas.SetAtRelease(i, ic_data);
  }
 
  for (int i = 0; i < ICDataTestTask::kTaskCount; i++) {
    Dart::thread_pool()->Run<ICDataTestTask>(isolate_group, ic_datas, &monitor,
                                             &exited, &done);
  }
 
  for (int i = 0; i < 0x10000; i++) {
    for (intptr_t i = 0; i < kNumICData; i++) {
      ic_data ^= ic_datas.At(i);
      if (ic_data.NumberOfChecks() < 4) {
        ic_data.AddReceiverCheck(kInstanceCid + ic_data.NumberOfChecks(), owner,
                                 1);
      } else {
        ic_data = ICData::New(owner, name, args_desc, /*deopt_id=*/0,
                              /*num_args_tested=*/1, ICData::kInstance,
                              Object::null_abstract_type());
        ic_datas.SetAtRelease(i, ic_data);
      }
    }
  }
  // Ensure we looped long enough to allow all helpers to succeed and exit.
  {
    done.store(true, std::memory_order_release);
    MonitorLocker ml(&monitor);
    while (exited != ICDataTestTask::kTaskCount) {
      ml.Wait();
    }
    EXPECT_EQ(ICDataTestTask::kTaskCount, exited);
  }
}

ISOLATE_UNIT_TEST_CASE() [155/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_Canonicalize_EqualityCompare

)

Definition at line 434 of file il_test.cc.

                                                        {
  TestNullAwareEqualityCompareCanonicalization(thread, true);
  TestNullAwareEqualityCompareCanonicalization(thread, false);
}

ISOLATE_UNIT_TEST_CASE() [156/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_Canonicalize_FinalFieldForwarding

)

Definition at line 1483 of file il_test.cc.

                                                             {
  const char* script_chars = R"(
    import 'dart:typed_data';
 
    class TestClass {
      final dynamic finalField;
      late final dynamic lateFinalField;
      dynamic normalField;
 
      TestClass(this.finalField, this.lateFinalField, this.normalField);
    }
  )";
  const auto& lib = Library::Handle(LoadTestScript(script_chars));
 
  const auto& test_cls = Class::ZoneHandle(
      lib.LookupClass(String::Handle(Symbols::New(thread, "TestClass"))));
  const auto& err = Error::Handle(test_cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
 
  const auto lookup_field = [&](const char* name) -> const Field& {
    const auto& original_field = Field::Handle(
        test_cls.LookupField(String::Handle(Symbols::New(thread, name))));
    EXPECT(!original_field.IsNull());
    return Field::Handle(original_field.CloneFromOriginal());
  };
 
  const auto& final_field = lookup_field("finalField");
  const auto& late_final_field = lookup_field("lateFinalField");
  const auto& normal_field = lookup_field("normalField");
 
  TestStaticFieldForwarding(thread, test_cls, final_field, /*num_stores=*/0,
                            /*expected_to_forward=*/false);
  TestStaticFieldForwarding(thread, test_cls, final_field, /*num_stores=*/1,
                            /*expected_to_forward=*/true);
  TestStaticFieldForwarding(thread, test_cls, final_field, /*num_stores=*/2,
                            /*expected_to_forward=*/false);
 
  TestStaticFieldForwarding(thread, test_cls, late_final_field,
                            /*num_stores=*/0, /*expected_to_forward=*/false);
  TestStaticFieldForwarding(thread, test_cls, late_final_field,
                            /*num_stores=*/1, /*expected_to_forward=*/false);
  TestStaticFieldForwarding(thread, test_cls, late_final_field,
                            /*num_stores=*/2, /*expected_to_forward=*/false);
 
  TestStaticFieldForwarding(thread, test_cls, normal_field, /*num_stores=*/0,
                            /*expected_to_forward=*/false);
  TestStaticFieldForwarding(thread, test_cls, normal_field, /*num_stores=*/1,
                            /*expected_to_forward=*/false);
  TestStaticFieldForwarding(thread, test_cls, normal_field, /*num_stores=*/2,
                            /*expected_to_forward=*/false);
}

ISOLATE_UNIT_TEST_CASE() [157/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_Canonicalize_InstanceCallWithNoICDataInAOT

)

Definition at line 1338 of file il_test.cc.

                                                                      {
  const auto& typed_data_lib = Library::Handle(Library::TypedDataLibrary());
  const auto& view_cls = Class::Handle(typed_data_lib.LookupClassAllowPrivate(
      String::Handle(Symbols::New(thread, "_TypedListBase"))));
  const Error& err = Error::Handle(view_cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
  const auto& getter = Function::Handle(
      view_cls.LookupFunctionAllowPrivate(Symbols::GetLength()));
  EXPECT(!getter.IsNull());
 
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/true, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
 
  InstanceCallInstr* length_call;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    // array <- AllocateTypedData(1)
    const auto array = builder.AddDefinition(new AllocateTypedDataInstr(
        InstructionSource(), kTypedDataFloat64ArrayCid,
        new Value(H.IntConstant(1)), DeoptId::kNone));
    // length_call <- InstanceCall('get:length', array, ICData[])
    length_call = builder.AddDefinition(new InstanceCallInstr(
        InstructionSource(), Symbols::GetLength(), Token::kGET,
        /*args=*/{new Value(array)}, 0, Array::empty_array(), 1,
        /*deopt_id=*/42));
    length_call->EnsureICData(H.flow_graph());
    // Return(load)
    ret = builder.AddReturn(new Value(length_call));
  }
  H.FinishGraph();
  H.flow_graph()->Canonicalize();
 
  EXPECT_PROPERTY(length_call, it.previous() == nullptr);
  EXPECT_PROPERTY(ret->value()->definition(), it.IsStaticCall());
  EXPECT_PROPERTY(ret->value()->definition()->AsStaticCall(),
                  it.function().ptr() == getter.ptr());
}

ISOLATE_UNIT_TEST_CASE() [158/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_Canonicalize_RepresentationChange

)

Definition at line 1244 of file il_test.cc.

                                                             {
  TestRepresentationChangeDuringCanonicalization(thread, true);
  TestRepresentationChangeDuringCanonicalization(thread, false);
}

ISOLATE_UNIT_TEST_CASE() [159/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_Canonicalize_TestRange

)

Definition at line 1410 of file il_test.cc.

                                                  {
  HierarchyInfo hierarchy_info(thread);
  TestTestRangeCanonicalize(AbstractType::ZoneHandle(Type::IntType()),
                            kOneByteStringCid, kTwoByteStringCid, false);
  TestTestRangeCanonicalize(AbstractType::ZoneHandle(Type::IntType()), kSmiCid,
                            kMintCid, true);
  TestTestRangeCanonicalize(AbstractType::ZoneHandle(Type::NullType()), kSmiCid,
                            kMintCid, false);
  TestTestRangeCanonicalize(AbstractType::ZoneHandle(Type::Double()), kSmiCid,
                            kMintCid, false);
  TestTestRangeCanonicalize(AbstractType::ZoneHandle(Type::ObjectType()), 1,
                            kClassIdTagMax, true);
}

ISOLATE_UNIT_TEST_CASE() [160/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_Canonicalize_TypedDataViewFactory

)

Definition at line 1328 of file il_test.cc.

                                                             {
  TestCanonicalizationOfTypedDataViewFieldLoads(thread, TypedDataBase_length);
  TestCanonicalizationOfTypedDataViewFieldLoads(thread,
                                                TypedDataView_offset_in_bytes);
  TestCanonicalizationOfTypedDataViewFieldLoads(thread,
                                                TypedDataView_typed_data);
}

ISOLATE_UNIT_TEST_CASE() [161/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_IntConverterCanonicalization

)

Definition at line 234 of file il_test.cc.

                                                        {
  EXPECT(TestIntConverterCanonicalizationRule(thread, kMinInt16, kMaxInt16,
                                              kUnboxedInt64, kUnboxedInt32,
                                              kUnboxedInt64));
  EXPECT(TestIntConverterCanonicalizationRule(thread, kMinInt32, kMaxInt32,
                                              kUnboxedInt64, kUnboxedInt32,
                                              kUnboxedInt64));
  EXPECT(!TestIntConverterCanonicalizationRule(
      thread, kMinInt32, static_cast<int64_t>(kMaxInt32) + 1, kUnboxedInt64,
      kUnboxedInt32, kUnboxedInt64));
  EXPECT(TestIntConverterCanonicalizationRule(
      thread, 0, kMaxInt16, kUnboxedInt64, kUnboxedUint32, kUnboxedInt64));
  EXPECT(TestIntConverterCanonicalizationRule(
      thread, 0, kMaxInt32, kUnboxedInt64, kUnboxedUint32, kUnboxedInt64));
  EXPECT(TestIntConverterCanonicalizationRule(
      thread, 0, kMaxUint32, kUnboxedInt64, kUnboxedUint32, kUnboxedInt64));
  EXPECT(!TestIntConverterCanonicalizationRule(
      thread, 0, static_cast<int64_t>(kMaxUint32) + 1, kUnboxedInt64,
      kUnboxedUint32, kUnboxedInt64));
  EXPECT(!TestIntConverterCanonicalizationRule(
      thread, -1, kMaxInt16, kUnboxedInt64, kUnboxedUint32, kUnboxedInt64));
 
  // Regression test for https://dartbug.com/53613.
  EXPECT(!TestIntConverterCanonicalizationRule(thread, kMinInt32, kMaxInt32,
                                               kUnboxedInt32, kUnboxedUint32,
                                               kUnboxedInt64));
  EXPECT(!TestIntConverterCanonicalizationRule(thread, kMinInt32, kMaxInt32,
                                               kUnboxedInt32, kUnboxedUint32,
                                               kUnboxedInt32));
  EXPECT(TestIntConverterCanonicalizationRule(
      thread, 0, kMaxInt32, kUnboxedInt32, kUnboxedUint32, kUnboxedInt64));
  EXPECT(TestIntConverterCanonicalizationRule(
      thread, 0, kMaxInt32, kUnboxedInt32, kUnboxedUint32, kUnboxedInt32));
}

ISOLATE_UNIT_TEST_CASE() [162/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_PhiCanonicalization

)

Definition at line 269 of file il_test.cc.

                                               {
  using compiler::BlockBuilder;
 
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
 
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::DynamicType()));
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
  auto b2 = H.JoinEntry();
  auto b3 = H.TargetEntry();
  auto b4 = H.TargetEntry();
 
  Definition* v0;
  DartReturnInstr* ret;
  PhiInstr* phi;
 
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    v0 = builder.AddParameter(0, kTagged);
    builder.AddInstruction(new GotoInstr(b2, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b2);
    phi = new PhiInstr(b2, 2);
    phi->SetInputAt(0, new Value(v0));
    phi->SetInputAt(1, new Value(phi));
    builder.AddPhi(phi);
    builder.AddBranch(new StrictCompareInstr(
                          InstructionSource(), Token::kEQ_STRICT,
                          new Value(H.IntConstant(1)), new Value(phi),
                          /*needs_number_check=*/false, S.GetNextDeoptId()),
                      b3, b4);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b3);
    builder.AddInstruction(new GotoInstr(b2, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b4);
    ret = builder.AddReturn(new Value(phi));
  }
 
  H.FinishGraph();
 
  H.flow_graph()->Canonicalize();
 
  EXPECT(ret->value()->definition() == v0);
}

ISOLATE_UNIT_TEST_CASE() [163/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IL_UnboxIntegerCanonicalization

)

Definition at line 323 of file il_test.cc.

                                                        {
  using compiler::BlockBuilder;
 
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
 
  FlowGraphBuilderHelper H(/*num_parameters=*/2);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::DynamicType()));
  H.AddVariable("v1", AbstractType::ZoneHandle(Type::DynamicType()));
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
  Definition* unbox;
 
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    Definition* index = H.IntConstant(0);
    Definition* int_type =
        H.flow_graph()->GetConstant(Type::Handle(Type::IntType()));
 
    Definition* float64_array = builder.AddParameter(0, kTagged);
    Definition* int64_array = builder.AddParameter(1, kTagged);
 
    Definition* load_indexed = builder.AddDefinition(new LoadIndexedInstr(
        new Value(float64_array), new Value(index),
        /* index_unboxed */ false,
        /* index_scale */ 8, kTypedDataFloat64ArrayCid, kAlignedAccess,
        S.GetNextDeoptId(), InstructionSource()));
    Definition* box = builder.AddDefinition(
        BoxInstr::Create(kUnboxedDouble, new Value(load_indexed)));
    Definition* cast = builder.AddDefinition(new AssertAssignableInstr(
        InstructionSource(), new Value(box), new Value(int_type),
        /* instantiator_type_arguments */
        new Value(H.flow_graph()->constant_null()),
        /* function_type_arguments */
        new Value(H.flow_graph()->constant_null()),
        /* dst_name */ String::Handle(String::New("not-null")),
        S.GetNextDeoptId()));
    unbox = builder.AddDefinition(new UnboxInt64Instr(
        new Value(cast), S.GetNextDeoptId(), BoxInstr::kGuardInputs));
 
    builder.AddInstruction(new StoreIndexedInstr(
        new Value(int64_array), new Value(index), new Value(unbox),
        kNoStoreBarrier,
        /* index_unboxed */ false,
        /* index_scale */ 8, kTypedDataInt64ArrayCid, kAlignedAccess,
        S.GetNextDeoptId(), InstructionSource()));
    builder.AddReturn(new Value(index));
  }
 
  H.FinishGraph();
 
  FlowGraphTypePropagator::Propagate(H.flow_graph());
  EXPECT(!unbox->ComputeCanDeoptimize());
 
  H.flow_graph()->Canonicalize();
  EXPECT(!unbox->ComputeCanDeoptimize());
 
  H.flow_graph()->RemoveRedefinitions();
  EXPECT(!unbox->ComputeCanDeoptimize());  // Previously this reverted to true.
}

ISOLATE_UNIT_TEST_CASE() [164/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Inliner_InlineForceOptimized

)

Definition at line 375 of file inliner_test.cc.

                                                     {
  const char* kScript = R"(
    import 'dart:ffi';
 
    @pragma('vm:never-inline')
    int foo(int x) {
      dynamic ptr = Pointer.fromAddress(x);
      return x + ptr.hashCode;
    }
    main() {
      int r = 0;
      for (int i = 0; i < 1000; i++) {
        r += foo(r);
      }
      return r;
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
 
  Invoke(root_library, "main");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
      CompilerPass::kApplyICData,
      CompilerPass::kTryOptimizePatterns,
      CompilerPass::kSetOuterInliningId,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyClassIds,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  StaticCallInstr* call_instr = nullptr;
  {
    ILMatcher cursor(flow_graph, entry);
    RELEASE_ASSERT(cursor.TryMatch({
        {kMoveGlob},
        {kMatchAndMoveStaticCall, &call_instr},
    }));
    EXPECT(strcmp(call_instr->function().UserVisibleNameCString(),
                  "Pointer.fromAddress") == 0);
  }
 
  pipeline.RunAdditionalPasses({
      CompilerPass::kInlining,
  });
 
  AllocateObjectInstr* allocate_object_instr = nullptr;
  {
    ILMatcher cursor(flow_graph, entry);
    RELEASE_ASSERT(cursor.TryMatch({
        {kMoveGlob},
        {kMatchAndMoveAllocateObject, &allocate_object_instr},
    }));
  }
 
  // Ensure that AllocateObject instruction that came from force-optimized
  // function has deopt and environment taken from the Call instruction.
  EXPECT(call_instr->deopt_id() == allocate_object_instr->deopt_id());
  EXPECT(DeoptId::IsDeoptBefore(call_instr->deopt_id()));
 
  auto allocate_object_instr_env = allocate_object_instr->env();
  EXPECT(allocate_object_instr_env->LazyDeoptToBeforeDeoptId());
  EXPECT(allocate_object_instr_env->Outermost()->GetDeoptId() ==
         call_instr->deopt_id());
  const auto call_instr_env = call_instr->env();
  const intptr_t call_first_index =
      call_instr_env->Length() - call_instr->InputCount();
  const intptr_t allocate_first_index =
      allocate_object_instr_env->Length() - call_instr->InputCount();
  for (intptr_t i = 0; i < call_instr->InputCount(); i++) {
    EXPECT(call_instr_env->ValueAt(call_first_index + i)->definition() ==
           allocate_object_instr_env->ValueAt(allocate_first_index + i)
               ->definition());
  }
}

ISOLATE_UNIT_TEST_CASE() [165/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Inliner_PolyInliningRedefinition

)

Definition at line 19 of file inliner_test.cc.

                                                         {
  const char* kScript = R"(
    abstract class A {
      String toInline() { return "A"; }
    }
 
    class B extends A {}
    class C extends A {
      @override
      String toInline() { return "C";}
    }
    class D extends A {}
 
    testInlining(A arg) {
      arg.toInline();
    }
 
    main() {
      for (var i = 0; i < 10; i++) {
        testInlining(B());
        testInlining(C());
        testInlining(D());
      }
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function =
      Function::Handle(GetFunction(root_library, "testInlining"));
 
  Invoke(root_library, "main");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
      CompilerPass::kApplyICData,
      CompilerPass::kTryOptimizePatterns,
      CompilerPass::kSetOuterInliningId,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyClassIds,
      CompilerPass::kInlining,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  EXPECT(entry->initial_definitions()->length() == 1);
  EXPECT(entry->initial_definitions()->At(0)->IsParameter());
  ParameterInstr* param = entry->initial_definitions()->At(0)->AsParameter();
 
  // First we find the start of the prelude for the inlined instruction,
  // and also keep a reference to the LoadClassId instruction for later.
  LoadClassIdInstr* lcid = nullptr;
  BranchInstr* prelude = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch(
      {
          {kMatchLoadClassId, &lcid},
          {kMatchBranch, &prelude},
      },
      /*insert_before=*/kMoveGlob));
 
  const Class& cls = Class::Handle(
      root_library.LookupClass(String::Handle(Symbols::New(thread, "B"))));
 
  Definition* cid_B = flow_graph->GetConstant(Smi::Handle(Smi::New(cls.id())));
  Instruction* current = prelude;
 
  // We walk false branches until we either reach a branch instruction that uses
  // B's cid for comparison to the value returned from the LCID instruction
  // above, or a default case if there was no branch instruction for B's cid.
  while (true) {
    EXPECT(current->IsBranch());
    const ComparisonInstr* check = current->AsBranch()->comparison();
    EXPECT(check->left()->definition() == lcid);
    if (check->right()->definition() == cid_B) break;
    current = current->SuccessorAt(1);
    // By following false paths, we should be walking a series of blocks that
    // looks like:
    // B#[target]:#
    //   Branch if <check on class ID>
    // If we end up not finding a branch, then we're in a default case
    // that contains a class check.
    current = current->next();
    if (!current->IsBranch()) {
      break;
    }
  }
  // If we found a branch that checks against the class ID, we follow the true
  // branch to a block that contains only a goto to the desired join block.
  if (current->IsBranch()) {
    current = current->SuccessorAt(0);
  } else {
    // We're in the default case, which will check the class ID to make sure
    // it's the one expected for the fallthrough. That check will be followed
    // by a goto to the desired join block.
    EXPECT(current->IsRedefinition());
    const auto redef = current->AsRedefinition();
    EXPECT(redef->value()->definition() == lcid);
    current = current->next();
    EXPECT(current->IsCheckClassId());
    EXPECT(current->AsCheckClassId()->value()->definition() == redef);
  }
  current = current->next();
  EXPECT(current->IsGoto());
  current = current->AsGoto()->successor();
  // Now we should be at a block that starts like:
  // BY[join]:# pred(...)
  //    vW <- Redefinition(vV)
  //
  // where vV is a reference to the function parameter (the receiver of
  // the inlined function).
  current = current->next();
  EXPECT(current->IsRedefinition());
  EXPECT(current->AsRedefinition()->value()->definition() == param);
  EXPECT(current->AsRedefinition()->Type()->ToCid() == kDynamicCid);
}

ISOLATE_UNIT_TEST_CASE() [166/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Inliner_TypedData_Regress7551

)

Definition at line 138 of file inliner_test.cc.

                                                      {
  const char* kScript = R"(
    import 'dart:typed_data';
 
    setValue(Int32List list, int value) {
      list[0] = value;
    }
 
    main() {
      final list = Int32List(10);
      setValue(list, 0x1122334455);
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function =
      Function::Handle(GetFunction(root_library, "setValue"));
 
  Invoke(root_library, "main");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
      CompilerPass::kApplyICData,
      CompilerPass::kTryOptimizePatterns,
      CompilerPass::kSetOuterInliningId,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyClassIds,
      CompilerPass::kInlining,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
 
  EXPECT(entry->initial_definitions()->length() == 2);
  EXPECT(entry->initial_definitions()->At(0)->IsParameter());
  EXPECT(entry->initial_definitions()->At(1)->IsParameter());
  ParameterInstr* list_param =
      entry->initial_definitions()->At(0)->AsParameter();
  ParameterInstr* value_param =
      entry->initial_definitions()->At(1)->AsParameter();
 
  ILMatcher cursor(flow_graph, entry);
 
  CheckArrayBoundInstr* bounds_check_instr = nullptr;
  UnboxInt32Instr* unbox_instr = nullptr;
  StoreIndexedInstr* store_instr = nullptr;
 
  RELEASE_ASSERT(cursor.TryMatch({
      {kMoveGlob},
      {kMatchAndMoveCheckArrayBound, &bounds_check_instr},
      {kMatchAndMoveUnboxInt32, &unbox_instr},
      {kMatchAndMoveStoreIndexed, &store_instr},
  }));
 
  RELEASE_ASSERT(unbox_instr->InputAt(0)->definition()->OriginalDefinition() ==
                 value_param);
  RELEASE_ASSERT(store_instr->InputAt(0)->definition() == list_param);
  RELEASE_ASSERT(store_instr->InputAt(2)->definition() == unbox_instr);
  RELEASE_ASSERT(unbox_instr->is_truncating());
}

ISOLATE_UNIT_TEST_CASE() [167/463]

dart::ISOLATE_UNIT_TEST_CASE

(

InstanceClass

)

Definition at line 315 of file object_test.cc.

                                      {
  // Allocate the class first.
  String& class_name = String::Handle(Symbols::New(thread, "EmptyClass"));
  Script& script = Script::Handle();
  const Class& empty_class =
      Class::Handle(CreateDummyClass(class_name, script));
 
  // EmptyClass has no fields and no functions.
  EXPECT_EQ(Array::Handle(empty_class.fields()).Length(), 0);
  EXPECT_EQ(Array::Handle(empty_class.current_functions()).Length(), 0);
 
  ClassFinalizer::FinalizeTypesInClass(empty_class);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    empty_class.Finalize();
  }
 
  EXPECT_EQ(kObjectAlignment, empty_class.host_instance_size());
  Instance& instance = Instance::Handle(Instance::New(empty_class));
  EXPECT_EQ(empty_class.ptr(), instance.clazz());
 
  class_name = Symbols::New(thread, "OneFieldClass");
  const Class& one_field_class =
      Class::Handle(CreateDummyClass(class_name, script));
 
  // No fields, functions, or super type for the OneFieldClass.
  EXPECT_EQ(Array::Handle(empty_class.fields()).Length(), 0);
  EXPECT_EQ(Array::Handle(empty_class.current_functions()).Length(), 0);
  EXPECT_EQ(empty_class.super_type(), AbstractType::null());
  ClassFinalizer::FinalizeTypesInClass(one_field_class);
 
  const Array& one_fields = Array::Handle(Array::New(1));
  const String& field_name = String::Handle(Symbols::New(thread, "the_field"));
  const Field& field = Field::Handle(
      Field::New(field_name, false, false, false, true, false, one_field_class,
                 Object::dynamic_type(), TokenPosition::kMinSource,
                 TokenPosition::kMinSource));
  one_fields.SetAt(0, field);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    one_field_class.SetFields(one_fields);
    one_field_class.Finalize();
  }
  intptr_t header_size = sizeof(UntaggedObject);
  EXPECT_EQ(Utils::RoundUp((header_size + (1 * kWordSize)), kObjectAlignment),
            one_field_class.host_instance_size());
  EXPECT_EQ(header_size, field.HostOffset());
  EXPECT(!one_field_class.is_implemented());
  one_field_class.set_is_implemented_unsafe();
  EXPECT(one_field_class.is_implemented());
}

ISOLATE_UNIT_TEST_CASE() [168/463]

dart::ISOLATE_UNIT_TEST_CASE

(

InstructionTests

)

Definition at line 21 of file il_test.cc.

                                         {
  TargetEntryInstr* target_instr =
      new TargetEntryInstr(1, kInvalidTryIndex, DeoptId::kNone);
  EXPECT(target_instr->IsBlockEntry());
  EXPECT(!target_instr->IsDefinition());
}

ISOLATE_UNIT_TEST_CASE() [169/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Integer

)

Definition at line 660 of file object_test.cc.

                                {
  Integer& i = Integer::Handle();
  i = Integer::NewCanonical(String::Handle(String::New("12")));
  EXPECT(i.IsSmi());
  i = Integer::NewCanonical(String::Handle(String::New("-120")));
  EXPECT(i.IsSmi());
  i = Integer::NewCanonical(String::Handle(String::New("0")));
  EXPECT(i.IsSmi());
  i = Integer::NewCanonical(
      String::Handle(String::New("12345678901234567890")));
  EXPECT(i.IsNull());
  i = Integer::NewCanonical(
      String::Handle(String::New("-12345678901234567890111222")));
  EXPECT(i.IsNull());
}

ISOLATE_UNIT_TEST_CASE() [170/463]

dart::ISOLATE_UNIT_TEST_CASE

(

InternalTypedData

)

Definition at line 2237 of file object_test.cc.

                                          {
  uint8_t data[] = {253, 254, 255, 0, 1, 2, 3, 4};
  intptr_t data_length = ARRAY_SIZE(data);
 
  const TypedData& int8_array =
      TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, data_length));
  EXPECT(!int8_array.IsNull());
  EXPECT_EQ(data_length, int8_array.Length());
  for (intptr_t i = 0; i < data_length; ++i) {
    int8_array.SetInt8(i, data[i]);
  }
 
  EXPECT_EQ(-3, int8_array.GetInt8(0));
  EXPECT_EQ(253, int8_array.GetUint8(0));
 
  EXPECT_EQ(-2, int8_array.GetInt8(1));
  EXPECT_EQ(254, int8_array.GetUint8(1));
 
  EXPECT_EQ(-1, int8_array.GetInt8(2));
  EXPECT_EQ(255, int8_array.GetUint8(2));
 
  EXPECT_EQ(0, int8_array.GetInt8(3));
  EXPECT_EQ(0, int8_array.GetUint8(3));
 
  EXPECT_EQ(1, int8_array.GetInt8(4));
  EXPECT_EQ(1, int8_array.GetUint8(4));
 
  EXPECT_EQ(2, int8_array.GetInt8(5));
  EXPECT_EQ(2, int8_array.GetUint8(5));
 
  EXPECT_EQ(3, int8_array.GetInt8(6));
  EXPECT_EQ(3, int8_array.GetUint8(6));
 
  EXPECT_EQ(4, int8_array.GetInt8(7));
  EXPECT_EQ(4, int8_array.GetUint8(7));
 
  const TypedData& int8_array2 =
      TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, data_length));
  EXPECT(!int8_array.IsNull());
  EXPECT_EQ(data_length, int8_array.Length());
  for (intptr_t i = 0; i < data_length; ++i) {
    int8_array2.SetInt8(i, data[i]);
  }
 
  for (intptr_t i = 0; i < data_length; ++i) {
    EXPECT_EQ(int8_array.GetInt8(i), int8_array2.GetInt8(i));
  }
  for (intptr_t i = 0; i < data_length; ++i) {
    int8_array.SetInt8(i, 123 + i);
  }
  for (intptr_t i = 0; i < data_length; ++i) {
    EXPECT(int8_array.GetInt8(i) != int8_array2.GetInt8(i));
  }
}

ISOLATE_UNIT_TEST_CASE() [171/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_CachableIdempotentCall

)

Definition at line 764 of file il_test.cc.

                                                      {
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
    int globalCounter = 0;
 
    int increment() => ++globalCounter;
 
    int cachedIncrement() {
      // We will replace this call with a cacheable call,
      // which will lead to the counter no longer being incremented.
      // Make sure to return the value, so we can see that the boxing and
      // unboxing works as expected.
      return increment();
    }
 
    int multipleIncrement() {
      int returnValue = 0;
      for(int i = 0; i < 10; i++) {
        // Save the last returned value.
        returnValue = cachedIncrement();
      }
      return returnValue;
    }
  )"), std::free);
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
  const auto& first_result =
      Object::Handle(Invoke(root_library, "multipleIncrement"));
  EXPECT(first_result.IsSmi());
  if (first_result.IsSmi()) {
    const intptr_t int_value = Smi::Cast(first_result).Value();
    EXPECT_EQ(10, int_value);
  }
 
  const auto& cached_increment_function =
      Function::Handle(GetFunction(root_library, "cachedIncrement"));
 
  const auto& increment_function =
      Function::ZoneHandle(GetFunction(root_library, "increment"));
 
  TestPipeline pipeline(cached_increment_function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  StaticCallInstr* static_call = nullptr;
  {
    ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
 
    EXPECT(cursor.TryMatch({
        kMoveGlob,
        {kMatchAndMoveStaticCall, &static_call},
        kMoveGlob,
        kMatchDartReturn,
    }));
  }
 
  InputsArray args;
  CachableIdempotentCallInstr* call = new CachableIdempotentCallInstr(
      InstructionSource(), kUnboxedAddress, increment_function,
      static_call->type_args_len(), Array::empty_array(), std::move(args),
      DeoptId::kNone);
  static_call->ReplaceWith(call, nullptr);
 
  pipeline.RunForcedOptimizedAfterSSAPasses();
 
  {
    ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
 
    EXPECT(cursor.TryMatch({
        kMoveGlob,
        kMatchAndMoveCachableIdempotentCall,
        kMoveGlob,
        // The cacheable call returns unboxed, so select representations
        // adds boxing.
        kMatchBox,
        kMoveGlob,
        kMatchDartReturn,
    }));
  }
 
  {
#if !defined(PRODUCT)
    SetFlagScope<bool> sfs(&FLAG_disassemble_optimized, true);
#endif
    pipeline.CompileGraphAndAttachFunction();
  }
 
  const auto& second_result =
      Object::Handle(Invoke(root_library, "multipleIncrement"));
  EXPECT(second_result.IsSmi());
  if (second_result.IsSmi()) {
    const intptr_t int_value = Smi::Cast(second_result).Value();
    EXPECT_EQ(11, int_value);
  }
}

ISOLATE_UNIT_TEST_CASE() [172/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_DoubleEqualsSmi

)

Definition at line 657 of file il_test.cc.

                                               {
  const char* kScript = R"(
    bool foo(double x) => (x + 0.5) == 0;
    main() {
      foo(-0.5);
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
 
  TestPipeline pipeline(function, CompilerPass::kAOT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                   ParallelMovesHandling::kSkip);
 
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      kMatchAndMoveBinaryDoubleOp,
      kMatchAndMoveEqualityCompare,
      kMatchDartReturn,
  }));
}

ISOLATE_UNIT_TEST_CASE() [173/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_EliminateWriteBarrier

)

Definition at line 49 of file il_test.cc.

                                                     {
  const char* nullable_tag = TestCase::NullableTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
      class Container<T> {
        operator []=(var index, var value) {
          return data[index] = value;
        }
 
        List<T%s> data = List<T%s>.filled(10, null);
      }
 
      Container<int> x = Container<int>();
 
      foo() {
        for (int i = 0; i < 10; ++i) {
          x[i] = i;
        }
      }
    )", nullable_tag, nullable_tag), std::free);
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
 
  Invoke(root_library, "foo");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  StoreIndexedInstr* store_indexed = nullptr;
 
  ILMatcher cursor(flow_graph, entry, true);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      kMatchAndMoveBranchTrue,
      kMoveGlob,
      {kMatchStoreIndexed, &store_indexed},
  }));
 
  EXPECT(!store_indexed->value()->NeedsWriteBarrier());
}

ISOLATE_UNIT_TEST_CASE() [174/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_FfiCallInstrLeafDoesntSpill

)

Definition at line 936 of file il_test.cc.

                                                           {
  const char* kScript = R"(
    import 'dart:ffi';
 
    // This is purely a placeholder and is never called.
    void placeholder() {}
 
    // Will call the "doFfiCall" and exercise its code.
    bool invokeDoFfiCall() {
      final double result = doFfiCall(1, 2, 3, 1.0, 2.0, 3.0);
      if (result != (2 + 3 + 4 + 2.0 + 3.0 + 4.0)) {
        throw 'Failed. Result was $result.';
      }
      return true;
    }
 
    // Will perform a "C" call while having live values in registers
    // across the FfiCall.
    double doFfiCall(int a, int b, int c, double x, double y, double z) {
      // Ensure there is at least one live value in a register.
      a += 1;
      b += 1;
      c += 1;
      x += 1.0;
      y += 1.0;
      z += 1.0;
      // We'll replace this StaticCall with an FfiCall.
      placeholder();
      // Use the live value.
      return (a + b + c + x + y + z);
    }
 
    // FFI trampoline function.
    typedef NT = Void Function();
    typedef DT = void Function();
    Pointer<NativeFunction<NT>> ptr = Pointer.fromAddress(0);
    DT getFfiTrampolineClosure() => ptr.asFunction(isLeaf:true);
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
 
  // Build a "C" function that we can actually invoke.
  auto& c_function = Instructions::Handle(
      BuildInstructions([](compiler::Assembler* assembler) {
        // Clobber all volatile registers to make sure caller doesn't rely on
        // any non-callee-save register.
        for (intptr_t reg = 0; reg < kNumberOfFpuRegisters; reg++) {
          if ((kAbiVolatileFpuRegs & (1 << reg)) != 0) {
#if defined(TARGET_ARCH_ARM)
            // On ARM we need an extra scratch register for LoadDImmediate.
            assembler->LoadDImmediate(static_cast<DRegister>(reg), 0.0, R3);
#else
            assembler->LoadDImmediate(static_cast<FpuRegister>(reg), 0.0);
#endif
          }
        }
        for (intptr_t reg = 0; reg < kNumberOfCpuRegisters; reg++) {
          if ((kDartVolatileCpuRegs & (1 << reg)) != 0) {
            assembler->LoadImmediate(static_cast<Register>(reg), 0xDEADBEEF);
          }
        }
        assembler->Ret();
      }));
  uword native_entry = c_function.EntryPoint();
 
  // Get initial compilation done.
  Invoke(root_library, "invokeDoFfiCall");
 
  const Function& do_ffi_call =
      Function::Handle(GetFunction(root_library, "doFfiCall"));
  RELEASE_ASSERT(!do_ffi_call.IsNull());
 
  const auto& value = Closure::Handle(
      Closure::RawCast(Invoke(root_library, "getFfiTrampolineClosure")));
  RELEASE_ASSERT(value.IsClosure());
  const auto& ffi_trampoline =
      Function::ZoneHandle(Closure::Cast(value).function());
  RELEASE_ASSERT(!ffi_trampoline.IsNull());
 
  // Construct the FFICallInstr from the trampoline matching our native
  // function.
  const char* error = nullptr;
  auto* const zone = thread->zone();
  const auto& c_signature =
      FunctionType::ZoneHandle(zone, ffi_trampoline.FfiCSignature());
  const auto marshaller_ptr = compiler::ffi::CallMarshaller::FromFunction(
      zone, ffi_trampoline, /*function_params_start_at=*/1, c_signature,
      &error);
  RELEASE_ASSERT(error == nullptr);
  RELEASE_ASSERT(marshaller_ptr != nullptr);
  const auto& marshaller = *marshaller_ptr;
 
  const auto& compile_and_run =
      [&](bool is_leaf, std::function<void(ParallelMoveInstr*)> verify) {
        // Build the SSA graph for "doFfiCall"
        TestPipeline pipeline(do_ffi_call, CompilerPass::kJIT);
        FlowGraph* flow_graph =
            SetupFfiFlowgraph(&pipeline, marshaller, native_entry, is_leaf);
 
        {
          ParallelMoveInstr* parallel_move = nullptr;
          ILMatcher cursor(flow_graph,
                           flow_graph->graph_entry()->normal_entry(),
                           /*trace=*/false);
          while (cursor.TryMatch(
              {kMoveGlob, {kMatchAndMoveParallelMove, &parallel_move}})) {
            verify(parallel_move);
          }
        }
 
        // Finish the compilation and attach code so we can run it.
        pipeline.CompileGraphAndAttachFunction();
 
        // Ensure we can successfully invoke the FFI call.
        auto& result = Object::Handle(Invoke(root_library, "invokeDoFfiCall"));
        RELEASE_ASSERT(result.IsBool());
        EXPECT(Bool::Cast(result).value());
      };
 
  intptr_t num_cpu_reg_to_stack_nonleaf = 0;
  intptr_t num_cpu_reg_to_stack_leaf = 0;
  intptr_t num_fpu_reg_to_stack_nonleaf = 0;
  intptr_t num_fpu_reg_to_stack_leaf = 0;
 
  // Test non-leaf spills live values.
  compile_and_run(/*is_leaf=*/false, [&](ParallelMoveInstr* parallel_move) {
    // TargetAddress is passed in register, live values are all spilled.
    for (int i = 0; i < parallel_move->NumMoves(); i++) {
      auto move = parallel_move->moves()[i];
      if (move->src_slot()->IsRegister() && move->dest_slot()->IsStackSlot()) {
        num_cpu_reg_to_stack_nonleaf++;
      } else if (move->src_slot()->IsFpuRegister() &&
                 move->dest_slot()->IsDoubleStackSlot()) {
        num_fpu_reg_to_stack_nonleaf++;
      }
    }
  });
 
  // Test leaf calls do not cause spills of live values.
  compile_and_run(/*is_leaf=*/true, [&](ParallelMoveInstr* parallel_move) {
    // TargetAddress is passed in registers, live values are not spilled and
    // remains in callee-save registers.
    for (int i = 0; i < parallel_move->NumMoves(); i++) {
      auto move = parallel_move->moves()[i];
      if (move->src_slot()->IsRegister() && move->dest_slot()->IsStackSlot()) {
        num_cpu_reg_to_stack_leaf++;
      } else if (move->src_slot()->IsFpuRegister() &&
                 move->dest_slot()->IsDoubleStackSlot()) {
        num_fpu_reg_to_stack_leaf++;
      }
    }
  });
 
  // We should have less moves to the stack (i.e. spilling) in leaf calls.
  EXPECT_LT(num_cpu_reg_to_stack_leaf, num_cpu_reg_to_stack_nonleaf);
  // We don't have volatile FPU registers on all platforms.
  const bool has_callee_save_fpu_regs =
      Utils::CountOneBitsWord(kAbiVolatileFpuRegs) <
      Utils::CountOneBitsWord(kAllFpuRegistersList);
  EXPECT(!has_callee_save_fpu_regs ||
         num_fpu_reg_to_stack_leaf < num_fpu_reg_to_stack_nonleaf);
}

ISOLATE_UNIT_TEST_CASE() [175/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_InitializingStores

)

Definition at line 134 of file il_test.cc.

                                                  {
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
    class Bar {
      var f;
      var g;
 
      Bar({this.f, this.g});
    }
    Bar f1() => Bar(f: 10);
    Bar f2() => Bar(g: 10);
    f3() {
      return () { };
    }
    f4<T>({T%s value}) {
      return () { return value; };
    }
    main() {
      f1();
      f2();
      f3();
      f4();
    }
  )",
  TestCase::NullableTag()), std::free);
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
  Invoke(root_library, "main");
 
  RunInitializingStoresTest(root_library, "f1", CompilerPass::kJIT,
                            /*expected_stores=*/{"f"});
  RunInitializingStoresTest(root_library, "f2", CompilerPass::kJIT,
                            /*expected_stores=*/{"g"});
  RunInitializingStoresTest(root_library, "f3", CompilerPass::kJIT,
                            /*expected_stores=*/
                            {"Closure.function", "Closure.entry_point"});
 
  // Note that in JIT mode we lower context allocation in a way that hinders
  // removal of initializing moves so there would be some redundant stores of
  // null left in the graph. In AOT mode we don't apply this optimization
  // which enables us to remove more stores.
  std::vector<const char*> expected_stores_jit;
  std::vector<const char*> expected_stores_aot;
 
  expected_stores_jit.insert(
      expected_stores_jit.end(),
      {"value", "Context.parent", "Context.parent", "value",
       "Closure.function_type_arguments", "Closure.context"});
  expected_stores_aot.insert(
      expected_stores_aot.end(),
      {"value", "Closure.function_type_arguments", "Closure.context"});
 
  RunInitializingStoresTest(root_library, "f4", CompilerPass::kJIT,
                            expected_stores_jit);
  RunInitializingStoresTest(root_library, "f4", CompilerPass::kAOT,
                            expected_stores_aot);
}

ISOLATE_UNIT_TEST_CASE() [176/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_LoadThread

)

Definition at line 683 of file il_test.cc.

                                          {
  // clang-format off
  auto kScript = R"(
    import 'dart:ffi';
 
    int myFunction() {
      return 100;
    }
 
    void anotherFunction() {}
  )";
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Zone* const zone = Thread::Current()->zone();
  auto& invoke_result = Instance::Handle(zone);
  invoke_result ^= Invoke(root_library, "myFunction");
  EXPECT_EQ(Smi::New(100), invoke_result.ptr());
 
  const auto& my_function =
      Function::Handle(GetFunction(root_library, "myFunction"));
 
  TestPipeline pipeline(my_function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  DartReturnInstr* return_instr = nullptr;
  {
    ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
 
    EXPECT(cursor.TryMatch({
        kMoveGlob,
        {kMatchDartReturn, &return_instr},
    }));
  }
 
  auto* const load_thread_instr = new (zone) LoadThreadInstr();
  flow_graph->InsertBefore(return_instr, load_thread_instr, nullptr,
                           FlowGraph::kValue);
  auto load_thread_value = Value(load_thread_instr);
 
  auto* const convert_instr = new (zone) IntConverterInstr(
      kUntagged, kUnboxedAddress, &load_thread_value, DeoptId::kNone);
  flow_graph->InsertBefore(return_instr, convert_instr, nullptr,
                           FlowGraph::kValue);
  auto convert_value = Value(convert_instr);
 
  auto* const box_instr = BoxInstr::Create(kUnboxedAddress, &convert_value);
  flow_graph->InsertBefore(return_instr, box_instr, nullptr, FlowGraph::kValue);
 
  return_instr->InputAt(0)->definition()->ReplaceUsesWith(box_instr);
 
  {
    // Check we constructed the right graph.
    ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
    EXPECT(cursor.TryMatch({
        kMoveGlob,
        kMatchAndMoveLoadThread,
        kMatchAndMoveIntConverter,
        kMatchAndMoveBox,
        kMatchDartReturn,
    }));
  }
 
  pipeline.RunForcedOptimizedAfterSSAPasses();
 
  {
#if !defined(PRODUCT) && !defined(USING_THREAD_SANITIZER)
    SetFlagScope<bool> sfs(&FLAG_disassemble_optimized, true);
#endif
    pipeline.CompileGraphAndAttachFunction();
  }
 
  // Ensure we can successfully invoke the function.
  invoke_result ^= Invoke(root_library, "myFunction");
  intptr_t result_int = Integer::Cast(invoke_result).AsInt64Value();
  EXPECT_EQ(reinterpret_cast<intptr_t>(thread), result_int);
}

ISOLATE_UNIT_TEST_CASE() [177/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_WriteBarrierElimination_Arrays

)

Definition at line 202 of file write_barrier_elimination_test.cc.

      {kMatchAndMoveStoreField, &store_into_c},

ISOLATE_UNIT_TEST_CASE() [178/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_WriteBarrierElimination_AtLeastOnce

)

Definition at line 85 of file write_barrier_elimination_test.cc.

                                                                   {
  DEBUG_ONLY(
      SetFlagScope<bool> sfs(&FLAG_trace_write_barrier_elimination, true));
  // Ensure that we process every block at least once during the analysis
  // phase so that the out-sets will be initialized. If we don't process
  // each block at least once, the store "c.next = n" will be marked
  // NoWriteBarrier.
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                                     R"(
      class C {
        %s C next;
      }
 
      @pragma("vm:never-inline")
      fn() {}
 
      foo(int x) {
        C c = C();
        C n = C();
        if (x > 5) {
          fn();
        }
        c.next = n;
        return c;
      }
 
      main() { foo(0); foo(10); }
      )", TestCase::LateTag()), std::free);
  // clang-format on
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);

ISOLATE_UNIT_TEST_CASE() [179/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_WriteBarrierElimination_JoinSuccessors

)

Definition at line 14 of file write_barrier_elimination_test.cc.

                                                                      {
  DEBUG_ONLY(
      SetFlagScope<bool> sfs(&FLAG_trace_write_barrier_elimination, true));
  const char* nullable_tag = TestCase::NullableTag();
  const char* null_assert_tag = TestCase::NullAssertTag();
 
  // This is a regression test for a bug where we were using
  // JoinEntry::SuccessorCount() to determine the number of outgoing blocks
  // from the join block. JoinEntry::SuccessorCount() is in fact always 0;
  // JoinEntry::last_instruction()->SuccessorCount() should be used instead.
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr, R"(
      class C {
        int%s value;
        C%s next;
        C%s prev;
      }
 
      @pragma("vm:never-inline")
      fn() {}
 
      foo(int x) {
        C%s prev = C();
        C%s next;
        while (x --> 0) {
          next = C();
          next%s.prev = prev;
          prev?.next = next;
          prev = next;
          fn();
        }
        return next;
      }
 
      main() { foo(10); }
      )",
      nullable_tag, nullable_tag, nullable_tag, nullable_tag,
      nullable_tag, null_assert_tag), std::free);
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  StoreFieldInstr* store1 = nullptr;
  StoreFieldInstr* store2 = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      kMatchAndMoveGoto,
      kMoveGlob,
      kMatchAndMoveBranchTrue,
      kMoveGlob,
      {kMatchAndMoveStoreField, &store1},
      kMoveGlob,
      {kMatchAndMoveStoreField, &store2},
  }));
 
  EXPECT(store1->ShouldEmitStoreBarrier() == false);
  EXPECT(store2->ShouldEmitStoreBarrier() == true);
}

ISOLATE_UNIT_TEST_CASE() [180/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_WriteBarrierElimination_LoadLateField

)

Definition at line 253 of file write_barrier_elimination_test.cc.

      {
          kMatchAndMoveCreateArray,
          kMatchAndMoveGoto,
          kMatchAndMoveBranchTrue,
          kMatchAndMoveCreateArray,
          {kMatchAndMoveStoreIndexed, &store_into_phi},
      },
      kMoveGlob));
 
  EXPECT(store_into_phi->array()->definition()->IsPhi());
  EXPECT(store_into_phi->ShouldEmitStoreBarrier());
}
 
ISOLATE_UNIT_TEST_CASE(IRTest_WriteBarrierElimination_LoadLateField) {
  DEBUG_ONLY(
      SetFlagScope<bool> sfs(&FLAG_trace_write_barrier_elimination, true));
  const char* kScript = R"(
    class A {
      late var x = new B();
    }
 
    class B {
    }
 
    class C {
      C(this.a, this.b);
      A a;
      B b;
    }
 
    foo(A a) => C(a, a.x);
 
    main() { foo(A()); }
    )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 

ISOLATE_UNIT_TEST_CASE() [181/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_WriteBarrierElimination_LoadLateStaticField

)

Definition at line 303 of file write_barrier_elimination_test.cc.

      {
          kMatchAndMoveAllocateObject,
          kMatchAndMoveLoadField,
          {kMatchAndMoveStoreField, &store1},
          {kMatchAndMoveStoreField, &store2},
      },
      kMoveGlob));
 
  EXPECT(!store1->ShouldEmitStoreBarrier());
  EXPECT(!store2->ShouldEmitStoreBarrier());
}
 
ISOLATE_UNIT_TEST_CASE(IRTest_WriteBarrierElimination_LoadLateStaticField) {
  DEBUG_ONLY(
      SetFlagScope<bool> sfs(&FLAG_trace_write_barrier_elimination, true));
  const char* kScript = R"(
    class A {
    }
 
    class B {
    }
 
    class C {
      C(this.a, this.b);
      A a;
      B b;
    }
 
    late var x = new B();
 
    foo(A a) => C(a, x);
 
    main() { foo(A()); }
    )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 

ISOLATE_UNIT_TEST_CASE() [182/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_WriteBarrierElimination_Regress43786

)

Definition at line 208 of file write_barrier_elimination_test.cc.

      {kMatchAndMoveStoreIndexed, &store_into_array_after_loop},
  }));
 
  EXPECT(store_into_c->ShouldEmitStoreBarrier() == false);
  EXPECT(store_into_array_before_loop->ShouldEmitStoreBarrier() == false);
  EXPECT(store_into_array_after_loop->ShouldEmitStoreBarrier() ==
         (length > Array::kMaxLengthForWriteBarrierElimination));
}
 
ISOLATE_UNIT_TEST_CASE(IRTest_WriteBarrierElimination_Arrays) {
  TestWBEForArrays(1);
  TestWBEForArrays(Array::kMaxLengthForWriteBarrierElimination);
  TestWBEForArrays(Array::kMaxLengthForWriteBarrierElimination + 1);
}
 
ISOLATE_UNIT_TEST_CASE(IRTest_WriteBarrierElimination_Regress43786) {
  DEBUG_ONLY(
      SetFlagScope<bool> sfs(&FLAG_trace_write_barrier_elimination, true));
  const char* kScript = R"(
      foo() {
        final root = List<dynamic>.filled(128, null);
        List<dynamic> last = root;
        for (int i = 0; i < 10 * 1024; ++i) {
          final nc = List<dynamic>.filled(128, null);
          last[0] = nc;
          last = nc;
        }
      }
 
      main() { foo(); }
      )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 

ISOLATE_UNIT_TEST_CASE() [183/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_YieldIndexAvailableAOT

)

Definition at line 93 of file yield_position_test.cc.

ISOLATE_UNIT_TEST_CASE() [184/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IRTest_YieldIndexAvailableJIT

)

Definition at line 89 of file yield_position_test.cc.

ISOLATE_UNIT_TEST_CASE() [185/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Isolate_MayExit_False

)

Definition at line 264 of file isolate_test.cc.

                                              {
  TransitionVMToNative transition(thread);
 
  EXPECT_EQ(false, thread->is_unwind_in_progress());
 
  Dart_EnterScope();
 
  Dart_Handle lib =
      Dart_LookupLibrary(Dart_NewStringFromCString("dart:isolate"));
  EXPECT(!Dart_IsError(lib));
 
  Dart_Handle isolate_type = Dart_GetNonNullableType(
      lib, Dart_NewStringFromCString("Isolate"), 0, nullptr);
  EXPECT(!Dart_IsError(isolate_type));
 
  Dart_Handle setter_result = Dart_SetField(
      isolate_type, Dart_NewStringFromCString("_mayExit"), Dart_False());
  EXPECT(!Dart_IsError(setter_result));
 
  Dart_Handle result =
      Dart_Invoke(isolate_type, Dart_NewStringFromCString("exit"), 0, nullptr);
  EXPECT(Dart_IsUnhandledExceptionError(result));
 
  Dart_ExitScope();
 
  EXPECT_EQ(false, thread->is_unwind_in_progress());
}

ISOLATE_UNIT_TEST_CASE() [186/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Isolate_MayExit_True

)

Definition at line 240 of file isolate_test.cc.

                                             {
  TransitionVMToNative transition(thread);
 
  EXPECT_EQ(false, thread->is_unwind_in_progress());
 
  Dart_EnterScope();
 
  Dart_Handle lib =
      Dart_LookupLibrary(Dart_NewStringFromCString("dart:isolate"));
  EXPECT(!Dart_IsError(lib));
 
  Dart_Handle isolate_type = Dart_GetNonNullableType(
      lib, Dart_NewStringFromCString("Isolate"), 0, nullptr);
  EXPECT(!Dart_IsError(isolate_type));
 
  Dart_Handle result =
      Dart_Invoke(isolate_type, Dart_NewStringFromCString("exit"), 0, nullptr);
  EXPECT(Dart_IsFatalError(result));
 
  Dart_ExitScope();
 
  EXPECT_EQ(true, thread->is_unwind_in_progress());
}

ISOLATE_UNIT_TEST_CASE() [187/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Isolate_Ports

)

Definition at line 177 of file isolate_test.cc.

                                      {
  auto isolate = thread->isolate();
  auto& port = ReceivePort::Handle();
 
  EXPECT(!isolate->HasLivePorts());
 
  {
    // Make port.
    port = isolate->CreateReceivePort(String::null_string());
    EXPECT(port.is_open());
    EXPECT(port.keep_isolate_alive());
    EXPECT(port.Id() != ILLEGAL_PORT);
    EXPECT(PortMap::PortExists(port.Id()));
    EXPECT(isolate->HasLivePorts());
 
    // Make port not keep isolate alive.
    isolate->SetReceivePortKeepAliveState(port, false);
    EXPECT(port.is_open());
    EXPECT(!port.keep_isolate_alive());
    EXPECT(!isolate->HasLivePorts());
 
    // Mark it alive again.
    isolate->SetReceivePortKeepAliveState(port, true);
    EXPECT(port.is_open());
    EXPECT(port.keep_isolate_alive());
    EXPECT(isolate->HasLivePorts());
 
    // Close the port.
    isolate->CloseReceivePort(port);
    EXPECT(!port.is_open());
    EXPECT(!port.keep_isolate_alive());
    EXPECT(!isolate->HasLivePorts());
 
    // Closing again should be a NOP.
    isolate->CloseReceivePort(port);
    EXPECT(!port.is_open());
    EXPECT(!port.keep_isolate_alive());
    EXPECT(!isolate->HasLivePorts());
  }
 
  {
    // Make port.
    port = isolate->CreateReceivePort(String::null_string());
    EXPECT_NE(0, port.Id());
    EXPECT(PortMap::PortExists(port.Id()));
    EXPECT(isolate->HasLivePorts());
 
    // Make port not keep isolate alive.
    isolate->SetReceivePortKeepAliveState(port, false);
    EXPECT(port.is_open());
    EXPECT(!port.keep_isolate_alive());
    EXPECT(!isolate->HasLivePorts());
 
    // Close the port while it's not keep alive port.
    isolate->CloseReceivePort(port);
    EXPECT(!port.is_open());
    EXPECT(!port.keep_isolate_alive());
    EXPECT(!isolate->HasLivePorts());
  }
 
  EXPECT(!isolate->HasLivePorts());
}

ISOLATE_UNIT_TEST_CASE() [188/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IsolateReload_DirectSubclasses_Failure

)

Definition at line 3552 of file isolate_reload_test.cc.

                                                               {
  Object& new_subclass = Object::Handle();
  String& name = String::Handle();
 
  // Lookup the Stopwatch class by name from the dart core library.
  ObjectStore* object_store = IsolateGroup::Current()->object_store();
  const Library& core_lib = Library::Handle(object_store->core_library());
  name = String::New("Stopwatch");
  const Class& stopwatch_cls = Class::Handle(core_lib.LookupClass(name));
 
  // Keep track of how many subclasses an Stopwatch has.
  auto& subclasses =
      GrowableObjectArray::Handle(stopwatch_cls.direct_subclasses_unsafe());
  intptr_t saved_subclass_count = subclasses.IsNull() ? 0 : subclasses.Length();
 
  const char* kScript =
      "class AStopwatch extends Stopwatch {\n"
      "}\n"
      "class Foo {\n"
      "  final a;\n"
      "  Foo(this.a);\n"
      "}\n"
      "main() {\n"
      "  new AStopwatch();\n"  // Force finalization.
      "  new Foo(5);\n"        // Force finalization.
      "  return 1;\n"
      "}\n";
 
  {
    TransitionVMToNative transition(thread);
    Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    EXPECT_EQ(1, SimpleInvoke(lib, "main"));
  }
 
  // Stopwatch has one non-core subclass...
  subclasses = stopwatch_cls.direct_subclasses_unsafe();
  EXPECT_EQ(saved_subclass_count + 1, subclasses.Length());
 
  // ... and the non-core subclass is named AStopwatch.
  subclasses = stopwatch_cls.direct_subclasses_unsafe();
  new_subclass = subclasses.At(subclasses.Length() - 1);
  name = Class::Cast(new_subclass).Name();
  EXPECT_STREQ("AStopwatch", name.ToCString());
 
  // Attempt to reload with a bogus script.
  const char* kReloadScript =
      "class BStopwatch extends Stopwatch {\n"
      "}\n"
      "class Foo {\n"
      "  final a kjsdf ksjdf ;\n"  // When we refinalize, we get an error.
      "  Foo(this.a);\n"
      "}\n"
      "main() {\n"
      "  new BStopwatch();\n"  // Force finalization.
      "  new Foo(5);\n"        // Force finalization.
      "  return 2;\n"
      "}\n";
 
  {
    TransitionVMToNative transition(thread);
    Dart_Handle lib = TestCase::ReloadTestScript(kReloadScript);
    EXPECT_ERROR(lib, "Expected ';' after this");
  }
 
  // If we don't clean up the subclasses, we would find BStopwatch in
  // the list of subclasses, which would be bad.  Make sure that
  // Stopwatch still has only one non-core subclass...
  subclasses = stopwatch_cls.direct_subclasses_unsafe();
  EXPECT_EQ(saved_subclass_count + 1, subclasses.Length());
 
  // ...and the non-core subclass is still named AStopwatch.
  new_subclass = subclasses.At(subclasses.Length() - 1);
  name = Class::Cast(new_subclass).Name();
  EXPECT_STREQ("AStopwatch", name.ToCString());
}

ISOLATE_UNIT_TEST_CASE() [189/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IsolateReload_DirectSubclasses_GhostSubclass

)

Definition at line 3483 of file isolate_reload_test.cc.

                                                                     {
  Object& new_subclass = Object::Handle();
  String& name = String::Handle();
 
  // Lookup the Stopwatch class by name from the dart core library.
  ObjectStore* object_store = IsolateGroup::Current()->object_store();
  const Library& core_lib = Library::Handle(object_store->core_library());
  name = String::New("Stopwatch");
  const Class& stopwatch_cls = Class::Handle(core_lib.LookupClass(name));
 
  // Keep track of how many subclasses an Stopwatch has.
  auto& subclasses =
      GrowableObjectArray::Handle(stopwatch_cls.direct_subclasses_unsafe());
  intptr_t saved_subclass_count = subclasses.IsNull() ? 0 : subclasses.Length();
 
  const char* kScript =
      "class AStopwatch extends Stopwatch {\n"
      "}\n"
      "main() {\n"
      "  new AStopwatch();\n"  // Force finalization.
      "  return 1;\n"
      "}\n";
 
  {
    TransitionVMToNative transition(thread);
    Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    EXPECT_EQ(1, SimpleInvoke(lib, "main"));
  }
 
  // Stopwatch has one new subclass.
  subclasses = stopwatch_cls.direct_subclasses_unsafe();
  EXPECT_EQ(saved_subclass_count + 1, subclasses.Length());
 
  // The new subclass is named AStopwatch.
  new_subclass = subclasses.At(subclasses.Length() - 1);
  name = Class::Cast(new_subclass).Name();
  EXPECT_STREQ("AStopwatch", name.ToCString());
 
  const char* kReloadScript =
      "class BStopwatch extends Stopwatch {\n"
      "}\n"
      "main() {\n"
      "  new BStopwatch();\n"  // Force finalization.
      "  return 2;\n"
      "}\n";
 
  {
    TransitionVMToNative transition(thread);
    Dart_Handle lib = TestCase::ReloadTestScript(kReloadScript);
    EXPECT_VALID(lib);
    EXPECT_EQ(2, SimpleInvoke(lib, "main"));
  }
 
  // Stopwatch has two non-core subclasses.
  subclasses = stopwatch_cls.direct_subclasses_unsafe();
  EXPECT_EQ(saved_subclass_count + 2, subclasses.Length());
 
  // The non-core subclasses are AStopwatch and BStopwatch.
  new_subclass = subclasses.At(subclasses.Length() - 2);
  name = Class::Cast(new_subclass).Name();
  EXPECT_STREQ("AStopwatch", name.ToCString());
 
  new_subclass = subclasses.At(subclasses.Length() - 1);
  name = Class::Cast(new_subclass).Name();
  EXPECT_STREQ("BStopwatch", name.ToCString());
}

ISOLATE_UNIT_TEST_CASE() [190/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IsolateReload_DirectSubclasses_Success

)

Definition at line 3416 of file isolate_reload_test.cc.

                                                               {
  Object& new_subclass = Object::Handle();
  String& name = String::Handle();
 
  // Lookup the Stopwatch class by name from the dart core library.
  ObjectStore* object_store = IsolateGroup::Current()->object_store();
  const Library& core_lib = Library::Handle(object_store->core_library());
  name = String::New("Stopwatch");
  const Class& stopwatch_cls = Class::Handle(core_lib.LookupClass(name));
 
  // Keep track of how many subclasses an Stopwatch has.
  auto& subclasses =
      GrowableObjectArray::Handle(stopwatch_cls.direct_subclasses_unsafe());
  intptr_t saved_subclass_count = subclasses.IsNull() ? 0 : subclasses.Length();
 
  const char* kScript =
      "class AStopwatch extends Stopwatch {\n"
      "}\n"
      "main() {\n"
      "  new AStopwatch();\n"  // Force finalization.
      "  return 1;\n"
      "}\n";
 
  {
    TransitionVMToNative transition(thread);
    Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    EXPECT_EQ(1, SimpleInvoke(lib, "main"));
  }
 
  // Stopwatch has one non-core subclass.
  subclasses = stopwatch_cls.direct_subclasses_unsafe();
  EXPECT_EQ(saved_subclass_count + 1, subclasses.Length());
 
  // The new subclass is named AStopwatch.
  new_subclass = subclasses.At(subclasses.Length() - 1);
  name = Class::Cast(new_subclass).Name();
  EXPECT_STREQ("AStopwatch", name.ToCString());
 
  const char* kReloadScript =
      "class AStopwatch {\n"
      "}\n"
      "class BStopwatch extends Stopwatch {\n"
      "}\n"
      "main() {\n"
      "  new AStopwatch();\n"  // Force finalization.
      "  new BStopwatch();\n"  // Force finalization.
      "  return 2;\n"
      "}\n";
 
  {
    TransitionVMToNative transition(thread);
    Dart_Handle lib = TestCase::ReloadTestScript(kReloadScript);
    EXPECT_VALID(lib);
    EXPECT_EQ(2, SimpleInvoke(lib, "main"));
  }
 
  // Stopwatch still has only one non-core subclass (AStopwatch is gone).
  subclasses = stopwatch_cls.direct_subclasses_unsafe();
  EXPECT_EQ(saved_subclass_count + 1, subclasses.Length());
 
  // The new subclass is named BStopwatch.
  new_subclass = subclasses.At(subclasses.Length() - 1);
  name = Class::Cast(new_subclass).Name();
  EXPECT_STREQ("BStopwatch", name.ToCString());
}

ISOLATE_UNIT_TEST_CASE() [191/463]

dart::ISOLATE_UNIT_TEST_CASE

(

IterateReadOnly

)

Definition at line 217 of file heap_test.cc.

                                        {
  const String& obj = String::Handle(String::New("x", Heap::kOld));
 
  // It is not safe to make the heap read-only if marking or sweeping is in
  // progress.
  GCTestHelper::WaitForGCTasks();
 
  Heap* heap = IsolateGroup::Current()->heap();
  EXPECT(heap->Contains(UntaggedObject::ToAddr(obj.ptr())));
  heap->WriteProtect(true);
  EXPECT(heap->Contains(UntaggedObject::ToAddr(obj.ptr())));
  heap->WriteProtect(false);
  EXPECT(heap->Contains(UntaggedObject::ToAddr(obj.ptr())));
}

ISOLATE_UNIT_TEST_CASE() [192/463]

dart::ISOLATE_UNIT_TEST_CASE

(

JSON_JSONStream_DartObject

)

Definition at line 175 of file json_test.cc.

                                                   {
  JSONStream js;
  {
    JSONArray jsarr(&js);
    jsarr.AddValue(Object::Handle(Object::null()));
    JSONObject jsobj(&jsarr);
    jsobj.AddProperty("object_key", Object::Handle(Object::null()));
  }
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 2048;
  char buffer[kBufferSize];
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  ElideJSONSubstring("objects", buffer, buffer);
  ElideJSONSubstring("line", buffer, buffer);
  ElideJSONSubstring("column", buffer, buffer);
  StripTokenPositions(buffer);
 
  EXPECT_STREQ(
      "[{\"type\":\"@Instance\",\"_vmType\":\"null\",\"class\":{\"type\":\"@"
      "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"Null\",\"location\":{"
      "\"type\":\"SourceLocation\",\"script\":{\"type\":\"@Script\","
      "\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core\\/null.dart\","
      "\"_kind\":\"kernel\"}},\"library\":{"
      "\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\",\"name\":\"dart."
      "core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\",\"fixedId\":true,"
      "\"id\":\"\",\"valueAsString\":\"null\"},{\"object_key\":{\"type\":\"@"
      "Instance\",\"_vmType\":\"null\",\"class\":{\"type\":\"@Class\","
      "\"fixedId\":true,\"id\":\"\",\"name\":\"Null\",\"location\":{\"type\":"
      "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
      "\"id\":\"\",\"uri\":\"dart:core\\/null.dart\",\"_kind\":\"kernel\"}},"
      "\"library\":{\"type\":\"@"
      "Library\",\"fixedId\":true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":"
      "\"dart:core\"}},\"kind\":\"Null\",\"fixedId\":true,\"id\":\"\","
      "\"valueAsString\":\"null\"}}]",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [193/463]

dart::ISOLATE_UNIT_TEST_CASE

(

KernelLineStartsReader_LocationForPosition

)

Definition at line 46 of file kernel_test.cc.

                                                                   {
  kernel::KernelLineStartsReader reader(CreateLineStartsData(), thread->zone());
  ExpectLocationForPosition(reader, 0, 1, 1);
  ExpectLocationForPosition(reader, 4, 1, 5);
  ExpectLocationForPosition(reader, 8, 2, 1);
  ExpectLocationForPosition(reader, 14, 3, 3);
  ExpectLocationForPosition(reader, 17, 4, 1);
  ExpectLocationForPosition(reader, 19, 5, 2);
  ExpectLocationForPosition(reader, 22, 6, 3);
  ExpectLocationForPosition(reader, 29, 7, 7);
  ExpectLocationForPosition(reader, 30, 8, 1);
  ExpectLocationForPosition(reader, 32, 9, 2);
  ExpectLocationForPosition(reader, 33, 10, 1);
 
  intptr_t line;
  intptr_t col;
  EXPECT_EQ(false, reader.LocationForPosition(-1, &line, &col));
  EXPECT_EQ(false, reader.LocationForPosition(34, &line, &col));
}

ISOLATE_UNIT_TEST_CASE() [194/463]

dart::ISOLATE_UNIT_TEST_CASE

(

KernelLineStartsReader_MaxPosition

)

Definition at line 30 of file kernel_test.cc.

                                                           {
  kernel::KernelLineStartsReader reader(CreateLineStartsData(), thread->zone());
  EXPECT_EQ(33u, reader.MaxPosition());
}

ISOLATE_UNIT_TEST_CASE() [195/463]

dart::ISOLATE_UNIT_TEST_CASE

(

KernelLineStartsReader_TokenRangeAtLine

)

Definition at line 77 of file kernel_test.cc.

                                                                {
  kernel::KernelLineStartsReader reader(CreateLineStartsData(), thread->zone());
  ExpectTokenRangeAtLine(reader, 1, 0, 7);
  ExpectTokenRangeAtLine(reader, 2, 8, 11);
  ExpectTokenRangeAtLine(reader, 3, 12, 16);
  ExpectTokenRangeAtLine(reader, 4, 17, 17);
  ExpectTokenRangeAtLine(reader, 5, 18, 19);
  ExpectTokenRangeAtLine(reader, 6, 20, 22);
  ExpectTokenRangeAtLine(reader, 7, 23, 29);
  ExpectTokenRangeAtLine(reader, 8, 30, 30);
  ExpectTokenRangeAtLine(reader, 9, 31, 32);
  ExpectTokenRangeAtLine(reader, 10, 33, 33);
 
  TokenPosition first_token = TokenPosition::Synthetic(0);
  TokenPosition last_token = TokenPosition::Synthetic(0);
  EXPECT_EQ(false, reader.TokenRangeAtLine(0, &first_token, &last_token));
  EXPECT_EQ(false, reader.TokenRangeAtLine(11, &first_token, &last_token));
}

ISOLATE_UNIT_TEST_CASE() [196/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LICM_Deopt_Regress50245

)

Definition at line 2011 of file redundancy_elimination_test.cc.

                                                {
  const char* kScript = R"(
    class A {
      List<int> foo;
      A(this.foo);
    }
 
    A obj = A([1, 2, 3]);
    int n = int.parse('3');
 
    main() {
      // Make sure A.foo= is compiled.
      obj.foo = [];
      int sum = 0;
      for (int i = 0; i < n; ++i) {
        if (int.parse('1') != 1) {
          // Field guard from this unreachable code is moved up
          // and causes repeated deoptimization.
          obj.foo = const [];
        }
        sum += i;
      }
      return sum;
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "main"));
 
  // Run unoptimized code.
  Invoke(root_library, "main");
  EXPECT(!function.HasOptimizedCode());
 
  Compiler::CompileOptimizedFunction(thread, function);
  EXPECT(function.HasOptimizedCode());
 
  // LICM should be disabled after the first round of deoptimization.

ISOLATE_UNIT_TEST_CASE() [197/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LICM_Deopt_Regress51220

)

Definition at line 1969 of file redundancy_elimination_test.cc.

                                                {
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                          R"(
        int n = int.parse('3');
        main() {
          int x = 0;
          for (int i = 0; i < n; ++i) {
            if (i > ((1 << %d)*1024)) {
              ++x;
            }
          }
          return x;
        }
      )",
                                          static_cast<int>(kSmiBits + 1 - 10)),
                              std::free);
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
  const auto& function = Function::Handle(GetFunction(root_library, "main"));
 
  // Run unoptimized code.
  Invoke(root_library, "main");
  EXPECT(!function.HasOptimizedCode());
 
  Compiler::CompileOptimizedFunction(thread, function);
  EXPECT(function.HasOptimizedCode());
 
  // Only 2 rounds of deoptimization are allowed:
  // * the first round should disable LICM;
  // * the second round should disable BinarySmiOp.
  Invoke(root_library, "main");
  EXPECT(!function.HasOptimizedCode());
  //  EXPECT(function.ProhibitsInstructionHoisting());
 
  Compiler::CompileOptimizedFunction(thread, function);
  EXPECT(function.HasOptimizedCode());
 

ISOLATE_UNIT_TEST_CASE() [198/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_AssertAssignable_Escape

)

Definition at line 556 of file redundancy_elimination_test.cc.

                                                                               {
  TestAliasingViaStore(thread, /*make_it_escape=*/true,
                       /* make_host_escape= */ false, MakeAssertAssignable);
}

ISOLATE_UNIT_TEST_CASE() [199/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_AssertAssignable_EscapeViaHost

)

Definition at line 561 of file redundancy_elimination_test.cc.

                                                                   {
  TestAliasingViaStore(thread, /*make_it_escape=*/false,
                       /* make_host_escape= */ true, MakeAssertAssignable);
}

ISOLATE_UNIT_TEST_CASE() [200/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_AssertAssignable_NoEscape

)

Definition at line 550 of file redundancy_elimination_test.cc.

                                                              {
  TestAliasingViaStore(thread, /*make_it_escape=*/false,
                       /* make_host_escape= */ false, MakeAssertAssignable);
}

ISOLATE_UNIT_TEST_CASE() [201/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_CheckNull_Escape

)

Definition at line 524 of file redundancy_elimination_test.cc.

                                                                        {
  TestAliasingViaStore(thread, /*make_it_escape=*/true,
                       /* make_host_escape= */ false, MakeCheckNull);
}

ISOLATE_UNIT_TEST_CASE() [202/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_CheckNull_EscapeViaHost

)

Definition at line 529 of file redundancy_elimination_test.cc.

                                                                               {
  TestAliasingViaStore(thread, /*make_it_escape=*/false,
                       /* make_host_escape= */ true, MakeCheckNull);
}

ISOLATE_UNIT_TEST_CASE() [203/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_CheckNull_NoEscape

)

Definition at line 519 of file redundancy_elimination_test.cc.

                                                                          {
  TestAliasingViaStore(thread, /*make_it_escape=*/false,
                       /* make_host_escape= */ false, MakeCheckNull);
}

ISOLATE_UNIT_TEST_CASE() [204/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_Redefinition_Escape

)

Definition at line 539 of file redundancy_elimination_test.cc.

                                                                           {
  TestAliasingViaStore(thread, /*make_it_escape=*/true,
                       /* make_host_escape= */ false, MakeRedefinition);
}

ISOLATE_UNIT_TEST_CASE() [205/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_Redefinition_EscapeViaHost

)

Definition at line 544 of file redundancy_elimination_test.cc.

                                                               {
  TestAliasingViaStore(thread, /*make_it_escape=*/false,
                       /* make_host_escape= */ true, MakeRedefinition);
}

ISOLATE_UNIT_TEST_CASE() [206/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaStore_Redefinition_NoEscape

)

Definition at line 534 of file redundancy_elimination_test.cc.

                                                                             {
  TestAliasingViaStore(thread, /*make_it_escape=*/false,
                       /* make_host_escape= */ false, MakeRedefinition);
}

ISOLATE_UNIT_TEST_CASE() [207/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_AliasingViaTypedDataAndUntaggedTypedData

)

Definition at line 569 of file redundancy_elimination_test.cc.

                                                                               {
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  const auto& lib = Library::Handle(Library::TypedDataLibrary());
  const Class& cls = Class::Handle(lib.LookupClass(Symbols::Uint32List()));
  const Error& err = Error::Handle(cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
 
  const Function& function = Function::ZoneHandle(
      cls.LookupFactory(String::Handle(String::New("Uint32List."))));
  EXPECT(!function.IsNull());
 
  auto zone = H.flow_graph()->zone();
 
  // We are going to build the following graph:
  //
  //   B0[graph_entry] {
  //     vc0 <- Constant(0)
  //     vc42 <- Constant(42)
  //   }
  //
  //   B1[function_entry] {
  //   }
  //   array <- StaticCall(...) {_Uint32List}
  //   v1 <- LoadIndexed(array)
  //   v2 <- LoadField(array, Slot::PointerBase_data())
  //   StoreIndexed(v2, index=vc0, value=vc42)
  //   v3 <- LoadIndexed(array)
  //   return v3
  // }
 
  auto vc0 = H.flow_graph()->GetConstant(Integer::Handle(Integer::New(0)));
  auto vc42 = H.flow_graph()->GetConstant(Integer::Handle(Integer::New(42)));
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
 
  StaticCallInstr* array;
  LoadIndexedInstr* v1;
  LoadFieldInstr* v2;
  StoreIndexedInstr* store;
  LoadIndexedInstr* v3;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
 
    //   array <- StaticCall(...) {_Uint32List}
    array = builder.AddDefinition(new StaticCallInstr(
        InstructionSource(), function, 0, Array::empty_array(), InputsArray(),
        DeoptId::kNone, 0, ICData::kNoRebind));
    array->UpdateType(CompileType::FromCid(kTypedDataUint32ArrayCid));
    array->SetResultType(zone, CompileType::FromCid(kTypedDataUint32ArrayCid));
    array->set_is_known_list_constructor(true);
 
    //   v1 <- LoadIndexed(array)
    v1 = builder.AddDefinition(new LoadIndexedInstr(
        new Value(array), new Value(vc0), /*index_unboxed=*/false, 1,
        kTypedDataUint32ArrayCid, kAlignedAccess, DeoptId::kNone,
        InstructionSource()));
 
    //   v2 <- LoadField(array, Slot::PointerBase_data())
    //   StoreIndexed(v2, index=0, value=42)
    v2 = builder.AddDefinition(new LoadFieldInstr(
        new Value(array), Slot::PointerBase_data(),
        InnerPointerAccess::kMayBeInnerPointer, InstructionSource()));
    store = builder.AddInstruction(new StoreIndexedInstr(
        new Value(v2), new Value(vc0), new Value(vc42), kNoStoreBarrier,
        /*index_unboxed=*/false, 1, kTypedDataUint32ArrayCid, kAlignedAccess,
        DeoptId::kNone, InstructionSource()));
 
    //   v3 <- LoadIndexed(array)
    v3 = builder.AddDefinition(new LoadIndexedInstr(
        new Value(array), new Value(vc0), /*index_unboxed=*/false, 1,
        kTypedDataUint32ArrayCid, kAlignedAccess, DeoptId::kNone,
        InstructionSource()));
 
    //   return v3
    ret = builder.AddInstruction(new DartReturnInstr(
        InstructionSource(), new Value(v3), S.GetNextDeoptId()));
  }
  H.FinishGraph();
 
  DominatorBasedCSE::Optimize(H.flow_graph());
  {
    Instruction* sc = nullptr;
    Instruction* li = nullptr;
    Instruction* lf = nullptr;
    Instruction* s = nullptr;
    Instruction* li2 = nullptr;
    Instruction* r = nullptr;
    ILMatcher cursor(H.flow_graph(), b1, true);
    RELEASE_ASSERT(cursor.TryMatch({
        kMatchAndMoveFunctionEntry,
        {kMatchAndMoveStaticCall, &sc},
        {kMatchAndMoveLoadIndexed, &li},
        {kMatchAndMoveLoadField, &lf},
        {kMatchAndMoveStoreIndexed, &s},
        {kMatchAndMoveLoadIndexed, &li2},
        {kMatchDartReturn, &r},
    }));
    EXPECT(array == sc);
    EXPECT(v1 == li);
    EXPECT(v2 == lf);
    EXPECT(store == s);
    EXPECT(v3 == li2);
    EXPECT(ret == r);
  }
}

ISOLATE_UNIT_TEST_CASE() [208/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_LoadDataFieldOfNewTypedData

)

Definition at line 683 of file redundancy_elimination_test.cc.

                                                                  {
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  auto zone = H.flow_graph()->zone();
 
  // We are going to build the following graph:
  //
  //   B0[graph_entry] {
  //     vc42 <- Constant(42)
  //   }
  //
  //   B1[function_entry] {
  //   }
  //   array <- AllocateTypedData(kTypedDataUint8ArrayCid, vc42)
  //   view <- AllocateObject(kTypedDataUint8ArrayViewCid)
  //   v1 <- LoadNativeField(array, Slot::PointerBase_data())
  //   StoreNativeField(Slot::PointerBase_data(), view, v1, kNoStoreBarrier,
  //                    kInitalizing)
  //   return view
  // }
 
  const auto& lib = Library::Handle(zone, Library::TypedDataLibrary());
  EXPECT(!lib.IsNull());
  const Class& view_cls = Class::ZoneHandle(
      zone, lib.LookupClassAllowPrivate(Symbols::_Uint8ArrayView()));
  EXPECT(!view_cls.IsNull());
  const Error& err = Error::Handle(zone, view_cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
 
  auto vc42 = H.flow_graph()->GetConstant(Integer::Handle(Integer::New(42)));
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
 
  AllocateTypedDataInstr* array;
  AllocateObjectInstr* view;
  LoadFieldInstr* v1;
  StoreFieldInstr* store;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
 
    //   array <- AllocateTypedData(kTypedDataUint8ArrayCid, vc42)
    array = builder.AddDefinition(
        new AllocateTypedDataInstr(InstructionSource(), kTypedDataUint8ArrayCid,
                                   new (zone) Value(vc42), DeoptId::kNone));
 
    //   view <- AllocateObject(kTypedDataUint8ArrayViewCid, vta)
    view = builder.AddDefinition(
        new AllocateObjectInstr(InstructionSource(), view_cls, DeoptId::kNone));
 
    //   v1 <- LoadNativeField(array, Slot::PointerBase_data())
    v1 = builder.AddDefinition(new LoadFieldInstr(
        new (zone) Value(array), Slot::PointerBase_data(),
        InnerPointerAccess::kMayBeInnerPointer, InstructionSource()));
 
    //   StoreNativeField(Slot::PointerBase_data(), view, v1, kNoStoreBarrier,
    //                    kInitalizing)
    store = builder.AddInstruction(new StoreFieldInstr(
        Slot::PointerBase_data(), new (zone) Value(view), new (zone) Value(v1),
        kNoStoreBarrier, InnerPointerAccess::kMayBeInnerPointer,
        InstructionSource(), StoreFieldInstr::Kind::kInitializing));
 
    //   return view
    ret = builder.AddInstruction(new DartReturnInstr(
        InstructionSource(), new Value(view), S.GetNextDeoptId()));
  }
  H.FinishGraph();
 
  DominatorBasedCSE::Optimize(H.flow_graph());
  {
    Instruction* alloc_array = nullptr;
    Instruction* alloc_view = nullptr;
    Instruction* lf = nullptr;
    Instruction* sf = nullptr;
    Instruction* r = nullptr;
    ILMatcher cursor(H.flow_graph(), b1, true);
    RELEASE_ASSERT(cursor.TryMatch({
        kMatchAndMoveFunctionEntry,
        {kMatchAndMoveAllocateTypedData, &alloc_array},
        {kMatchAndMoveAllocateObject, &alloc_view},
        {kMatchAndMoveLoadField, &lf},
        {kMatchAndMoveStoreField, &sf},
        {kMatchDartReturn, &r},
    }));
    EXPECT(array == alloc_array);
    EXPECT(view == alloc_view);
    EXPECT(v1 == lf);
    EXPECT(store == sf);
    EXPECT(ret == r);
  }
}

ISOLATE_UNIT_TEST_CASE() [209/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedefinitionAliasing_AssertAssignable_Escape

)

Definition at line 374 of file redundancy_elimination_test.cc.

                                                                {
  TestAliasingViaRedefinition(thread, /*make_it_escape=*/true,
                              MakeAssertAssignable);
}

ISOLATE_UNIT_TEST_CASE() [210/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedefinitionAliasing_AssertAssignable_NoEscape

)

Definition at line 368 of file redundancy_elimination_test.cc.

                                                                  {
  TestAliasingViaRedefinition(thread, /*make_it_escape=*/false,
                              MakeAssertAssignable);
}

ISOLATE_UNIT_TEST_CASE() [211/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedefinitionAliasing_CheckNull_Escape

)

Definition at line 353 of file redundancy_elimination_test.cc.

                                                                            {
  TestAliasingViaRedefinition(thread, /*make_it_escape=*/true, MakeCheckNull);
}

ISOLATE_UNIT_TEST_CASE() [212/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedefinitionAliasing_CheckNull_NoEscape

)

Definition at line 349 of file redundancy_elimination_test.cc.

                                                                              {
  TestAliasingViaRedefinition(thread, /*make_it_escape=*/false, MakeCheckNull);
}

ISOLATE_UNIT_TEST_CASE() [213/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedefinitionAliasing_Redefinition_Escape

)

Definition at line 363 of file redundancy_elimination_test.cc.

                                                                               {
  TestAliasingViaRedefinition(thread, /*make_it_escape=*/true,
                              MakeRedefinition);
}

ISOLATE_UNIT_TEST_CASE() [214/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedefinitionAliasing_Redefinition_NoEscape

)

Definition at line 357 of file redundancy_elimination_test.cc.

                                                              {
  TestAliasingViaRedefinition(thread, /*make_it_escape=*/false,
                              MakeRedefinition);
}

ISOLATE_UNIT_TEST_CASE() [215/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedundantInitializerCallAfterIf

)

Definition at line 967 of file redundancy_elimination_test.cc.

                                                                      {
  const char* kScript = R"(
    int x = int.parse('1');
 
    @pragma('vm:never-inline')
    use(int arg) {}
 
    foo(bool condition) {
      if (condition) {
        x = 3;
      } else {
        use(x);
      }
      use(x);
    }
 
    main() {
      foo(true);
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  ASSERT(flow_graph != nullptr);
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  LoadStaticFieldInstr* load_static_after_if = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      kMatchAndMoveBranchTrue,
      kMoveGlob,
      kMatchAndMoveGoto,
      kMatchAndMoveJoinEntry,
      kMoveParallelMoves,
      {kMatchAndMoveLoadStaticField, &load_static_after_if},
      kMoveGlob,
      kMatchDartReturn,
  }));
  EXPECT(!load_static_after_if->calls_initializer());
}

ISOLATE_UNIT_TEST_CASE() [216/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedundantInitializerCallInLoop

)

Definition at line 1015 of file redundancy_elimination_test.cc.

                                                                     {
  if (!TestCase::IsNNBD()) {
    return;
  }
 
  const char* kScript = R"(
    class A {
      late int x = int.parse('1');
      A? next;
    }
 
    @pragma('vm:never-inline')
    use(int arg) {}
 
    foo(A obj) {
      use(obj.x);
      for (;;) {
        use(obj.x);
        final next = obj.next;
        if (next == null) {
          break;
        }
        obj = next;
        use(obj.x);
      }
    }
 
    main() {
      foo(A()..next = A());
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  ASSERT(flow_graph != nullptr);
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  LoadFieldInstr* load_field_before_loop = nullptr;
  LoadFieldInstr* load_field_in_loop1 = nullptr;
  LoadFieldInstr* load_field_in_loop2 = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveLoadField, &load_field_before_loop},
      kMoveGlob,
      kMatchAndMoveGoto,
      kMatchAndMoveJoinEntry,
      kMoveGlob,
      {kMatchAndMoveLoadField, &load_field_in_loop1},
      kMoveGlob,
      kMatchAndMoveBranchFalse,
      kMoveGlob,
      {kMatchAndMoveLoadField, &load_field_in_loop2},
  }));
 
  EXPECT(load_field_before_loop->calls_initializer());
  EXPECT(!load_field_in_loop1->calls_initializer());
  EXPECT(load_field_in_loop2->calls_initializer());
}

ISOLATE_UNIT_TEST_CASE() [217/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedundantInitializingStoreAOT

)

Definition at line 1083 of file redundancy_elimination_test.cc.

                                                                    {
  const char* kScript = R"(
class Vec3 {
  final double x, y, z;
 
  @pragma('vm:prefer-inline')
  const Vec3(this.x, this.y, this.z);
 
  @override
  @pragma('vm:prefer-inline')
  String toString() => _vec3ToString(x, y, z);
}
 
@pragma('vm:never-inline')
String _vec3ToString(double x, double y, double z) => '';
 
// Boxed storage for Vec3.
// Fields are unboxed.
class Vec3Mut {
  double _x = 0.0;
  double _y = 0.0;
  double _z = 0.0;
 
  Vec3Mut(Vec3 v)
      : _x = v.x,
        _y = v.y,
        _z = v.z;
 
  @override
  String toString() => _vec3ToString(_x, _y, _z);
 
  @pragma('vm:prefer-inline')
  set vec(Vec3 v) {
      _x = v.x;
      _y = v.y;
      _z = v.z;
  }
}
 
Vec3Mut main() {
  final a = Vec3(3, 4, 5);
  final b = Vec3(8, 9, 10);
  final c = Vec3(18, 19, 20);
  final d = Vec3(180, 190, 200);
  final e = Vec3(1800, 1900, 2000);
  final v = Vec3Mut(a);
  v.vec = b;
  v.vec = c;
  v.vec = d;
  v.vec = e;
  return v;
}
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "main"));
 
  TestPipeline pipeline(function, CompilerPass::kAOT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  auto entry = flow_graph->graph_entry()->normal_entry();
 
  AllocateObjectInstr* allocate;
  StoreFieldInstr* store1;
  StoreFieldInstr* store2;
  StoreFieldInstr* store3;
 
  ILMatcher cursor(flow_graph, entry, true, ParallelMovesHandling::kSkip);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveAllocateObject, &allocate},
      {kMatchAndMoveStoreField, &store1},
      {kMatchAndMoveStoreField, &store2},
      {kMatchAndMoveStoreField, &store3},
      kMatchDartReturn,
  }));
 
  EXPECT(store1->instance()->definition() == allocate);
  EXPECT(store2->instance()->definition() == allocate);
  EXPECT(store3->instance()->definition() == allocate);
}

ISOLATE_UNIT_TEST_CASE() [218/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedundantStaticFieldInitialization

)

Definition at line 931 of file redundancy_elimination_test.cc.

                                                                         {
  const char* kScript = R"(
    int getX() => 2;
    int x = getX();
 
    foo() => x + x;
 
    main() {
      foo();
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  ASSERT(flow_graph != nullptr);
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveFunctionEntry,
      kMatchAndMoveCheckStackOverflow,
      kMatchAndMoveLoadStaticField,
      kMoveParallelMoves,
      kMatchAndMoveCheckSmi,
      kMoveParallelMoves,
      kMatchAndMoveBinarySmiOp,
      kMoveParallelMoves,
      kMatchDartReturn,
  }));
}

ISOLATE_UNIT_TEST_CASE() [219/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedundantStoreAOT

)

Definition at line 1164 of file redundancy_elimination_test.cc.

                                                        {
  const char* kScript = R"(
class Foo {
  int x = -1;
 
  toString() => "Foo x: $x";
}
 
class Bar {}
 
main() {
  final foo = Foo();
  foo.x = 11;
  new Bar();
  foo.x = 12;
  new Bar();
  foo.x = 13;
  return foo;
}
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
  const auto& function = Function::Handle(GetFunction(root_library, "main"));
  TestPipeline pipeline(function, CompilerPass::kAOT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  auto entry = flow_graph->graph_entry()->normal_entry();
 
  AllocateObjectInstr* allocate;
  StoreFieldInstr* store1;
 
  ILMatcher cursor(flow_graph, entry, true, ParallelMovesHandling::kSkip);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveAllocateObject, &allocate},
      {kMatchAndMoveStoreField, &store1},  // initializing store
      kMatchDartReturn,
  }));
 
  EXPECT(store1->instance()->definition() == allocate);
}

ISOLATE_UNIT_TEST_CASE() [220/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_RedundantStoresAndLoads

)

Definition at line 877 of file redundancy_elimination_test.cc.

                                                              {
  const char* kScript = R"(
    class Bar {
      Bar() { a = null; }
      dynamic a;
    }
 
    Bar foo() {
      Bar bar = new Bar();
      bar.a = null;
      bar.a = bar;
      bar.a = bar.a;
      return bar.a;
    }
 
    main() {
      foo();
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyICData,
      CompilerPass::kInlining,
      CompilerPass::kTypePropagation,
      CompilerPass::kSelectRepresentations,
      CompilerPass::kCanonicalize,
      CompilerPass::kConstantPropagation,
  });
 
  ASSERT(flow_graph != nullptr);
 
  // Before CSE, we have 2 loads and 4 stores.
  intptr_t bef_loads = 0;
  intptr_t bef_stores = 0;
  CountLoadsStores(flow_graph, &bef_loads, &bef_stores);
  EXPECT_EQ(2, bef_loads);
  EXPECT_EQ(4, bef_stores);
 
  DominatorBasedCSE::Optimize(flow_graph);
 
  // After CSE, no load and only one store remains.
  intptr_t aft_loads = 0;
  intptr_t aft_stores = 0;
  CountLoadsStores(flow_graph, &aft_loads, &aft_stores);
  EXPECT_EQ(0, aft_loads);
  EXPECT_EQ(1, aft_stores);
}

ISOLATE_UNIT_TEST_CASE() [221/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LoadOptimizer_TypedArrayViewAliasing

)

Definition at line 780 of file redundancy_elimination_test.cc.

                                                             {
  const char* script_chars = R"(
    import 'dart:typed_data';
 
    class View {
      final Float64List data;
      View(this.data);
    }
  )";
  const Library& lib =
      Library::Handle(LoadTestScript(script_chars, NoopNativeLookup));
 
  const Class& view_cls = Class::ZoneHandle(
      lib.LookupClass(String::Handle(Symbols::New(thread, "View"))));
  const Error& err = Error::Handle(view_cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
 
  const Field& original_field = Field::Handle(
      view_cls.LookupField(String::Handle(Symbols::New(thread, "data"))));
  EXPECT(!original_field.IsNull());
  const Field& field = Field::Handle(original_field.CloneFromOriginal());
 
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
 
  Definition* load;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    // array <- AllocateTypedData(1)
    const auto array = builder.AddDefinition(new AllocateTypedDataInstr(
        InstructionSource(), kTypedDataFloat64ArrayCid,
        new Value(H.IntConstant(1)), DeoptId::kNone));
    // view <- AllocateObject(View)
    const auto view = builder.AddDefinition(
        new AllocateObjectInstr(InstructionSource(), view_cls, DeoptId::kNone));
    // StoreField(view.data = array)
    builder.AddInstruction(new StoreFieldInstr(
        field, new Value(view), new Value(array),
        StoreBarrierType::kNoStoreBarrier, InstructionSource(),
        &H.flow_graph()->parsed_function()));
    // StoreIndexed(array <float64>, 0, 1.0)
    builder.AddInstruction(new StoreIndexedInstr(
        new Value(array), new Value(H.IntConstant(0)),
        new Value(H.DoubleConstant(1.0)), StoreBarrierType::kNoStoreBarrier,
        /*index_unboxed=*/false,
        /*index_scale=*/Instance::ElementSizeFor(kTypedDataFloat64ArrayCid),
        kTypedDataFloat64ArrayCid, AlignmentType::kAlignedAccess,
        DeoptId::kNone, InstructionSource()));
    // array_alias <- LoadField(view.data)
    const auto array_alias = builder.AddDefinition(new LoadFieldInstr(
        new Value(view), Slot::Get(field, &H.flow_graph()->parsed_function()),
        InstructionSource()));
    // StoreIndexed(array_alias <float32>, 1, 2.0)
    builder.AddInstruction(new StoreIndexedInstr(
        new Value(array_alias), new Value(H.IntConstant(1)),
        new Value(H.DoubleConstant(2.0)), StoreBarrierType::kNoStoreBarrier,
        /*index_unboxed=*/false,
        /*index_scale=*/Instance::ElementSizeFor(kTypedDataFloat32ArrayCid),
        kTypedDataFloat32ArrayCid, AlignmentType::kAlignedAccess,
        DeoptId::kNone, InstructionSource()));
    // load <- LoadIndexed(array <float64>, 0)
    load = builder.AddDefinition(new LoadIndexedInstr(
        new Value(array), new Value(H.IntConstant(0)), /*index_unboxed=*/false,
        /*index_scale=*/Instance::ElementSizeFor(kTypedDataFloat64ArrayCid),
        kTypedDataFloat64ArrayCid, AlignmentType::kAlignedAccess,
        DeoptId::kNone, InstructionSource()));
    // Return(load)
    ret = builder.AddReturn(new Value(load));
  }
  H.FinishGraph();
  DominatorBasedCSE::Optimize(H.flow_graph());
 
  // Check that we do not forward the load in question.
  EXPECT_PROPERTY(ret, it.value()->definition() == load);
}

ISOLATE_UNIT_TEST_CASE() [222/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LocalScope

)

Definition at line 11 of file scopes_test.cc.

                                   {
  // Allocate a couple of local variables first.
  const Type& dynamic_type = Type::ZoneHandle(Type::DynamicType());
  const String& a = String::ZoneHandle(Symbols::New(thread, "a"));
  LocalVariable* var_a = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, a, dynamic_type);
  LocalVariable* inner_var_a = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, a, dynamic_type);
  const String& b = String::ZoneHandle(Symbols::New(thread, "b"));
  LocalVariable* var_b = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, b, dynamic_type);
  const String& c = String::ZoneHandle(Symbols::New(thread, "c"));
  LocalVariable* var_c = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, c, dynamic_type);
 
  LocalScope* outer_scope = new LocalScope(nullptr, 0, 0);
  LocalScope* inner_scope1 = new LocalScope(outer_scope, 0, 0);
  LocalScope* inner_scope2 = new LocalScope(outer_scope, 0, 0);
 
  EXPECT(outer_scope->parent() == nullptr);
  EXPECT_EQ(outer_scope, inner_scope1->parent());
  EXPECT_EQ(outer_scope, inner_scope2->parent());
  EXPECT_EQ(inner_scope2, outer_scope->child());
  EXPECT_EQ(inner_scope1, inner_scope2->sibling());
  EXPECT(inner_scope1->child() == nullptr);
  EXPECT(inner_scope2->child() == nullptr);
 
  // Populate the local scopes as follows:
  // {  // outer_scope
  //   var a;
  //   {  // inner_scope1
  //     var b;
  //   }
  //   L: {  // inner_scope2
  //     var c;
  //   }
  // }
  EXPECT(outer_scope->AddVariable(var_a));
  EXPECT(inner_scope1->AddVariable(var_b));
  EXPECT(inner_scope2->AddVariable(var_c));
  EXPECT(!outer_scope->AddVariable(var_a));
 
  // Check the simple layout above.
  EXPECT_EQ(var_a, outer_scope->LocalLookupVariable(
                       a, LocalVariable::kNoKernelOffset));
  EXPECT_EQ(var_a, inner_scope1->LookupVariable(
                       a, LocalVariable::kNoKernelOffset, true));
  EXPECT(outer_scope->LocalLookupVariable(b, LocalVariable::kNoKernelOffset) ==
         nullptr);
  EXPECT(inner_scope1->LocalLookupVariable(c, LocalVariable::kNoKernelOffset) ==
         nullptr);
 
  // Modify the local scopes to contain shadowing:
  // {  // outer_scope
  //   var a;
  //   {  // inner_scope1
  //     var b;
  //     var a;  // inner_var_a
  //   }
  //   {  // inner_scope2
  //     var c;
  //     L: ...
  //   }
  // }
  EXPECT(inner_scope1->AddVariable(inner_var_a));
  EXPECT_EQ(inner_var_a, inner_scope1->LookupVariable(
                             a, LocalVariable::kNoKernelOffset, true));
  EXPECT(inner_scope1->LookupVariable(a, LocalVariable::kNoKernelOffset,
                                      true) != var_a);
 
  // Modify the local scopes with access of an outer scope variable:
  // {  // outer_scope
  //   var a;
  //   {  // inner_scope1
  //     var b;
  //     var a;  // inner_var_a
  //   }
  //   {  // inner_scope2
  //     var c = a;
  //     L: ...
  //   }
  // }
  EXPECT(inner_scope2->LocalLookupVariable(a, LocalVariable::kNoKernelOffset) ==
         nullptr);
  EXPECT(inner_scope2->AddVariable(var_a));
  EXPECT_EQ(var_a, inner_scope2->LocalLookupVariable(
                       a, LocalVariable::kNoKernelOffset));
 
  EXPECT_EQ(1, outer_scope->num_variables());
  EXPECT_EQ(2, inner_scope1->num_variables());
  EXPECT_EQ(2, inner_scope2->num_variables());
 
  // Cannot depend on the order, but we should find the variables.
  EXPECT(outer_scope->VariableAt(0) == var_a);
  EXPECT((inner_scope1->VariableAt(0) == inner_var_a) ||
         (inner_scope1->VariableAt(1) == inner_var_a));
  EXPECT((inner_scope1->VariableAt(0) == var_b) ||
         (inner_scope1->VariableAt(1) == var_b));
  EXPECT((inner_scope2->VariableAt(0) == var_a) ||
         (inner_scope2->VariableAt(1) == var_a) ||
         (inner_scope2->VariableAt(2) == var_a));
  EXPECT((inner_scope2->VariableAt(0) == var_c) ||
         (inner_scope2->VariableAt(1) == var_c) ||
         (inner_scope2->VariableAt(2) == var_c));
}

ISOLATE_UNIT_TEST_CASE() [223/463]

dart::ISOLATE_UNIT_TEST_CASE

(

LongJump

)

Definition at line 18 of file longjump_test.cc.

                                 {
  LongJumpScope* base = Thread::Current()->long_jump_base();
  {
    LongJumpScope jump;
    if (setjmp(*jump.Set()) == 0) {
      LongJumpHelper(&jump);
      UNREACHABLE();
    } else {
      ASSERT(Error::Handle(thread->StealStickyError()).IsLanguageError());
    }
  }
  ASSERT(base == Thread::Current()->long_jump_base());
}

ISOLATE_UNIT_TEST_CASE() [224/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ManySimpleTasksWithZones

)

Definition at line 309 of file thread_test.cc.

                                                 {
  const int kTaskCount = 10;
  Monitor monitor;
  Monitor sync;
  Thread* threads[kTaskCount];
  auto isolate_group = thread->isolate_group();
  intptr_t done_count = 0;
  bool wait = true;
 
  EXPECT(!thread->force_growth());
 
  ForceGrowthScope no_heap_growth_scope(thread);
 
  for (intptr_t i = 0; i < kTaskCount; i++) {
    Dart::thread_pool()->Run<SimpleTaskWithZoneAllocation>(
        (i + 1), isolate_group, &threads[i], &sync, &monitor, &done_count,
        &wait);
  }
  // Wait until all spawned tasks finish their memory operations.
  {
    MonitorLocker ml(&monitor);
    while (done_count < kTaskCount) {
      ml.Wait();
    }
    // Reset the done counter for use later.
    done_count = 0;
  }
 
  // Unblock the tasks so they can finish.
  {
    MonitorLocker sync_ml(&sync);
    wait = false;
    sync_ml.NotifyAll();
  }
  // Now wait for them all to exit before destroying the isolate.
  {
    MonitorLocker ml(&monitor);
    while (done_count < kTaskCount) {
      ml.Wait();
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [225/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ManyTasksWithZones

)

Definition at line 190 of file thread_test.cc.

                                           {
  const int kTaskCount = 100;
  Monitor sync[kTaskCount];
  bool done[kTaskCount];
  auto isolate = thread->isolate();
  auto isolate_group = thread->isolate_group();
  for (int i = 0; i < kTaskCount; i++) {
    done[i] = false;
    Dart::thread_pool()->Run<TaskWithZoneAllocation>(isolate_group, &sync[i],
                                                     &done[i], i);
  }
  bool in_isolate = true;
  for (int i = 0; i < kTaskCount; i++) {
    // Check that main mutator thread can still freely use its own zone.
    String& bar = String::Handle(String::New("bar"));
    if (i % 10 == 0) {
      // Mutator thread is free to independently move in/out/between isolates.
      Thread::ExitIsolate();
      in_isolate = false;
    }
    MonitorLocker ml(&sync[i]);
    while (!done[i]) {
      if (in_isolate) {
        ml.WaitWithSafepointCheck(thread);
      } else {
        ml.Wait();
      }
    }
    EXPECT(done[i]);
    if (i % 10 == 0) {
      Thread::EnterIsolate(isolate);
      in_isolate = true;
    }
    EXPECT(bar.Equals("bar"));
  }
}

ISOLATE_UNIT_TEST_CASE() [226/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Maps

)

Definition at line 253 of file hash_table_test.cc.

                             {
  for (intptr_t initial_capacity = 0; initial_capacity < 32;
       ++initial_capacity) {
    TestMap<UnorderedHashMap<TestTraits> >(initial_capacity, false);
  }
}

ISOLATE_UNIT_TEST_CASE() [227/463]

dart::ISOLATE_UNIT_TEST_CASE

(

MegamorphicCache

)

Definition at line 3149 of file object_test.cc.

                                         {
  const auto& name = String::Handle(Symbols::New(thread, "name"));
  const auto& args_descriptor =
      Array::Handle(ArgumentsDescriptor::NewBoxed(1, 1, Object::null_array()));
 
  const auto& cidA = Smi::Handle(Smi::New(1));
  const auto& cidB = Smi::Handle(Smi::New(2));
 
  const auto& valueA = Smi::Handle(Smi::New(42));
  const auto& valueB = Smi::Handle(Smi::New(43));
 
  // Test normal insert/lookup methods.
  {
    const auto& cache =
        MegamorphicCache::Handle(MegamorphicCache::New(name, args_descriptor));
 
    EXPECT(cache.Lookup(cidA) == Object::null());
    cache.EnsureContains(cidA, valueA);
    EXPECT(cache.Lookup(cidA) == valueA.ptr());
 
    EXPECT(cache.Lookup(cidB) == Object::null());
    cache.EnsureContains(cidB, valueB);
    EXPECT(cache.Lookup(cidB) == valueB.ptr());
  }
 
  // Try to insert many keys to hit collisions & growth.
  {
    const auto& cache =
        MegamorphicCache::Handle(MegamorphicCache::New(name, args_descriptor));
 
    auto& cid = Smi::Handle();
    auto& value = Object::Handle();
    for (intptr_t i = 0; i < 100; ++i) {
      cid = Smi::New(100 * i);
      if (cid.Value() == kIllegalCid) continue;
 
      value = Smi::New(i);
      cache.EnsureContains(cid, value);
    }
    auto& expected = Object::Handle();
    for (intptr_t i = 0; i < 100; ++i) {
      cid = Smi::New(100 * i);
      if (cid.Value() == kIllegalCid) continue;
 
      expected = Smi::New(i);
      value = cache.Lookup(cid);
      EXPECT(Smi::Cast(value).Equals(Smi::Cast(expected)));
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [228/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Metric_EmbedderAPI

)

Definition at line 79 of file metrics_test.cc.

                                           {
  {
    TransitionVMToNative transition(thread);
 
    const char* kScript = "void main() {}";
    Dart_Handle api_lib = TestCase::LoadTestScript(
        kScript, /*resolver=*/nullptr, RESOLVED_USER_TEST_URI);
    EXPECT_VALID(api_lib);
  }
 
  // Ensure we've done new/old GCs to ensure max metrics are initialized.
  String::New("<land-in-new-space>", Heap::kNew);
  thread->heap()->CollectGarbage(thread, GCType::kScavenge,
                                 GCReason::kDebugging);
  thread->heap()->CollectGarbage(thread, GCType::kMarkCompact,
                                 GCReason::kDebugging);
 
  // Ensure we've something live in new space.
  String::New("<land-in-new-space2>", Heap::kNew);
 
  EXPECT(thread->isolate_group()->GetHeapOldUsedMaxMetric()->Value() > 0);
  EXPECT(thread->isolate_group()->GetHeapOldCapacityMaxMetric()->Value() > 0);
  EXPECT(thread->isolate_group()->GetHeapNewUsedMaxMetric()->Value() > 0);
  EXPECT(thread->isolate_group()->GetHeapNewCapacityMaxMetric()->Value() > 0);
  EXPECT(thread->isolate_group()->GetHeapGlobalUsedMetric()->Value() > 0);
  EXPECT(thread->isolate_group()->GetHeapGlobalUsedMaxMetric()->Value() > 0);
 
  {
    TransitionVMToNative transition(thread);
 
    Dart_IsolateGroup isolate_group = Dart_CurrentIsolateGroup();
    EXPECT(Dart_IsolateGroupHeapOldUsedMetric(isolate_group) > 0);
    EXPECT(Dart_IsolateGroupHeapOldCapacityMetric(isolate_group) > 0);
    EXPECT(Dart_IsolateGroupHeapNewUsedMetric(isolate_group) > 0);
    EXPECT(Dart_IsolateGroupHeapNewCapacityMetric(isolate_group) > 0);
  }
}

ISOLATE_UNIT_TEST_CASE() [229/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Mint

)

Definition at line 512 of file object_test.cc.

                             {
// On 64-bit architectures a Smi is stored in a 64 bit word. A Midint cannot
// be allocated if it does fit into a Smi.
#if !defined(ARCH_IS_64_BIT) || defined(DART_COMPRESSED_POINTERS)
  {
    Mint& med = Mint::Handle();
    EXPECT(med.IsNull());
    int64_t v = DART_2PART_UINT64_C(1, 0);
    med ^= Integer::New(v);
    EXPECT_EQ(v, med.value());
    const String& smi_str = String::Handle(String::New("1"));
    const String& mint1_str = String::Handle(String::New("2147419168"));
    const String& mint2_str = String::Handle(String::New("-2147419168"));
    Integer& i = Integer::Handle(Integer::NewCanonical(smi_str));
    EXPECT(i.IsSmi());
    i = Integer::NewCanonical(mint1_str);
    EXPECT(i.IsMint());
    EXPECT(!i.IsZero());
    EXPECT(!i.IsNegative());
    i = Integer::NewCanonical(mint2_str);
    EXPECT(i.IsMint());
    EXPECT(!i.IsZero());
    EXPECT(i.IsNegative());
  }
  Integer& i = Integer::Handle(Integer::New(DART_2PART_UINT64_C(1, 0)));
  EXPECT(i.IsMint());
  EXPECT(!i.IsZero());
  EXPECT(!i.IsNegative());
  Integer& i1 = Integer::Handle(Integer::New(DART_2PART_UINT64_C(1010, 0)));
  Mint& i2 = Mint::Handle();
  i2 ^= Integer::New(DART_2PART_UINT64_C(1010, 0));
  EXPECT(i1.Equals(i2));
  EXPECT(!i.Equals(i1));
  int64_t test = DART_2PART_UINT64_C(1010, 0);
  EXPECT_EQ(test, i2.value());
 
  Mint& a = Mint::Handle();
  a ^= Integer::New(DART_2PART_UINT64_C(5, 0));
  Mint& b = Mint::Handle();
  b ^= Integer::New(DART_2PART_UINT64_C(3, 0));
  EXPECT_EQ(1, a.CompareWith(b));
  EXPECT_EQ(-1, b.CompareWith(a));
  EXPECT_EQ(0, a.CompareWith(a));
 
  Mint& c = Mint::Handle();
  c ^= Integer::New(-DART_2PART_UINT64_C(3, 0));
  Smi& smi1 = Smi::Handle(Smi::New(4));
  Smi& smi2 = Smi::Handle(Smi::New(-4));
  EXPECT_EQ(1, a.CompareWith(smi1));
  EXPECT_EQ(1, a.CompareWith(smi2));
  EXPECT_EQ(-1, c.CompareWith(smi1));
  EXPECT_EQ(-1, c.CompareWith(smi2));
 
  int64_t mint_value = DART_2PART_UINT64_C(0x7FFFFFFF, 64);
  const String& mint_string = String::Handle(String::New("0x7FFFFFFF00000064"));
  Mint& mint1 = Mint::Handle();
  mint1 ^= Integer::NewCanonical(mint_string);
  Mint& mint2 = Mint::Handle();
  mint2 ^= Integer::NewCanonical(mint_string);
  EXPECT_EQ(mint1.value(), mint_value);
  EXPECT_EQ(mint2.value(), mint_value);
  EXPECT_EQ(mint1.ptr(), mint2.ptr());
#endif
}

ISOLATE_UNIT_TEST_CASE() [230/463]

dart::ISOLATE_UNIT_TEST_CASE

(

MirrorReference

)

Definition at line 5266 of file object_test.cc.

                                        {
  const MirrorReference& reference =
      MirrorReference::Handle(MirrorReference::New(Object::Handle()));
  Object& initial_referent = Object::Handle(reference.referent());
  EXPECT(initial_referent.IsNull());
 
  Library& library = Library::Handle(Library::CoreLibrary());
  EXPECT(!library.IsNull());
  EXPECT(library.IsLibrary());
  reference.set_referent(library);
  const Object& returned_referent = Object::Handle(reference.referent());
  EXPECT(returned_referent.IsLibrary());
  EXPECT_EQ(returned_referent.ptr(), library.ptr());
 
  const MirrorReference& other_reference =
      MirrorReference::Handle(MirrorReference::New(Object::Handle()));
  EXPECT_NE(reference.ptr(), other_reference.ptr());
  other_reference.set_referent(library);
  EXPECT_NE(reference.ptr(), other_reference.ptr());
  EXPECT_EQ(reference.referent(), other_reference.referent());
 
  Object& obj = Object::Handle(reference.ptr());
  EXPECT(obj.IsMirrorReference());
}

ISOLATE_UNIT_TEST_CASE() [231/463]

dart::ISOLATE_UNIT_TEST_CASE

(

NonStrictConditionDown

)

Definition at line 267 of file loops_test.cc.

             {
        foo();
      }
    )";
  const char* expected =
      "  [0\n"

ISOLATE_UNIT_TEST_CASE() [232/463]

dart::ISOLATE_UNIT_TEST_CASE

(

NonStrictConditionDownWrap

)

Definition at line 278 of file loops_test.cc.

                                             {

ISOLATE_UNIT_TEST_CASE() [233/463]

dart::ISOLATE_UNIT_TEST_CASE

(

NonStrictConditionUp

)

Definition at line 245 of file loops_test.cc.

ISOLATE_UNIT_TEST_CASE() [234/463]

dart::ISOLATE_UNIT_TEST_CASE

(

NonStrictConditionUpWrap

)

Definition at line 256 of file loops_test.cc.

                                         {
  const char* script_chars =
      R"(
      foo() {
        for (int i = 1; i < 100; i++) {
          int a = i + 3;

ISOLATE_UNIT_TEST_CASE() [235/463]

dart::ISOLATE_UNIT_TEST_CASE

(

NotEqualConditionDown

)

Definition at line 300 of file loops_test.cc.

             {
        foo();
      }
      )";
  const char* expected =
      "  [0\n"
      "  WRAP(99, LIN(0 + 1 * i))\n"    // phi (w)
      "  LIN(0 + 1 * i) 100\n"          // phi (i)
      "  WRAP(102, LIN(3 + 1 * i))\n"   // a
      "  WRAP(94, LIN(-5 + 1 * i))\n"   // b

ISOLATE_UNIT_TEST_CASE() [236/463]

dart::ISOLATE_UNIT_TEST_CASE

(

NotEqualConditionUp

)

Definition at line 289 of file loops_test.cc.

            {
        int w = 99;
        for (int i = 0; i < 100; i++) {
          int a = w + 3;
          int b = w - 5;
          int c = w * 7;
          int d = - w;
          w = i;
        }

ISOLATE_UNIT_TEST_CASE() [237/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ObjectGraph

)

Definition at line 42 of file object_graph_test.cc.

                                    {
  auto heap = thread->isolate_group()->heap();
 
  // Create a simple object graph with objects a, b, c, d:
  //  a+->b+->c
  //  +   +
  //  |   v
  //  +-->d
  Array& a = Array::Handle(Array::New(12, Heap::kNew));
  Array& b = Array::Handle(Array::New(2, Heap::kOld));
  Array& c = Array::Handle(Array::New(0, Heap::kOld));
  Array& d = Array::Handle(Array::New(0, Heap::kOld));
  a.SetAt(10, b);
  b.SetAt(0, c);
  b.SetAt(1, d);
  a.SetAt(11, d);
  intptr_t a_size = a.ptr()->untag()->HeapSize();
  intptr_t b_size = b.ptr()->untag()->HeapSize();
  intptr_t c_size = c.ptr()->untag()->HeapSize();
  intptr_t d_size = d.ptr()->untag()->HeapSize();
  {
    // No more allocation; raw pointers ahead.
    GcSafepointOperationScope safepoint(thread);
    ObjectPtr b_raw = b.ptr();
    // Clear handles to cut unintended retained paths.
    b = Array::null();
    c = Array::null();
    d = Array::null();
    ObjectGraph graph(thread);
    {
      HeapIterationScope iteration_scope(thread, true);
      {
        // Compare count and size when 'b' is/isn't skipped.
        CounterVisitor with(Object::null(), Object::null());
        graph.IterateObjectsFrom(a, &with);
        CounterVisitor without(b_raw, a.ptr());
        graph.IterateObjectsFrom(a, &without);
        // Only 'b' and 'c' were cut off.
        EXPECT_EQ(2, with.count() - without.count());
        EXPECT_EQ(b_size + c_size, with.size() - without.size());
      }
      {
        // Like above, but iterate over the entire isolate. The counts and sizes
        // are thus larger, but the difference should still be just 'b' and 'c'.
        CounterVisitor with(Object::null(), Object::null());
        graph.IterateObjects(&with);
        CounterVisitor without(b_raw, a.ptr());
        graph.IterateObjects(&without);
        EXPECT_EQ(2, with.count() - without.count());
        EXPECT_EQ(b_size + c_size, with.size() - without.size());
      }
    }
    EXPECT_EQ(a_size + b_size + c_size + d_size,
              graph.SizeRetainedByInstance(a));
  }
  {
    // Get hold of c again.
    b ^= a.At(10);
    c ^= b.At(0);
    b = Array::null();
    ObjectGraph graph(thread);
    // A retaining path should end like this: c <- b <- a <- ...
    {
      HANDLESCOPE(thread);
      // Test null, empty, and length 1 array.
      intptr_t null_length =
          graph.RetainingPath(&c, Object::null_array()).length;
      intptr_t empty_length =
          graph.RetainingPath(&c, Object::empty_array()).length;
      Array& path = Array::Handle(Array::New(1, Heap::kNew));
      intptr_t one_length = graph.RetainingPath(&c, path).length;
      EXPECT_EQ(null_length, empty_length);
      EXPECT_EQ(null_length, one_length);
      EXPECT_LE(3, null_length);
    }
    {
      HANDLESCOPE(thread);
      Array& path = Array::Handle(Array::New(6, Heap::kNew));
      // Trigger a full GC to increase probability of concurrent tasks.
      heap->CollectAllGarbage();
      intptr_t length = graph.RetainingPath(&c, path).length;
      EXPECT_LE(3, length);
      Array& expected_c = Array::Handle();
      expected_c ^= path.At(0);
      // c is the first element in b.
      Smi& offset_from_parent = Smi::Handle();
      offset_from_parent ^= path.At(1);
      EXPECT_EQ(Array::element_offset(0), offset_from_parent.Value());
      Array& expected_b = Array::Handle();
      expected_b ^= path.At(2);
      // b is the element with index 10 in a.
      offset_from_parent ^= path.At(3);
      EXPECT_EQ(Array::element_offset(10), offset_from_parent.Value());
      Array& expected_a = Array::Handle();
      expected_a ^= path.At(4);
      EXPECT(expected_c.ptr() == c.ptr());
      EXPECT(expected_b.ptr() == a.At(10));
      EXPECT(expected_a.ptr() == a.ptr());
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [238/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ObjectIdRingExpiredEntryTest

)

Definition at line 246 of file object_id_ring_test.cc.

                                                     {
  Isolate* isolate = Isolate::Current();
  ObjectIdRing* ring = isolate->EnsureObjectIdRing();
 
  // Insert an object and check we can look it up.
  String& obj = String::Handle(String::New("I will expire"));
  intptr_t obj_id = ring->GetIdForObject(obj.ptr());
  ObjectIdRing::LookupResult kind = ObjectIdRing::kInvalid;
  ObjectPtr obj_lookup = ring->GetObjectForId(obj_id, &kind);
  EXPECT_EQ(ObjectIdRing::kValid, kind);
  EXPECT_EQ(obj.ptr(), obj_lookup);
 
  // Insert as many new objects as the ring size to bump out our first entry.
  Object& new_obj = Object::Handle();
  for (intptr_t i = 0; i < ObjectIdRing::kDefaultCapacity; i++) {
    new_obj = String::New("Bump");
    intptr_t new_obj_id = ring->GetIdForObject(new_obj.ptr());
    ObjectIdRing::LookupResult kind = ObjectIdRing::kInvalid;
    ObjectPtr new_obj_lookup = ring->GetObjectForId(new_obj_id, &kind);
    EXPECT_EQ(ObjectIdRing::kValid, kind);
    EXPECT_EQ(new_obj.ptr(), new_obj_lookup);
  }
 
  // Check our first entry reports it has expired.
  obj_lookup = ring->GetObjectForId(obj_id, &kind);
  EXPECT_EQ(ObjectIdRing::kExpired, kind);
  EXPECT_NE(obj.ptr(), obj_lookup);
  EXPECT_EQ(Object::null(), obj_lookup);
}

ISOLATE_UNIT_TEST_CASE() [239/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ObjectIdRingOldGCTest

)

Definition at line 199 of file object_id_ring_test.cc.

                                              {
  Isolate* isolate = thread->isolate();
  ObjectIdRing* ring = isolate->EnsureObjectIdRing();
 
  ObjectIdRing::LookupResult kind = ObjectIdRing::kInvalid;
  intptr_t raw_obj_id1 = -1;
  intptr_t raw_obj_id2 = -1;
  {
    HandleScope handle_scope(thread);
    const String& str = String::Handle(String::New("old", Heap::kOld));
    EXPECT(!str.IsNull());
    EXPECT_EQ(3, str.Length());
 
    ObjectPtr raw_obj = Object::RawCast(str.ptr());
    // Verify that it is located in old heap.
    EXPECT(raw_obj->IsOldObject());
    EXPECT_NE(Object::null(), raw_obj);
    raw_obj_id1 = ring->GetIdForObject(raw_obj);
    EXPECT_EQ(0, raw_obj_id1);
    raw_obj_id2 = ring->GetIdForObject(raw_obj);
    EXPECT_EQ(1, raw_obj_id2);
    ObjectPtr raw_obj1 = ring->GetObjectForId(raw_obj_id1, &kind);
    EXPECT_EQ(ObjectIdRing::kValid, kind);
    ObjectPtr raw_obj2 = ring->GetObjectForId(raw_obj_id2, &kind);
    EXPECT_EQ(ObjectIdRing::kValid, kind);
    EXPECT_NE(Object::null(), raw_obj1);
    EXPECT_NE(Object::null(), raw_obj2);
    EXPECT_EQ(UntaggedObject::ToAddr(raw_obj),
              UntaggedObject::ToAddr(raw_obj1));
    EXPECT_EQ(UntaggedObject::ToAddr(raw_obj),
              UntaggedObject::ToAddr(raw_obj2));
    // Exit scope. Freeing String handle.
  }
  // Force a GC. No reference exist to the old string anymore. It should be
  // collected and the object id ring will now return the null object for
  // those ids.
  GCTestHelper::CollectOldSpace();
  ObjectPtr raw_object_moved1 = ring->GetObjectForId(raw_obj_id1, &kind);
  EXPECT_EQ(ObjectIdRing::kCollected, kind);
  EXPECT_EQ(Object::null(), raw_object_moved1);
  ObjectPtr raw_object_moved2 = ring->GetObjectForId(raw_obj_id2, &kind);
  EXPECT_EQ(ObjectIdRing::kCollected, kind);
  EXPECT_EQ(Object::null(), raw_object_moved2);
}

ISOLATE_UNIT_TEST_CASE() [240/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ObjectIdRingSerialWrapTest

)

Definition at line 53 of file object_id_ring_test.cc.

                                                   {
  Isolate* isolate = Isolate::Current();
  ObjectIdRing* ring = isolate->EnsureObjectIdRing();
  ObjectIdRingTestHelper::SetCapacityAndMaxSerial(ring, 2, 4);
  intptr_t id;
  ObjectIdRing::LookupResult kind = ObjectIdRing::kInvalid;
  id = ring->GetIdForObject(ObjectIdRingTestHelper::MakeString("0"));
  EXPECT_EQ(0, id);
  ObjectIdRingTestHelper::ExpectIndexId(ring, 0, 0);
  ObjectIdRingTestHelper::ExpectInvalidIndex(ring, 1);
  id = ring->GetIdForObject(ObjectIdRingTestHelper::MakeString("1"));
  EXPECT_EQ(1, id);
  ObjectIdRingTestHelper::ExpectIndexId(ring, 0, 0);
  ObjectIdRingTestHelper::ExpectIndexId(ring, 1, 1);
  // Test that id 1 gives us the "1" string.
  ObjectIdRingTestHelper::ExpectString(ring->GetObjectForId(id, &kind), "1");
  EXPECT_EQ(ObjectIdRing::kValid, kind);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 0);
  ObjectIdRingTestHelper::ExpectIndexId(ring, 0, 0);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 1);
  ObjectIdRingTestHelper::ExpectIndexId(ring, 1, 1);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 2);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 3);
  // We have wrapped, index 0 is being reused.
  id = ring->GetIdForObject(ObjectIdRingTestHelper::MakeString("2"));
  EXPECT_EQ(2, id);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 0);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 1);
  // Index 0 has id 2.
  ObjectIdRingTestHelper::ExpectIndexId(ring, 0, 2);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 2);
  // Index 1 has id 1.
  ObjectIdRingTestHelper::ExpectIndexId(ring, 1, 1);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 3);
  id = ring->GetIdForObject(ObjectIdRingTestHelper::MakeString("3"));
  EXPECT_EQ(3, id);
  // Index 0 has id 2.
  ObjectIdRingTestHelper::ExpectIndexId(ring, 0, 2);
  // Index 1 has id 3.
  ObjectIdRingTestHelper::ExpectIndexId(ring, 1, 3);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 0);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 1);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 2);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 3);
  id = ring->GetIdForObject(ObjectIdRingTestHelper::MakeString("4"));
  EXPECT_EQ(0, id);
  // Index 0 has id 0.
  ObjectIdRingTestHelper::ExpectIndexId(ring, 0, 0);
  // Index 1 has id 3.
  ObjectIdRingTestHelper::ExpectIndexId(ring, 1, 3);
  ObjectIdRingTestHelper::ExpectString(ring->GetObjectForId(id, &kind), "4");
  EXPECT_EQ(ObjectIdRing::kValid, kind);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 0);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 1);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 2);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 3);
  id = ring->GetIdForObject(ObjectIdRingTestHelper::MakeString("5"));
  EXPECT_EQ(1, id);
  // Index 0 has id 0.
  ObjectIdRingTestHelper::ExpectIndexId(ring, 0, 0);
  // Index 1 has id 1.
  ObjectIdRingTestHelper::ExpectIndexId(ring, 1, 1);
  ObjectIdRingTestHelper::ExpectString(ring->GetObjectForId(id, &kind), "5");
  EXPECT_EQ(ObjectIdRing::kValid, kind);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 0);
  ObjectIdRingTestHelper::ExpectIdIsValid(ring, 1);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 2);
  ObjectIdRingTestHelper::ExpectIdIsInvalid(ring, 3);
}

ISOLATE_UNIT_TEST_CASE() [241/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ObjectPrinting

)

Definition at line 2598 of file object_test.cc.

                                       {
  // Simple Smis.
  EXPECT_STREQ("2", Smi::Handle(Smi::New(2)).ToCString());
  EXPECT_STREQ("-15", Smi::Handle(Smi::New(-15)).ToCString());
 
  // bool class and true/false values.
  ObjectStore* object_store = IsolateGroup::Current()->object_store();
  const Class& bool_class = Class::Handle(object_store->bool_class());
  EXPECT_STREQ("Library:'dart:core' Class: bool", bool_class.ToCString());
  EXPECT_STREQ("true", Bool::True().ToCString());
  EXPECT_STREQ("false", Bool::False().ToCString());
 
  // Strings.
  EXPECT_STREQ("Sugarbowl",
               String::Handle(String::New("Sugarbowl")).ToCString());
}

ISOLATE_UNIT_TEST_CASE() [242/463]

dart::ISOLATE_UNIT_TEST_CASE

(

OptimizationTests

)

Definition at line 28 of file il_test.cc.

                                          {
  JoinEntryInstr* join =
      new JoinEntryInstr(1, kInvalidTryIndex, DeoptId::kNone);
 
  Definition* def1 = new PhiInstr(join, 0);
  Definition* def2 = new PhiInstr(join, 0);
  Value* use1a = new Value(def1);
  Value* use1b = new Value(def1);
  EXPECT(use1a->Equals(*use1b));
  Value* use2 = new Value(def2);
  EXPECT(!use2->Equals(*use1a));
 
  ConstantInstr* c1 = new ConstantInstr(Bool::True());
  ConstantInstr* c2 = new ConstantInstr(Bool::True());
  EXPECT(c1->Equals(*c2));
  ConstantInstr* c3 = new ConstantInstr(Object::ZoneHandle());
  ConstantInstr* c4 = new ConstantInstr(Object::ZoneHandle());
  EXPECT(c3->Equals(*c4));
  EXPECT(!c3->Equals(*c1));
}

ISOLATE_UNIT_TEST_CASE() [243/463]

dart::ISOLATE_UNIT_TEST_CASE

(

OptimizeCompileFunctionOnHelperThread

)

Definition at line 61 of file compiler_test.cc.

                                                              {
  // Create a simple function and compile it without optimization.
  const char* kScriptChars =
      "class A {\n"
      "  static foo() { return 42; }\n"
      "}\n";
  Dart_Handle library;
  {
    TransitionVMToNative transition(thread);
    library = TestCase::LoadTestScript(kScriptChars, nullptr);
  }
  const Library& lib =
      Library::Handle(Library::RawCast(Api::UnwrapHandle(library)));
  EXPECT(ClassFinalizer::ProcessPendingClasses());
  Class& cls =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
  EXPECT(!cls.IsNull());
  String& function_foo_name = String::Handle(String::New("foo"));
  const auto& error = cls.EnsureIsFinalized(thread);
  EXPECT(error == Error::null());
  Function& func =
      Function::Handle(cls.LookupStaticFunction(function_foo_name));
  EXPECT(!func.HasCode());
  CompilerTest::TestCompileFunction(func);
  EXPECT(func.HasCode());
  EXPECT(!func.HasOptimizedCode());
#if !defined(PRODUCT)
  // Constant in product mode.
  FLAG_background_compilation = true;
#endif
  auto isolate_group = thread->isolate_group();
  isolate_group->background_compiler()->EnqueueCompilation(func);
  Monitor* m = new Monitor();
  {
    SafepointMonitorLocker ml(m);
    while (!func.HasOptimizedCode()) {
      ml.Wait(1);
    }
  }
  delete m;
}

ISOLATE_UNIT_TEST_CASE() [244/463]

dart::ISOLATE_UNIT_TEST_CASE

(

PcDescriptors

)

Definition at line 2822 of file object_test.cc.

                                      {
  DescriptorList* builder = new DescriptorList(thread->zone());
 
  // kind, pc_offset, deopt_id, token_pos, try_index, yield_index
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 10, 1,
                         TokenPosition::Deserialize(20), 1, 1);
  builder->AddDescriptor(UntaggedPcDescriptors::kDeopt, 20, 2,
                         TokenPosition::Deserialize(30), 0, -1);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 30, 3,
                         TokenPosition::Deserialize(40), 1, 10);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 10, 4,
                         TokenPosition::Deserialize(40), 2, 20);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 10, 5,
                         TokenPosition::Deserialize(80), 3, 30);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 80, 6,
                         TokenPosition::Deserialize(150), 3, 30);
 
  PcDescriptors& descriptors = PcDescriptors::Handle();
  descriptors ^= builder->FinalizePcDescriptors(0);
 
  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
      Code::PoolAttachment::kAttachPool));
  code.set_pc_descriptors(descriptors);
 
  // Verify the PcDescriptor entries by accessing them.
  const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors());
  PcDescriptors::Iterator iter(pc_descs, UntaggedPcDescriptors::kAnyKind);
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(1, iter.YieldIndex());
  EXPECT_EQ(20, iter.TokenPos().Pos());
  EXPECT_EQ(1, iter.TryIndex());
  EXPECT_EQ(static_cast<uword>(10), iter.PcOffset());
  EXPECT_EQ(1, iter.DeoptId());
  EXPECT_EQ(UntaggedPcDescriptors::kOther, iter.Kind());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(-1, iter.YieldIndex());
  EXPECT_EQ(30, iter.TokenPos().Pos());
  EXPECT_EQ(UntaggedPcDescriptors::kDeopt, iter.Kind());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(10, iter.YieldIndex());
  EXPECT_EQ(40, iter.TokenPos().Pos());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(20, iter.YieldIndex());
  EXPECT_EQ(40, iter.TokenPos().Pos());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(30, iter.YieldIndex());
  EXPECT_EQ(80, iter.TokenPos().Pos());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(30, iter.YieldIndex());
  EXPECT_EQ(150, iter.TokenPos().Pos());
 
  EXPECT_EQ(3, iter.TryIndex());
  EXPECT_EQ(static_cast<uword>(80), iter.PcOffset());
  EXPECT_EQ(150, iter.TokenPos().Pos());
  EXPECT_EQ(UntaggedPcDescriptors::kOther, iter.Kind());
 
  EXPECT_EQ(false, iter.MoveNext());
}

ISOLATE_UNIT_TEST_CASE() [245/463]

dart::ISOLATE_UNIT_TEST_CASE

(

PcDescriptorsLargeDeltas

)

Definition at line 2894 of file object_test.cc.

                                                 {
  DescriptorList* builder = new DescriptorList(thread->zone());
 
  // kind, pc_offset, deopt_id, token_pos, try_index
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 100, 1,
                         TokenPosition::Deserialize(200), 1, 10);
  builder->AddDescriptor(UntaggedPcDescriptors::kDeopt, 200, 2,
                         TokenPosition::Deserialize(300), 0, -1);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 300, 3,
                         TokenPosition::Deserialize(400), 1, 10);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 100, 4,
                         TokenPosition::Deserialize(0), 2, 20);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 100, 5,
                         TokenPosition::Deserialize(800), 3, 30);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 800, 6,
                         TokenPosition::Deserialize(150), 3, 30);
 
  PcDescriptors& descriptors = PcDescriptors::Handle();
  descriptors ^= builder->FinalizePcDescriptors(0);
 
  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
      Code::PoolAttachment::kAttachPool));
  code.set_pc_descriptors(descriptors);
 
  // Verify the PcDescriptor entries by accessing them.
  const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors());
  PcDescriptors::Iterator iter(pc_descs, UntaggedPcDescriptors::kAnyKind);
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(10, iter.YieldIndex());
  EXPECT_EQ(200, iter.TokenPos().Pos());
  EXPECT_EQ(1, iter.TryIndex());
  EXPECT_EQ(static_cast<uword>(100), iter.PcOffset());
  EXPECT_EQ(1, iter.DeoptId());
  EXPECT_EQ(UntaggedPcDescriptors::kOther, iter.Kind());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(-1, iter.YieldIndex());
  EXPECT_EQ(300, iter.TokenPos().Pos());
  EXPECT_EQ(UntaggedPcDescriptors::kDeopt, iter.Kind());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(10, iter.YieldIndex());
  EXPECT_EQ(400, iter.TokenPos().Pos());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(20, iter.YieldIndex());
  EXPECT_EQ(0, iter.TokenPos().Pos());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(30, iter.YieldIndex());
  EXPECT_EQ(800, iter.TokenPos().Pos());
 
  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(30, iter.YieldIndex());
  EXPECT_EQ(150, iter.TokenPos().Pos());
 
  EXPECT_EQ(3, iter.TryIndex());
  EXPECT_EQ(static_cast<uword>(800), iter.PcOffset());
  EXPECT_EQ(150, iter.TokenPos().Pos());
  EXPECT_EQ(UntaggedPcDescriptors::kOther, iter.Kind());
 
  EXPECT_EQ(false, iter.MoveNext());
}

ISOLATE_UNIT_TEST_CASE() [246/463]

dart::ISOLATE_UNIT_TEST_CASE

(

PeriodicAndDerived

)

Definition at line 222 of file loops_test.cc.

                                        {
  const char* script_chars =
      R"(
      foo() {
        int j = 123;
        for (int i = 0; i < 100; i++) {
           if (i == 10) {
             j += 3;
           } else {

ISOLATE_UNIT_TEST_CASE() [247/463]

dart::ISOLATE_UNIT_TEST_CASE

(

PrintJSON

)

Definition at line 5902 of file object_test.cc.

                                                  {
    StackZone zone(thread);
    HANDLESCOPE(thread);
 
    // All ToCString implementations should not allocate on the Dart heap so
    // they remain useful in all parts of the VM.
    NoSafepointScope no_safepoint;
    objects[i]->ToCString();
  }
}
 
ISOLATE_UNIT_TEST_CASE(PrintJSON) {
  // Set native resolvers in case we need to read native methods.
  {
    TransitionVMToNative transition(thread);
    bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
    bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
    bin::Builtin::SetNativeResolver(bin::Builtin::kCLILibrary);
    bin::VmService::SetNativeResolver();
  }
 
  GCTestHelper::CollectAllGarbage();
  GrowableArray<Object*> objects;

ISOLATE_UNIT_TEST_CASE() [248/463]

dart::ISOLATE_UNIT_TEST_CASE

(

PrintJSONPrimitives

)

Definition at line 5926 of file object_test.cc.

                                                  {
    JSONStream js;
    objects[i]->PrintJSON(&js, false);
    EXPECT_SUBSTRING("\"type\":", js.ToCString());
  }
}
 
ISOLATE_UNIT_TEST_CASE(PrintJSONPrimitives) {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 4096;
  char buffer[kBufferSize];
  Isolate* isolate = Isolate::Current();
 
  // Class reference
  {
    JSONStream js;
    Class& cls = Class::Handle(isolate->group()->object_store()->bool_class());
    cls.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
 
    EXPECT_STREQ(
        "{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"bool\","
        "\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":\"@"
        "Script\","
        "\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core\\/bool.dart\","
        "\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}}",
        buffer);
  }
  // Function reference
  {
    Thread* thread = Thread::Current();
    JSONStream js;
    Class& cls = Class::Handle(isolate->group()->object_store()->bool_class());
    const String& func_name = String::Handle(String::New("toString"));
    Function& func =
        Function::Handle(Resolver::ResolveFunction(Z, cls, func_name));
    ASSERT(!func.IsNull());
    func.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Function\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"toString\",\"owner\":{\"type\":\"@Class\","
        "\"fixedId\":true,\"id\":\"\",\"name\":\"bool\","
        "\"location\":{\"type\":\"SourceLocation\","
        "\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core\\/bool.dart\","
        "\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"_kind\":\"RegularFunction\",\"static\":false,\"const\":false,"
        "\"implicit\":false,\"abstract\":false,"
        "\"_intrinsic\":false,\"_native\":false,\"isGetter\":false,"
        "\"isSetter\":false,\"location\":{\"type\":\"SourceLocation\","
        "\"script\":{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
        "\"uri\":\"dart:core\\/bool.dart\",\"_kind\":\"kernel\"}}}",
        buffer);
  }
  // Library reference
  {
    JSONStream js;
    Library& lib =
        Library::Handle(isolate->group()->object_store()->core_library());
    lib.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("libraries", json_str, buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}",
        buffer);
  }
  // Bool reference
  {
    JSONStream js;
    Bool::True().PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"Bool\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"bool\",\"location\":{"
        "\"type\":\"SourceLocation\",\"script\":{\"type\":\"@Script\","
        "\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core\\/bool.dart\",\"_"
        "kind\":\"kernel\"}},\"library\":"
        "{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\",\"name\":\"dart."
        "core\",\"uri\":\"dart:core\"}},\"identityHashCode\":0,\"kind\":"
        "\"Bool\",\"fixedId\":true,\"id\":\"objects\\/bool-true\","
        "\"valueAsString\":\"true\"}",
        buffer);
  }
  // Smi reference
  {
    JSONStream js;
    const Integer& smi = Integer::Handle(Integer::New(7));
    smi.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("_Smi@", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"Smi\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_Smi\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/integers.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":0,\"kind\":\"Int\",\"fixedId\":true,\"id\":"
        "\"objects\\/int-7\",\"valueAsString\":\"7\"}",
        buffer);
  }
  // Mint reference
  {
    JSONStream js;
    const Integer& smi = Integer::Handle(Integer::New(Mint::kMinValue));
    smi.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_Mint@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"Mint\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_Mint\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/integers.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"Int\",\"valueAsString\":"
        "\"-9223372036854775808\"}",
        buffer);
  }
  // Double reference
  {
    JSONStream js;
    const Double& dub = Double::Handle(Double::New(0.1234));
    dub.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_Double@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"Double\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_Double\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/double.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"Double\","
        "\"valueAsString\":\"0.1234\"}",
        buffer);
  }
  // String reference
  {
    JSONStream js;
    const String& str = String::Handle(String::New("dw"));
    str.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_OneByteString@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"String\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_OneByteString\",\"_"
        "vmName\":\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/string_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"String\",\"length\":2,"
        "\"valueAsString\":\"dw\"}",
        buffer);
  }
  // Array reference
  {
    JSONStream js;
    const Array& array = Array::Handle(Array::New(0));
    array.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_List@", buffer, buffer);
    ElideJSONSubstring("_TypeParameter@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_SUBSTRING(
        "{\"type\":\"@Instance\",\"_vmType\":\"Array\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_List\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-patch\\/"
        "array.dart\",\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"},\"typeParameters\":[{"
        "\"type\":\"@"
        "Instance\",\"_vmType\":\"TypeParameter\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_TypeParameter\",\"_"
        "vmName\":\"\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core-patch\\/"
        "type_patch.dart\",\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":",
        buffer);
 
    EXPECT_SUBSTRING(
        "\"id\":\"\",\"kind\":\"TypeParameter\",\"name\":\"X0\","
        "\"parameterizedClass\":{\"type\":\"@Instance\",\"_vmType\":\"Class\","
        "\"class\":{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\",\"name\":"
        "\"Null\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:"
        "core\\/"
        "null.dart\",\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\","
        "\"fixedId\":true,\"id\":\"\",\"valueAsString\":\"null\"}}]},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"List\",\"length\":0}",
        buffer);
  }
  OS::PrintErr("\n\n\n");
  // GrowableObjectArray reference
  {
    JSONStream js;
    const GrowableObjectArray& array =
        GrowableObjectArray::Handle(GrowableObjectArray::New());
    array.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_GrowableList@", buffer, buffer);
    StripTokenPositions(buffer);
    ElideJSONSubstring("_TypeParameter@", buffer, buffer);
    EXPECT_SUBSTRING(
        "{\"type\":\"@Instance\",\"_vmType\":\"GrowableObjectArray\",\"class\":"
        "{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_"
        "GrowableList\",\"_vmName\":\"\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core-patch\\/"
        "growable_array.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"},"
        "\"typeParameters\":[{\"type\":\"@Instance\",\"_vmType\":"
        "\"TypeParameter\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"_TypeParameter\",\"_vmName\":\""
        "\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/"
        "type_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":",
        buffer);
 
    EXPECT_SUBSTRING(
        "\"id\":\"\",\"kind\":\"TypeParameter\",\"name\":\"X0\","
        "\"parameterizedClass\":{\"type\":\"@Instance\","
        "\"_vmType\":\"Class\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"Null\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core\\/"
        "null.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\","
        "\"fixedId\":true,\"id\":\"\",\"valueAsString\":\"null\"}}]},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"List\",\"length\":0}",
        buffer);
  }
  // Map reference
  {
    JSONStream js;
    const Map& array = Map::Handle(Map::NewDefault());
    array.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_Map@", buffer, buffer);
    StripTokenPositions(buffer);
    ElideJSONSubstring("_TypeParameter@", buffer, buffer);
    EXPECT_SUBSTRING(
        "{\"type\":\"@Instance\",\"_vmType\":\"Map\",\"class\":{"
        "\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_"
        "Map\",\"_vmName\":\"\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:collection-patch\\/"
        "compact_hash.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.collection\",\"uri\":\"dart:"
        "collection\"},\"typeParameters\":[{\"type\":\"@Instance\",\"_vmType\":"
        "\"TypeParameter\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"_TypeParameter\",\"_vmName\":\""
        "\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/"
        "type_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":",
        buffer);
 
    EXPECT_SUBSTRING(
        "\"id\":\"\",\"kind\":\"TypeParameter\",\"name\":\"X0\","
        "\"parameterizedClass\":{\"type\":\"@Instance\","
        "\"_vmType\":\"Class\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"Null\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core\\/"
        "null.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\","
        "\"fixedId\":true,\"id\":\"\",\"valueAsString\":\"null\"}},{\"type\":"
        "\"@Instance\",\"_vmType\":\"TypeParameter\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_TypeParameter\",\"_"
        "vmName\":\"\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core-patch\\/"
        "type_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":",
        buffer);
 
    EXPECT_SUBSTRING(
        "\"id\":\"\",\"kind\":\"TypeParameter\",\"name\":\"X1\","
        "\"parameterizedClass\":{\"type\":\"@Instance\","
        "\"_vmType\":\"Class\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"Null\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core\\/"
        "null.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\","
        "\"fixedId\":true,\"id\":\"\",\"valueAsString\":\"null\"}}]},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"Map\",\"length\":0}",
        buffer);
  }
  // UserTag reference
  {
    JSONStream js;
    Instance& tag = Instance::Handle(isolate->default_tag());
    tag.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_UserTag@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_SUBSTRING(
        "\"type\":\"@Instance\",\"_vmType\":\"UserTag\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_UserTag\",\"_"
        "vmName\":\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:"
        "developer-patch\\/"
        "profiler.dart\",\"_kind\":\"kernel\"}},\"library\":{\"type\":\"@"
        "Library\","
        "\"fixedId\":true,\"id\":\"\",\"name\":\"dart.developer\",\"uri\":"
        "\"dart:developer\"}},"
        // Handle non-zero identity hash.
        "\"identityHashCode\":",
        buffer);
    EXPECT_SUBSTRING(
        "\"id\":\"\","
        "\"kind\":\"UserTag\",\"label\":\"Default\"}",
        buffer);
  }
  // Type reference
  // TODO(turnidge): Add in all of the other Type siblings.
  {
    JSONStream js;
    Instance& type =
        Instance::Handle(isolate->group()->object_store()->bool_type());
    type.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_Type@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_SUBSTRING(
        "{\"type\":\"@Instance\",\"_vmType\":\"Type\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_Type\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/type_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        // Handle non-zero identity hash.
        "\"identityHashCode\":",
        buffer);
    EXPECT_SUBSTRING(
        "\"kind\":\"Type\","
        "\"fixedId\":true,\"id\":\"\","
        "\"typeClass\":{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"bool\",\"location\":{\"type\":\"SourceLocation\","
        "\"script\":{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":"
        "\"dart:core\\/bool.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"name\":\"bool\"}",
        buffer);
  }
  // Null reference
  {
    JSONStream js;
    Object::null_object().PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"null\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"Null\",\"location\":{"
        "\"type\":\"SourceLocation\",\"script\":{\"type\":\"@Script\","
        "\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core\\/null.dart\",\"_"
        "kind\":\"kernel\"}},\"library\":"
        "{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\",\"name\":\"dart."
        "core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\",\"fixedId\":true,"
        "\"id\":\"objects\\/null\",\"valueAsString\":\"null\"}",
        buffer);
  }
  // Sentinel reference
  {
    JSONStream js;
    Object::sentinel().PrintJSON(&js, true);
    EXPECT_STREQ(
        "{\"type\":\"Sentinel\","
        "\"kind\":\"NotInitialized\","
        "\"valueAsString\":\"<not initialized>\"}",
        js.ToCString());
  }

ISOLATE_UNIT_TEST_CASE() [249/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_ArrayAllocation

)

Definition at line 835 of file profiler_test.cc.

                                                 {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "List foo() => List.filled(4, null);\n"
      "List bar() => List.filled(0, null, growable: true);\n";
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
  Isolate* isolate = thread->isolate();
 
  const Class& array_class =
      Class::Handle(isolate->group()->object_store()->array_class());
  EXPECT(!array_class.IsNull());
 
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), array_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  array_class.SetTraceAllocation(true);
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), array_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_STREQ("DRT_AllocateArray", walker.VMTagName());
    EXPECT_STREQ("[Stub] AllocateArray", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] new _List", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] foo", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  array_class.SetTraceAllocation(false);
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), array_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
  }
 
  // Clear the samples.
  ProfilerService::ClearSamples();
 
  // Compile bar (many List objects allocated).
  Invoke(root_library, "bar");
 
  // Enable again.
  array_class.SetTraceAllocation(true);
 
  // Run bar.
  Invoke(root_library, "bar");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), array_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples, since empty
    // growable lists use a shared backing.
    EXPECT_EQ(0, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [250/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_BasicSourcePosition

)

Definition at line 1606 of file profiler_test.cc.

                                                     {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "  @pragma('vm:never-inline') A() { }\n"
      "}\n"
      "class B {\n"
      "  @pragma('vm:prefer-inline')\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  B.boo();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  Invoke(root_library, "main");
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate one time.
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation samples.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile, true);
 
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT_EQ(1, walker.CurrentExclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.boo", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_STREQ("A", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("main", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("boo", walker.CurrentToken());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [251/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_BasicSourcePositionOptimized

)

Definition at line 1670 of file profiler_test.cc.

                                                              {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "  @pragma('vm:never-inline') A() { }\n"
      "}\n"
      "class B {\n"
      "  @pragma('vm:prefer-inline')\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  B.boo();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  const Function& main = Function::Handle(GetFunction(root_library, "main"));
  EXPECT(!main.IsNull());
 
  // Optimize quickly.
  SetFlagScope<int> sfs(&FLAG_optimization_counter_threshold, 5);
  // Warm up function.
  while (true) {
    Invoke(root_library, "main");
    const Code& code = Code::Handle(main.CurrentCode());
    if (code.is_optimized()) {
      // Warmed up.
      break;
    }
  }
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate one time.
  Invoke(root_library, "main");
 
  // Still optimized.
  const Code& code = Code::Handle(main.CurrentCode());
  EXPECT(code.is_optimized());
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation samples.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile, true);
 
    // Move down from the root.
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT_EQ(1, walker.CurrentExclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.boo", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_STREQ("A", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("main", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("boo", walker.CurrentToken());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [252/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_BinaryOperatorSourcePosition

)

Definition at line 1951 of file profiler_test.cc.

                                                              {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "  @pragma('vm:never-inline') A() { }\n"
      "}\n"
      "class B {\n"
      "  @pragma('vm:never-inline')\n"
      "  static oats() {\n"
      "    return boo();\n"
      "  }\n"
      "  @pragma('vm:prefer-inline')\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "class C {\n"
      "  @pragma('vm:never-inline') bacon() {\n"
      "    return this + this;\n"
      "  }\n"
      "  @pragma('vm:prefer-inline') operator+(C other) {\n"
      "    return fox();\n"
      "  }\n"
      "  @pragma('vm:prefer-inline') fox() {\n"
      "    return B.oats();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  new C()..bacon();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  Invoke(root_library, "main");
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate one time.
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation samples.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile, true);
 
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT_EQ(1, walker.CurrentExclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.boo", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_STREQ("A", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.oats", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("boo", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.fox", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("oats", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.+", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("fox", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.bacon", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("+", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("main", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("bacon", walker.CurrentToken());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [253/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_BinaryOperatorSourcePositionOptimized

)

Definition at line 2050 of file profiler_test.cc.

                                                                       {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
 
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "  @pragma('vm:never-inline') A() { }\n"
      "}\n"
      "class B {\n"
      "  @pragma('vm:never-inline')\n"
      "  static oats() {\n"
      "    return boo();\n"
      "  }\n"
      "  @pragma('vm:prefer-inline')\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "class C {\n"
      "  @pragma('vm:never-inline') bacon() {\n"
      "    return this + this;\n"
      "  }\n"
      "  @pragma('vm:prefer-inline') operator+(C other) {\n"
      "    return fox();\n"
      "  }\n"
      "  @pragma('vm:prefer-inline') fox() {\n"
      "    return B.oats();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  new C()..bacon();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  const Function& main = Function::Handle(GetFunction(root_library, "main"));
  EXPECT(!main.IsNull());
 
  // Optimize quickly.
  SetFlagScope<int> sfs(&FLAG_optimization_counter_threshold, 5);
  // Warm up function.
  while (true) {
    Invoke(root_library, "main");
    const Code& code = Code::Handle(main.CurrentCode());
    if (code.is_optimized()) {
      // Warmed up.
      break;
    }
  }
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate one time.
  Invoke(root_library, "main");
 
  // Still optimized.
  const Code& code = Code::Handle(main.CurrentCode());
  EXPECT(code.is_optimized());
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation samples.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile, true);
 
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT_EQ(1, walker.CurrentExclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.boo", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_STREQ("A", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.oats", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("boo", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.fox", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("oats", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.+", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("fox", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.bacon", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("+", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("main", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("bacon", walker.CurrentToken());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [254/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_ChainedSamples

)

Definition at line 1498 of file profiler_test.cc.

                                                {
  EnableProfiler();
  MaxProfileDepthScope mpds(32);
  DisableNativeProfileScope dnps;
 
  // Each sample holds 8 stack frames.
  // This chain is 20 stack frames deep.
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      "class B {\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "go() => init();\n"
      "init() => secondInit();\n"
      "secondInit() => apple();\n"
      "apple() => banana();\n"
      "banana() => cantaloupe();\n"
      "cantaloupe() => dog();\n"
      "dog() => elephant();\n"
      "elephant() => fred();\n"
      "fred() => granola();\n"
      "granola() => haystack();\n"
      "haystack() => ice();\n"
      "ice() => jeep();\n"
      "jeep() => kindle();\n"
      "kindle() => lemon();\n"
      "lemon() => mayo();\n"
      "mayo() => napkin();\n"
      "napkin() => orange();\n"
      "orange() => B.boo();\n"
      "main() {\n"
      "  return go();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
  class_a.SetTraceAllocation(true);
 
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have 1 allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] B.boo", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] orange", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] napkin", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] mayo", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] lemon", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] kindle", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] jeep", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] ice", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] haystack", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] granola", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] fred", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] elephant", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] dog", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] cantaloupe", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] banana", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] apple", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] secondInit", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] init", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] go", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] main", walker.CurrentName());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [255/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_ClosureAllocation

)

Definition at line 975 of file profiler_test.cc.

                                                   {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "var msg1 = 'a';\n"
      "\n"
      "foo() {\n"
      "  var msg = msg1 + msg1;\n"
      "  var msg2 = msg + msg;\n"
      "  return (x, y, z, w) { return '$x + $y + $z'; }(msg, msg2, msg, msg);\n"
      "}\n"
      "bar() {\n"
      "  var msg = msg1 + msg1;\n"
      "  var msg2 = msg + msg;\n"
      "  return (x, y) { return '$x + $y'; }(msg, msg2);\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
  Isolate* isolate = thread->isolate();
 
  const Class& closure_class =
      Class::Handle(IsolateGroup::Current()->object_store()->closure_class());
  EXPECT(!closure_class.IsNull());
  closure_class.SetTraceAllocation(true);
 
  // Invoke "foo" which during compilation, triggers a closure allocation.
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), closure_class.id());
    filter.set_enable_vm_ticks(true);
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_SUBSTRING("DRT_AllocateClosure", walker.VMTagName());
    EXPECT_STREQ("[Stub] AllocateClosure", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_SUBSTRING("foo", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  // Disable allocation tracing for Closure.
  closure_class.SetTraceAllocation(false);
 
  // Invoke "bar" which during compilation, triggers a closure allocation.
  Invoke(root_library, "bar");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), closure_class.id());
    filter.set_enable_vm_ticks(true);
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [256/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_CodeTicks

)

Definition at line 624 of file profiler_test.cc.

                                           {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      "class B {\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return B.boo();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate three times.
  Invoke(root_library, "main");
  Invoke(root_library, "main");
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have three allocation samples.
    EXPECT_EQ(3, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    // Move down from the root.
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT_EQ(3, walker.CurrentExclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] B.boo", walker.CurrentName());
    EXPECT_EQ(3, walker.CurrentInclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] main", walker.CurrentName());
    EXPECT_EQ(3, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [257/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_ContextAllocation

)

Definition at line 916 of file profiler_test.cc.

                                                   {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "var msg1 = 'a';\n"
      "foo() {\n"
      "  var msg = msg1 + msg1;\n"
      "  return (x) { return '$msg + $msg'; }(msg);\n"
      "}\n";
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
  Isolate* isolate = thread->isolate();
 
  const Class& context_class = Class::Handle(Object::context_class());
  EXPECT(!context_class.IsNull());
 
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), context_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  context_class.SetTraceAllocation(true);
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), context_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_STREQ("DRT_AllocateContext", walker.VMTagName());
    EXPECT_STREQ("[Stub] AllocateContext", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] foo", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  context_class.SetTraceAllocation(false);
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), context_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [258/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_EnterExitIsolate

)

Definition at line 2435 of file profiler_test.cc.

                                                  {
  EnableProfiler();
  Profiler::SetSamplePeriod(50);  // Microseconds.
 
  const char* kScript = "main() => null;\n";
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  Isolate* isolate = Isolate::Current();
  for (intptr_t i = 0; i < 100000; i++) {
    Thread::ExitIsolate();
    Thread::EnterIsolate(isolate);
    Invoke(root_library, "main");
  }
}

ISOLATE_UNIT_TEST_CASE() [259/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_FunctionInline

)

Definition at line 1266 of file profiler_test.cc.

                                                {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  SetFlagScope<int> sfs(&FLAG_optimization_counter_threshold, 30000);
 
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      "class B {\n"
      "  static choo(bool alloc) {\n"
      "    if (alloc) return new A();\n"
      "    return alloc && alloc && !alloc;\n"
      "  }\n"
      "  static foo(bool alloc) {\n"
      "    choo(alloc);\n"
      "  }\n"
      "  static boo(bool alloc) {\n"
      "    for (var i = 0; i < 50000; i++) {\n"
      "      foo(alloc);\n"
      "    }\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  B.boo(false);\n"
      "}\n"
      "mainA() {\n"
      "  B.boo(true);\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  // Compile "main".
  Invoke(root_library, "main");
  // Compile "mainA".
  Invoke(root_library, "mainA");
  // At this point B.boo should be optimized and inlined B.foo and B.choo.
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate 50,000 instances of A.
  Invoke(root_library, "mainA");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have 50,000 allocation samples.
    EXPECT_EQ(50000, profile.sample_count());
    {
      ProfileStackWalker walker(&profile);
      // We have two code objects: mainA and B.boo.
      EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
      EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
      EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
      EXPECT_EQ(50000, walker.CurrentExclusiveTicks());
      EXPECT(walker.Down());
      EXPECT_STREQ("[Optimized] B.boo", walker.CurrentName());
      EXPECT_EQ(50000, walker.CurrentInclusiveTicks());
      EXPECT(walker.Down());
      EXPECT_STREQ("[Unoptimized] mainA", walker.CurrentName());
      EXPECT_EQ(50000, walker.CurrentInclusiveTicks());
      EXPECT_EQ(0, walker.CurrentExclusiveTicks());
      EXPECT(!walker.Down());
    }
    {
      ProfileStackWalker walker(&profile, true);
      // Inline expansion should show us the complete call chain:
      // mainA -> B.boo -> B.foo -> B.choo.
      EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
      EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
      EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
      EXPECT_EQ(50000, walker.CurrentExclusiveTicks());
      EXPECT(walker.Down());
      EXPECT_STREQ("B.choo", walker.CurrentName());
      EXPECT_EQ(50000, walker.CurrentInclusiveTicks());
      EXPECT(walker.Down());
      EXPECT_STREQ("B.foo", walker.CurrentName());
      EXPECT_EQ(50000, walker.CurrentInclusiveTicks());
      EXPECT_EQ(0, walker.CurrentExclusiveTicks());
      EXPECT(walker.Down());
      EXPECT_STREQ("B.boo", walker.CurrentName());
      EXPECT_EQ(50000, walker.CurrentInclusiveTicks());
      EXPECT_EQ(0, walker.CurrentExclusiveTicks());
      EXPECT(walker.Down());
      EXPECT_STREQ("mainA", walker.CurrentName());
      EXPECT_EQ(50000, walker.CurrentInclusiveTicks());
      EXPECT_EQ(0, walker.CurrentExclusiveTicks());
      EXPECT(!walker.Down());
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [260/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_FunctionTicks

)

Definition at line 697 of file profiler_test.cc.

                                               {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      "class B {\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return B.boo();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate three times.
  Invoke(root_library, "main");
  Invoke(root_library, "main");
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have three allocation samples.
    EXPECT_EQ(3, profile.sample_count());
    ProfileStackWalker walker(&profile, true);
 
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
 
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT_EQ(3, walker.CurrentExclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.boo", walker.CurrentName());
    EXPECT_EQ(3, walker.CurrentInclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("main", walker.CurrentName());
    EXPECT_EQ(3, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [261/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_GetSourceReport

)

Definition at line 2206 of file profiler_test.cc.

                                                 {
  EnableProfiler();
  const char* kScript =
      "int doWork(i) => i * i;\n"
      "int main() {\n"
      "  int sum = 0;\n"
      "  for (int i = 0; i < 100; i++) {\n"
      "     sum += doWork(i);\n"
      "  }\n"
      "  return sum;\n"
      "}\n";
 
  // Token position of * in `i * i`.
  const TokenPosition squarePosition = TokenPosition::Deserialize(19);
 
  // Token position of the call to `doWork`.
  const TokenPosition callPosition = TokenPosition::Deserialize(95);
 
  DisableNativeProfileScope dnps;
  // Disable profiling for this thread.
  DisableThreadInterruptsScope dtis(Thread::Current());
 
  DisableBackgroundCompilationScope dbcs;
 
  SampleBlockBuffer* sample_block_buffer = Profiler::sample_block_buffer();
  ASSERT(sample_block_buffer != nullptr);
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  // Invoke main so that it gets compiled.
  Invoke(root_library, "main");
 
  {
    // Clear the profile for this isolate.
    ClearProfileVisitor cpv(Isolate::Current());
    sample_block_buffer->VisitSamples(&cpv);
  }
 
  // Query the code object for main and determine the PC at some token
  // positions.
  const Function& main = Function::Handle(GetFunction(root_library, "main"));
  EXPECT(!main.IsNull());
 
  const Function& do_work =
      Function::Handle(GetFunction(root_library, "doWork"));
  EXPECT(!do_work.IsNull());
 
  const Script& script = Script::Handle(main.script());
  EXPECT(!script.IsNull());
 
  const Code& main_code = Code::Handle(main.CurrentCode());
  EXPECT(!main_code.IsNull());
 
  const Code& do_work_code = Code::Handle(do_work.CurrentCode());
  EXPECT(!do_work_code.IsNull());
 
  // Dump code source map.
  do_work_code.DumpSourcePositions();
  main_code.DumpSourcePositions();
 
  // Look up some source token position's pc.
  uword squarePositionPc = FindPCForTokenPosition(do_work_code, squarePosition);
  EXPECT(squarePositionPc != 0);
 
  uword callPositionPc = FindPCForTokenPosition(main_code, callPosition);
  EXPECT(callPositionPc != 0);
 
  // Look up some classifying token position's pc.
  uword controlFlowPc =
      FindPCForTokenPosition(do_work_code, TokenPosition::kControlFlow);
  EXPECT(controlFlowPc != 0);
 
  // Insert fake samples.
 
  // Sample 1:
  // squarePositionPc exclusive.
  // callPositionPc inclusive.
  uword sample1[] = {squarePositionPc,  // doWork.
                     callPositionPc,    // main.
                     0};
 
  // Sample 2:
  // squarePositionPc exclusive.
  uword sample2[] = {
      squarePositionPc,  // doWork.
      0,
  };
 
  // Sample 3:
  // controlFlowPc exclusive.
  // callPositionPc inclusive.
  uword sample3[] = {controlFlowPc,   // doWork.
                     callPositionPc,  // main.
                     0};
 
  InsertFakeSample(&sample1[0]);
  InsertFakeSample(&sample2[0]);
  InsertFakeSample(&sample3[0]);
 
  // Generate source report for main.
  JSONStream js;
  {
    SourceReport sourceReport(SourceReport::kProfile);
    sourceReport.PrintJSON(&js, script, do_work.token_pos(),
                           main.end_token_pos());
  }
 
  // Verify positions in do_work.
  EXPECT_SUBSTRING("\"positions\":[\"ControlFlow\",19]", js.ToCString());
  // Verify exclusive ticks in do_work.
  EXPECT_SUBSTRING("\"exclusiveTicks\":[1,2]", js.ToCString());
  // Verify inclusive ticks in do_work.
  EXPECT_SUBSTRING("\"inclusiveTicks\":[1,2]", js.ToCString());
 
  // Verify positions in main.
  EXPECT_SUBSTRING("\"positions\":[95]", js.ToCString());
  // Verify exclusive ticks in main.
  EXPECT_SUBSTRING("\"exclusiveTicks\":[0]", js.ToCString());
  // Verify inclusive ticks in main.
  EXPECT_SUBSTRING("\"inclusiveTicks\":[2]", js.ToCString());
}

ISOLATE_UNIT_TEST_CASE() [262/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_InliningIntervalBoundary

)

Definition at line 1385 of file profiler_test.cc.

                                                          {
  // The PC of frames below the top frame is a call's return address,
  // which can belong to a different inlining interval than the call.
  // This test checks the profiler service takes this into account; see
  // ProfileBuilder::ProcessFrame.
 
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  SetFlagScope<int> sfs(&FLAG_optimization_counter_threshold, 30000);
 
  const char* kScript =
      "class A {\n"
      "}\n"
      "bool alloc = false;"
      "maybeAlloc() {\n"
      "  try {\n"
      "    if (alloc) new A();\n"
      "  } catch (e) {\n"
      "  }\n"
      "}\n"
      "right() => maybeAlloc();\n"
      "doNothing() {\n"
      "  try {\n"
      "  } catch (e) {\n"
      "  }\n"
      "}\n"
      "wrong() => doNothing();\n"
      "a() {\n"
      "  try {\n"
      "    right();\n"
      "    wrong();\n"
      "  } catch (e) {\n"
      "  }\n"
      "}\n"
      "mainNoAlloc() {\n"
      "  for (var i = 0; i < 20000; i++) {\n"
      "    a();\n"
      "  }\n"
      "}\n"
      "mainAlloc() {\n"
      "  alloc = true;\n"
      "  a();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  // Compile and optimize.
  Invoke(root_library, "mainNoAlloc");
  Invoke(root_library, "mainAlloc");
 
  // At this point a should be optimized and have inlined both right and wrong,
  // but not maybeAllocate or doNothing.
  Function& func = Function::Handle();
  func = GetFunction(root_library, "a");
  EXPECT(!func.is_inlinable());
  EXPECT(func.HasOptimizedCode());
  func = GetFunction(root_library, "right");
  EXPECT(func.is_inlinable());
  func = GetFunction(root_library, "wrong");
  EXPECT(func.is_inlinable());
  func = GetFunction(root_library, "doNothing");
  EXPECT(!func.is_inlinable());
  func = GetFunction(root_library, "maybeAlloc");
  EXPECT(!func.is_inlinable());
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  Invoke(root_library, "mainAlloc");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile, true);
 
    // Inline expansion should show us the complete call chain:
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT(walker.Down());
    EXPECT_STREQ("maybeAlloc", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("right", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("a", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("mainAlloc", walker.CurrentName());
  }
}

ISOLATE_UNIT_TEST_CASE() [263/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_IntrinsicAllocation

)

Definition at line 771 of file profiler_test.cc.

                                                     {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript = "double foo(double a, double b) => a + b;";
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
  Isolate* isolate = thread->isolate();
 
  const Class& double_class =
      Class::Handle(isolate->group()->object_store()->double_class());
  EXPECT(!double_class.IsNull());
 
  Dart_Handle args[2];
  {
    TransitionVMToNative transition(thread);
    args[0] = Dart_NewDouble(1.0);
    args[1] = Dart_NewDouble(2.0);
  }
 
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), double_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  double_class.SetTraceAllocation(true);
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), double_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_STREQ("Double_add", walker.VMTagName());
    EXPECT_STREQ("[Unoptimized] double._add", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] double.+", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] foo", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  double_class.SetTraceAllocation(false);
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), double_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [264/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_NullSampleBuffer

)

Definition at line 531 of file profiler_test.cc.

                                                  {
  Isolate* isolate = thread->isolate();
 
  SampleFilter filter(isolate->main_port(), Thread::kMutatorTask, -1, -1);
  Profile profile;
  profile.Build(thread, isolate, &filter, nullptr);
 
  EXPECT_EQ(0, profile.sample_count());
}

ISOLATE_UNIT_TEST_CASE() [265/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_ProfileCodeTableTest

)

Definition at line 2328 of file profiler_test.cc.

                                                      {
  Zone* Z = Thread::Current()->zone();
 
  ProfileCodeTable* table = new (Z) ProfileCodeTable();
  EXPECT_EQ(table->length(), 0);
  EXPECT_EQ(table->FindCodeForPC(42), static_cast<ProfileCode*>(nullptr));
 
  int64_t timestamp = 0;
  const AbstractCode null_code(Code::null());
 
  ProfileCode* code1 = new (Z)
      ProfileCode(ProfileCode::kNativeCode, 50, 60, timestamp, null_code);
  EXPECT_EQ(table->InsertCode(code1), 0);
  EXPECT_EQ(table->FindCodeForPC(0), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(100), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(50), code1);
  EXPECT_EQ(table->FindCodeForPC(55), code1);
  EXPECT_EQ(table->FindCodeForPC(59), code1);
  EXPECT_EQ(table->FindCodeForPC(60), static_cast<ProfileCode*>(nullptr));
 
  // Insert below all.
  ProfileCode* code2 = new (Z)
      ProfileCode(ProfileCode::kNativeCode, 10, 20, timestamp, null_code);
  EXPECT_EQ(table->InsertCode(code2), 0);
  EXPECT_EQ(table->FindCodeForPC(0), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(100), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(50), code1);
  EXPECT_EQ(table->FindCodeForPC(10), code2);
  EXPECT_EQ(table->FindCodeForPC(19), code2);
  EXPECT_EQ(table->FindCodeForPC(20), static_cast<ProfileCode*>(nullptr));
 
  // Insert above all.
  ProfileCode* code3 = new (Z)
      ProfileCode(ProfileCode::kNativeCode, 80, 90, timestamp, null_code);
  EXPECT_EQ(table->InsertCode(code3), 2);
  EXPECT_EQ(table->FindCodeForPC(0), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(100), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(50), code1);
  EXPECT_EQ(table->FindCodeForPC(10), code2);
  EXPECT_EQ(table->FindCodeForPC(80), code3);
  EXPECT_EQ(table->FindCodeForPC(89), code3);
  EXPECT_EQ(table->FindCodeForPC(90), static_cast<ProfileCode*>(nullptr));
 
  // Insert between.
  ProfileCode* code4 = new (Z)
      ProfileCode(ProfileCode::kNativeCode, 65, 75, timestamp, null_code);
  EXPECT_EQ(table->InsertCode(code4), 2);
  EXPECT_EQ(table->FindCodeForPC(0), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(100), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(50), code1);
  EXPECT_EQ(table->FindCodeForPC(10), code2);
  EXPECT_EQ(table->FindCodeForPC(80), code3);
  EXPECT_EQ(table->FindCodeForPC(65), code4);
  EXPECT_EQ(table->FindCodeForPC(74), code4);
  EXPECT_EQ(table->FindCodeForPC(75), static_cast<ProfileCode*>(nullptr));
 
  // Insert overlapping left.
  ProfileCode* code5 = new (Z)
      ProfileCode(ProfileCode::kNativeCode, 15, 25, timestamp, null_code);
  EXPECT_EQ(table->InsertCode(code5), 0);
  EXPECT_EQ(table->FindCodeForPC(0), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(100), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(50), code1);
  EXPECT_EQ(table->FindCodeForPC(10), code2);
  EXPECT_EQ(table->FindCodeForPC(80), code3);
  EXPECT_EQ(table->FindCodeForPC(65), code4);
  EXPECT_EQ(table->FindCodeForPC(15), code2);  // Merged left.
  EXPECT_EQ(table->FindCodeForPC(24), code2);  // Merged left.
  EXPECT_EQ(table->FindCodeForPC(25), static_cast<ProfileCode*>(nullptr));
 
  // Insert overlapping right.
  ProfileCode* code6 = new (Z)
      ProfileCode(ProfileCode::kNativeCode, 45, 55, timestamp, null_code);
  EXPECT_EQ(table->InsertCode(code6), 1);
  EXPECT_EQ(table->FindCodeForPC(0), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(100), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(50), code1);
  EXPECT_EQ(table->FindCodeForPC(10), code2);
  EXPECT_EQ(table->FindCodeForPC(80), code3);
  EXPECT_EQ(table->FindCodeForPC(65), code4);
  EXPECT_EQ(table->FindCodeForPC(15), code2);  // Merged left.
  EXPECT_EQ(table->FindCodeForPC(24), code2);  // Merged left.
  EXPECT_EQ(table->FindCodeForPC(45), code1);  // Merged right.
  EXPECT_EQ(table->FindCodeForPC(54), code1);  // Merged right.
  EXPECT_EQ(table->FindCodeForPC(55), code1);
 
  // Insert overlapping both.
  ProfileCode* code7 = new (Z)
      ProfileCode(ProfileCode::kNativeCode, 20, 50, timestamp, null_code);
  EXPECT_EQ(table->InsertCode(code7), 0);
  EXPECT_EQ(table->FindCodeForPC(0), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(100), static_cast<ProfileCode*>(nullptr));
  EXPECT_EQ(table->FindCodeForPC(50), code1);
  EXPECT_EQ(table->FindCodeForPC(10), code2);
  EXPECT_EQ(table->FindCodeForPC(80), code3);
  EXPECT_EQ(table->FindCodeForPC(65), code4);
  EXPECT_EQ(table->FindCodeForPC(15), code2);  // Merged left.
  EXPECT_EQ(table->FindCodeForPC(24), code2);  // Merged left.
  EXPECT_EQ(table->FindCodeForPC(45), code1);  // Merged right.
  EXPECT_EQ(table->FindCodeForPC(54), code1);  // Merged right.
  EXPECT_EQ(table->FindCodeForPC(20), code2);  // Merged left.
  EXPECT_EQ(table->FindCodeForPC(49), code1);  // Truncated.
  EXPECT_EQ(table->FindCodeForPC(50), code1);
}

ISOLATE_UNIT_TEST_CASE() [266/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_SourcePosition

)

Definition at line 1752 of file profiler_test.cc.

                                                {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "  @pragma('vm:never-inline') A() { }\n"
      "}\n"
      "class B {\n"
      "  @pragma('vm:never-inline')\n"
      "  static oats() {\n"
      "    return boo();\n"
      "  }\n"
      "  @pragma('vm:prefer-inline')\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "class C {\n"
      "  @pragma('vm:never-inline') bacon() {\n"
      "    return fox();\n"
      "  }\n"
      "  @pragma('vm:prefer-inline') fox() {\n"
      "    return B.oats();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  new C()..bacon();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  Invoke(root_library, "main");
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate one time.
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation samples.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile, true);
 
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT_EQ(1, walker.CurrentExclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.boo", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_STREQ("A", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.oats", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("boo", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.fox", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("oats", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.bacon", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("fox", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("main", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("bacon", walker.CurrentToken());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [267/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_SourcePositionOptimized

)

Definition at line 1843 of file profiler_test.cc.

                                                         {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "  @pragma('vm:never-inline') A() { }\n"
      "}\n"
      "class B {\n"
      "  @pragma('vm:never-inline')\n"
      "  static oats() {\n"
      "    return boo();\n"
      "  }\n"
      "  @pragma('vm:prefer-inline')\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "class C {\n"
      "  @pragma('vm:never-inline') bacon() {\n"
      "    return fox();\n"
      "  }\n"
      "  @pragma('vm:prefer-inline') fox() {\n"
      "    return B.oats();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  new C()..bacon();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  const Function& main = Function::Handle(GetFunction(root_library, "main"));
  EXPECT(!main.IsNull());
 
  // Optimize quickly.
  SetFlagScope<int> sfs(&FLAG_optimization_counter_threshold, 5);
  // Warm up function.
  while (true) {
    Invoke(root_library, "main");
    const Code& code = Code::Handle(main.CurrentCode());
    if (code.is_optimized()) {
      // Warmed up.
      break;
    }
  }
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  // Allocate one time.
  Invoke(root_library, "main");
 
  // Still optimized.
  const Code& code = Code::Handle(main.CurrentCode());
  EXPECT(code.is_optimized());
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation samples.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile, true);
 
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT_EQ(1, walker.CurrentExclusiveTicks());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.boo", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_STREQ("A", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("B.oats", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("boo", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.fox", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("oats", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("C.bacon", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("fox", walker.CurrentToken());
    EXPECT(walker.Down());
    EXPECT_STREQ("main", walker.CurrentName());
    EXPECT_EQ(1, walker.CurrentInclusiveTicks());
    EXPECT_EQ(0, walker.CurrentExclusiveTicks());
    EXPECT_STREQ("bacon", walker.CurrentToken());
    EXPECT(!walker.Down());
  }
}

ISOLATE_UNIT_TEST_CASE() [268/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_StringAllocation

)

Definition at line 1112 of file profiler_test.cc.

                                                  {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript = "String foo(String a, String b) => a + b;";
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
  Isolate* isolate = thread->isolate();
 
  const Class& one_byte_string_class =
      Class::Handle(isolate->group()->object_store()->one_byte_string_class());
  EXPECT(!one_byte_string_class.IsNull());
 
  Dart_Handle args[2];
  {
    TransitionVMToNative transition(thread);
    args[0] = NewString("a");
    args[1] = NewString("b");
  }
 
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), one_byte_string_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  one_byte_string_class.SetTraceAllocation(true);
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), one_byte_string_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_STREQ("String_concat", walker.VMTagName());
    EXPECT_STREQ("[Unoptimized] _StringBase.+", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] foo", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  one_byte_string_class.SetTraceAllocation(false);
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), one_byte_string_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
  }
 
  one_byte_string_class.SetTraceAllocation(true);
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), one_byte_string_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should now have two allocation samples.
    EXPECT_EQ(2, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [269/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_StringInterpolation

)

Definition at line 1186 of file profiler_test.cc.

                                                     {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript = "String foo(String a, String b) => '$a | $b';";
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
  Isolate* isolate = thread->isolate();
 
  const Class& one_byte_string_class =
      Class::Handle(isolate->group()->object_store()->one_byte_string_class());
  EXPECT(!one_byte_string_class.IsNull());
 
  Dart_Handle args[2];
  {
    TransitionVMToNative transition(thread);
    args[0] = NewString("a");
    args[1] = NewString("b");
  }
 
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), one_byte_string_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  one_byte_string_class.SetTraceAllocation(true);
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), one_byte_string_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_STREQ("Internal_allocateOneByteString", walker.VMTagName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] String._allocate", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] String._concatAll", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] _StringBase._interpolate",
                 walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] foo", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  one_byte_string_class.SetTraceAllocation(false);
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), one_byte_string_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
  }
 
  one_byte_string_class.SetTraceAllocation(true);
  Invoke(root_library, "foo", 2, &args[0]);
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), one_byte_string_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should now have two allocation samples.
    EXPECT_EQ(2, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [270/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_ToggleRecordAllocation

)

Definition at line 541 of file profiler_test.cc.

                                                        {
  EnableProfiler();
 
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      "class B {\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return B.boo();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
 
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  // Turn on allocation tracing for A.
  class_a.SetTraceAllocation(true);
 
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] B.boo", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] main", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  // Turn off allocation tracing for A.
  class_a.SetTraceAllocation(false);
 
  Invoke(root_library, "main");
 
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [271/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_TrivialRecordAllocation

)

Definition at line 458 of file profiler_test.cc.

                                                         {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      "class B {\n"
      "  static boo() {\n"
      "    return new A();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return B.boo();\n"
      "}\n";
 
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
 
  const int64_t before_allocations_micros = Dart_TimelineGetMicros();
  const Class& class_a = Class::Handle(GetClass(root_library, "A"));
  EXPECT(!class_a.IsNull());
  class_a.SetTraceAllocation(true);
 
  Invoke(root_library, "main");
 
  const int64_t after_allocations_micros = Dart_TimelineGetMicros();
  const int64_t allocation_extent_micros =
      after_allocations_micros - before_allocations_micros;
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    // Filter for the class in the time range.
    AllocationFilter filter(isolate->main_port(), class_a.id(),
                            before_allocations_micros,
                            allocation_extent_micros);
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have 1 allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    // Move down from the root.
    EXPECT_STREQ("DRT_AllocateObject", walker.VMTagName());
#if defined(TARGET_ARCH_IA32)  // Alloc. stub not impl. for ia32.
    EXPECT_STREQ("[Stub] Allocate A", walker.CurrentName());
#else
    EXPECT_STREQ("[Stub] AllocateObjectSlow", walker.CurrentName());
#endif
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] B.boo", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] main", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  // Query with a time filter where no allocations occurred.
  {
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), class_a.id(),
                            Dart_TimelineGetMicros(), 16000);
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples because none occurred within
    // the specified time range.
    EXPECT_EQ(0, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [272/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Profiler_TypedArrayAllocation

)

Definition at line 1038 of file profiler_test.cc.

                                                      {
  EnableProfiler();
  DisableNativeProfileScope dnps;
  DisableBackgroundCompilationScope dbcs;
  const char* kScript =
      "import 'dart:typed_data';\n"
      "List foo() => new Float32List(4);\n";
  const Library& root_library = Library::Handle(LoadTestScript(kScript));
  Isolate* isolate = thread->isolate();
 
  const Library& typed_data_library =
      Library::Handle(isolate->group()->object_store()->typed_data_library());
 
  const Class& float32_list_class =
      Class::Handle(GetClass(typed_data_library, "_Float32List"));
  EXPECT(!float32_list_class.IsNull());
 
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), float32_list_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have no allocation samples.
    EXPECT_EQ(0, profile.sample_count());
  }
 
  float32_list_class.SetTraceAllocation(true);
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), float32_list_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
    ProfileStackWalker walker(&profile);
 
    EXPECT_STREQ("DRT_AllocateTypedData", walker.VMTagName());
    EXPECT_STREQ("[Stub] AllocateFloat32Array", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] new Float32List", walker.CurrentName());
    EXPECT(walker.Down());
    EXPECT_STREQ("[Unoptimized] foo", walker.CurrentName());
    EXPECT(!walker.Down());
  }
 
  float32_list_class.SetTraceAllocation(false);
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), float32_list_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should still only have one allocation sample.
    EXPECT_EQ(1, profile.sample_count());
  }
 
  float32_list_class.SetTraceAllocation(true);
  Invoke(root_library, "foo");
 
  {
    StackZone zone(thread);
    Profile profile;
    AllocationFilter filter(isolate->main_port(), float32_list_class.id());
    profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
    // We should now have two allocation samples.
    EXPECT_EQ(2, profile.sample_count());
  }
}

ISOLATE_UNIT_TEST_CASE() [273/463]

dart::ISOLATE_UNIT_TEST_CASE

(

RangeAnalysis_LoadClassId

)

Definition at line 641 of file range_analysis_test.cc.

                                                  {
  const char* kScript = R"(
    @pragma('vm:never-inline')
    bool foo(num x) {
      return x is int;
    }
    void main() {
      foo(42);
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kAOT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
  ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                   ParallelMovesHandling::kSkip);
 
  LoadClassIdInstr* load_cid = nullptr;
 
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveLoadClassId, &load_cid},
      kMoveGlob,
      kMatchAndMoveTestRange,
      kMoveGlob,
      kMatchDartReturn,
  }));
 
  EXPECT(load_cid->range() != nullptr);
  EXPECT(kSmiCid < kMintCid);
  EXPECT(kMintCid < kDoubleCid);
  EXPECT(load_cid->range()->min().ConstantValue() == kSmiCid);
  EXPECT(load_cid->range()->max().ConstantValue() == kDoubleCid);
}

ISOLATE_UNIT_TEST_CASE() [274/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ReachabilityFence_Loop

)

Definition at line 59 of file reachability_fence_test.cc.

                                 {
      kMoveGlob,
      // Allocate the object.
      {kMatchAndMoveAllocateObject, &allocate_object},
      kMoveGlob,
      // The call.
      kMatchAndMoveStoreStaticField,
      // The fence should not be moved before the call.
      {kMatchAndMoveReachabilityFence, &fence},
  }));
 
  EXPECT(fence->value()->definition() == allocate_object);
}
 
ISOLATE_UNIT_TEST_CASE(ReachabilityFence_Loop) {
  // clang-format off
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
      import 'dart:_internal' show reachabilityFence;
 
      int someGlobal = 0;
 
      class A {
        int%s a;
      }
 
      @pragma('vm:never-inline')
      A makeSomeA() {
        return A()..a = 10;
      }
 
      void someFunction(int arg) {
        someGlobal += arg;
      }
 
      main() {
        final object = makeSomeA();
        for(int i = 0; i < 100000; i++) {
          someFunction(object.a%s);
          reachabilityFence(object);
        }
      }
      )", TestCase::NullableTag(), TestCase::NullAssertTag()), std::free);
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "main"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  ASSERT(flow_graph != nullptr);
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  StaticCallInstr* object = nullptr;
  LoadFieldInstr* field_load = nullptr;
  ReachabilityFenceInstr* fence = nullptr;

ISOLATE_UNIT_TEST_CASE() [275/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ReachabilityFence_NoCanonicalize

)

Definition at line 124 of file reachability_fence_test.cc.

      {
          // Get the object from some method
          {kMatchAndMoveStaticCall, &object},
          // Load the field outside the loop.
          {kMatchAndMoveLoadField, &field_load},
          // Go into the loop.
          kMatchAndMoveBranchTrue,
          // The fence should not be moved outside of the loop.
          {kMatchAndMoveReachabilityFence, &fence},
      },
      /*insert_before=*/kMoveGlob));
 
  EXPECT(field_load->instance()->definition() == object);
  EXPECT(fence->value()->definition() == object);
}
 
ISOLATE_UNIT_TEST_CASE(ReachabilityFence_NoCanonicalize) {
  // clang-format off
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
      import 'dart:_internal' show reachabilityFence;
 
      int someGlobal = 0;
 
      class A {
        int%s a;
      }
 
      @pragma('vm:never-inline')
      A makeSomeA() {
        return A()..a = 10;
      }
 
      void someFunction(int arg) {
        someGlobal += arg;
      }
 
      main() {
        final object = makeSomeA();
        reachabilityFence(object);
        for(int i = 0; i < 100000; i++) {
          someFunction(object.a%s);
          reachabilityFence(object);
        }
        reachabilityFence(object);
        reachabilityFence(object);
      }
      )", TestCase::NullableTag(), TestCase::NullAssertTag()), std::free);
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "main"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  ASSERT(flow_graph != nullptr);
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  StaticCallInstr* object = nullptr;
  ReachabilityFenceInstr* fence1 = nullptr;
  ReachabilityFenceInstr* fence2 = nullptr;
  ReachabilityFenceInstr* fence3 = nullptr;
  ReachabilityFenceInstr* fence4 = nullptr;
 

ISOLATE_UNIT_TEST_CASE() [276/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ReachabilityFence_Simple

)

Definition at line 17 of file reachability_fence_test.cc.

                                                 {
  // clang-format off
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                          R"(
      import 'dart:_internal' show reachabilityFence;
 
      int someGlobal = 0;
 
      class A {
        int%s a;
      }
 
      void someFunction(int arg) {
        someGlobal += arg;
      }
 
      main() {
        final object = A()..a = 10;
        someFunction(object.a%s);
        reachabilityFence(object);
      }
      )",
      TestCase::NullableTag(), TestCase::NullAssertTag()), std::free);
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "main"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
  ASSERT(flow_graph != nullptr);
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  //  v2 <- AllocateObject(A <not-aliased>) T{A}
  //  ...
  //  [use field of object v2]

ISOLATE_UNIT_TEST_CASE() [277/463]

dart::ISOLATE_UNIT_TEST_CASE

(

RecursiveSafepointTest1

)

Definition at line 684 of file thread_test.cc.

                                                {
  intptr_t count = 0;
  {
    GcSafepointOperationScope safepoint_scope(thread);
    count += 1;
    {
      GcSafepointOperationScope safepoint_scope(thread);
      count += 1;
      {
        GcSafepointOperationScope safepoint_scope(thread);
        count += 1;
      }
    }
  }
  EXPECT(count == 3);
}

ISOLATE_UNIT_TEST_CASE() [278/463]

dart::ISOLATE_UNIT_TEST_CASE

(

RecursiveSafepointTest2

)

Definition at line 816 of file thread_test.cc.

                                                {
  Isolate* isolate = thread->isolate();
  Monitor monitor;
  intptr_t expected_count = 0;
  intptr_t total_done = 0;
  intptr_t exited = 0;
  for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
    Dart::thread_pool()->Run<SafepointTestTask>(
        isolate, &monitor, &expected_count, &total_done, &exited);
  }
  bool all_helpers = false;
  do {
    GcSafepointOperationScope safepoint_scope(thread);
    {
      GcSafepointOperationScope safepoint_scope(thread);
      MonitorLocker ml(&monitor);
      if (expected_count == SafepointTestTask::kTaskCount) {
        all_helpers = true;
      }
    }
  } while (!all_helpers);
  String& label = String::Handle(String::New("foo"));
  UserTag& tag = UserTag::Handle(UserTag::New(label));
  isolate->set_current_tag(tag);
  bool all_exited = false;
  do {
    GcSafepointOperationScope safepoint_scope(thread);
    {
      GcSafepointOperationScope safepoint_scope(thread);
      MonitorLocker ml(&monitor);
      if (exited == SafepointTestTask::kTaskCount) {
        all_exited = true;
      }
    }
  } while (!all_exited);
}

ISOLATE_UNIT_TEST_CASE() [279/463]

dart::ISOLATE_UNIT_TEST_CASE

(

RegenerateAllocStubs

)

Definition at line 130 of file compiler_test.cc.

                                             {
  const char* kScriptChars =
      "class A {\n"
      "}\n"
      "unOpt() => new A(); \n"
      "optIt() => new A(); \n"
      "A main() {\n"
      "  return unOpt();\n"
      "}\n";
 
  Class& cls = Class::Handle();
  TransitionVMToNative transition(thread);
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
 
  {
    TransitionNativeToVM transition(thread);
    Library& lib_handle =
        Library::Handle(Library::RawCast(Api::UnwrapHandle(lib)));
    cls = lib_handle.LookupClass(String::Handle(Symbols::New(thread, "A")));
    EXPECT(!cls.IsNull());
  }
 
  {
    TransitionNativeToVM transition(thread);
    cls.DisableAllocationStub();
  }
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
 
  {
    TransitionNativeToVM transition(thread);
    cls.DisableAllocationStub();
  }
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
 
  {
    TransitionNativeToVM transition(thread);
    cls.DisableAllocationStub();
  }
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
}

ISOLATE_UNIT_TEST_CASE() [280/463]

dart::ISOLATE_UNIT_TEST_CASE

(

RegExp_OneByteString

)

Definition at line 25 of file regexp_test.cc.

                                             {
  uint8_t chars[] = {'a', 'b', 'c', 'b', 'a'};
  intptr_t len = ARRAY_SIZE(chars);
  const String& str =
      String::Handle(OneByteString::New(chars, len, Heap::kNew));
 
  const String& pat =
      String::Handle(Symbols::New(thread, String::Handle(String::New("bc"))));
  const Array& res = Array::Handle(Match(pat, str));
  EXPECT_EQ(2, res.Length());
 
  const Object& res_1 = Object::Handle(res.At(0));
  const Object& res_2 = Object::Handle(res.At(1));
  EXPECT(res_1.IsSmi());
  EXPECT(res_2.IsSmi());
 
  const Smi& smi_1 = Smi::Cast(res_1);
  const Smi& smi_2 = Smi::Cast(res_2);
  EXPECT_EQ(1, smi_1.Value());
  EXPECT_EQ(3, smi_2.Value());
}

ISOLATE_UNIT_TEST_CASE() [281/463]

dart::ISOLATE_UNIT_TEST_CASE

(

RegExp_TwoByteString

)

Definition at line 47 of file regexp_test.cc.

                                             {
  uint16_t chars[] = {'a', 'b', 'c', 'b', 'a'};
  intptr_t len = ARRAY_SIZE(chars);
  const String& str =
      String::Handle(TwoByteString::New(chars, len, Heap::kNew));
 
  const String& pat =
      String::Handle(Symbols::New(thread, String::Handle(String::New("bc"))));
  const Array& res = Array::Handle(Match(pat, str));
  EXPECT_EQ(2, res.Length());
 
  const Object& res_1 = Object::Handle(res.At(0));
  const Object& res_2 = Object::Handle(res.At(1));
  EXPECT(res_1.IsSmi());
  EXPECT(res_2.IsSmi());
 
  const Smi& smi_1 = Smi::Cast(res_1);
  const Smi& smi_2 = Smi::Cast(res_2);
  EXPECT_EQ(1, smi_1.Value());
  EXPECT_EQ(3, smi_2.Value());
}

ISOLATE_UNIT_TEST_CASE() [282/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Reload_AtNonReloadSafepoint

)

Definition at line 791 of file safepoint_test.cc.

                                                    {
  auto isolate = thread->isolate();
  auto messages = isolate->message_handler();
 
  ThreadPool pool;
 
  // The [ReloadTask] will trigger a reload safepoint operation, sees that
  // we are at not at reload safepoint & sends us an OOB and waits for us to
  // check-in.
  std::shared_ptr<ReloadTask::Data> task(
      new ReloadTask::Data(isolate->group()));
  pool.Run<ReloadTask>(task);
  task->WaitUntil(ReloadTask::kEntered);
 
  {
    NoReloadScope no_reload(thread);
 
    // We are not at a safepoint.
    ASSERT(!thread->IsAtSafepoint());
 
    // Enter a non-reload safepoint.
    thread->EnterSafepoint();
    {
      // We are at a safepoint but not a reload safepoint. So we'll get an OOM.
      ASSERT(thread->IsAtSafepoint());
      while (!messages->HasOOBMessages()) {
        OS::Sleep(1000);
      }
      // Ensure we got a valid OOM
      std::unique_ptr<Message> message = messages->StealOOBMessage();
      EnsureValidOOBMessage(thread, isolate, std::move(message));
    }
    thread->ExitSafepoint();
 
    EXPECT(!messages->HasOOBMessages());
  }
 
  // We left the [NoReloadScope] which in it's destructor should detect
  // that a reload safepoint operation is requested and re-send OOM message to
  // current isolate.
  EXPECT(messages->HasOOBMessages());
  std::unique_ptr<Message> message = messages->StealOOBMessage();
  EnsureValidOOBMessage(thread, isolate, std::move(message));
 
  // Finally participate in the reload safepoint and finish.
  {
    ReloadParticipationScope allow_reload(thread);
    thread->BlockForSafepoint();
  }
 
  task->MarkAndNotify(ReloadTask::kPleaseExit);
  task->WaitUntil(ReloadTask::kExited);
}

ISOLATE_UNIT_TEST_CASE() [283/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Reload_AtReloadSafepoint

)

Definition at line 704 of file safepoint_test.cc.

                                                 {
  auto isolate = thread->isolate();
  auto messages = isolate->message_handler();
 
  ThreadPool pool;
 
  {
    ReloadParticipationScope allow_reload(thread);
 
    // We are not at a safepoint.
    ASSERT(!thread->IsAtSafepoint());
 
    // Enter a reload safepoint.
    thread->EnterSafepoint();
    {
      // The [ReloadTask] will trigger a reload safepoint operation, sees that
      // we are at reload safepoint & finishes without sending OOB message.
      std::shared_ptr<ReloadTask::Data> task(
          new ReloadTask::Data(isolate->group()));
      pool.Run<ReloadTask>(task);
      task->WaitUntil(ReloadTask::kEntered);
      task->MarkAndNotify(ReloadTask::kPleaseExit);
      task->WaitUntil(ReloadTask::kExited);
    }
    thread->ExitSafepoint();
 
    EXPECT(!messages->HasOOBMessages());
  }
}

ISOLATE_UNIT_TEST_CASE() [284/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Reload_NotAtSafepoint

)

Definition at line 750 of file safepoint_test.cc.

                                              {
  auto isolate = thread->isolate();
  auto messages = isolate->message_handler();
 
  ThreadPool pool;
 
  std::shared_ptr<ReloadTask::Data> task(
      new ReloadTask::Data(isolate->group()));
 
  {
    // Even if we are not running with an active isolate (e.g. due to being in
    // GC / Compiler) the reload safepoint operation should still send us an OOB
    // message (it should know this thread belongs to an isolate).
    NoActiveIsolateScope no_active_isolate(thread);
 
    pool.Run<ReloadTask>(task);
    task->WaitUntil(ReloadTask::kEntered);
 
    // We are not at a safepoint. The [ReloadTask] will trigger a reload
    // safepoint operation, sees that we are not at reload safepoint and instead
    // sends us an OOB.
    ASSERT(!thread->IsAtSafepoint());
    while (!messages->HasOOBMessages()) {
      OS::Sleep(1000);
    }
  }
 
  // Examine the OOB message for it's content.
  std::unique_ptr<Message> message = messages->StealOOBMessage();
  EnsureValidOOBMessage(thread, isolate, std::move(message));
 
  // Finally participate in the reload safepoint and finish.
  {
    ReloadParticipationScope allow_reload(thread);
    thread->BlockForSafepoint();
  }
 
  task->MarkAndNotify(ReloadTask::kPleaseExit);
  task->WaitUntil(ReloadTask::kExited);
}

ISOLATE_UNIT_TEST_CASE() [285/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ReloadScopes_Test

)

Definition at line 653 of file safepoint_test.cc.

                                          {
  // Unscheduling an isolate will enter a safepoint that is reloadable.
  {
    TransitionVMToNative transition(thread);
    IsolateExitScope isolate_leave_scope;
    EXPECT(thread->IsAtSafepoint(SafepointLevel::kGCAndDeoptAndReload));
  }
 
  // Unscheduling an isolate with active [NoReloadScope] will enter a safepoint
  // that is not reloadable.
  {
    // [NoReloadScope] only works if reload is supported.
#if !defined(PRODUCT)
    NoReloadScope no_reload_scope(thread);
    TransitionVMToNative transition(thread);
    IsolateExitScope isolate_leave_scope;
    EXPECT(!thread->IsAtSafepoint(SafepointLevel::kGCAndDeoptAndReload));
    EXPECT(thread->IsAtSafepoint(SafepointLevel::kGCAndDeopt));
#endif  // !defined(PRODUCT)
  }
 
  // Transitioning to native doesn't mean we enter a safepoint that is
  // reloadable.
  // => We may want to allow this in the future (so e.g. isolates that perform
  // blocking FFI call can be reloaded while being blocked).
  {
    TransitionVMToNative transition(thread);
    EXPECT(!thread->IsAtSafepoint(SafepointLevel::kGCAndDeoptAndReload));
    EXPECT(thread->IsAtSafepoint(SafepointLevel::kGCAndDeopt));
  }
 
  // Transitioning to native with explicit [ReloadParticipationScope] will
  // enter a safepoint that is reloadable.
  {
    ReloadParticipationScope enable_reload(thread);
    TransitionVMToNative transition(thread);
    EXPECT(thread->IsAtSafepoint(SafepointLevel::kGCAndDeoptAndReload));
  }
}

ISOLATE_UNIT_TEST_CASE() [286/463]

dart::ISOLATE_UNIT_TEST_CASE

(

RetainingPathGCRoot

)

Definition at line 146 of file object_graph_test.cc.

                                            {
  Dart_PersistentHandle persistent_handle;
  Dart_WeakPersistentHandle weak_persistent_handle;
  Array& path = Array::Handle(Array::New(1, Heap::kNew));
  ObjectGraph graph(thread);
  Dart_Handle handle = Api::NewHandle(thread, path.ptr());
 
  // GC root should be a local handle
  auto result = graph.RetainingPath(&path, path);
  EXPECT_STREQ(result.gc_root_type, "local handle");
 
  // GC root should now be a weak persistent handle
  {
    TransitionVMToNative transition(thread);
    weak_persistent_handle = Dart_NewWeakPersistentHandle(
        handle, reinterpret_cast<void*>(0xdeadbeef), 128, WeakHandleFinalizer);
  }
  result = graph.RetainingPath(&path, path);
  EXPECT_STREQ(result.gc_root_type, "weak persistent handle");
 
  // GC root should now be a persistent handle
  {
    TransitionVMToNative transition(thread);
    persistent_handle = Dart_NewPersistentHandle(handle);
  }
  result = graph.RetainingPath(&path, path);
  EXPECT_STREQ(result.gc_root_type, "persistent handle");
 
  // Delete the persistent handle. GC root should now be weak persistent handle
  {
    TransitionVMToNative transition(thread);
    Dart_DeletePersistentHandle(persistent_handle);
    persistent_handle = nullptr;
  }
  result = graph.RetainingPath(&path, path);
  EXPECT_STREQ(result.gc_root_type, "weak persistent handle");
 
  // Delete the weak persistent handle. GC root should now be local handle.
  {
    TransitionVMToNative transition(thread);
    Dart_DeleteWeakPersistentHandle(weak_persistent_handle);
    weak_persistent_handle = nullptr;
  }
  result = graph.RetainingPath(&path, path);
  EXPECT_STREQ(result.gc_root_type, "local handle");
}

ISOLATE_UNIT_TEST_CASE() [287/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointMonitorUnlockScope

)

Definition at line 1141 of file thread_test.cc.

                                                    {
  // This test uses ASSERT instead of EXPECT because IsOwnedByCurrentThread is
  // only available in debug mode. Since our vm/cc tests run in DEBUG mode that
  // is sufficient for this test.
  Monitor monitor;
  {
    SafepointMonitorLocker ml(&monitor);
    ASSERT(monitor.IsOwnedByCurrentThread());
    {
      SafepointMonitorUnlockScope ml_unlocker(&ml);
      ASSERT(!monitor.IsOwnedByCurrentThread());
      {
        SafepointMonitorLocker inner_ml(&monitor);
        ASSERT(monitor.IsOwnedByCurrentThread());
      }
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [288/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointMutexLockerWithLongJmp

)

Definition at line 1059 of file thread_test.cc.

                                                        {
  RunLockerWithLongJumpTest<Mutex, SafepointMutexLocker>();
}

ISOLATE_UNIT_TEST_CASE() [289/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointOperation_DeoptAndNonDeoptNesting

)

Definition at line 601 of file safepoint_test.cc.

                                                                   {
  auto safepoint_handler = thread->isolate_group()->safepoint_handler();
  {
    DeoptSafepointOperationScope safepoint_scope(thread);
    EXPECT(safepoint_handler->InnermostSafepointOperation(thread) ==
           SafepointLevel::kGCAndDeopt);
    DeoptSafepointOperationScope safepoint_scope2(thread);
    EXPECT(safepoint_handler->InnermostSafepointOperation(thread) ==
           SafepointLevel::kGCAndDeopt);
    GcSafepointOperationScope safepoint_scope3(thread);
    EXPECT(safepoint_handler->InnermostSafepointOperation(thread) ==
           SafepointLevel::kGC);
    GcSafepointOperationScope safepoint_scope4(thread);
    EXPECT(safepoint_handler->InnermostSafepointOperation(thread) ==
           SafepointLevel::kGC);
  }
  {
    DeoptSafepointOperationScope safepoint_scope(thread);
    EXPECT(safepoint_handler->InnermostSafepointOperation(thread) ==
           SafepointLevel::kGCAndDeopt);
    GcSafepointOperationScope safepoint_scope2(thread);
    EXPECT(safepoint_handler->InnermostSafepointOperation(thread) ==
           SafepointLevel::kGC);
  }
  {
    GcSafepointOperationScope safepoint_scope1(thread);
    EXPECT(safepoint_handler->InnermostSafepointOperation(thread) ==
           SafepointLevel::kGC);
    GcSafepointOperationScope safepoint_scope2(thread);
    EXPECT(safepoint_handler->InnermostSafepointOperation(thread) ==
           SafepointLevel::kGC);
  }
}

ISOLATE_UNIT_TEST_CASE() [290/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointOperation_SafepointOpBlockedWhileDeoptSafepointOp

)

Definition at line 241 of file safepoint_test.cc.

                                                                {
  auto isolate_group = thread->isolate_group();
 
  std::shared_ptr<LongDeoptTask::Data> deopt(
      new LongDeoptTask::Data(isolate_group));
  std::shared_ptr<WaiterTask::Data> gc(new WaiterTask::Data(isolate_group));
 
  thread->EnterSafepoint();
  {
    // Will join outstanding threads on destruction.
    ThreadPool pool;
 
    pool.Run<LongDeoptTask>(deopt);
    pool.Run<WaiterTask>(gc);
 
    // Wait until both threads entered the isolate group.
    deopt->WaitUntil(LongDeoptTask::kEntered);
    gc->WaitUntil(WaiterTask::kEntered);
 
    // Let gc task enter safepoint.
    gc->MarkAndNotify(WaiterTask::kEnterSafepoint);
    gc->WaitUntil(WaiterTask::kInsideSafepoint);
 
    // Now let the "deopt operation" run and block.
    deopt->MarkAndNotify(LongDeoptTask::kStartDeoptOperation);
    deopt->WaitUntil(LongDeoptTask::kInsideDeoptOperation);
 
    // Now let the gc task try to exit safepoint and do it's own safepoint
    // operation: We expect it to block on exiting safepoint, since the deopt
    // operation is still ongoing.
    gc->MarkAndNotify(WaiterTask::kPleaseExitSafepoint);
    OS::Sleep(200);
    gc->AssertIsNotIn(WaiterTask::kExitedSafepoint);
 
    // Now let's finish the deopt operation & ensure the waiter thread made
    // progress.
    deopt->MarkAndNotify(LongDeoptTask::kFinishDeoptOperation);
    gc->WaitUntil(WaiterTask::kExitedSafepoint);
 
    // Make both threads exit the isolate group.
    deopt->MarkAndNotify(LongDeoptTask::kPleaseExit);
    gc->MarkAndNotify(WaiterTask::kPleaseExit);
 
    deopt->WaitUntil(LongDeoptTask::kExited);
    gc->WaitUntil(WaiterTask::kExited);
  }
  thread->ExitSafepoint();
}

ISOLATE_UNIT_TEST_CASE() [291/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointOperation_SafepointOpWhileDeoptSafepointOpBlocked

)

Definition at line 140 of file safepoint_test.cc.

                                                                {
  auto isolate_group = thread->isolate_group();
 
  std::shared_ptr<DeoptTask::Data> deopt(new DeoptTask::Data(isolate_group));
  std::shared_ptr<GcWithoutDeoptTask::Data> gc(
      new GcWithoutDeoptTask::Data(isolate_group));
 
  thread->EnterSafepoint();
  {
    // Will join outstanding threads on destruction.
    ThreadPool pool;
 
    pool.Run<DeoptTask>(deopt);
    pool.Run<GcWithoutDeoptTask>(gc);
 
    // Wait until both threads entered the isolate group.
    deopt->WaitUntil(DeoptTask::kEntered);
    gc->WaitUntil(GcWithoutDeoptTask::kEntered);
 
    // Let deopt task start deopt operation scope (it will block in
    // [SafepointOperationScope] constructor until all threads have checked-in).
    deopt->MarkAndNotify(DeoptTask::kStartDeoptOperation);
    OS::Sleep(200);  // Give it time to actually start the deopt operation
 
    // Now let the other thread do a full safepoint operation and wait until
    // it's done: We want to ensure that we can do normal safepoint operations
    // while a deopt operation is being started and is waiting for all mutators
    // to reach an appropriate place where they can be deopted.
    gc->MarkAndNotify(GcWithoutDeoptTask::kStartSafepointOperation);
    gc->WaitUntil(GcWithoutDeoptTask::kEndSafepointOperation);
 
    // We were successfully doing a safepoint operation, now let's ensure the
    // first thread is still stuck in the starting of deopt operation.
    deopt->AssertIsIn(DeoptTask::kStartDeoptOperation);
 
    // Now we'll let the other thread check-in and ensure the deopt operation
    // proceeded and finished.
    gc->MarkAndNotify(GcWithoutDeoptTask::kJoinDeoptOperation);
    gc->WaitUntil(GcWithoutDeoptTask::kDeoptOperationDone);
    deopt->WaitUntil(DeoptTask::kFinishedDeoptOperation);
 
    // Make both threads exit the isolate group.
    deopt->MarkAndNotify(DeoptTask::kPleaseExit);
    gc->MarkAndNotify(GcWithoutDeoptTask::kPleaseExit);
 
    deopt->WaitUntil(DeoptTask::kExited);
    gc->WaitUntil(GcWithoutDeoptTask::kExited);
  }
  thread->ExitSafepoint();
}

ISOLATE_UNIT_TEST_CASE() [292/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointOperation_SafepointPointTest

)

Definition at line 392 of file safepoint_test.cc.

                                                              {
  auto isolate_group = thread->isolate_group();
 
  const intptr_t kTaskCount = 6;
  std::atomic<intptr_t> gc_only_checkins[kTaskCount];
  std::atomic<intptr_t> deopt_checkins[kTaskCount];
  std::atomic<intptr_t> reload_checkins[kTaskCount];
  std::atomic<intptr_t> timeout_checkins[kTaskCount];
  for (intptr_t i = 0; i < kTaskCount; ++i) {
    gc_only_checkins[i] = 0;
    deopt_checkins[i] = 0;
    reload_checkins[i] = 0;
    timeout_checkins[i] = 0;
  }
 
  auto task_to_level = [](intptr_t task_id) -> SafepointLevel {
    switch (task_id) {
      case 0:
      case 1:
        return SafepointLevel::kGC;
      case 2:
      case 3:
        return SafepointLevel::kGCAndDeopt;
      case 4:
      case 5:
        return SafepointLevel::kGCAndDeoptAndReload;
      default:
        UNREACHABLE();
        return SafepointLevel::kGC;
    }
  };
  auto wait_for_sync = [&](intptr_t syncs) {
    while (true) {
      bool ready = true;
      for (intptr_t i = 0; i < kTaskCount; ++i) {
        const intptr_t all = gc_only_checkins[i] + deopt_checkins[i] +
                             reload_checkins[i] + timeout_checkins[i];
        if (all != syncs) {
          ready = false;
          break;
        }
      }
      if (ready) {
        return;
      }
      OS::SleepMicros(1000);
    }
  };
 
  std::vector<std::shared_ptr<CheckinTask::Data>> threads;
  for (intptr_t i = 0; i < kTaskCount; ++i) {
    const auto level = task_to_level(i);
    std::unique_ptr<CheckinTask::Data> data(new CheckinTask::Data(
        isolate_group, level, &gc_only_checkins[i], &deopt_checkins[i],
        &reload_checkins[i], &timeout_checkins[i]));
    threads.push_back(std::move(data));
  }
 
  {
    // Will join outstanding threads on destruction.
    ThreadPool pool;
 
    for (intptr_t i = 0; i < kTaskCount; i++) {
      pool.Run<CheckinTask>(threads[i]);
    }
    for (intptr_t i = 0; i < kTaskCount; i++) {
      threads[i]->WaitUntil(CheckinTask::kEntered);
    }
    for (intptr_t i = 0; i < kTaskCount; i++) {
      threads[i]->MarkAndNotify(CheckinTask::kStartLoop);
    }
    {
      { GcSafepointOperationScope safepoint_operation(thread); }
      wait_for_sync(1);  // Wait for threads to exit safepoint
      { DeoptSafepointOperationScope safepoint_operation(thread); }
      wait_for_sync(2);  // Wait for threads to exit safepoint
      { RELOAD_OPERATION_SCOPE(thread); }
      wait_for_sync(3);  // Wait for threads to exit safepoint
      { GcSafepointOperationScope safepoint_operation(thread); }
      wait_for_sync(4);  // Wait for threads to exit safepoint
      { DeoptSafepointOperationScope safepoint_operation(thread); }
      wait_for_sync(5);  // Wait for threads to exit safepoint
      { RELOAD_OPERATION_SCOPE(thread); }
    }
    for (intptr_t i = 0; i < kTaskCount; i++) {
      threads[i]->MarkAndNotify(CheckinTask::kPleaseExit);
    }
    for (intptr_t i = 0; i < kTaskCount; i++) {
      threads[i]->WaitUntil(CheckinTask::kExited);
    }
    for (intptr_t i = 0; i < kTaskCount; ++i) {
      switch (task_to_level(i)) {
        case SafepointLevel::kGC:
          EXPECT_EQ(2, gc_only_checkins[i]);
          EXPECT_EQ(0, deopt_checkins[i]);
          EXPECT_EQ(0, reload_checkins[i]);
          EXPECT_EQ(4, timeout_checkins[i]);
          break;
        case SafepointLevel::kGCAndDeopt:
          EXPECT_EQ(0, gc_only_checkins[i]);
          EXPECT_EQ(4, deopt_checkins[i]);
          EXPECT_EQ(0, reload_checkins[i]);
          EXPECT_EQ(2, timeout_checkins[i]);
          break;
        case SafepointLevel::kGCAndDeoptAndReload:
          EXPECT_EQ(0, gc_only_checkins[i]);
          EXPECT_EQ(0, deopt_checkins[i]);
          EXPECT_EQ(6, reload_checkins[i]);
          EXPECT_EQ(0, timeout_checkins[i]);
          break;
        case SafepointLevel::kNumLevels:
        case SafepointLevel::kNoSafepoint:
          UNREACHABLE();
      }
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [293/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointOperation_StressTest

)

Definition at line 565 of file safepoint_test.cc.

                                                      {
  auto isolate_group = thread->isolate_group();
 
  const intptr_t kTaskCount = 5;
 
  std::vector<std::shared_ptr<StressTask::Data>> threads;
  for (intptr_t i = 0; i < kTaskCount; ++i) {
    std::unique_ptr<StressTask::Data> data(new StressTask::Data(isolate_group));
    threads.push_back(std::move(data));
  }
 
  thread->EnterSafepoint();
  {
    // Will join outstanding threads on destruction.
    ThreadPool pool;
 
    for (intptr_t i = 0; i < kTaskCount; i++) {
      pool.Run<StressTask>(threads[i]);
    }
    for (intptr_t i = 0; i < kTaskCount; i++) {
      threads[i]->WaitUntil(StressTask::kEntered);
    }
    for (intptr_t i = 0; i < kTaskCount; i++) {
      threads[i]->MarkAndNotify(StressTask::kStart);
    }
    OS::Sleep(3 * 1000);
    for (intptr_t i = 0; i < kTaskCount; i++) {
      threads[i]->MarkAndNotify(StressTask::kPleaseExit);
    }
    for (intptr_t i = 0; i < kTaskCount; i++) {
      threads[i]->WaitUntil(StressTask::kExited);
    }
  }
  thread->ExitSafepoint();
}

ISOLATE_UNIT_TEST_CASE() [294/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockExclusiveNestedWriter_Regress44000

)

Definition at line 1097 of file thread_test.cc.

                                                                          {
  auto isolate_group = IsolateGroup::Current();
 
  SafepointRwLock lock;
  ReaderThreadState state;
  state.rw_lock = &lock;
  state.isolate_group = isolate_group;
  state.value = 0;
  state.child_started = false;
  state.monitor = new Monitor();
  {
    // Hold one writer lock.
    SafepointWriteRwLocker locker(Thread::Current(), &lock);
    {
      // Hold another, nested, writer lock.
      SafepointWriteRwLocker locker2(Thread::Current(), &lock);
 
      // Start a thread, it will try to acquire read lock but it will have to
      // wait until we have exited both writer scopes.
      if (OSThread::Start("DartWorker", &Helper,
                          reinterpret_cast<uword>(&state)) != 0) {
        FATAL("Could not start worker thread");
      }
      // Wait for the thread to start.
      {
        MonitorLocker ml(state.monitor);
        while (!state.child_started) {
          ml.Wait();
        }
      }
      state.value = 1;
    }
    state.value = 2;
  }
  // Join the other thread.
  OSThread::Join(state.reader_id);
 
  // Ensure the reader thread had to wait before it entered the
  // SafepointWriteRwLocker scope.
  EXPECT(state.observed_value == 2);
 
  delete state.monitor;
}

ISOLATE_UNIT_TEST_CASE() [295/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockReadWithLongJmp

)

Definition at line 1055 of file thread_test.cc.

                                                       {
  RunLockerWithLongJumpTest<SafepointRwLock, SafepointReadRwLocker>();
}

ISOLATE_UNIT_TEST_CASE() [296/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockReentrantReadLock

)

Definition at line 981 of file thread_test.cc.

                                                         {
  SafepointRwLock lock;
  {
    SafepointReadRwLocker locker(Thread::Current(), &lock);
    {
      SafepointReadRwLocker locker1(Thread::Current(), &lock);
      DEBUG_ONLY(EXPECT(lock.IsCurrentThreadReader()));
      EXPECT(!lock.IsCurrentThreadWriter());
    }
    DEBUG_ONLY(EXPECT(lock.IsCurrentThreadReader()));
    EXPECT(!lock.IsCurrentThreadWriter());
  }
  DEBUG_ONLY(EXPECT(!lock.IsCurrentThreadReader()));
  EXPECT(!lock.IsCurrentThreadWriter());
}

ISOLATE_UNIT_TEST_CASE() [297/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockReentrantWriteLock

)

Definition at line 997 of file thread_test.cc.

                                                          {
  SafepointRwLock lock;
  {
    SafepointWriteRwLocker locker(Thread::Current(), &lock);
    {
      SafepointWriteRwLocker locker1(Thread::Current(), &lock);
      DEBUG_ONLY(EXPECT(lock.IsCurrentThreadReader()));
      EXPECT(lock.IsCurrentThreadWriter());
    }
    DEBUG_ONLY(EXPECT(lock.IsCurrentThreadReader()));
    EXPECT(lock.IsCurrentThreadWriter());
  }
  DEBUG_ONLY(EXPECT(!lock.IsCurrentThreadReader()));
  EXPECT(!lock.IsCurrentThreadWriter());
}

ISOLATE_UNIT_TEST_CASE() [298/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockWithoutAnyLocks

)

Definition at line 975 of file thread_test.cc.

                                                       {
  SafepointRwLock lock;
  DEBUG_ONLY(EXPECT(!lock.IsCurrentThreadReader()));
  EXPECT(!lock.IsCurrentThreadWriter());
}

ISOLATE_UNIT_TEST_CASE() [299/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockWithReadLock

)

Definition at line 961 of file thread_test.cc.

                                                    {
  SafepointRwLock lock;
  SafepointReadRwLocker locker(Thread::Current(), &lock);
  DEBUG_ONLY(EXPECT(lock.IsCurrentThreadReader()));
  EXPECT(!lock.IsCurrentThreadWriter());
}

ISOLATE_UNIT_TEST_CASE() [300/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockWithWriteLock

)

Definition at line 968 of file thread_test.cc.

                                                     {
  SafepointRwLock lock;
  SafepointWriteRwLocker locker(Thread::Current(), &lock);
  DEBUG_ONLY(EXPECT(lock.IsCurrentThreadReader()));
  EXPECT(lock.IsCurrentThreadWriter());
}

ISOLATE_UNIT_TEST_CASE() [301/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockWriteToReadLock

)

Definition at line 1013 of file thread_test.cc.

                                                       {
  SafepointRwLock lock;
  {
    SafepointWriteRwLocker locker(Thread::Current(), &lock);
    {
      SafepointReadRwLocker locker1(Thread::Current(), &lock);
      DEBUG_ONLY(EXPECT(lock.IsCurrentThreadReader()));
      EXPECT(lock.IsCurrentThreadWriter());
    }
    DEBUG_ONLY(EXPECT(lock.IsCurrentThreadReader()));
    EXPECT(lock.IsCurrentThreadWriter());
  }
  DEBUG_ONLY(EXPECT(!lock.IsCurrentThreadReader()));
  EXPECT(!lock.IsCurrentThreadWriter());
}

ISOLATE_UNIT_TEST_CASE() [302/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointRwLockWriteWithLongJmp

)

Definition at line 1051 of file thread_test.cc.

                                                        {
  RunLockerWithLongJumpTest<SafepointRwLock, SafepointWriteRwLocker>();
}

ISOLATE_UNIT_TEST_CASE() [303/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointTestVM

)

Definition at line 664 of file thread_test.cc.

                                        {
  Isolate* isolate = thread->isolate();
  Monitor monitor;
  intptr_t expected_count = 0;
  intptr_t total_done = 0;
  intptr_t exited = 0;
  for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
    Dart::thread_pool()->Run<SafepointTestTask>(
        isolate, &monitor, &expected_count, &total_done, &exited);
  }
  String& label = String::Handle(String::New("foo"));
  UserTag& tag = UserTag::Handle(UserTag::New(label));
  isolate->set_current_tag(tag);
  MonitorLocker ml(&monitor);
  while (exited != SafepointTestTask::kTaskCount) {
    ml.WaitWithSafepointCheck(thread);
  }
}

ISOLATE_UNIT_TEST_CASE() [304/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SafepointTestVM2

)

Definition at line 785 of file thread_test.cc.

                                         {
  Isolate* isolate = thread->isolate();
  Monitor monitor;
  intptr_t expected_count = 0;
  intptr_t total_done = 0;
  intptr_t exited = 0;
  for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
    Dart::thread_pool()->Run<SafepointTestTask>(
        isolate, &monitor, &expected_count, &total_done, &exited);
  }
  bool all_helpers = false;
  do {
    GcSafepointOperationScope safepoint_scope(thread);
    {
      MonitorLocker ml(&monitor);
      if (expected_count == SafepointTestTask::kTaskCount) {
        all_helpers = true;
      }
    }
  } while (!all_helpers);
  String& label = String::Handle(String::New("foo"));
  UserTag& tag = UserTag::Handle(UserTag::New(label));
  isolate->set_current_tag(tag);
  MonitorLocker ml(&monitor);
  while (exited != SafepointTestTask::kTaskCount) {
    ml.WaitWithSafepointCheck(thread);
  }
}

ISOLATE_UNIT_TEST_CASE() [305/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Script

)

Definition at line 2354 of file object_test.cc.

                               {
  {
    const char* url_chars = "builtin:test-case";
    const char* source_chars = "This will not compile.";
    const String& url = String::Handle(String::New(url_chars));
    const String& source = String::Handle(String::New(source_chars));
    const Script& script = Script::Handle(Script::New(url, source));
    EXPECT(!script.IsNull());
    EXPECT(script.IsScript());
    String& str = String::Handle(script.url());
    EXPECT_EQ(17, str.Length());
    EXPECT_EQ('b', str.CharAt(0));
    EXPECT_EQ(':', str.CharAt(7));
    EXPECT_EQ('e', str.CharAt(16));
    str = script.Source();
    EXPECT_EQ(22, str.Length());
    EXPECT_EQ('T', str.CharAt(0));
    EXPECT_EQ('n', str.CharAt(10));
    EXPECT_EQ('.', str.CharAt(21));
  }
 
  {
    const char* url_chars = "";
    // Single line, no terminators.
    const char* source_chars = "abc";
    const String& url = String::Handle(String::New(url_chars));
    const String& source = String::Handle(String::New(source_chars));
    const Script& script = Script::Handle(Script::New(url, source));
    EXPECT(!script.IsNull());
    EXPECT(script.IsScript());
    auto& str = String::Handle(Z);
    str = script.GetLine(1);
    EXPECT_STREQ("abc", str.ToCString());
    str = script.GetSnippet(1, 1, 1, 2);
    EXPECT_STREQ("a", str.ToCString());
    str = script.GetSnippet(1, 2, 1, 4);
    EXPECT_STREQ("bc", str.ToCString());
    // Lines not in the source should return the empty string.
    str = script.GetLine(-500);
    EXPECT_STREQ("", str.ToCString());
    str = script.GetLine(0);
    EXPECT_STREQ("", str.ToCString());
    str = script.GetLine(2);
    EXPECT_STREQ("", str.ToCString());
    str = script.GetLine(10000);
    EXPECT_STREQ("", str.ToCString());
    // Snippets not contained within the source should be the null string.
    str = script.GetSnippet(-1, 1, 1, 2);
    EXPECT(str.IsNull());
    str = script.GetSnippet(2, 1, 2, 2);
    EXPECT(str.IsNull());
    str = script.GetSnippet(1, 1, 1, 5);
    EXPECT(str.IsNull());
  }
 
  TransitionVMToNative transition(thread);
  const char* kScript = "main() {}";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
}

ISOLATE_UNIT_TEST_CASE() [306/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SecondExitDown

)

Definition at line 322 of file loops_test.cc.

                                      {
          int a = p1 + 3;
          int b = p1 - 5;
          int c = p1 * 7;
          int d = - p1;
          p1 = - p1;
          p2 = 100 - p2;
        }
      }

ISOLATE_UNIT_TEST_CASE() [307/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SecondExitUp

)

Definition at line 311 of file loops_test.cc.

                                           {
  const char* script_chars =
      R"(
      foo() {

ISOLATE_UNIT_TEST_CASE() [308/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeArray

)

Definition at line 410 of file snapshot_test.cc.

                                       {
  // Write snapshot with object content.
  const int kArrayLength = 10;
  Array& array = Array::Handle(Array::New(kArrayLength));
  Smi& smi = Smi::Handle();
  for (int i = 0; i < kArrayLength; i++) {
    smi ^= Smi::New(i);
    array.SetAt(i, smi);
  }
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, array, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  Array& serialized_array = Array::Handle();
  serialized_array ^= ReadMessage(thread, message.get());
  EXPECT(array.CanonicalizeEquals(serialized_array));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_EQ(Dart_CObject_kArray, root->type);
  EXPECT_EQ(kArrayLength, root->value.as_array.length);
  for (int i = 0; i < kArrayLength; i++) {
    Dart_CObject* element = root->value.as_array.values[i];
    EXPECT_EQ(Dart_CObject_kInt32, element->type);
    EXPECT_EQ(i, element->value.as_int32);
  }
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [309/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeArrayWithTypeArgument

)

Definition at line 440 of file snapshot_test.cc.

                                                       {
  // Write snapshot with object content.
  const int kArrayLength = 10;
  Array& array =
      Array::Handle(Array::New(kArrayLength, Type::Handle(Type::ObjectType())));
 
  Smi& smi = Smi::Handle();
  for (int i = 0; i < kArrayLength; i++) {
    smi ^= Smi::New(i);
    array.SetAt(i, smi);
  }
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, array, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  Array& serialized_array = Array::Handle();
  serialized_array ^= ReadMessage(thread, message.get());
  EXPECT(array.CanonicalizeEquals(serialized_array));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_EQ(Dart_CObject_kArray, root->type);
  EXPECT_EQ(kArrayLength, root->value.as_array.length);
  for (int i = 0; i < kArrayLength; i++) {
    Dart_CObject* element = root->value.as_array.values[i];
    EXPECT_EQ(Dart_CObject_kInt32, element->type);
    EXPECT_EQ(i, element->value.as_int32);
  }
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [310/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeByteArray

)

Definition at line 556 of file snapshot_test.cc.

                                           {
  // Write snapshot with object content.
  const int kTypedDataLength = 256;
  TypedData& typed_data = TypedData::Handle(
      TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
  for (int i = 0; i < kTypedDataLength; i++) {
    typed_data.SetUint8(i, i);
  }
  std::unique_ptr<Message> message =
      WriteMessage(/* same_group */ false, typed_data, ILLEGAL_PORT,
                   Message::kNormalPriority);
 
  // Read object back from the snapshot.
  TypedData& serialized_typed_data = TypedData::Handle();
  serialized_typed_data ^= ReadMessage(thread, message.get());
  EXPECT(serialized_typed_data.IsTypedData());
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_EQ(Dart_CObject_kTypedData, root->type);
  EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
  for (int i = 0; i < kTypedDataLength; i++) {
    EXPECT(root->value.as_typed_data.values[i] == i);
  }
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [311/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeCapability

)

Definition at line 326 of file snapshot_test.cc.

                                            {
  // Write snapshot with object content.
  const Capability& capability = Capability::Handle(Capability::New(12345));
  std::unique_ptr<Message> message =
      WriteMessage(/* same_group */ false, capability, ILLEGAL_PORT,
                   Message::kNormalPriority);
 
  // Read object back from the snapshot.
  Capability& obj = Capability::Handle();
  obj ^= ReadMessage(thread, message.get());
 
  EXPECT_EQ(static_cast<uint64_t>(12345), obj.Id());
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kCapability, root->type);
  int64_t id = root->value.as_capability.id;
  EXPECT_EQ(12345, id);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [312/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeDouble

)

Definition at line 258 of file snapshot_test.cc.

                                        {
  StackZone zone(thread);
 
  // Write snapshot with object content.
  const Double& dbl = Double::Handle(Double::New(101.29));
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, dbl, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  const Object& serialized_object =
      Object::Handle(ReadMessage(thread, message.get()));
  EXPECT(Equals(dbl, serialized_object));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kDouble, root->type);
  EXPECT_EQ(dbl.value(), root->value.as_double);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [313/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeEmptyArray

)

Definition at line 535 of file snapshot_test.cc.

                                            {
  // Write snapshot with object content.
  const int kArrayLength = 0;
  Array& array = Array::Handle(Array::New(kArrayLength));
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, array, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  Array& serialized_array = Array::Handle();
  serialized_array ^= ReadMessage(thread, message.get());
  EXPECT(array.CanonicalizeEquals(serialized_array));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_EQ(Dart_CObject_kArray, root->type);
  EXPECT_EQ(kArrayLength, root->value.as_array.length);
  EXPECT(root->value.as_array.values == nullptr);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [314/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeEmptyByteArray

)

Definition at line 685 of file snapshot_test.cc.

                                                {
  // Write snapshot with object content.
  const int kTypedDataLength = 0;
  TypedData& typed_data = TypedData::Handle(
      TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
  std::unique_ptr<Message> message =
      WriteMessage(/* same_group */ false, typed_data, ILLEGAL_PORT,
                   Message::kNormalPriority);
 
  // Read object back from the snapshot.
  TypedData& serialized_typed_data = TypedData::Handle();
  serialized_typed_data ^= ReadMessage(thread, message.get());
  EXPECT(serialized_typed_data.IsTypedData());
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_EQ(Dart_CObject_kTypedData, root->type);
  EXPECT_EQ(Dart_TypedData_kUint8, root->value.as_typed_data.type);
  EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
  EXPECT(root->value.as_typed_data.values == nullptr);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [315/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeExternalTypedArray

)

Definition at line 659 of file snapshot_test.cc.

                                                    {
  TEST_EXTERNAL_TYPED_ARRAY(Int8, int8_t);
  TEST_EXTERNAL_TYPED_ARRAY(Uint8, uint8_t);
  TEST_EXTERNAL_TYPED_ARRAY(Int16, int16_t);
  TEST_EXTERNAL_TYPED_ARRAY(Uint16, uint16_t);
  TEST_EXTERNAL_TYPED_ARRAY(Int32, int32_t);
  TEST_EXTERNAL_TYPED_ARRAY(Uint32, uint32_t);
  TEST_EXTERNAL_TYPED_ARRAY(Int64, int64_t);
  TEST_EXTERNAL_TYPED_ARRAY(Uint64, uint64_t);
  TEST_EXTERNAL_TYPED_ARRAY(Float32, float);
  TEST_EXTERNAL_TYPED_ARRAY(Float64, double);
}

ISOLATE_UNIT_TEST_CASE() [316/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeFalse

)

Definition at line 304 of file snapshot_test.cc.

                                       {
  StackZone zone(thread);
 
  // Write snapshot with false object.
  const Bool& bl = Bool::False();
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, bl, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  const Object& serialized_object =
      Object::Handle(ReadMessage(thread, message.get()));
  EXPECT(Equals(bl, serialized_object));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kBool, root->type);
  EXPECT_EQ(false, root->value.as_bool);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [317/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeMints

)

Definition at line 239 of file snapshot_test.cc.

                                       {
  // Min positive mint.
  CheckMint(Smi::kMaxValue + 1);
  // Min positive mint + 1.
  CheckMint(Smi::kMaxValue + 2);
  // Max negative mint.
  CheckMint(Smi::kMinValue - 1);
  // Max negative mint - 1.
  CheckMint(Smi::kMinValue - 2);
  // Max positive mint.
  CheckMint(kMaxInt64);
  // Max positive mint - 1.
  CheckMint(kMaxInt64 - 1);
  // Min negative mint.
  CheckMint(kMinInt64);
  // Min negative mint + 1.
  CheckMint(kMinInt64 + 1);
}

ISOLATE_UNIT_TEST_CASE() [318/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeNull

)

Definition at line 125 of file snapshot_test.cc.

                                      {
  StackZone zone(thread);
 
  // Write snapshot with object content.
  const Object& null_object = Object::Handle();
  std::unique_ptr<Message> message =
      WriteMessage(/* same_group */ false, null_object, ILLEGAL_PORT,
                   Message::kNormalPriority);
 
  // Read object back from the snapshot.
  const Object& serialized_object =
      Object::Handle(ReadMessage(thread, message.get()));
  EXPECT(Equals(null_object, serialized_object));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kNull, root->type);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [319/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeSingletons

)

Definition at line 359 of file snapshot_test.cc.

                                            {
  TEST_ROUND_TRIP_IDENTICAL(Object::class_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::type_arguments_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::function_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::field_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::script_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::library_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::code_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::instructions_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::pc_descriptors_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::exception_handlers_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::context_class());
  TEST_ROUND_TRIP_IDENTICAL(Object::context_scope_class());
}

ISOLATE_UNIT_TEST_CASE() [320/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeSmi1

)

Definition at line 147 of file snapshot_test.cc.

                                      {
  StackZone zone(thread);
 
  // Write snapshot with object content.
  const Smi& smi = Smi::Handle(Smi::New(124));
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, smi, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  const Object& serialized_object =
      Object::Handle(ReadMessage(thread, message.get()));
  EXPECT(Equals(smi, serialized_object));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kInt32, root->type);
  EXPECT_EQ(smi.Value(), root->value.as_int32);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [321/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeSmi2

)

Definition at line 169 of file snapshot_test.cc.

                                      {
  StackZone zone(thread);
 
  // Write snapshot with object content.
  const Smi& smi = Smi::Handle(Smi::New(-1));
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, smi, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  const Object& serialized_object =
      Object::Handle(ReadMessage(thread, message.get()));
  EXPECT(Equals(smi, serialized_object));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kInt32, root->type);
  EXPECT_EQ(smi.Value(), root->value.as_int32);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [322/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeString

)

Definition at line 395 of file snapshot_test.cc.

                                        {
  TestString("This string shall be serialized");
  TestString("æøå");  // This file is UTF-8 encoded.
  const char* data =
      "\x01"
      "\x7F"
      "\xC2\x80"       // U+0080
      "\xDF\xBF"       // U+07FF
      "\xE0\xA0\x80"   // U+0800
      "\xEF\xBF\xBF";  // U+FFFF
 
  TestString(data);
  // TODO(sgjesse): Add tests with non-BMP characters.
}

ISOLATE_UNIT_TEST_CASE() [323/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeTrue

)

Definition at line 280 of file snapshot_test.cc.

                                      {
  StackZone zone(thread);
 
  // Write snapshot with true object.
  const Bool& bl = Bool::True();
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, bl, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  const Object& serialized_object =
      Object::Handle(ReadMessage(thread, message.get()));
  fprintf(stderr, "%s / %s\n", bl.ToCString(), serialized_object.ToCString());
 
  EXPECT(Equals(bl, serialized_object));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_NOTNULL(root);
  EXPECT_EQ(Dart_CObject_kBool, root->type);
  EXPECT_EQ(true, root->value.as_bool);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

ISOLATE_UNIT_TEST_CASE() [324/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeTypedArray

)

Definition at line 646 of file snapshot_test.cc.

                                            {
  TEST_TYPED_ARRAY(Int8, int8_t);
  TEST_TYPED_ARRAY(Uint8, uint8_t);
  TEST_TYPED_ARRAY(Int16, int16_t);
  TEST_TYPED_ARRAY(Uint16, uint16_t);
  TEST_TYPED_ARRAY(Int32, int32_t);
  TEST_TYPED_ARRAY(Uint32, uint32_t);
  TEST_TYPED_ARRAY(Int64, int64_t);
  TEST_TYPED_ARRAY(Uint64, uint64_t);
  TEST_TYPED_ARRAY(Float32, float);
  TEST_TYPED_ARRAY(Float64, double);
}

ISOLATE_UNIT_TEST_CASE() [325/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SerializeUnmodifiableExternalTypedArray

)

Definition at line 672 of file snapshot_test.cc.

                                                                {
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Int8, int8_t);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Uint8, uint8_t);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Int16, int16_t);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Uint16, uint16_t);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Int32, int32_t);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Uint32, uint32_t);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Int64, int64_t);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Uint64, uint64_t);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Float32, float);
  TEST_UNMODIFIABLE_EXTERNAL_TYPED_ARRAY(Float64, double);
}

ISOLATE_UNIT_TEST_CASE() [326/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_Code

)

Definition at line 221 of file service_test.cc.

                                     {
  const char* kScript =
      "var port;\n"  // Set to our mock port by C++.
      "\n"
      "class A {\n"
      "  var a;\n"
      "  dynamic b() {}\n"
      "  dynamic c() {\n"
      "    var d = () { b(); };\n"
      "    return d;\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  var z = new A();\n"
      "  var x = z.c();\n"
      "  x();\n"
      "}";
 
  Isolate* isolate = thread->isolate();
  isolate->set_is_runnable(true);
  Dart_Handle lib;
  Library& vmlib = Library::Handle();
  {
    TransitionVMToNative transition(thread);
    lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    EXPECT(!Dart_IsNull(lib));
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
  }
  vmlib ^= Api::UnwrapHandle(lib);
  EXPECT(!vmlib.IsNull());
  const Class& class_a = Class::Handle(GetClass(vmlib, "A"));
  EXPECT(!class_a.IsNull());
  const Function& function_c = Function::Handle(GetFunction(class_a, "c"));
  EXPECT(!function_c.IsNull());
  const Code& code_c = Code::Handle(function_c.CurrentCode());
  EXPECT(!code_c.IsNull());
  // Use the entry of the code object as it's reference.
  uword entry = code_c.PayloadStart();
  int64_t compile_timestamp = code_c.compile_timestamp();
  EXPECT_GT(code_c.Size(), 16u);
  uword last = entry + code_c.Size();
 
  // Build a mock message handler and wrap it in a dart port.
  ServiceTestMessageHandler handler;
  Dart_Port port_id = PortMap::CreatePort(&handler);
  Dart_Handle port = Api::NewHandle(thread, SendPort::New(port_id));
  {
    TransitionVMToNative transition(thread);
    EXPECT_VALID(port);
    EXPECT_VALID(Dart_SetField(lib, NewString("port"), port));
  }
 
  Array& service_msg = Array::Handle();
 
  // Request an invalid code object.
  service_msg =
      Eval(lib, "[0, port, '0', 'getObject', ['objectId'], ['code/0']]");
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_SUBSTRING("\"error\"", handler.msg());
 
  // The following test checks that a code object can be found only
  // at compile_timestamp()-code.EntryPoint().
  service_msg = EvalF(lib,
                      "[0, port, '0', 'getObject', "
                      "['objectId'], ['code/%" Px64 "-%" Px "']]",
                      compile_timestamp, entry);
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_SUBSTRING("\"type\":\"Code\"", handler.msg());
  {
    // Only perform a partial match.
    const intptr_t kBufferSize = 512;
    char buffer[kBufferSize];
    Utils::SNPrint(buffer, kBufferSize - 1,
                   "\"fixedId\":true,\"id\":\"code\\/%" Px64 "-%" Px "\",",
                   compile_timestamp, entry);
    EXPECT_SUBSTRING(buffer, handler.msg());
  }
 
  // Request code object at compile_timestamp-code.EntryPoint() + 16
  // Expect this to fail because the address is not the entry point.
  uintptr_t address = entry + 16;
  service_msg = EvalF(lib,
                      "[0, port, '0', 'getObject', "
                      "['objectId'], ['code/%" Px64 "-%" Px "']]",
                      compile_timestamp, address);
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_SUBSTRING("\"error\"", handler.msg());
 
  // Request code object at (compile_timestamp - 1)-code.EntryPoint()
  // Expect this to fail because the timestamp is wrong.
  address = entry;
  service_msg = EvalF(lib,
                      "[0, port, '0', 'getObject', "
                      "['objectId'], ['code/%" Px64 "-%" Px "']]",
                      compile_timestamp - 1, address);
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_SUBSTRING("\"error\"", handler.msg());
 
  // Request native code at address. Expect the null code object back.
  address = last;
  service_msg = EvalF(lib,
                      "[0, port, '0', 'getObject', "
                      "['objectId'], ['code/native-%" Px "']]",
                      address);
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  // TODO(turnidge): It is pretty broken to return an Instance here.  Fix.
  EXPECT_SUBSTRING("\"kind\":\"Null\"", handler.msg());
 
  // Request malformed native code.
  service_msg = EvalF(lib,
                      "[0, port, '0', 'getObject', ['objectId'], "
                      "['code/native%" Px "']]",
                      address);
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_SUBSTRING("\"error\"", handler.msg());
}

ISOLATE_UNIT_TEST_CASE() [327/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_EmbedderIsolateHandler

)

Definition at line 628 of file service_test.cc.

                                                       {
  const char* kScript =
      "var port;\n"  // Set to our mock port by C++.
      "\n"
      "var x = 7;\n"
      "main() {\n"
      "  x = x * x;\n"
      "  x = (x / 13).floor();\n"
      "}";
 
  Dart_Handle lib;
  {
    TransitionVMToNative transition(thread);
 
    Dart_RegisterIsolateServiceRequestCallback("alpha", alpha_callback,
                                               nullptr);
    Dart_RegisterIsolateServiceRequestCallback("beta", beta_callback, nullptr);
 
    lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
  }
 
  // Build a mock message handler and wrap it in a dart port.
  ServiceTestMessageHandler handler;
  Dart_Port port_id = PortMap::CreatePort(&handler);
  Dart_Handle port = Api::NewHandle(thread, SendPort::New(port_id));
  {
    TransitionVMToNative transition(thread);
    EXPECT_VALID(port);
    EXPECT_VALID(Dart_SetField(lib, NewString("port"), port));
  }
 
  Isolate* isolate = thread->isolate();
  Array& service_msg = Array::Handle();
  service_msg = Eval(lib, "[0, port, '0', 'alpha', [], []]");
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_STREQ("{\"jsonrpc\":\"2.0\", \"result\":alpha,\"id\":\"0\"}",
               handler.msg());
  service_msg = Eval(lib, "[0, port, '0', 'beta', [], []]");
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_STREQ("{\"jsonrpc\":\"2.0\", \"error\":beta,\"id\":\"0\"}",
               handler.msg());
}

ISOLATE_UNIT_TEST_CASE() [328/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_EmbedderRootHandler

)

Definition at line 583 of file service_test.cc.

                                                    {
  const char* kScript =
      "var port;\n"  // Set to our mock port by C++.
      "\n"
      "var x = 7;\n"
      "main() {\n"
      "  x = x * x;\n"
      "  x = (x / 13).floor();\n"
      "}";
 
  Dart_Handle lib;
  {
    TransitionVMToNative transition(thread);
 
    Dart_RegisterRootServiceRequestCallback("alpha", alpha_callback, nullptr);
    Dart_RegisterRootServiceRequestCallback("beta", beta_callback, nullptr);
 
    lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
  }
 
  // Build a mock message handler and wrap it in a dart port.
  ServiceTestMessageHandler handler;
  Dart_Port port_id = PortMap::CreatePort(&handler);
  Dart_Handle port = Api::NewHandle(thread, SendPort::New(port_id));
  {
    TransitionVMToNative transition(thread);
    EXPECT_VALID(port);
    EXPECT_VALID(Dart_SetField(lib, NewString("port"), port));
  }
 
  Array& service_msg = Array::Handle();
  service_msg = Eval(lib, "[0, port, '\"', 'alpha', [], []]");
  HandleRootMessage(service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_STREQ("{\"jsonrpc\":\"2.0\", \"result\":alpha,\"id\":\"\\\"\"}",
               handler.msg());
  service_msg = Eval(lib, "[0, port, 1, 'beta', [], []]");
  HandleRootMessage(service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_STREQ("{\"jsonrpc\":\"2.0\", \"error\":beta,\"id\":1}", handler.msg());
}

ISOLATE_UNIT_TEST_CASE() [329/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_IdZones

)

Definition at line 187 of file service_test.cc.

                                        {
  Zone* zone = thread->zone();
  Isolate* isolate = thread->isolate();
  ObjectIdRing* ring = isolate->EnsureObjectIdRing();
 
  const String& test_a = String::Handle(zone, String::New("a"));
  const String& test_b = String::Handle(zone, String::New("b"));
  const String& test_c = String::Handle(zone, String::New("c"));
  const String& test_d = String::Handle(zone, String::New("d"));
 
  // Both RingServiceIdZones share the same backing store and id space.
 
  // Always allocate a new id.
  RingServiceIdZone always_new_zone;
  always_new_zone.Init(ring, ObjectIdRing::kAllocateId);
  EXPECT_STREQ("objects/0", always_new_zone.GetServiceId(test_a));
  EXPECT_STREQ("objects/1", always_new_zone.GetServiceId(test_a));
  EXPECT_STREQ("objects/2", always_new_zone.GetServiceId(test_a));
  EXPECT_STREQ("objects/3", always_new_zone.GetServiceId(test_b));
  EXPECT_STREQ("objects/4", always_new_zone.GetServiceId(test_c));
 
  // Reuse an existing id or allocate a new id.
  RingServiceIdZone reuse_zone;
  reuse_zone.Init(ring, ObjectIdRing::kReuseId);
  EXPECT_STREQ("objects/0", reuse_zone.GetServiceId(test_a));
  EXPECT_STREQ("objects/0", reuse_zone.GetServiceId(test_a));
  EXPECT_STREQ("objects/3", reuse_zone.GetServiceId(test_b));
  EXPECT_STREQ("objects/3", reuse_zone.GetServiceId(test_b));
  EXPECT_STREQ("objects/4", reuse_zone.GetServiceId(test_c));
  EXPECT_STREQ("objects/4", reuse_zone.GetServiceId(test_c));
  EXPECT_STREQ("objects/5", reuse_zone.GetServiceId(test_d));
  EXPECT_STREQ("objects/5", reuse_zone.GetServiceId(test_d));
}

ISOLATE_UNIT_TEST_CASE() [330/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_IsolateStickyError

)

Definition at line 144 of file service_test.cc.

                                                   {
  const char* kScript = "main() => throw 'HI THERE STICKY';\n";
 
  Isolate* isolate = thread->isolate();
  isolate->set_is_runnable(true);
  Dart_Handle result;
  {
    TransitionVMToNative transition(thread);
    Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT(Dart_IsUnhandledExceptionError(result));
    EXPECT(!Dart_HasStickyError());
  }
  EXPECT(Thread::Current()->sticky_error() == Error::null());
 
  {
    JSONStream js;
    isolate->PrintJSON(&js, false);
    // No error property and no PauseExit state.
    EXPECT_NOTSUBSTRING("\"error\":", js.ToCString());
    EXPECT_NOTSUBSTRING("HI THERE STICKY", js.ToCString());
    EXPECT_NOTSUBSTRING("PauseExit", js.ToCString());
  }
 
  {
    // Set the sticky error.
    TransitionVMToNative transition(thread);
    Dart_SetStickyError(result);
    Dart_SetPausedOnExit(true);
    EXPECT(Dart_HasStickyError());
  }
 
  {
    JSONStream js;
    isolate->PrintJSON(&js, false);
    // Error and PauseExit set.
    EXPECT_SUBSTRING("\"error\":", js.ToCString());
    EXPECT_SUBSTRING("HI THERE STICKY", js.ToCString());
    EXPECT_SUBSTRING("PauseExit", js.ToCString());
  }
}

ISOLATE_UNIT_TEST_CASE() [331/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_LocalVarDescriptors

)

Definition at line 417 of file service_test.cc.

                                                    {
  const char* kScript =
      "var port;\n"  // Set to our mock port by C++.
      "\n"
      "class A {\n"
      "  var a;\n"
      "  dynamic b() {}\n"
      "  dynamic c() {\n"
      "    var d = () { b(); };\n"
      "    return d;\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  var z = new A();\n"
      "  var x = z.c();\n"
      "  x();\n"
      "}";
 
  Isolate* isolate = thread->isolate();
  isolate->set_is_runnable(true);
  Dart_Handle lib;
  Library& vmlib = Library::Handle();
  {
    TransitionVMToNative transition(thread);
    lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    EXPECT(!Dart_IsNull(lib));
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
  }
  vmlib ^= Api::UnwrapHandle(lib);
  EXPECT(!vmlib.IsNull());
  const Class& class_a = Class::Handle(GetClass(vmlib, "A"));
  EXPECT(!class_a.IsNull());
  const Function& function_c = Function::Handle(GetFunction(class_a, "c"));
  EXPECT(!function_c.IsNull());
  const Code& code_c = Code::Handle(function_c.CurrentCode());
  EXPECT(!code_c.IsNull());
 
  const LocalVarDescriptors& descriptors =
      LocalVarDescriptors::Handle(code_c.GetLocalVarDescriptors());
  // Generate an ID for this object.
  ObjectIdRing* ring = isolate->EnsureObjectIdRing();
  intptr_t id = ring->GetIdForObject(descriptors.ptr());
 
  // Build a mock message handler and wrap it in a dart port.
  ServiceTestMessageHandler handler;
  Dart_Port port_id = PortMap::CreatePort(&handler);
  Dart_Handle port = Api::NewHandle(thread, SendPort::New(port_id));
  {
    TransitionVMToNative transition(thread);
    EXPECT_VALID(port);
    EXPECT_VALID(Dart_SetField(lib, NewString("port"), port));
  }
 
  Array& service_msg = Array::Handle();
 
  // Fetch object.
  service_msg = EvalF(lib,
                      "[0, port, '0', 'getObject', "
                      "['objectId'], ['objects/%" Pd "']]",
                      id);
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  // Check type.
  EXPECT_SUBSTRING("\"type\":\"Object\"", handler.msg());
  EXPECT_SUBSTRING("\"_vmType\":\"LocalVarDescriptors\"", handler.msg());
  // Check for members array.
  EXPECT_SUBSTRING("\"members\":[", handler.msg());
}

ISOLATE_UNIT_TEST_CASE() [332/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_ParseJSONArray

)

Definition at line 729 of file service_test.cc.

                                               {
  {
    const auto& elements =
        GrowableObjectArray::Handle(GrowableObjectArray::New());
    EXPECT_EQ(-1, ParseJSONArray(thread, "", elements));
    EXPECT_EQ(-1, ParseJSONArray(thread, "[", elements));
  }
 
  {
    const auto& elements =
        GrowableObjectArray::Handle(GrowableObjectArray::New());
    EXPECT_EQ(0, ParseJSONArray(thread, "[]", elements));
    EXPECT_EQ(0, elements.Length());
  }
 
  {
    const auto& elements =
        GrowableObjectArray::Handle(GrowableObjectArray::New());
    EXPECT_EQ(0, ParseJSONArray(thread, "[a]", elements));
    EXPECT_EQ(1, elements.Length());
    auto& element = String::Handle();
    element ^= elements.At(0);
    EXPECT(element.Equals("a"));
  }
 
  {
    const auto& elements =
        GrowableObjectArray::Handle(GrowableObjectArray::New());
    EXPECT_EQ(0, ParseJSONArray(thread, "[abc, def]", elements));
    EXPECT_EQ(2, elements.Length());
    auto& element = String::Handle();
    element ^= elements.At(0);
    EXPECT(element.Equals("abc"));
    element ^= elements.At(1);
    EXPECT(element.Equals("def"));
  }
 
  {
    const auto& elements =
        GrowableObjectArray::Handle(GrowableObjectArray::New());
    EXPECT_EQ(0, ParseJSONArray(thread, "[abc, def, ghi]", elements));
    EXPECT_EQ(3, elements.Length());
    auto& element = String::Handle();
    element ^= elements.At(0);
    EXPECT(element.Equals("abc"));
    element ^= elements.At(1);
    EXPECT(element.Equals("def"));
    element ^= elements.At(2);
    EXPECT(element.Equals("ghi"));
  }
 
  {
    const auto& elements =
        GrowableObjectArray::Handle(GrowableObjectArray::New());
    EXPECT_EQ(0, ParseJSONArray(thread, "[abc, , ghi]", elements));
    EXPECT_EQ(3, elements.Length());
    auto& element = String::Handle();
    element ^= elements.At(0);
    EXPECT(element.Equals("abc"));
    element ^= elements.At(1);
    EXPECT(element.Equals(""));
    element ^= elements.At(2);
    EXPECT(element.Equals("ghi"));
  }
}

ISOLATE_UNIT_TEST_CASE() [333/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_PcDescriptors

)

Definition at line 346 of file service_test.cc.

                                              {
  const char* kScript =
      "var port;\n"  // Set to our mock port by C++.
      "\n"
      "class A {\n"
      "  var a;\n"
      "  dynamic b() {}\n"
      "  dynamic c() {\n"
      "    var d = () { b(); };\n"
      "    return d;\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  var z = new A();\n"
      "  var x = z.c();\n"
      "  x();\n"
      "}";
 
  Isolate* isolate = thread->isolate();
  isolate->set_is_runnable(true);
  Dart_Handle lib;
  Library& vmlib = Library::Handle();
  {
    TransitionVMToNative transition(thread);
    lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    EXPECT(!Dart_IsNull(lib));
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
  }
  vmlib ^= Api::UnwrapHandle(lib);
  EXPECT(!vmlib.IsNull());
  const Class& class_a = Class::Handle(GetClass(vmlib, "A"));
  EXPECT(!class_a.IsNull());
  const Function& function_c = Function::Handle(GetFunction(class_a, "c"));
  EXPECT(!function_c.IsNull());
  const Code& code_c = Code::Handle(function_c.CurrentCode());
  EXPECT(!code_c.IsNull());
 
  const PcDescriptors& descriptors =
      PcDescriptors::Handle(code_c.pc_descriptors());
  EXPECT(!descriptors.IsNull());
  ObjectIdRing* ring = isolate->EnsureObjectIdRing();
  intptr_t id = ring->GetIdForObject(descriptors.ptr());
 
  // Build a mock message handler and wrap it in a dart port.
  ServiceTestMessageHandler handler;
  Dart_Port port_id = PortMap::CreatePort(&handler);
  Dart_Handle port = Api::NewHandle(thread, SendPort::New(port_id));
  {
    TransitionVMToNative transition(thread);
    EXPECT_VALID(port);
    EXPECT_VALID(Dart_SetField(lib, NewString("port"), port));
  }
 
  Array& service_msg = Array::Handle();
 
  // Fetch object.
  service_msg = EvalF(lib,
                      "[0, port, '0', 'getObject', "
                      "['objectId'], ['objects/%" Pd "']]",
                      id);
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  // Check type.
  EXPECT_SUBSTRING("\"type\":\"Object\"", handler.msg());
  EXPECT_SUBSTRING("\"_vmType\":\"PcDescriptors\"", handler.msg());
  // Check for members array.
  EXPECT_SUBSTRING("\"members\":[", handler.msg());
}

ISOLATE_UNIT_TEST_CASE() [334/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_PersistentHandles

)

Definition at line 490 of file service_test.cc.

                                                  {
  const char* kScript =
      "var port;\n"  // Set to our mock port by C++.
      "\n"
      "class A {\n"
      "  var a;\n"
      "}\n"
      "var global = new A();\n"
      "main() {\n"
      "  return global;\n"
      "}";
 
  Isolate* isolate = thread->isolate();
  isolate->set_is_runnable(true);
 
  Dart_Handle lib;
  Dart_PersistentHandle persistent_handle;
  Dart_WeakPersistentHandle weak_persistent_handle;
  {
    TransitionVMToNative transition(thread);
    lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
 
    // Create a persistent handle to global.
    persistent_handle = Dart_NewPersistentHandle(result);
 
    // Create a weak persistent handle to global.
    weak_persistent_handle = Dart_NewWeakPersistentHandle(
        result, reinterpret_cast<void*>(0xdeadbeef), 128, WeakHandleFinalizer);
  }
 
  // Build a mock message handler and wrap it in a dart port.
  ServiceTestMessageHandler handler;
  Dart_Port port_id = PortMap::CreatePort(&handler);
  Dart_Handle port = Api::NewHandle(thread, SendPort::New(port_id));
  {
    TransitionVMToNative transition(thread);
    EXPECT_VALID(port);
    EXPECT_VALID(Dart_SetField(lib, NewString("port"), port));
  }
 
  Array& service_msg = Array::Handle();
 
  // Get persistent handles.
  service_msg = Eval(lib, "[0, port, '0', '_getPersistentHandles', [], []]");
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  // Look for a heart beat.
  EXPECT_SUBSTRING("\"type\":\"_PersistentHandles\"", handler.msg());
  EXPECT_SUBSTRING("\"peer\":\"0xdeadbeef\"", handler.msg());
  EXPECT_SUBSTRING("\"name\":\"A\"", handler.msg());
  EXPECT_SUBSTRING("\"externalSize\":\"128\"", handler.msg());
 
  // Delete persistent handles.
  {
    TransitionVMToNative transition(thread);
    Dart_DeletePersistentHandle(persistent_handle);
    Dart_DeleteWeakPersistentHandle(weak_persistent_handle);
  }
 
  // Get persistent handles (again).
  service_msg = Eval(lib, "[0, port, '0', '_getPersistentHandles', [], []]");
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_SUBSTRING("\"type\":\"_PersistentHandles\"", handler.msg());
  // Verify that old persistent handles are not present.
  EXPECT_NOTSUBSTRING("\"peer\":\"0xdeadbeef\"", handler.msg());
  EXPECT_NOTSUBSTRING("\"name\":\"A\"", handler.msg());
  EXPECT_NOTSUBSTRING("\"externalSize\":\"128\"", handler.msg());
}

ISOLATE_UNIT_TEST_CASE() [335/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Service_Profile

)

Definition at line 686 of file service_test.cc.

                                        {
  EnableProfiler();
  const char* kScript =
      "var port;\n"  // Set to our mock port by C++.
      "\n"
      "var x = 7;\n"
      "main() {\n"
      "  x = x * x;\n"
      "  x = (x / 13).floor();\n"
      "}";
 
  Isolate* isolate = thread->isolate();
  isolate->set_is_runnable(true);
  Dart_Handle lib;
  {
    TransitionVMToNative transition(thread);
 
    lib = TestCase::LoadTestScript(kScript, nullptr);
    EXPECT_VALID(lib);
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
  }
 
  // Build a mock message handler and wrap it in a dart port.
  ServiceTestMessageHandler handler;
  Dart_Port port_id = PortMap::CreatePort(&handler);
  Dart_Handle port = Api::NewHandle(thread, SendPort::New(port_id));
  {
    TransitionVMToNative transition(thread);
    EXPECT_VALID(port);
    EXPECT_VALID(Dart_SetField(lib, NewString("port"), port));
  }
 
  Array& service_msg = Array::Handle();
  service_msg = Eval(lib, "[0, port, '0', 'getCpuSamples', [], []]");
  HandleIsolateMessage(isolate, service_msg);
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  // Expect profile
  EXPECT_SUBSTRING("\"type\":\"CpuSamples\"", handler.msg());
}

ISOLATE_UNIT_TEST_CASE() [336/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Sets

)

Definition at line 246 of file hash_table_test.cc.

                             {
  for (intptr_t initial_capacity = 0; initial_capacity < 32;
       ++initial_capacity) {
    TestSet<UnorderedHashSet<TestTraits> >(initial_capacity, false);
  }
}

ISOLATE_UNIT_TEST_CASE() [337/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SixtyThousandDartClasses

)

Definition at line 174 of file object_test.cc.

                                                 {
  auto zone = thread->zone();
  auto isolate_group = thread->isolate_group();
  auto class_table = isolate_group->class_table();
 
  const intptr_t start_cid = class_table->NumCids();
  const intptr_t num_classes = std::numeric_limits<uint16_t>::max() - start_cid;
 
  const Script& script = Script::Handle(zone);
  String& name = String::Handle(zone);
  Class& cls = Class::Handle(zone);
  Field& field = Field::Handle(zone);
  Array& fields = Array::Handle(zone);
  Instance& instance = Instance::Handle(zone);
  Instance& instance2 = Instance::Handle(zone);
 
  const auto& instances =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
 
  // Create many top-level classes - they should not consume 16-bit range.
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    for (intptr_t i = 0; i < (1 << 16); ++i) {
      cls = CreateDummyClass(Symbols::TopLevel(), script);
      cls.Finalize();
      EXPECT(cls.id() > std::numeric_limits<uint16_t>::max());
    }
  }
 
  // Create many concrete classes - they should occupy the entire 16-bit space.
  for (intptr_t i = 0; i < num_classes; ++i) {
    name = Symbols::New(thread, OS::SCreate(zone, "MyClass%" Pd "", i));
    cls = CreateDummyClass(name, script);
    EXPECT_EQ(start_cid + i, cls.id());
 
    const intptr_t num_fields = (i % 10);
    fields = Array::New(num_fields);
    for (intptr_t f = 0; f < num_fields; ++f) {
      name =
          Symbols::New(thread, OS::SCreate(zone, "myField_%" Pd "_%" Pd, i, f));
      field = Field::New(name, false, false, false, true, false, cls,
                         Object::dynamic_type(), TokenPosition::kMinSource,
                         TokenPosition::kMinSource);
      fields.SetAt(f, field);
    }
 
    cls.set_interfaces(Array::empty_array());
    {
      SafepointWriteRwLocker ml(thread,
                                thread->isolate_group()->program_lock());
      cls.SetFunctions(Array::empty_array());
      cls.SetFields(fields);
      cls.Finalize();
    }
 
    instance = Instance::New(cls);
    for (intptr_t f = 0; f < num_fields; ++f) {
      field ^= fields.At(f);
      name = Symbols::New(thread,
                          OS::SCreate(zone, "myFieldValue_%" Pd "_%" Pd, i, f));
      instance.SetField(field, name);
    }
    instances.Add(instance);
  }
  EXPECT_EQ((1 << 16) - 1, class_table->NumCids());
 
  // Ensure GC runs and can recognize all those new instances.
  isolate_group->heap()->CollectAllGarbage();
 
  // Ensure the instances are what we expect.
  for (intptr_t i = 0; i < num_classes; ++i) {
    instance ^= instances.At(i);
    cls = instance.clazz();
    fields = cls.fields();
 
    name = cls.Name();
    EXPECT(strstr(name.ToCString(), OS::SCreate(zone, "MyClass%" Pd "", i)) !=
           0);
    EXPECT_EQ((i % 10), fields.Length());
 
    for (intptr_t f = 0; f < fields.Length(); ++f) {
      field ^= fields.At(f);
      instance2 ^= instance.GetField(field);
      EXPECT(strstr(instance2.ToCString(),
                    OS::SCreate(zone, "myFieldValue_%" Pd "_%" Pd, i, f)) != 0);
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [338/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Smi

)

Definition at line 367 of file object_test.cc.

                            {
  const Smi& smi = Smi::Handle(Smi::New(5));
  Object& smi_object = Object::Handle(smi.ptr());
  EXPECT(smi.IsSmi());
  EXPECT(smi_object.IsSmi());
  EXPECT_EQ(5, smi.Value());
  const Object& object = Object::Handle();
  EXPECT(!object.IsSmi());
  smi_object = Object::null();
  EXPECT(!smi_object.IsSmi());
 
  EXPECT(smi.Equals(Smi::Handle(Smi::New(5))));
  EXPECT(!smi.Equals(Smi::Handle(Smi::New(6))));
  EXPECT(smi.Equals(smi));
  EXPECT(!smi.Equals(Smi::Handle()));
 
  EXPECT(Smi::IsValid(0));
  EXPECT(Smi::IsValid(-15));
  EXPECT(Smi::IsValid(0xFFu));
// Upper two bits must be either 00 or 11.
#if defined(ARCH_IS_64_BIT) && !defined(DART_COMPRESSED_POINTERS)
  EXPECT(!Smi::IsValid(kMaxInt64));
  EXPECT(Smi::IsValid(0x3FFFFFFFFFFFFFFF));
  EXPECT(Smi::IsValid(-1));
#else
  EXPECT(!Smi::IsValid(kMaxInt32));
  EXPECT(Smi::IsValid(0x3FFFFFFF));
  EXPECT(Smi::IsValid(-1));
  EXPECT(!Smi::IsValid(0xFFFFFFFFu));
#endif
 
  EXPECT_EQ(5, smi.AsInt64Value());
  EXPECT_EQ(5.0, smi.AsDoubleValue());
 
  Smi& a = Smi::Handle(Smi::New(5));
  Smi& b = Smi::Handle(Smi::New(3));
  EXPECT_EQ(1, a.CompareWith(b));
  EXPECT_EQ(-1, b.CompareWith(a));
  EXPECT_EQ(0, a.CompareWith(a));
 
  Smi& c = Smi::Handle(Smi::New(-1));
 
  Mint& mint1 = Mint::Handle();
  mint1 ^= Integer::New(DART_2PART_UINT64_C(0x7FFFFFFF, 100));
  Mint& mint2 = Mint::Handle();
  mint2 ^= Integer::New(-DART_2PART_UINT64_C(0x7FFFFFFF, 100));
  EXPECT_EQ(-1, a.CompareWith(mint1));
  EXPECT_EQ(1, a.CompareWith(mint2));
  EXPECT_EQ(-1, c.CompareWith(mint1));
  EXPECT_EQ(1, c.CompareWith(mint2));
}

ISOLATE_UNIT_TEST_CASE() [339/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_BranchCoverage_if

)

Definition at line 1343 of file source_report_test.cc.

                                                       {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript = R"(
int ifTest(int x) {
  if (x > 0) {
    if (x > 10) {
      return 10;
    } else {
      return 1;
    }
  } else {
    return 0;
  }
}
 
main() {
  ifTest(1);
}
)";
 
  Library& lib = Library::Handle();
  const bool old_branch_coverage = IsolateGroup::Current()->branch_coverage();
  IsolateGroup::Current()->set_branch_coverage(true);
  lib ^= ExecuteScript(kScript);
  IsolateGroup::Current()->set_branch_coverage(old_branch_coverage);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kBranchCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // In ifTest, the outer true case is hit, the inner true case is missed,
      // the inner false case is hit, and the outer false case is missed.
      "{\"scriptIndex\":0,\"startPos\":1,\"endPos\":135,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[1,34,82],\"misses\":[52,115]}},"
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":138,\"endPos\":160,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[138],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [340/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_BranchCoverage_loops

)

Definition at line 1399 of file source_report_test.cc.

                                                          {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript = R"(
int loopTest() {
  var x = 0;
 
  while (x < 10) {
    ++x;
  }
 
  do {
    ++x;
  } while (false);
 
  for (int i = 0; i < 10; ++i) {
    ++x;
  }
 
  for (final i in [1, 2, 3]) {
    ++x;
  }
 
  return x;
}
 
main() {
  loopTest();
}
)";
 
  Library& lib = Library::Handle();
  const bool old_branch_coverage = IsolateGroup::Current()->branch_coverage();
  IsolateGroup::Current()->set_branch_coverage(true);
  lib ^= ExecuteScript(kScript);
  IsolateGroup::Current()->set_branch_coverage(old_branch_coverage);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kBranchCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // In loopTest, the while loop, do-while loop, for loop, and for-in loop
      // are all hit.
      "{\"scriptIndex\":0,\"startPos\":1,\"endPos\":205,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[1,49,70,132,177],\"misses\":[]}},"
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":208,\"endPos\":231,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[208],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [341/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_BranchCoverage_switch

)

Definition at line 1465 of file source_report_test.cc.

                                                           {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript = R"(
int switchTest(int x) {
  switch (x) {
    case 0:
      return 10;
    case 1:
      return 20;
    default:
      return 30;
  }
}
 
main() {
  switchTest(1);
}
)";
 
  Library& lib = Library::Handle();
  const bool old_branch_coverage = IsolateGroup::Current()->branch_coverage();
  IsolateGroup::Current()->set_branch_coverage(true);
  lib ^= ExecuteScript(kScript);
  IsolateGroup::Current()->set_branch_coverage(old_branch_coverage);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kBranchCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // In switchTest, the 1 case is hit and the others are missed.
      "{\"scriptIndex\":0,\"startPos\":1,\"endPos\":132,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[1,73],\"misses\":[44,102]}},"
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":135,\"endPos\":161,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[135],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [342/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_BranchCoverage_try

)

Definition at line 1519 of file source_report_test.cc.

                                                        {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript = R"(
void tryTestInner() {
  try {
    throw "abc";
  } catch (e) {
  } finally {
  }
 
  try {
    throw "def";
  } finally {
  }
}
 
void tryTestOuter() {
  try {
    tryTestInner();
  } catch (e) {
  }
}
 
main() {
  tryTestOuter();
}
)";
 
  Library& lib = Library::Handle();
  const bool old_branch_coverage = IsolateGroup::Current()->branch_coverage();
  IsolateGroup::Current()->set_branch_coverage(true);
  lib ^= ExecuteScript(kScript);
  IsolateGroup::Current()->set_branch_coverage(old_branch_coverage);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kBranchCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // In tryTestInner, the try/catch/finally and the try/finally are all hit,
      // and the try/finally rethrows its exception.
      "{\"scriptIndex\":0,\"startPos\":1,\"endPos\":126,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[1,29,62,76,89,120],\"misses\":[]}},"
 
      // In tryTestOuter, the exception thrown by tryTestInner causes both the
      // try and the catch to be hit.
      "{\"scriptIndex\":0,\"startPos\":129,\"endPos\":199,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[129,157,193],\"misses\":[]}},"
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":202,\"endPos\":229,\"compiled\":true,"
      "\"branchCoverage\":{\"hits\":[202],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [343/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_CallSites_PolymorphicCall

)

Definition at line 670 of file source_report_test.cc.

                                                               {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 4096;
  char buffer[kBufferSize];
  const char* kScript =
      "class Common {\n"
      "  func() {}\n"
      "}\n"
      "class Uncommon {\n"
      "  func() {}\n"
      "}\n"
      "helper(arg) {\n"
      "  arg.func();\n"
      "}\n"
      "main() {\n"
      "  Common common = new Common();\n"
      "  Uncommon uncommon = new Uncommon();\n"
      "  helper(common);\n"
      "  helper(common);\n"
      "  helper(uncommon);\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
  const Function& helper = Function::Handle(
      lib.LookupFunctionAllowPrivate(String::Handle(String::New("helper"))));
 
  SourceReport report(SourceReport::kCallSites);
  JSONStream js;
  report.PrintJSON(&js, script, helper.token_pos(), helper.end_token_pos());
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // One range...
      "{\"scriptIndex\":0,\"startPos\":60,\"endPos\":88,\"compiled\":true,"
 
      // With one call site...
      "\"callSites\":[{\"name\":\"dyn:func\",\"tokenPos\":80,\"cacheEntries\":["
 
      // First receiver: "Common", called twice.
      "{\"receiver\":{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\","
      "\"name\":\"Common\","
      "\"location\":{\"type\":\"SourceLocation\","
      "\"script\":{\"type\":\"@Script\","
      "\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\","
      "\"_kind\":\"kernel\"},\"tokenPos\":0,\"endTokenPos\":27,\"line\":1,"
      "\"column\":1},"
      "\"library\":{\"type\":\"@Library\",\"fixedId\":true,"
      "\"id\":\"\",\"name\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\"}},"
 
      "\"target\":{\"type\":\"@Function\",\"fixedId\":true,\"id\":\"\","
      "\"name\":\"func\","
      "\"owner\":{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\","
      "\"name\":\"Common\","
      "\"location\":{\"type\":\"SourceLocation\","
      "\"script\":{\"type\":\"@Script\","
      "\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\","
      "\"_kind\":\"kernel\"},\"tokenPos\":0,\"endTokenPos\":27,\"line\":1,"
      "\"column\":1},"
      "\"library\":{\"type\":\"@Library\",\"fixedId\":true,"
      "\"id\":\"\",\"name\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\"}"
      "},\"_kind\":\"RegularFunction\","
      "\"static\":false,\"const\":false,\"implicit\":false,\"abstract\":"
      "false,\"_intrinsic\":false,"
      "\"_native\":false,\"isGetter\":false,\"isSetter\":false,"
      "\"location\":{\"type\":\"SourceLocation\","
      "\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
      "\"id\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\","
      "\"_kind\":\"kernel\"},\"tokenPos\":17,\"endTokenPos\":25,\"line\":2,"
      "\"column\":3}},"
 
      "\"count\":2},"
 
      // Second receiver: "Uncommon", called once.
      "{\"receiver\":{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\","
      "\"name\":\"Uncommon\","
      "\"location\":{\"type\":\"SourceLocation\","
      "\"script\":{\"type\":\"@Script\","
      "\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\","
      "\"_kind\":\"kernel\"},\"tokenPos\":29,\"endTokenPos\":58,\"line\":4,"
      "\"column\":1},"
      "\"library\":{\"type\":\"@Library\",\"fixedId\":true,"
      "\"id\":\"\",\"name\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\"}},"
 
      "\"target\":{\"type\":\"@Function\",\"fixedId\":true,\"id\":\"\","
      "\"name\":\"func\","
      "\"owner\":{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\","
      "\"name\":\"Uncommon\","
      "\"location\":{\"type\":\"SourceLocation\","
      "\"script\":{\"type\":\"@Script\","
      "\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\","
      "\"_kind\":\"kernel\"},\"tokenPos\":29,\"endTokenPos\":58,\"line\":4,"
      "\"column\":1},"
      "\"library\":{\"type\":\"@Library\",\"fixedId\":true,"
      "\"id\":\"\",\"name\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\"}"
      "},\"_kind\":\"RegularFunction\","
      "\"static\":false,\"const\":false,\"implicit\":false,\"abstract\":"
      "false,\"_intrinsic\":false,"
      "\"_native\":false,\"isGetter\":false,\"isSetter\":false,"
      "\"location\":{\"type\":\"SourceLocation\","
      "\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
      "\"id\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\","
      "\"_kind\":\"kernel\"},\"tokenPos\":48,\"endTokenPos\":56,\"line\":5,"
      "\"column\":3}},"
 
      "\"count\":1}]}]}],"
 
      // One script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [344/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_CallSites_SimpleCall

)

Definition at line 614 of file source_report_test.cc.

                                                          {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 2048;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "helper1() {}\n"
      "main() {\n"
      "  helper0();\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCallSites);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // One range compiled with no callsites (helper0).
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"callSites\":[]},"
 
      // One range not compiled (helper1).
      "{\"scriptIndex\":0,\"startPos\":13,\"endPos\":24,\"compiled\":false},"
 
      // One range compiled with one callsite (main).
      "{\"scriptIndex\":0,\"startPos\":26,\"endPos\":48,\"compiled\":true,"
      "\"callSites\":["
      "{\"name\":\"helper0\",\"tokenPos\":37,\"cacheEntries\":["
      "{\"target\":{\"type\":\"@Function\",\"fixedId\":true,\"id\":\"\","
      "\"name\":\"helper0\",\"owner\":{\"type\":\"@Library\",\"fixedId\":true,"
      "\"id\":\"\",\"name\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\"},"
      "\"_kind\":\"RegularFunction\",\"static\":true,\"const\":false,"
      "\"implicit\":false,\"abstract\":false,"
      "\"_intrinsic\":false,\"_native\":false,\"isGetter\":false,"
      "\"isSetter\":false,\"location\":{\"type\":"
      "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
      "\"id\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"},"
      "\"tokenPos\":0,\"endTokenPos\":11,\"line\":1,\"column\":1}},\"count\":1}"
      "]}]}],"
 
      // One script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [345/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_AllFunctions

)

Definition at line 536 of file source_report_test.cc.

                                                           {
  const char* kScript =
      "helper0() {}\n"
      "helper1() {}\n"
      "main() {\n"
      "  if (true) {\n"
      "    helper0();\n"
      "  } else {\n"
      "    helper1();\n"
      "  }\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
 
  SourceReport report(SourceReport::kCoverage);
  JSONStream js;
 
  // We generate a report with all functions in the VM.
  Script& null_script = Script::Handle();
  report.PrintJSON(&js, null_script);
  const char* result = js.ToCString();
 
  // Sanity check the header.
  EXPECT_SUBSTRING("{\"type\":\"SourceReport\",\"ranges\":[", result);
 
  // Make sure that the main function was found.
  EXPECT_SUBSTRING(
      "\"startPos\":26,\"endPos\":94,\"compiled\":true,"
      "\"coverage\":{\"hits\":[26,53],\"misses\":[79]}",
      result);
 
  // More than one script is referenced in the report.
  EXPECT_SUBSTRING("\"scriptIndex\":0", result);
  EXPECT_SUBSTRING("\"scriptIndex\":1", result);
  EXPECT_SUBSTRING("\"scriptIndex\":2", result);
}

ISOLATE_UNIT_TEST_CASE() [346/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_AllFunctions_ForceCompile

)

Definition at line 575 of file source_report_test.cc.

                                                                        {
  const char* kScript =
      "helper0() {}\n"
      "helper1() {}\n"
      "main() {\n"
      "  if (true) {\n"
      "    helper0();\n"
      "  } else {\n"
      "    helper1();\n"
      "  }\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
 
  // We generate a report with all functions in the VM.
  Script& null_script = Script::Handle();
  report.PrintJSON(&js, null_script);
  const char* result = js.ToCString();
 
  // Sanity check the header.
  EXPECT_SUBSTRING("{\"type\":\"SourceReport\",\"ranges\":[", result);
 
  // Make sure that the main function was found.
  EXPECT_SUBSTRING(
      "\"startPos\":26,\"endPos\":94,\"compiled\":true,"
      "\"coverage\":{\"hits\":[26,53],\"misses\":[79]}",
      result);
 
  // More than one script is referenced in the report.
  EXPECT_SUBSTRING("\"scriptIndex\":0", result);
  EXPECT_SUBSTRING("\"scriptIndex\":1", result);
  EXPECT_SUBSTRING("\"scriptIndex\":2", result);
}

ISOLATE_UNIT_TEST_CASE() [347/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_Filters_empty

)

Definition at line 95 of file source_report_test.cc.

                                                            {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "main() {\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
 
  GrowableObjectArray& filters =
      GrowableObjectArray::Handle(GrowableObjectArray::New());
  filters.Add(String::Handle(String::New("foo:bar/")));
  SourceReport report(SourceReport::kCoverage, filters);
  JSONStream js;
  report.PrintJSON(&js, Script::Handle(Script::null()));
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("libraries", json_str, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":"
 
      // No compiled range.
      "[],"
 
      // No script.
      "\"scripts\":[]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [348/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_Filters_single

)

Definition at line 61 of file source_report_test.cc.

                                                             {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "main() {\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
 
  GrowableObjectArray& filters =
      GrowableObjectArray::Handle(GrowableObjectArray::New());
  filters.Add(String::Handle(String::New(RESOLVED_USER_TEST_URI)));
  SourceReport report(SourceReport::kCoverage, filters);
  JSONStream js;
  report.PrintJSON(&js, Script::Handle(Script::null()));
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("libraries", json_str, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":"
 
      // One compiled range, one hit at function declaration.
      "[{\"scriptIndex\":0,\"startPos\":0,\"endPos\":9,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}}],"
 
      // One script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [349/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_ForceCompile

)

Definition at line 175 of file source_report_test.cc.

                                                           {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "helper1() {}\n"
      "main() {\n"
      "  if (true) {\n"
      "    helper0();\n"
      "  } else {\n"
      "    helper1();\n"
      "  }\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
 
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // One range compiled with one hit at function declaration (helper0).
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}},"
 
      // This range is compiled even though it wasn't called (helper1).
      "{\"scriptIndex\":0,\"startPos\":13,\"endPos\":24,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[13]}},"
 
      // One range with two hits and a miss (main).
      "{\"scriptIndex\":0,\"startPos\":26,\"endPos\":94,\"compiled\":true,"
      "\"coverage\":{\"hits\":[26,53],\"misses\":[79]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [350/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_Issue35453_NoSuchMethod

)

Definition at line 899 of file source_report_test.cc.

                                                                      {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "class Foo {\n"
      "  void bar() {}\n"
      "}\n"
      "class Unused implements Foo {\n"
      "  dynamic noSuchMethod(_) {}\n"
      "}\n"
      "void main() {\n"
      "  Foo().bar();\n"
      "}\n";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // Foo is hit.
      "{\"scriptIndex\":0,\"startPos\":14,\"endPos\":26,\"compiled\":true,"
      "\"coverage\":{\"hits\":[14],\"misses\":[]}},"
 
      // Unused is missed.
      "{\"scriptIndex\":0,\"startPos\":62,\"endPos\":87,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[62]}},"
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":91,\"endPos\":120,\"compiled\":true,"
      "\"coverage\":{\"hits\":[91,107,113],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [351/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_Issue47017_Assert

)

Definition at line 948 of file source_report_test.cc.

                                                                {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "void foo(Object? bar) {\n"
      "  assert(bar == null);\n"
      "}\n"
      "void main() {\n"
      "  foo(null);\n"
      "}\n";
 
  Library& lib = Library::Handle();
  const bool old_asserts = IsolateGroup::Current()->asserts();
  IsolateGroup::Current()->set_asserts(true);
  lib ^= ExecuteScript(kScript);
  IsolateGroup::Current()->set_asserts(old_asserts);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // Foo is hit, and the assert is hit.
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":47,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0,33],\"misses\":[]}},"
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":49,\"endPos\":76,\"compiled\":true,"
      "\"coverage\":{\"hits\":[49,65],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [352/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_Issue47021_StaticOnlyClasses

)

Definition at line 993 of file source_report_test.cc.

                                                                           {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 2048;
  char buffer[kBufferSize];
  const char* kScript =
      "abstract class AllStatic {\n"
      "  AllStatic._();\n"
      "  static int test() => 123;\n"
      "  static int foo = 456;\n"
      "}\n"
      "class NotAbstract {\n"
      "  NotAbstract._();\n"
      "  static int test() => 123;\n"
      "  static int foo = 456;\n"
      "}\n"
      "abstract class NotConstructor {\n"
      "  void _() {}\n"
      "  static int test() => 123;\n"
      "}\n"
      "abstract class NotPrivate {\n"
      "  NotPrivate();\n"
      "  static int test() => 123;\n"
      "}\n"
      "abstract class HasParams {\n"
      "  HasParams._(int i);\n"
      "  static int test() => 123;\n"
      "}\n"
      "abstract class HasFields {\n"
      "  HasFields._();\n"
      "  static int test() => 123;\n"
      "  int foo = 0;\n"
      "}\n"
      "abstract class HasNonStaticFunction {\n"
      "  HasNonStaticFunction._();\n"
      "  static int test() => 123;\n"
      "  int foo() => 456;\n"
      "}\n"
      "abstract class HasSubclass {\n"
      "  HasSubclass._();\n"
      "  static int test() => 123;\n"
      "  static int foo = 456;\n"
      "}\n"
      "abstract class Subclass extends HasSubclass {\n"
      "  Subclass() : super._();\n"
      "}\n"
      "void main() {\n"
      "  AllStatic.test();\n"
      "  NotAbstract.test();\n"
      "  NotConstructor.test();\n"
      "  NotPrivate.test();\n"
      "  HasParams.test();\n"
      "  HasFields.test();\n"
      "  HasNonStaticFunction.test();\n"
      "  HasSubclass.test();\n"
      "}\n";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // Subclass() is missed.
      "{\"scriptIndex\":0,\"startPos\":775,\"endPos\":797,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[775,794]}},"
 
      // AllStatic.test() is hit. AllStatic._() is ignored (would be pos: 29).
      "{\"scriptIndex\":0,\"startPos\":46,\"endPos\":70,\"compiled\":true,"
      "\"coverage\":{\"hits\":[46],\"misses\":[]}},"
 
      // HasSubclass._() is missed, not ignored.
      "{\"scriptIndex\":0,\"startPos\":656,\"endPos\":671,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[656]}},"
 
      // HasSubclass.test() is hit.
      "{\"scriptIndex\":0,\"startPos\":675,\"endPos\":699,\"compiled\":true,"
      "\"coverage\":{\"hits\":[675],\"misses\":[]}},"
 
      // HasParams._(int i) is missed, not ignored.
      "{\"scriptIndex\":0,\"startPos\":370,\"endPos\":388,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[370]}},"
 
      // HasParams.test() is hit.
      "{\"scriptIndex\":0,\"startPos\":392,\"endPos\":416,\"compiled\":true,"
      "\"coverage\":{\"hits\":[392],\"misses\":[]}},"
 
      // NotAbstract._() is missed, not ignored.
      "{\"scriptIndex\":0,\"startPos\":120,\"endPos\":135,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[120]}},"
 
      // NotAbstract.test() is hit.
      "{\"scriptIndex\":0,\"startPos\":139,\"endPos\":163,\"compiled\":true,"
      "\"coverage\":{\"hits\":[139],\"misses\":[]}},"
 
      // HasFields._() is missed, not ignored.
      "{\"scriptIndex\":0,\"startPos\":449,\"endPos\":462,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[449]}},"
 
      // HasFields.test() is hit.
      "{\"scriptIndex\":0,\"startPos\":466,\"endPos\":490,\"compiled\":true,"
      "\"coverage\":{\"hits\":[466],\"misses\":[]}},"
 
      // NotPrivate() is missed, not ignored.
      "{\"scriptIndex\":0,\"startPos\":297,\"endPos\":309,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[297]}},"
 
      // NotPrivate.test() is hit.
      "{\"scriptIndex\":0,\"startPos\":313,\"endPos\":337,\"compiled\":true,"
      "\"coverage\":{\"hits\":[313],\"misses\":[]}},"
 
      // HasNonStaticFunction._() is missed, not ignored.
      "{\"scriptIndex\":0,\"startPos\":549,\"endPos\":573,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[549]}},"
 
      // HasNonStaticFunction.test() is hit.
      "{\"scriptIndex\":0,\"startPos\":577,\"endPos\":601,\"compiled\":true,"
      "\"coverage\":{\"hits\":[577],\"misses\":[]}},"
 
      // HasNonStaticFunction.foo() is missed.
      "{\"scriptIndex\":0,\"startPos\":605,\"endPos\":621,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[605]}},"
 
      // NotConstructor._() is missed, not ignored.
      "{\"scriptIndex\":0,\"startPos\":225,\"endPos\":235,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[225]}},"
 
      // NotConstructor.test() is hit.
      "{\"scriptIndex\":0,\"startPos\":239,\"endPos\":263,\"compiled\":true,"
      "\"coverage\":{\"hits\":[239],\"misses\":[]}},"
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":801,\"endPos\":996,\"compiled\":true,"
      "\"coverage\":{\"hits\":"
      "[801,827,849,874,895,915,935,966,988],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [353/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_IssueCov341_LateFinalVars

)

Definition at line 1144 of file source_report_test.cc.

                                                                        {
  // https://github.com/dart-lang/coverage/issues/341
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "int foo(bool bar) {\n"
      "  late final int baz;\n"
      "  if (bar) {\n"
      "    baz = 123;\n"
      "  } else {\n"
      "    baz = 456;\n"
      "  }\n"
      "  return baz;\n"
      "}\n"
      "main() {\n"
      "  foo(true);\n"
      "  foo(false);\n"
      "}\n";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // foo is hit, but the late variable sets and gets are ignored.
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":114,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}},"
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":116,\"endPos\":152,\"compiled\":true,\""
      "coverage\":{\"hits\":[116,127,140],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [354/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_IssueCov386_EnhancedEnums

)

Definition at line 1194 of file source_report_test.cc.

                                                                        {
  // https://github.com/dart-lang/coverage/issues/386
  // https://github.com/dart-lang/coverage/issues/377
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "enum FoodType {\n"
      "  candy();\n"
      "  const FoodType();\n"
      "  factory FoodType.candyFactory() => candy;\n"
      "}\n"
      "void main() {\n"
      "  final food = FoodType.candyFactory();\n"
      "}\n";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // Main is hit.
      "{\"scriptIndex\":0,\"startPos\":49,\"endPos\":89,\"compiled\":true,"
      "\"coverage\":{\"hits\":[49],\"misses\":[]}},"
 
      // The enum's constructor, and toString, are not included in the hitmap,
      // but the factory is included.
      "{\"scriptIndex\":0,\"startPos\":93,\"endPos\":147,\"compiled\":true,"
      "\"coverage\":{\"hits\":[93,131],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [355/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_LibrariesAlreadyCompiled

)

Definition at line 370 of file source_report_test.cc.

                                                                       {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "class Unused {\n"
      "  helper1() { helper0(); }\n"
      "}\n"
      "main() {\n"
      "  helper0();\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  Zone* zone = thread->zone();
  ZoneCStringSet* libraries_already_compiled = new (zone) ZoneCStringSet(zone);
  libraries_already_compiled->Insert(RESOLVED_USER_TEST_URI);
  SourceReport report(SourceReport::kCoverage, GrowableObjectArray::Handle(),
                      libraries_already_compiled, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // UnusedClass is not compiled.
      "{\"scriptIndex\":0,\"startPos\":13,\"endPos\":55,\"compiled\":false},"
 
      // helper0 is compiled.
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}},"
 
      // One range with two hits (main).
      "{\"scriptIndex\":0,\"startPos\":57,\"endPos\":79,\"compiled\":true,"
      "\"coverage\":{\"hits\":[57,68],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [356/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_NestedFunctions

)

Definition at line 420 of file source_report_test.cc.

                                                              {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {\n"
      "  nestedHelper0() {}\n"
      "  nestedHelper1() {}\n"
      "  nestedHelper0();\n"
      "}\n"
      "helper1() {}\n"
      "main() {\n"
      "  if (true) {\n"
      "    helper0();\n"
      "  } else {\n"
      "    helper1();\n"
      "  }\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
 
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // One range compiled with one hit (helper0).
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":73,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0,56],\"misses\":[]}},"
 
      // One range not compiled (helper1).
      "{\"scriptIndex\":0,\"startPos\":75,\"endPos\":86,\"compiled\":false},"
 
      // One range with two hits and a miss (main).
      "{\"scriptIndex\":0,\"startPos\":88,\"endPos\":156,\"compiled\":true,"
      "\"coverage\":{\"hits\":[88,115],\"misses\":[141]}},"
 
      // Nested range compiled (nestedHelper0).
      "{\"scriptIndex\":0,\"startPos\":14,\"endPos\":31,\"compiled\":true,"
      "\"coverage\":{\"hits\":[14],\"misses\":[]}},"
 
      // Nested range not compiled (nestedHelper1).
      "{\"scriptIndex\":0,\"startPos\":35,\"endPos\":52,\"compiled\":false}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [357/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_NoCalls

)

Definition at line 29 of file source_report_test.cc.

                                                      {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "main() {\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
  SourceReport report(SourceReport::kCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("libraries", json_str, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":"
 
      // One compiled range, one hit at function declaration.
      "[{\"scriptIndex\":0,\"startPos\":0,\"endPos\":9,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}}],"
 
      // One script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [358/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_RestrictedRange

)

Definition at line 480 of file source_report_test.cc.

                                                              {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {\n"
      "  nestedHelper0() {}\n"
      "  nestedHelper1() {}\n"
      "  nestedHelper0();\n"
      "}\n"
      "helper1() {}\n"
      "main() {\n"
      "  if (true) {\n"
      "    helper0();\n"
      "  } else {\n"
      "    helper1();\n"
      "  }\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
  const Function& helper = Function::Handle(
      lib.LookupFunctionAllowPrivate(String::Handle(String::New("helper0"))));
 
  SourceReport report(SourceReport::kCoverage);
  JSONStream js;
  // Restrict the report to only helper0 and it's nested functions.
  report.PrintJSON(&js, script, helper.token_pos(), helper.end_token_pos());
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
 
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // One range compiled with one hit (helper0).
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":73,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0,56],\"misses\":[]}},"
 
      // Nested range compiled (nestedHelper0).
      "{\"scriptIndex\":0,\"startPos\":14,\"endPos\":31,\"compiled\":true,"
      "\"coverage\":{\"hits\":[14],\"misses\":[]}},"
 
      // Nested range not compiled (nestedHelper1).
      "{\"scriptIndex\":0,\"startPos\":35,\"endPos\":52,\"compiled\":false}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [359/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_SimpleCall

)

Definition at line 127 of file source_report_test.cc.

                                                         {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "helper1() {}\n"
      "main() {\n"
      "  if (true) {\n"
      "    helper0();\n"
      "  } else {\n"
      "    helper1();\n"
      "  }\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // One range compiled with one hit at function declaration (helper0).
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}},"
 
      // One range not compiled (helper1).
      "{\"scriptIndex\":0,\"startPos\":13,\"endPos\":24,\"compiled\":false},"
 
      // One range with two hits and a miss (main).
      "{\"scriptIndex\":0,\"startPos\":26,\"endPos\":94,\"compiled\":true,"
      "\"coverage\":{\"hits\":[26,53],\"misses\":[79]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [360/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_UnusedClass_ForceCompile

)

Definition at line 271 of file source_report_test.cc.

                                                                       {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "class Unused {\n"
      "  helper1() { helper0(); }\n"
      "}\n"
      "main() {\n"
      "  helper0();\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // UnusedClass.helper1 is compiled.
      "{\"scriptIndex\":0,\"startPos\":30,\"endPos\":53,\"compiled\":true,"
      "\"coverage\":{\"hits\":[],\"misses\":[30,42]}},"
 
      // helper0 is compiled.
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}},"
 
      // One range with two hits (main).
      "{\"scriptIndex\":0,\"startPos\":57,\"endPos\":79,\"compiled\":true,"
      "\"coverage\":{\"hits\":[57,68],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [361/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_UnusedClass_ForceCompileError

)

Definition at line 318 of file source_report_test.cc.

                                                                            {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "class Unused {\n"
      "  helper1() { helper0()+ }\n"  // syntax error
      "}\n"
      "main() {\n"
      "  helper0();\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript, true);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage, SourceReport::kForceCompile);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // UnusedClass has a syntax error.
      "{\"scriptIndex\":0,\"startPos\":30,\"endPos\":53,\"compiled\":false,"
      "\"error\":{\"type\":\"@Error\",\"_vmType\":\"LanguageError\","
      "\"kind\":\"LanguageError\",\"id\":\"objects\\/0\","
      "\"message\":\"'file:\\/\\/\\/test-lib': error: "
      "\\/test-lib:3:26: "
      "Error: This couldn't be parsed.\\n"
      "  helper1() { helper0()+ }\\n                         ^\"}},"
 
      // helper0 is compiled.
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}},"
 
      // One range with two hits (main).
      "{\"scriptIndex\":0,\"startPos\":57,\"endPos\":79,\"compiled\":true,"
      "\"coverage\":{\"hits\":[57,68],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [362/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Coverage_UnusedClass_NoForceCompile

)

Definition at line 225 of file source_report_test.cc.

                                                                         {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "class Unused {\n"
      "  helper1() { helper0(); }\n"
      "}\n"
      "main() {\n"
      "  helper0();\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // UnusedClass is not compiled.
      "{\"scriptIndex\":0,\"startPos\":13,\"endPos\":55,\"compiled\":false},"
 
      // helper0 is compiled.
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}},"
 
      // One range with two hits (main).
      "{\"scriptIndex\":0,\"startPos\":57,\"endPos\":79,\"compiled\":true,"
      "\"coverage\":{\"hits\":[57,68],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [363/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_MultipleReports

)

Definition at line 794 of file source_report_test.cc.

                                                     {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 2048;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "helper1() {}\n"
      "main() {\n"
      "  helper0();\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCallSites | SourceReport::kCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // One range compiled with no callsites (helper0).
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"callSites\":[],"
      "\"coverage\":{\"hits\":[0],\"misses\":[]}},"
 
      // One range not compiled (helper1).
      "{\"scriptIndex\":0,\"startPos\":13,\"endPos\":24,\"compiled\":false},"
 
      // One range compiled with one callsite (main)m
      "{\"scriptIndex\":0,\"startPos\":26,\"endPos\":48,\"compiled\":true,"
      "\"callSites\":[{\"name\":\"helper0\",\"tokenPos\":37,\"cacheEntries\":[{"
      "\"target\":{\"type\":\"@Function\",\"fixedId\":true,\"id\":\"\","
      "\"name\":\"helper0\",\"owner\":{\"type\":\"@Library\",\"fixedId\":true,"
      "\"id\":\"\",\"name\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\"},\"_"
      "kind\":\"RegularFunction\",\"static\":true,\"const\":false,\"implicit\":"
      "false,\"abstract\":false,\"_"
      "intrinsic\":false,\"_native\":false,\"isGetter\":false,"
      "\"isSetter\":false,\"location\":{\"type\":"
      "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
      "\"id\":\"\",\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"},"
      "\"tokenPos\":0,\"endTokenPos\":11,\"line\":1,\"column\":1}},\"count\":1}"
      "]}],\"coverage\":{"
      "\"hits\":[26,37],\"misses\":[]}}],"
 
      // One script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [364/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_PossibleBreakpoints_Simple

)

Definition at line 851 of file source_report_test.cc.

                                                                {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript =
      "helper0() {}\n"
      "helper1() {}\n"
      "main() {\n"
      "  if (true) {\n"
      "    helper0();\n"
      "  } else {\n"
      "    helper1();\n"
      "  }\n"
      "}";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kPossibleBreakpoints);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // helper0.
      "{\"scriptIndex\":0,\"startPos\":0,\"endPos\":11,\"compiled\":true,"
      "\"possibleBreakpoints\":[7,11]},"
 
      // One range not compiled (helper1).
      "{\"scriptIndex\":0,\"startPos\":13,\"endPos\":24,\"compiled\":false},"
 
      // main.
      "{\"scriptIndex\":0,\"startPos\":26,\"endPos\":94,\"compiled\":true,"
      "\"possibleBreakpoints\":[30,53,79,94]}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [365/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Regress53519_Destructuring

)

Definition at line 1295 of file source_report_test.cc.

                                                                {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript = R"(
main() {
  destructure({
    'hello': 'world',
    'count': [1, 2, 3],
  });
}
 
String destructure(Map<String, dynamic> map) {
  final {'hello': world, 'count': count} = map;
  return 'Hello $world, count: $count';
}
)";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // main
      "{\"scriptIndex\":0,\"startPos\":1,\"endPos\":78,\"compiled\":true,"
      "\"coverage\":{\"hits\":[1,12,24,61],\"misses\":[]}},"
 
      // destructure
      "{\"scriptIndex\":0,\"startPos\":81,\"endPos\":216,\"compiled\":true,"
      "\"coverage\":{\"hits\":[81,144,160,214],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [366/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SourceReport_Regress95008_RedirectingFactory

)

Definition at line 1241 of file source_report_test.cc.

                                                                     {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 1024;
  char buffer[kBufferSize];
  const char* kScript = R"(
class A {
  A();
  factory A.foo(int i) = B; // LINE_A
}
 
class B extends A {
  int i;
  B(this.i); // LINE_B
}
 
main() {
  A.foo(42);
}
)";
 
  Library& lib = Library::Handle();
  lib ^= ExecuteScript(kScript);
  ASSERT(!lib.IsNull());
  const Script& script =
      Script::Handle(lib.LookupScript(String::Handle(String::New("test-lib"))));
 
  SourceReport report(SourceReport::kCoverage);
  JSONStream js;
  report.PrintJSON(&js, script);
  const char* json_str = js.ToCString();
  ASSERT(strlen(json_str) < kBufferSize);
  ElideJSONSubstring("classes", json_str, buffer);
  ElideJSONSubstring("libraries", buffer, buffer);
  EXPECT_STREQ(
      "{\"type\":\"SourceReport\",\"ranges\":["
 
      // A()
      "{\"scriptIndex\":0,\"startPos\":13,\"endPos\":16,\"compiled\":true,"
      "\"coverage\":{\"hits\":[13],\"misses\":[]}},"
 
      // B()
      "{\"scriptIndex\":0,\"startPos\":90,\"endPos\":99,\"compiled\":true,"
      "\"coverage\":{\"hits\":[90],\"misses\":[]}},"
 
      // main
      "{\"scriptIndex\":0,\"startPos\":114,\"endPos\":136,\"compiled\":true,"
      "\"coverage\":{\"hits\":[114,127],\"misses\":[]}}],"
 
      // Only one script in the script table.
      "\"scripts\":[{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
      "\"uri\":\"file:\\/\\/\\/test-lib\",\"_kind\":\"kernel\"}]}",
      buffer);
}

ISOLATE_UNIT_TEST_CASE() [367/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SpecialClassesHaveEmptyArrays

)

Definition at line 5823 of file object_test.cc.

  {
    bool result =
        Dart_RunLoopAsync(/*errors_are_fatal=*/true,
                          /*on_error_port=*/0, /*on_exit_port=*/0, &error);
    EXPECT_EQ(true, result);
  }
  EXPECT_EQ(nullptr, error);
  Dart_EnterIsolate(parent);
}
 
ISOLATE_UNIT_TEST_CASE(SpecialClassesHaveEmptyArrays) {
  ObjectStore* object_store = IsolateGroup::Current()->object_store();
  Class& cls = Class::Handle();
  Object& array = Object::Handle();
 
  cls = object_store->null_class();
  array = cls.fields();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());
  array = cls.current_functions();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());
 
  cls = Object::void_class();
  array = cls.fields();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());
  array = cls.current_functions();

ISOLATE_UNIT_TEST_CASE() [368/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StackAllocatedDestruction

)

Definition at line 76 of file allocation_test.cc.

                                                  {
  int data = 1;
  StackAllocatedDestructionHelper(&data);
  EXPECT_EQ(4, data);
}

ISOLATE_UNIT_TEST_CASE() [369/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StackAllocatedLongJump

)

Definition at line 92 of file allocation_test.cc.

                                               {
  LongJumpScope jump;
  int data = 1;
  if (setjmp(*jump.Set()) == 0) {
    StackAllocatedLongJumpHelper(&data, &jump);
    UNREACHABLE();
  } else {
    ASSERT(Error::Handle(thread->StealStickyError()).IsLanguageError());
  }
  EXPECT_EQ(3, data);
}

ISOLATE_UNIT_TEST_CASE() [370/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StackResourceDestruction

)

Definition at line 119 of file allocation_test.cc.

                                                 {
  int data = 1;
  StackResourceDestructionHelper(&data);
  EXPECT_EQ(7, data);
}

ISOLATE_UNIT_TEST_CASE() [371/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StackResourceLongJump

)

Definition at line 143 of file allocation_test.cc.

                                              {
  LongJumpScope* base = Thread::Current()->long_jump_base();
  {
    LongJumpScope jump;
    int data = 1;
    if (setjmp(*jump.Set()) == 0) {
      StackResourceLongJumpHelper(&data, &jump);
      UNREACHABLE();
    } else {
      ASSERT(Error::Handle(thread->StealStickyError()).IsLanguageError());
    }
    EXPECT_EQ(7, data);
  }
  ASSERT(base == Thread::Current()->long_jump_base());
}

ISOLATE_UNIT_TEST_CASE() [372/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StreamingFlowGraphBuilder_ConcatStringLits

)

Definition at line 182 of file kernel_binary_flowgraph_test.cc.

                                                                   {
  // We should drop empty strings from StringInterpolates:
  const char* kScript = R"(
    test(s) {
      return '' 'a' '' 'b' '$s' '' 'c' '' 'd' '';
    }
    main() => test('u');
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  Invoke(root_library, "main");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  StoreIndexedInstr* store1 = nullptr;
  StoreIndexedInstr* store2 = nullptr;
  StoreIndexedInstr* store3 = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  // clang-format off
  RELEASE_ASSERT(cursor.TryMatch({
    kMatchAndMoveFunctionEntry,
    kMatchAndMoveCheckStackOverflow,
    kMoveDebugStepChecks,
    kMatchAndMoveCreateArray,
    {kMatchAndMoveStoreIndexed, &store1},
    {kMatchAndMoveStoreIndexed, &store2},
    {kMatchAndMoveStoreIndexed, &store3},
    kMatchAndMoveStaticCall,
    kMoveDebugStepChecks,
    kMatchDartReturn,
  }));
  // clang-format on
 
  // StoreIndexed(tmp_array, 0, "ab")
  EXPECT(store1->index()->BindsToConstant());
  EXPECT(store1->index()->BoundConstant().IsInteger());
  EXPECT(Integer::Cast(store1->index()->BoundConstant()).AsInt64Value() == 0);
 
  EXPECT(store1->value()->BindsToConstant());
  EXPECT(store1->value()->BoundConstant().IsString());
  EXPECT(String::Cast(store1->value()->BoundConstant()).Equals("ab"));
 
  // StoreIndexed(tmp_array, 1, s)
  EXPECT(store2->index()->BindsToConstant());
  EXPECT(store2->index()->BoundConstant().IsInteger());
  EXPECT(Integer::Cast(store2->index()->BoundConstant()).AsInt64Value() == 1);
 
  EXPECT(!store2->value()->BindsToConstant());
 
  // StoreIndexed(tmp_array, 2, "cd")
  EXPECT(store3->index()->BindsToConstant());
  EXPECT(store3->index()->BoundConstant().IsInteger());
  EXPECT(Integer::Cast(store3->index()->BoundConstant()).AsInt64Value() == 2);
 
  EXPECT(store3->value()->BindsToConstant());
  EXPECT(store3->value()->BoundConstant().IsString());
  EXPECT(String::Cast(store3->value()->BoundConstant()).Equals("cd"));
}

ISOLATE_UNIT_TEST_CASE() [373/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StreamingFlowGraphBuilder_ConstFoldStringConcats

)

Definition at line 13 of file kernel_binary_flowgraph_test.cc.

                                                                         {
  // According to the Dart spec:
  // "Adjacent strings are implicitly concatenated to form a single string
  // literal."
  const char* kScript = R"(
    test() {
      var s = 'aaaa'
          'bbbb'
          'cccc';
      return s;
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  Invoke(root_library, "test");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  DartReturnInstr* ret = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  // clang-format off
  RELEASE_ASSERT(cursor.TryMatch({
    kMatchAndMoveFunctionEntry,
    kMatchAndMoveCheckStackOverflow,
    kMoveDebugStepChecks,
    {kMatchDartReturn, &ret},
  }));
  // clang-format on
 
  EXPECT(ret->value()->BindsToConstant());
  EXPECT(ret->value()->BoundConstant().IsString());
  const String& ret_str = String::Cast(ret->value()->BoundConstant());
  EXPECT(ret_str.Equals("aaaabbbbcccc"));
}

ISOLATE_UNIT_TEST_CASE() [374/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StreamingFlowGraphBuilder_DropEmptyStringInterp

)

Definition at line 114 of file kernel_binary_flowgraph_test.cc.

                                                                        {
  // We should drop empty strings from StringInterpolates:
  const char* kScript = R"(
    test(s) {
      return '' 'a' '$s' '' 'b' '';
    }
    main() => test('u');
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  Invoke(root_library, "main");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  StoreIndexedInstr* store1 = nullptr;
  StoreIndexedInstr* store2 = nullptr;
  StoreIndexedInstr* store3 = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  // clang-format off
  RELEASE_ASSERT(cursor.TryMatch({
    kMatchAndMoveFunctionEntry,
    kMatchAndMoveCheckStackOverflow,
    kMoveDebugStepChecks,
    kMatchAndMoveCreateArray,
    {kMatchAndMoveStoreIndexed, &store1},
    {kMatchAndMoveStoreIndexed, &store2},
    {kMatchAndMoveStoreIndexed, &store3},
    kMatchAndMoveStaticCall,
    kMoveDebugStepChecks,
    kMatchDartReturn,
  }));
  // clang-format on
 
  // StoreIndexed(tmp_array, 0, "ab")
  EXPECT(store1->index()->BindsToConstant());
  EXPECT(store1->index()->BoundConstant().IsInteger());
  EXPECT(Integer::Cast(store1->index()->BoundConstant()).AsInt64Value() == 0);
 
  EXPECT(store1->value()->BindsToConstant());
  EXPECT(store1->value()->BoundConstant().IsString());
  EXPECT(String::Cast(store1->value()->BoundConstant()).Equals("a"));
 
  // StoreIndexed(tmp_array, 1, s)
  EXPECT(store2->index()->BindsToConstant());
  EXPECT(store2->index()->BoundConstant().IsInteger());
  EXPECT(Integer::Cast(store2->index()->BoundConstant()).AsInt64Value() == 1);
 
  EXPECT(!store2->value()->BindsToConstant());
 
  // StoreIndexed(tmp_array, 2, "b")
  EXPECT(store3->index()->BindsToConstant());
  EXPECT(store3->index()->BoundConstant().IsInteger());
  EXPECT(Integer::Cast(store3->index()->BoundConstant()).AsInt64Value() == 2);
 
  EXPECT(store3->value()->BindsToConstant());
  EXPECT(store3->value()->BoundConstant().IsString());
  EXPECT(String::Cast(store3->value()->BoundConstant()).Equals("b"));
}

ISOLATE_UNIT_TEST_CASE() [375/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StreamingFlowGraphBuilder_FlattenNestedStringInterp

)

Definition at line 57 of file kernel_binary_flowgraph_test.cc.

                                                                            {
  // We should collapse nested StringInterpolates:
  const char* kScript = R"(
    test(String s) {
      return '$s' '${'d' 'e'}';
    }
    main() => test('u');
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  Invoke(root_library, "main");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  StoreIndexedInstr* store1 = nullptr;
  StoreIndexedInstr* store2 = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  // clang-format off
  RELEASE_ASSERT(cursor.TryMatch({
    kMatchAndMoveFunctionEntry,
    kMatchAndMoveCheckStackOverflow,
    kMoveDebugStepChecks,
    kMatchAndMoveCreateArray,
    {kMatchAndMoveStoreIndexed, &store1},
    {kMatchAndMoveStoreIndexed, &store2},
    kMatchAndMoveStaticCall,
    kMoveDebugStepChecks,
    kMatchDartReturn,
  }));
  // clang-format on
 
  // StoreIndexed(tmp_array, 0, s)
  EXPECT(store1->index()->BindsToConstant());
  EXPECT(store1->index()->BoundConstant().IsInteger());
  EXPECT(Integer::Cast(store1->index()->BoundConstant()).AsInt64Value() == 0);
 
  EXPECT(!store1->value()->BindsToConstant());
 
  // StoreIndexed(tmp_array, 1, "de")
  EXPECT(store2->index()->BindsToConstant());
  EXPECT(store2->index()->BoundConstant().IsInteger());
  EXPECT(Integer::Cast(store2->index()->BoundConstant()).AsInt64Value() == 1);
 
  EXPECT(store2->value()->BindsToConstant());
  EXPECT(store2->value()->BoundConstant().IsString());
  EXPECT(String::Cast(store2->value()->BoundConstant()).Equals("de"));
}

ISOLATE_UNIT_TEST_CASE() [376/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StreamingFlowGraphBuilder_InvariantFlagInListLiterals

)

Definition at line 250 of file kernel_binary_flowgraph_test.cc.

                                                                              {
  const char* kScript = R"(
    test() {
      return [...[], 42];
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  Invoke(root_library, "test");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  InstanceCallInstr* call_add = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  // clang-format off
  RELEASE_ASSERT(cursor.TryMatch({
    kMatchAndMoveFunctionEntry,
    kMatchAndMoveCheckStackOverflow,
    kMoveDebugStepChecks,
    kMatchAndMoveStaticCall,
    kMatchAndMoveStaticCall,
    {kMatchAndMoveInstanceCall, &call_add},
    kMoveDebugStepChecks,
    kMatchDartReturn,
  }));
  // clang-format on
 
  EXPECT(call_add != nullptr);
  EXPECT(call_add->function_name().Equals("add"));
  EXPECT(call_add->entry_kind() == Code::EntryKind::kUnchecked);
}

ISOLATE_UNIT_TEST_CASE() [377/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StreamingFlowGraphBuilder_StaticGetFinalFieldWithTrivialInitializer

)

Definition at line 347 of file kernel_binary_flowgraph_test.cc.

                                                                         {
  const char* kScript = R"(
    final int x = 0xFEEDFEED;
    test() {
      return x;
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "test"));
 
  Invoke(root_library, "test");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  DartReturnInstr* return_instr = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveFunctionEntry,
      kMatchAndMoveCheckStackOverflow,
      kMoveDebugStepChecks,
      {kMatchDartReturn, &return_instr},
  }));
 
  EXPECT(return_instr != nullptr);
  ConstantInstr* const_value =
      return_instr->value()->definition()->AsConstant();
  EXPECT(const_value != nullptr);
  EXPECT(const_value->value().IsInteger());
  EXPECT_EQ(0xFEEDFEED, Integer::Cast(const_value->value()).AsInt64Value());
}

ISOLATE_UNIT_TEST_CASE() [378/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StreamingFlowGraphBuilder_TypedClosureCall

)

Definition at line 291 of file kernel_binary_flowgraph_test.cc.

                                                                   {
  // This test ensures that a typed closure call (i.e. the closure being called
  // has a real function type as static type) ends up compiling to
  //
  //   CheckNull()+ClosureCall()
  //
  // instead of
  //
  //   InstanceCall(dyn:call)
  //
  // This is a regression test for a case where JIT support uses dynamic calls
  // instead of typed closure calls if call-site attribute metadata is missing
  // which is the case if an incremental kernel compiler is used. The
  // [LoadTestScript] below uses IKG compiler, so this is a regression test for:
  //
  //   - https://github.com/dart-lang/sdk/issues/46320
  //   - https://github.com/dart-lang/sdk/issues/45421
  //
  const char* kScript = R"(
    int callClosure(int Function(int) fun, int value) => fun(value);
    test() => callClosure((int a) => a + 1, 10);
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "test");
 
  const auto& callClosureFunction =
      Function::Handle(GetFunction(root_library, "callClosure"));
  TestPipeline pipeline(callClosureFunction, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  ILMatcher cursor(flow_graph, entry, true);
  // clang-format off
  std::initializer_list<MatchCode> expected = {
    kMatchAndMoveFunctionEntry,
    kMatchAndMoveCheckStackOverflow,
    kMoveDebugStepChecks,
    kMatchAndMoveCheckNull,
    kMatchAndMoveLoadField,
    kMoveDebugStepChecks,
#if !defined(PRODUCT)
    kMatchAndMoveRecordCoverage,
#endif
    kMatchAndMoveClosureCall,
    kMoveDebugStepChecks,
    kMatchDartReturn,
  };
  RELEASE_ASSERT(cursor.TryMatch(expected));
  // clang-format on
}

ISOLATE_UNIT_TEST_CASE() [379/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StressMallocThroughZones

)

Definition at line 239 of file zone_test.cc.

                                                 {
#if defined(CHECK_RSS)
  int64_t start_rss = Service::CurrentRSS();
#endif
 
  for (size_t i = 0; i < ((3u * GB) / (512u * KB)); i++) {
    StackZone stack_zone(Thread::Current());
    Zone* zone = stack_zone.GetZone();
    for (size_t j = 0; j < ARRAY_SIZE(kSizes); j++) {
      zone->Alloc<uint8_t>(kSizes[j]);
    }
  }
 
#if defined(CHECK_RSS)
  int64_t stop_rss = Service::CurrentRSS();
  EXPECT_LT(stop_rss, start_rss + kRssSlack);
#endif
}

ISOLATE_UNIT_TEST_CASE() [380/463]

dart::ISOLATE_UNIT_TEST_CASE

(

String

)

Definition at line 676 of file object_test.cc.

                               {
  const char* kHello = "Hello World!";
  int32_t hello_len = strlen(kHello);
  const String& str = String::Handle(String::New(kHello));
  EXPECT(str.IsInstance());
  EXPECT(str.IsString());
  EXPECT(str.IsOneByteString());
  EXPECT(!str.IsTwoByteString());
  EXPECT(!str.IsNumber());
  EXPECT_EQ(hello_len, str.Length());
  EXPECT_EQ('H', str.CharAt(0));
  EXPECT_EQ('e', str.CharAt(1));
  EXPECT_EQ('l', str.CharAt(2));
  EXPECT_EQ('l', str.CharAt(3));
  EXPECT_EQ('o', str.CharAt(4));
  EXPECT_EQ(' ', str.CharAt(5));
  EXPECT_EQ('W', str.CharAt(6));
  EXPECT_EQ('o', str.CharAt(7));
  EXPECT_EQ('r', str.CharAt(8));
  EXPECT_EQ('l', str.CharAt(9));
  EXPECT_EQ('d', str.CharAt(10));
  EXPECT_EQ('!', str.CharAt(11));
 
  const uint8_t* motto =
      reinterpret_cast<const uint8_t*>("Dart's bescht wos je hets gits");
  const String& str2 = String::Handle(String::FromUTF8(motto + 7, 4));
  EXPECT_EQ(4, str2.Length());
  EXPECT_EQ('b', str2.CharAt(0));
  EXPECT_EQ('e', str2.CharAt(1));
  EXPECT_EQ('s', str2.CharAt(2));
  EXPECT_EQ('c', str2.CharAt(3));
 
  const String& str3 = String::Handle(String::New(kHello));
  EXPECT(str.Equals(str));
  EXPECT_EQ(str.Hash(), str.Hash());
  EXPECT(!str.Equals(str2));
  EXPECT(str.Equals(str3));
  EXPECT_EQ(str.Hash(), str3.Hash());
  EXPECT(str3.Equals(str));
 
  const String& str4 = String::Handle(String::New("foo"));
  const String& str5 = String::Handle(String::New("bar"));
  const String& str6 = String::Handle(String::Concat(str4, str5));
  const String& str7 = String::Handle(String::New("foobar"));
  EXPECT(str6.Equals(str7));
  EXPECT(!str6.Equals(Smi::Handle(Smi::New(4))));
 
  const String& empty1 = String::Handle(String::New(""));
  const String& empty2 = String::Handle(String::New(""));
  EXPECT(empty1.Equals(empty2, 0, 0));
 
  const intptr_t kCharsLen = 8;
  const uint8_t chars[kCharsLen] = {1, 2, 127, 64, 92, 0, 55, 55};
  const String& str8 = String::Handle(String::FromUTF8(chars, kCharsLen));
  EXPECT_EQ(kCharsLen, str8.Length());
  EXPECT_EQ(1, str8.CharAt(0));
  EXPECT_EQ(127, str8.CharAt(2));
  EXPECT_EQ(64, str8.CharAt(3));
  EXPECT_EQ(0, str8.CharAt(5));
  EXPECT_EQ(55, str8.CharAt(6));
  EXPECT_EQ(55, str8.CharAt(7));
  const intptr_t kCharsIndex = 3;
  const String& sub1 = String::Handle(String::SubString(str8, kCharsIndex));
  EXPECT_EQ((kCharsLen - kCharsIndex), sub1.Length());
  EXPECT_EQ(64, sub1.CharAt(0));
  EXPECT_EQ(92, sub1.CharAt(1));
  EXPECT_EQ(0, sub1.CharAt(2));
  EXPECT_EQ(55, sub1.CharAt(3));
  EXPECT_EQ(55, sub1.CharAt(4));
 
  const intptr_t kWideCharsLen = 7;
  uint16_t wide_chars[kWideCharsLen] = {'H', 'e', 'l', 'l', 'o', 256, '!'};
  const String& two_str =
      String::Handle(String::FromUTF16(wide_chars, kWideCharsLen));
  EXPECT(two_str.IsInstance());
  EXPECT(two_str.IsString());
  EXPECT(two_str.IsTwoByteString());
  EXPECT(!two_str.IsOneByteString());
  EXPECT_EQ(kWideCharsLen, two_str.Length());
  EXPECT_EQ('H', two_str.CharAt(0));
  EXPECT_EQ(256, two_str.CharAt(5));
  const intptr_t kWideCharsIndex = 3;
  const String& sub2 = String::Handle(String::SubString(two_str, kCharsIndex));
  EXPECT_EQ((kWideCharsLen - kWideCharsIndex), sub2.Length());
  EXPECT_EQ('l', sub2.CharAt(0));
  EXPECT_EQ('o', sub2.CharAt(1));
  EXPECT_EQ(256, sub2.CharAt(2));
  EXPECT_EQ('!', sub2.CharAt(3));
 
  {
    const String& str1 = String::Handle(String::New("My.create"));
    const String& str2 = String::Handle(String::New("My"));
    const String& str3 = String::Handle(String::New("create"));
    EXPECT_EQ(true, str1.StartsWith(str2));
    EXPECT_EQ(false, str1.StartsWith(str3));
  }
 
  const int32_t four_chars[] = {'C', 0xFF, 'h', 0xFFFF, 'a', 0x10FFFF, 'r'};
  const String& four_str = String::Handle(String::FromUTF32(four_chars, 7));
  EXPECT_EQ(four_str.Hash(), four_str.Hash());
  EXPECT(four_str.IsTwoByteString());
  EXPECT(!four_str.IsOneByteString());
  EXPECT_EQ(8, four_str.Length());
  EXPECT_EQ('C', four_str.CharAt(0));
  EXPECT_EQ(0xFF, four_str.CharAt(1));
  EXPECT_EQ('h', four_str.CharAt(2));
  EXPECT_EQ(0xFFFF, four_str.CharAt(3));
  EXPECT_EQ('a', four_str.CharAt(4));
  EXPECT_EQ(0xDBFF, four_str.CharAt(5));
  EXPECT_EQ(0xDFFF, four_str.CharAt(6));
  EXPECT_EQ('r', four_str.CharAt(7));
 
  // Create a 1-byte string from an array of 2-byte elements.
  {
    const uint16_t char16[] = {0x00, 0x7F, 0xFF};
    const String& str8 = String::Handle(String::FromUTF16(char16, 3));
    EXPECT(str8.IsOneByteString());
    EXPECT(!str8.IsTwoByteString());
    EXPECT_EQ(0x00, str8.CharAt(0));
    EXPECT_EQ(0x7F, str8.CharAt(1));
    EXPECT_EQ(0xFF, str8.CharAt(2));
  }
 
  // Create a 1-byte string from an array of 4-byte elements.
  {
    const int32_t char32[] = {0x00, 0x1F, 0x7F};
    const String& str8 = String::Handle(String::FromUTF32(char32, 3));
    EXPECT(str8.IsOneByteString());
    EXPECT(!str8.IsTwoByteString());
    EXPECT_EQ(0x00, str8.CharAt(0));
    EXPECT_EQ(0x1F, str8.CharAt(1));
    EXPECT_EQ(0x7F, str8.CharAt(2));
  }
 
  // Create a 2-byte string from an array of 4-byte elements.
  {
    const int32_t char32[] = {0, 0x7FFF, 0xFFFF};
    const String& str16 = String::Handle(String::FromUTF32(char32, 3));
    EXPECT(!str16.IsOneByteString());
    EXPECT(str16.IsTwoByteString());
    EXPECT_EQ(0x0000, str16.CharAt(0));
    EXPECT_EQ(0x7FFF, str16.CharAt(1));
    EXPECT_EQ(0xFFFF, str16.CharAt(2));
  }
}

ISOLATE_UNIT_TEST_CASE() [381/463]

dart::ISOLATE_UNIT_TEST_CASE

(

String_EqualsUTF32

)

Definition at line 7364 of file object_test.cc.

      {"_MyClass@6328321.named", "_MyClass.named"},
  };
  String& test = String::Handle();
  const char* result;
  for (size_t i = 0; i < ARRAY_SIZE(tests); i++) {
    test = String::New(tests[i].in);
    result = String::ScrubName(test);
    EXPECT_STREQ(tests[i].out, result);
  }
}
 
ISOLATE_UNIT_TEST_CASE(String_EqualsUTF32) {

ISOLATE_UNIT_TEST_CASE() [382/463]

dart::ISOLATE_UNIT_TEST_CASE

(

String_ScrubName

)

Definition at line 7338 of file object_test.cc.

                            {&Symbols::TypeError(), &empty,
                             &Symbols::isPaused()};
    CheckConcatAll(data, 3);
  }
}
 
struct TestResult {
  const char* in;
  const char* out;
};
 
ISOLATE_UNIT_TEST_CASE(String_ScrubName) {
  TestResult tests[] = {
      {"(dynamic, dynamic) => void", "(dynamic, dynamic) => void"},
      {"_List@915557746", "_List"},
      {"_HashMap@600006304<K, V>(dynamic) => V",
       "_HashMap<K, V>(dynamic) => V"},
      {"set:foo", "foo="},
      {"get:foo", "foo"},
      {"_ReceivePortImpl@709387912", "_ReceivePortImpl"},
      {"_ReceivePortImpl@709387912._internal@709387912",
       "_ReceivePortImpl._internal"},
      {"_C@6328321&_E@6328321&_F@6328321", "_C&_E&_F"},
      {"List.", "List"},
      {"get:foo@6328321", "foo"},

ISOLATE_UNIT_TEST_CASE() [383/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringCodePointIterator

)

Definition at line 1993 of file object_test.cc.

                                                {
  const String& str0 = String::Handle(String::New(""));
  String::CodePointIterator it0(str0);
  EXPECT(!it0.Next());
 
  const String& str1 = String::Handle(String::New(" \xc3\xa7 "));
  String::CodePointIterator it1(str1);
  EXPECT(it1.Next());
  EXPECT_EQ(' ', it1.Current());
  EXPECT(it1.Next());
  EXPECT_EQ(0xE7, it1.Current());
  EXPECT(it1.Next());
  EXPECT_EQ(' ', it1.Current());
  EXPECT(!it1.Next());
 
  const String& str2 =
      String::Handle(String::New("\xD7\x92\xD7\x9C"
                                 "\xD7\xA2\xD7\x93"
                                 "\xD7\x91\xD7\xA8"
                                 "\xD7\x9B\xD7\x94"));
  String::CodePointIterator it2(str2);
  EXPECT(it2.Next());
  EXPECT_EQ(0x5D2, it2.Current());
  EXPECT(it2.Next());
  EXPECT_EQ(0x5DC, it2.Current());
  EXPECT(it2.Next());
  EXPECT_EQ(0x5E2, it2.Current());
  EXPECT(it2.Next());
  EXPECT_EQ(0x5D3, it2.Current());
  EXPECT(it2.Next());
  EXPECT_EQ(0x5D1, it2.Current());
  EXPECT(it2.Next());
  EXPECT_EQ(0x5E8, it2.Current());
  EXPECT(it2.Next());
  EXPECT_EQ(0x5DB, it2.Current());
  EXPECT(it2.Next());
  EXPECT_EQ(0x5D4, it2.Current());
  EXPECT(!it2.Next());
 
  const String& str3 =
      String::Handle(String::New("\xF0\x9D\x91\xA0"
                                 "\xF0\x9D\x91\xA1"
                                 "\xF0\x9D\x91\xA2"
                                 "\xF0\x9D\x91\xA3"));
  String::CodePointIterator it3(str3);
  EXPECT(it3.Next());
  EXPECT_EQ(0x1D460, it3.Current());
  EXPECT(it3.Next());
  EXPECT_EQ(0x1D461, it3.Current());
  EXPECT(it3.Next());
  EXPECT_EQ(0x1D462, it3.Current());
  EXPECT(it3.Next());
  EXPECT_EQ(0x1D463, it3.Current());
  EXPECT(!it3.Next());
}

ISOLATE_UNIT_TEST_CASE() [384/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringCodePointIteratorRange

)

Definition at line 2049 of file object_test.cc.

                                                     {
  const String& str = String::Handle(String::New("foo bar baz"));
 
  String::CodePointIterator it0(str, 3, 0);
  EXPECT(!it0.Next());
 
  String::CodePointIterator it1(str, 4, 3);
  EXPECT(it1.Next());
  EXPECT_EQ('b', it1.Current());
  EXPECT(it1.Next());
  EXPECT_EQ('a', it1.Current());
  EXPECT(it1.Next());
  EXPECT_EQ('r', it1.Current());
  EXPECT(!it1.Next());
}

ISOLATE_UNIT_TEST_CASE() [385/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringCompareTo

)

Definition at line 419 of file object_test.cc.

                                        {
  const String& abcd = String::Handle(String::New("abcd"));
  const String& abce = String::Handle(String::New("abce"));
  EXPECT_EQ(0, abcd.CompareTo(abcd));
  EXPECT_EQ(0, abce.CompareTo(abce));
  EXPECT(abcd.CompareTo(abce) < 0);
  EXPECT(abce.CompareTo(abcd) > 0);
 
  const int kMonkeyLen = 4;
  const uint8_t monkey_utf8[kMonkeyLen] = {0xf0, 0x9f, 0x90, 0xb5};
  const String& monkey_face =
      String::Handle(String::FromUTF8(monkey_utf8, kMonkeyLen));
  const int kDogLen = 4;
  // 0x1f436 DOG FACE.
  const uint8_t dog_utf8[kDogLen] = {0xf0, 0x9f, 0x90, 0xb6};
  const String& dog_face = String::Handle(String::FromUTF8(dog_utf8, kDogLen));
  EXPECT_EQ(0, monkey_face.CompareTo(monkey_face));
  EXPECT_EQ(0, dog_face.CompareTo(dog_face));
  EXPECT(monkey_face.CompareTo(dog_face) < 0);
  EXPECT(dog_face.CompareTo(monkey_face) > 0);
 
  const int kDominoLen = 4;
  // 0x1f036 DOMINO TILE HORIZONTAL-00-05.
  const uint8_t domino_utf8[kDominoLen] = {0xf0, 0x9f, 0x80, 0xb6};
  const String& domino =
      String::Handle(String::FromUTF8(domino_utf8, kDominoLen));
  EXPECT_EQ(0, domino.CompareTo(domino));
  EXPECT(domino.CompareTo(dog_face) < 0);
  EXPECT(domino.CompareTo(monkey_face) < 0);
  EXPECT(dog_face.CompareTo(domino) > 0);
  EXPECT(monkey_face.CompareTo(domino) > 0);
 
  EXPECT(abcd.CompareTo(monkey_face) < 0);
  EXPECT(abce.CompareTo(monkey_face) < 0);
  EXPECT(abcd.CompareTo(domino) < 0);
  EXPECT(abce.CompareTo(domino) < 0);
  EXPECT(domino.CompareTo(abcd) > 0);
  EXPECT(domino.CompareTo(abcd) > 0);
  EXPECT(monkey_face.CompareTo(abce) > 0);
  EXPECT(monkey_face.CompareTo(abce) > 0);
}

ISOLATE_UNIT_TEST_CASE() [386/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringConcat

)

Definition at line 834 of file object_test.cc.

                                     {
  // Create strings from concatenated 1-byte empty strings.
  {
    const String& empty1 = String::Handle(String::New(""));
    EXPECT(empty1.IsOneByteString());
    EXPECT_EQ(0, empty1.Length());
 
    const String& empty2 = String::Handle(String::New(""));
    EXPECT(empty2.IsOneByteString());
    EXPECT_EQ(0, empty2.Length());
 
    // Concat
 
    const String& empty3 = String::Handle(String::Concat(empty1, empty2));
    EXPECT(empty3.IsOneByteString());
    EXPECT_EQ(0, empty3.Length());
 
    // ConcatAll
 
    const Array& array1 = Array::Handle(Array::New(0));
    EXPECT_EQ(0, array1.Length());
    const String& empty4 = String::Handle(String::ConcatAll(array1));
    EXPECT_EQ(0, empty4.Length());
 
    const Array& array2 = Array::Handle(Array::New(10));
    EXPECT_EQ(10, array2.Length());
    for (int i = 0; i < array2.Length(); ++i) {
      array2.SetAt(i, String::Handle(String::New("")));
    }
    const String& empty5 = String::Handle(String::ConcatAll(array2));
    EXPECT(empty5.IsOneByteString());
    EXPECT_EQ(0, empty5.Length());
 
    const Array& array3 = Array::Handle(Array::New(123));
    EXPECT_EQ(123, array3.Length());
 
    const String& empty6 = String::Handle(String::New(""));
    EXPECT(empty6.IsOneByteString());
    EXPECT_EQ(0, empty6.Length());
    for (int i = 0; i < array3.Length(); ++i) {
      array3.SetAt(i, empty6);
    }
    const String& empty7 = String::Handle(String::ConcatAll(array3));
    EXPECT(empty7.IsOneByteString());
    EXPECT_EQ(0, empty7.Length());
  }
 
  // Concatenated empty and non-empty 1-byte strings.
  {
    const String& str1 = String::Handle(String::New(""));
    EXPECT_EQ(0, str1.Length());
    EXPECT(str1.IsOneByteString());
 
    const String& str2 = String::Handle(String::New("one"));
    EXPECT(str2.IsOneByteString());
    EXPECT_EQ(3, str2.Length());
 
    // Concat
 
    const String& str3 = String::Handle(String::Concat(str1, str2));
    EXPECT(str3.IsOneByteString());
    EXPECT_EQ(3, str3.Length());
    EXPECT(str3.Equals(str2));
 
    const String& str4 = String::Handle(String::Concat(str2, str1));
    EXPECT(str4.IsOneByteString());
    EXPECT_EQ(3, str4.Length());
    EXPECT(str4.Equals(str2));
 
    // ConcatAll
 
    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, str1);
    array1.SetAt(1, str2);
    const String& str5 = String::Handle(String::ConcatAll(array1));
    EXPECT(str5.IsOneByteString());
    EXPECT_EQ(3, str5.Length());
    EXPECT(str5.Equals(str2));
 
    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, str1);
    array2.SetAt(1, str2);
    const String& str6 = String::Handle(String::ConcatAll(array2));
    EXPECT(str6.IsOneByteString());
    EXPECT_EQ(3, str6.Length());
    EXPECT(str6.Equals(str2));
 
    const Array& array3 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array3.Length());
    array3.SetAt(0, str2);
    array3.SetAt(1, str1);
    array3.SetAt(2, str2);
    const String& str7 = String::Handle(String::ConcatAll(array3));
    EXPECT(str7.IsOneByteString());
    EXPECT_EQ(6, str7.Length());
    EXPECT(str7.Equals("oneone"));
    EXPECT(!str7.Equals("oneoneone"));
  }
 
  // Create a string by concatenating non-empty 1-byte strings.
  {
    const char* one = "one";
    intptr_t one_len = strlen(one);
    const String& onestr = String::Handle(String::New(one));
    EXPECT(onestr.IsOneByteString());
    EXPECT_EQ(one_len, onestr.Length());
 
    const char* three = "three";
    intptr_t three_len = strlen(three);
    const String& threestr = String::Handle(String::New(three));
    EXPECT(threestr.IsOneByteString());
    EXPECT_EQ(three_len, threestr.Length());
 
    // Concat
 
    const String& str3 = String::Handle(String::Concat(onestr, threestr));
    EXPECT(str3.IsOneByteString());
    const char* one_three = "onethree";
    EXPECT(str3.Equals(one_three));
 
    const String& str4 = String::Handle(String::Concat(threestr, onestr));
    EXPECT(str4.IsOneByteString());
    const char* three_one = "threeone";
    intptr_t three_one_len = strlen(three_one);
    EXPECT_EQ(three_one_len, str4.Length());
    EXPECT(str4.Equals(three_one));
 
    // ConcatAll
 
    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, onestr);
    array1.SetAt(1, threestr);
    const String& str5 = String::Handle(String::ConcatAll(array1));
    EXPECT(str5.IsOneByteString());
    intptr_t one_three_len = strlen(one_three);
    EXPECT_EQ(one_three_len, str5.Length());
    EXPECT(str5.Equals(one_three));
 
    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, threestr);
    array2.SetAt(1, onestr);
    const String& str6 = String::Handle(String::ConcatAll(array2));
    EXPECT(str6.IsOneByteString());
    EXPECT_EQ(three_one_len, str6.Length());
    EXPECT(str6.Equals(three_one));
 
    const Array& array3 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array3.Length());
    array3.SetAt(0, onestr);
    array3.SetAt(1, threestr);
    array3.SetAt(2, onestr);
    const String& str7 = String::Handle(String::ConcatAll(array3));
    EXPECT(str7.IsOneByteString());
    const char* one_three_one = "onethreeone";
    intptr_t one_three_one_len = strlen(one_three_one);
    EXPECT_EQ(one_three_one_len, str7.Length());
    EXPECT(str7.Equals(one_three_one));
 
    const Array& array4 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array4.Length());
    array4.SetAt(0, threestr);
    array4.SetAt(1, onestr);
    array4.SetAt(2, threestr);
    const String& str8 = String::Handle(String::ConcatAll(array4));
    EXPECT(str8.IsOneByteString());
    const char* three_one_three = "threeonethree";
    intptr_t three_one_three_len = strlen(three_one_three);
    EXPECT_EQ(three_one_three_len, str8.Length());
    EXPECT(str8.Equals(three_one_three));
  }
 
  // Concatenate empty and non-empty 2-byte strings.
  {
    const String& str1 = String::Handle(String::New(""));
    EXPECT(str1.IsOneByteString());
    EXPECT_EQ(0, str1.Length());
 
    uint16_t two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
    intptr_t two_len = sizeof(two) / sizeof(two[0]);
    const String& str2 = String::Handle(String::FromUTF16(two, two_len));
    EXPECT(str2.IsTwoByteString());
    EXPECT_EQ(two_len, str2.Length());
 
    // Concat
 
    const String& str3 = String::Handle(String::Concat(str1, str2));
    EXPECT(str3.IsTwoByteString());
    EXPECT_EQ(two_len, str3.Length());
    EXPECT(str3.Equals(str2));
 
    const String& str4 = String::Handle(String::Concat(str2, str1));
    EXPECT(str4.IsTwoByteString());
    EXPECT_EQ(two_len, str4.Length());
    EXPECT(str4.Equals(str2));
 
    // ConcatAll
 
    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, str1);
    array1.SetAt(1, str2);
    const String& str5 = String::Handle(String::ConcatAll(array1));
    EXPECT(str5.IsTwoByteString());
    EXPECT_EQ(two_len, str5.Length());
    EXPECT(str5.Equals(str2));
 
    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, str1);
    array2.SetAt(1, str2);
    const String& str6 = String::Handle(String::ConcatAll(array2));
    EXPECT(str6.IsTwoByteString());
    EXPECT_EQ(two_len, str6.Length());
    EXPECT(str6.Equals(str2));
 
    const Array& array3 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array3.Length());
    array3.SetAt(0, str2);
    array3.SetAt(1, str1);
    array3.SetAt(2, str2);
    const String& str7 = String::Handle(String::ConcatAll(array3));
    EXPECT(str7.IsTwoByteString());
    EXPECT_EQ(two_len * 2, str7.Length());
    uint16_t twotwo[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
                         0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
    intptr_t twotwo_len = sizeof(twotwo) / sizeof(twotwo[0]);
    EXPECT(str7.IsTwoByteString());
    EXPECT(str7.Equals(twotwo, twotwo_len));
  }
 
  // Concatenating non-empty 2-byte strings.
  {
    const uint16_t one[] = {0x05D0, 0x05D9, 0x05D9, 0x05DF};
    intptr_t one_len = sizeof(one) / sizeof(one[0]);
    const String& str1 = String::Handle(String::FromUTF16(one, one_len));
    EXPECT(str1.IsTwoByteString());
    EXPECT_EQ(one_len, str1.Length());
 
    const uint16_t two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
    intptr_t two_len = sizeof(two) / sizeof(two[0]);
    const String& str2 = String::Handle(String::FromUTF16(two, two_len));
    EXPECT(str2.IsTwoByteString());
    EXPECT_EQ(two_len, str2.Length());
 
    // Concat
 
    const String& one_two_str = String::Handle(String::Concat(str1, str2));
    EXPECT(one_two_str.IsTwoByteString());
    const uint16_t one_two[] = {0x05D0, 0x05D9, 0x05D9, 0x05DF, 0x05E6,
                                0x05D5, 0x05D5, 0x05D9, 0x05D9};
    intptr_t one_two_len = sizeof(one_two) / sizeof(one_two[0]);
    EXPECT_EQ(one_two_len, one_two_str.Length());
    EXPECT(one_two_str.Equals(one_two, one_two_len));
 
    const String& two_one_str = String::Handle(String::Concat(str2, str1));
    EXPECT(two_one_str.IsTwoByteString());
    const uint16_t two_one[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
                                0x05D0, 0x05D9, 0x05D9, 0x05DF};
    intptr_t two_one_len = sizeof(two_one) / sizeof(two_one[0]);
    EXPECT_EQ(two_one_len, two_one_str.Length());
    EXPECT(two_one_str.Equals(two_one, two_one_len));
 
    // ConcatAll
 
    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, str1);
    array1.SetAt(1, str2);
    const String& str3 = String::Handle(String::ConcatAll(array1));
    EXPECT(str3.IsTwoByteString());
    EXPECT_EQ(one_two_len, str3.Length());
    EXPECT(str3.Equals(one_two, one_two_len));
 
    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, str2);
    array2.SetAt(1, str1);
    const String& str4 = String::Handle(String::ConcatAll(array2));
    EXPECT(str4.IsTwoByteString());
    EXPECT_EQ(two_one_len, str4.Length());
    EXPECT(str4.Equals(two_one, two_one_len));
 
    const Array& array3 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array3.Length());
    array3.SetAt(0, str1);
    array3.SetAt(1, str2);
    array3.SetAt(2, str1);
    const String& str5 = String::Handle(String::ConcatAll(array3));
    EXPECT(str5.IsTwoByteString());
    const uint16_t one_two_one[] = {0x05D0, 0x05D9, 0x05D9, 0x05DF, 0x05E6,
                                    0x05D5, 0x05D5, 0x05D9, 0x05D9, 0x05D0,
                                    0x05D9, 0x05D9, 0x05DF};
    intptr_t one_two_one_len = sizeof(one_two_one) / sizeof(one_two_one[0]);
    EXPECT_EQ(one_two_one_len, str5.Length());
    EXPECT(str5.Equals(one_two_one, one_two_one_len));
 
    const Array& array4 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array4.Length());
    array4.SetAt(0, str2);
    array4.SetAt(1, str1);
    array4.SetAt(2, str2);
    const String& str6 = String::Handle(String::ConcatAll(array4));
    EXPECT(str6.IsTwoByteString());
    const uint16_t two_one_two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
                                    0x05D0, 0x05D9, 0x05D9, 0x05DF, 0x05E6,
                                    0x05D5, 0x05D5, 0x05D9, 0x05D9};
    intptr_t two_one_two_len = sizeof(two_one_two) / sizeof(two_one_two[0]);
    EXPECT_EQ(two_one_two_len, str6.Length());
    EXPECT(str6.Equals(two_one_two, two_one_two_len));
  }
 
  // Concatenated empty and non-empty strings built from 4-byte elements.
  {
    const String& str1 = String::Handle(String::New(""));
    EXPECT(str1.IsOneByteString());
    EXPECT_EQ(0, str1.Length());
 
    int32_t four[] = {0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1};
    intptr_t four_len = sizeof(four) / sizeof(four[0]);
    intptr_t expected_len = (four_len * 2);
    const String& str2 = String::Handle(String::FromUTF32(four, four_len));
    EXPECT(str2.IsTwoByteString());
    EXPECT_EQ(expected_len, str2.Length());
 
    // Concat
 
    const String& str3 = String::Handle(String::Concat(str1, str2));
    EXPECT_EQ(expected_len, str3.Length());
    EXPECT(str3.Equals(str2));
 
    const String& str4 = String::Handle(String::Concat(str2, str1));
    EXPECT(str4.IsTwoByteString());
    EXPECT_EQ(expected_len, str4.Length());
    EXPECT(str4.Equals(str2));
 
    // ConcatAll
 
    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, str1);
    array1.SetAt(1, str2);
    const String& str5 = String::Handle(String::ConcatAll(array1));
    EXPECT(str5.IsTwoByteString());
    EXPECT_EQ(expected_len, str5.Length());
    EXPECT(str5.Equals(str2));
 
    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, str1);
    array2.SetAt(1, str2);
    const String& str6 = String::Handle(String::ConcatAll(array2));
    EXPECT(str6.IsTwoByteString());
    EXPECT_EQ(expected_len, str6.Length());
    EXPECT(str6.Equals(str2));
 
    const Array& array3 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array3.Length());
    array3.SetAt(0, str2);
    array3.SetAt(1, str1);
    array3.SetAt(2, str2);
    const String& str7 = String::Handle(String::ConcatAll(array3));
    EXPECT(str7.IsTwoByteString());
    int32_t fourfour[] = {0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1,
                          0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1};
    intptr_t fourfour_len = sizeof(fourfour) / sizeof(fourfour[0]);
    EXPECT_EQ((fourfour_len * 2), str7.Length());
    const String& fourfour_str =
        String::Handle(String::FromUTF32(fourfour, fourfour_len));
    EXPECT(str7.Equals(fourfour_str));
  }
 
  // Concatenate non-empty strings built from 4-byte elements.
  {
    const int32_t one[] = {0x105D0, 0x105D9, 0x105D9, 0x105DF};
    intptr_t one_len = sizeof(one) / sizeof(one[0]);
    const String& onestr = String::Handle(String::FromUTF32(one, one_len));
    EXPECT(onestr.IsTwoByteString());
    EXPECT_EQ((one_len * 2), onestr.Length());
 
    const int32_t two[] = {0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9};
    intptr_t two_len = sizeof(two) / sizeof(two[0]);
    const String& twostr = String::Handle(String::FromUTF32(two, two_len));
    EXPECT(twostr.IsTwoByteString());
    EXPECT_EQ((two_len * 2), twostr.Length());
 
    // Concat
 
    const String& str1 = String::Handle(String::Concat(onestr, twostr));
    EXPECT(str1.IsTwoByteString());
    const int32_t one_two[] = {0x105D0, 0x105D9, 0x105D9, 0x105DF, 0x105E6,
                               0x105D5, 0x105D5, 0x105D9, 0x105D9};
    intptr_t one_two_len = sizeof(one_two) / sizeof(one_two[0]);
    EXPECT_EQ((one_two_len * 2), str1.Length());
    const String& one_two_str =
        String::Handle(String::FromUTF32(one_two, one_two_len));
    EXPECT(str1.Equals(one_two_str));
 
    const String& str2 = String::Handle(String::Concat(twostr, onestr));
    EXPECT(str2.IsTwoByteString());
    const int32_t two_one[] = {0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9,
                               0x105D0, 0x105D9, 0x105D9, 0x105DF};
    intptr_t two_one_len = sizeof(two_one) / sizeof(two_one[0]);
    EXPECT_EQ((two_one_len * 2), str2.Length());
    const String& two_one_str =
        String::Handle(String::FromUTF32(two_one, two_one_len));
    EXPECT(str2.Equals(two_one_str));
 
    // ConcatAll
 
    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, onestr);
    array1.SetAt(1, twostr);
    const String& str3 = String::Handle(String::ConcatAll(array1));
    EXPECT(str3.IsTwoByteString());
    EXPECT_EQ((one_two_len * 2), str3.Length());
    EXPECT(str3.Equals(one_two_str));
 
    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, twostr);
    array2.SetAt(1, onestr);
    const String& str4 = String::Handle(String::ConcatAll(array2));
    EXPECT(str4.IsTwoByteString());
    EXPECT_EQ((two_one_len * 2), str4.Length());
    EXPECT(str4.Equals(two_one_str));
 
    const Array& array3 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array3.Length());
    array3.SetAt(0, onestr);
    array3.SetAt(1, twostr);
    array3.SetAt(2, onestr);
    const String& str5 = String::Handle(String::ConcatAll(array3));
    EXPECT(str5.IsTwoByteString());
    const int32_t one_two_one[] = {0x105D0, 0x105D9, 0x105D9, 0x105DF, 0x105E6,
                                   0x105D5, 0x105D5, 0x105D9, 0x105D9, 0x105D0,
                                   0x105D9, 0x105D9, 0x105DF};
    intptr_t one_two_one_len = sizeof(one_two_one) / sizeof(one_two_one[0]);
    EXPECT_EQ((one_two_one_len * 2), str5.Length());
    const String& one_two_one_str =
        String::Handle(String::FromUTF32(one_two_one, one_two_one_len));
    EXPECT(str5.Equals(one_two_one_str));
 
    const Array& array4 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array4.Length());
    array4.SetAt(0, twostr);
    array4.SetAt(1, onestr);
    array4.SetAt(2, twostr);
    const String& str6 = String::Handle(String::ConcatAll(array4));
    EXPECT(str6.IsTwoByteString());
    const int32_t two_one_two[] = {0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9,
                                   0x105D0, 0x105D9, 0x105D9, 0x105DF, 0x105E6,
                                   0x105D5, 0x105D5, 0x105D9, 0x105D9};
    intptr_t two_one_two_len = sizeof(two_one_two) / sizeof(two_one_two[0]);
    EXPECT_EQ((two_one_two_len * 2), str6.Length());
    const String& two_one_two_str =
        String::Handle(String::FromUTF32(two_one_two, two_one_two_len));
    EXPECT(str6.Equals(two_one_two_str));
  }
 
  // Concatenate 1-byte strings and 2-byte strings.
  {
    const uint8_t one[] = {'o', 'n', 'e', ' ', 'b', 'y', 't', 'e'};
    intptr_t one_len = sizeof(one) / sizeof(one[0]);
    const String& onestr = String::Handle(String::FromLatin1(one, one_len));
    EXPECT(onestr.IsOneByteString());
    EXPECT_EQ(one_len, onestr.Length());
    EXPECT(onestr.EqualsLatin1(one, one_len));
 
    uint16_t two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
    intptr_t two_len = sizeof(two) / sizeof(two[0]);
    const String& twostr = String::Handle(String::FromUTF16(two, two_len));
    EXPECT(twostr.IsTwoByteString());
    EXPECT_EQ(two_len, twostr.Length());
    EXPECT(twostr.Equals(two, two_len));
 
    // Concat
 
    const String& one_two_str = String::Handle(String::Concat(onestr, twostr));
    EXPECT(one_two_str.IsTwoByteString());
    uint16_t one_two[] = {'o', 'n',    'e',    ' ',    'b',    'y',   't',
                          'e', 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
    intptr_t one_two_len = sizeof(one_two) / sizeof(one_two[0]);
    EXPECT_EQ(one_two_len, one_two_str.Length());
    EXPECT(one_two_str.Equals(one_two, one_two_len));
 
    const String& two_one_str = String::Handle(String::Concat(twostr, onestr));
    EXPECT(two_one_str.IsTwoByteString());
    uint16_t two_one[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9, 'o', 'n',
                          'e',    ' ',    'b',    'y',    't',    'e'};
    intptr_t two_one_len = sizeof(two_one) / sizeof(two_one[0]);
    EXPECT_EQ(two_one_len, two_one_str.Length());
    EXPECT(two_one_str.Equals(two_one, two_one_len));
 
    // ConcatAll
 
    const Array& array1 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array1.Length());
    array1.SetAt(0, onestr);
    array1.SetAt(1, twostr);
    array1.SetAt(2, onestr);
    const String& one_two_one_str = String::Handle(String::ConcatAll(array1));
    EXPECT(one_two_one_str.IsTwoByteString());
    EXPECT_EQ(onestr.Length() * 2 + twostr.Length(), one_two_one_str.Length());
    uint16_t one_two_one[] = {'o', 'n',    'e',    ' ',    'b',    'y',    't',
                              'e', 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9, 'o',
                              'n', 'e',    ' ',    'b',    'y',    't',    'e'};
    intptr_t one_two_one_len = sizeof(one_two_one) / sizeof(one_two_one[0]);
    EXPECT(one_two_one_str.Equals(one_two_one, one_two_one_len));
 
    const Array& array2 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array2.Length());
    array2.SetAt(0, twostr);
    array2.SetAt(1, onestr);
    array2.SetAt(2, twostr);
    const String& two_one_two_str = String::Handle(String::ConcatAll(array2));
    EXPECT(two_one_two_str.IsTwoByteString());
    EXPECT_EQ(twostr.Length() * 2 + onestr.Length(), two_one_two_str.Length());
    uint16_t two_one_two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9, 'o',
                              'n',    'e',    ' ',    'b',    'y',    't',
                              'e',    0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
    intptr_t two_one_two_len = sizeof(two_one_two) / sizeof(two_one_two[0]);
    EXPECT(two_one_two_str.Equals(two_one_two, two_one_two_len));
  }
}

ISOLATE_UNIT_TEST_CASE() [387/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringDecodeIRI

)

Definition at line 472 of file object_test.cc.

                                        {
  const char* kOutput =
      "file:///usr/local/johnmccutchan/workspace/dart-repo/dart/test.dart";
  const char* kInput =
      "file%3A%2F%2F%2Fusr%2Flocal%2Fjohnmccutchan%2Fworkspace%2F"
      "dart-repo%2Fdart%2Ftest.dart";
  const String& input = String::Handle(String::New(kInput));
  const String& output = String::Handle(String::New(kOutput));
  const String& decoded = String::Handle(String::DecodeIRI(input));
  EXPECT(output.Equals(decoded));
}

ISOLATE_UNIT_TEST_CASE() [388/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringDecodeIRIInvalid

)

Definition at line 484 of file object_test.cc.

                                               {
  String& input = String::Handle();
  input = String::New("file%");
  String& decoded = String::Handle();
  decoded = String::DecodeIRI(input);
  EXPECT(decoded.IsNull());
  input = String::New("file%3");
  decoded = String::DecodeIRI(input);
  EXPECT(decoded.IsNull());
  input = String::New("file%3g");
  decoded = String::DecodeIRI(input);
  EXPECT(decoded.IsNull());
}

ISOLATE_UNIT_TEST_CASE() [389/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringEncodeIRI

)

Definition at line 461 of file object_test.cc.

                                        {
  const char* kInput =
      "file:///usr/local/johnmccutchan/workspace/dart-repo/dart/test.dart";
  const char* kOutput =
      "file%3A%2F%2F%2Fusr%2Flocal%2Fjohnmccutchan%2Fworkspace%2F"
      "dart-repo%2Fdart%2Ftest.dart";
  const String& input = String::Handle(String::New(kInput));
  const char* encoded = String::EncodeIRI(input);
  EXPECT(strcmp(encoded, kOutput) == 0);
}

ISOLATE_UNIT_TEST_CASE() [390/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringEqualsUTF32

)

Definition at line 1629 of file object_test.cc.

                                          {
  const String& empty = String::Handle(String::New(""));
  const String& t_str = String::Handle(String::New("t"));
  const String& th_str = String::Handle(String::New("th"));
  const int32_t chars[] = {'t', 'h', 'i', 's'};
  EXPECT(!empty.Equals(chars, -1));
  EXPECT(empty.Equals(chars, 0));
  EXPECT(!empty.Equals(chars, 1));
  EXPECT(!t_str.Equals(chars, 0));
  EXPECT(t_str.Equals(chars, 1));
  EXPECT(!t_str.Equals(chars, 2));
  EXPECT(!th_str.Equals(chars, 1));
  EXPECT(th_str.Equals(chars, 2));
  EXPECT(!th_str.Equals(chars, 3));
}

ISOLATE_UNIT_TEST_CASE() [391/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringEqualsUtf8

)

Definition at line 1598 of file object_test.cc.

                                         {
  const char* onesrc = "abc";
  const String& onestr = String::Handle(String::New(onesrc));
  EXPECT(onestr.IsOneByteString());
  EXPECT(!onestr.Equals(""));
  EXPECT(!onestr.Equals("a"));
  EXPECT(!onestr.Equals("ab"));
  EXPECT(onestr.Equals("abc"));
  EXPECT(!onestr.Equals("abcd"));
 
  const char* twosrc = "\xD7\x90\xD7\x91\xD7\x92";
  const String& twostr = String::Handle(String::New(twosrc));
  EXPECT(twostr.IsTwoByteString());
  EXPECT(!twostr.Equals(""));
  EXPECT(!twostr.Equals("\xD7\x90"));
  EXPECT(!twostr.Equals("\xD7\x90\xD7\x91"));
  EXPECT(twostr.Equals("\xD7\x90\xD7\x91\xD7\x92"));
  EXPECT(!twostr.Equals("\xD7\x90\xD7\x91\xD7\x92\xD7\x93"));
 
  const char* foursrc = "\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1\xF0\x90\x8E\xA2";
  const String& fourstr = String::Handle(String::New(foursrc));
  EXPECT(fourstr.IsTwoByteString());
  EXPECT(!fourstr.Equals(""));
  EXPECT(!fourstr.Equals("\xF0\x90\x8E\xA0"));
  EXPECT(!fourstr.Equals("\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1"));
  EXPECT(fourstr.Equals("\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1\xF0\x90\x8E\xA2"));
  EXPECT(
      !fourstr.Equals("\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1"
                      "\xF0\x90\x8E\xA2\xF0\x90\x8E\xA3"));
}

ISOLATE_UNIT_TEST_CASE() [392/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringFormat

)

Definition at line 822 of file object_test.cc.

                                     {
  const char* hello_str = "Hello World!";
  const String& str =
      String::Handle(String::NewFormatted("Hello %s!", "World"));
  EXPECT(str.IsInstance());
  EXPECT(str.IsString());
  EXPECT(str.IsOneByteString());
  EXPECT(!str.IsTwoByteString());
  EXPECT(!str.IsNumber());
  EXPECT(str.Equals(hello_str));
}

ISOLATE_UNIT_TEST_CASE() [393/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringFromUtf8Literal

)

Definition at line 1439 of file object_test.cc.

                                              {
  // Create a 1-byte string from a UTF-8 encoded string literal.
  {
    const char* src =
        "\xC2\xA0\xC2\xA1\xC2\xA2\xC2\xA3"
        "\xC2\xA4\xC2\xA5\xC2\xA6\xC2\xA7"
        "\xC2\xA8\xC2\xA9\xC2\xAA\xC2\xAB"
        "\xC2\xAC\xC2\xAD\xC2\xAE\xC2\xAF"
        "\xC2\xB0\xC2\xB1\xC2\xB2\xC2\xB3"
        "\xC2\xB4\xC2\xB5\xC2\xB6\xC2\xB7"
        "\xC2\xB8\xC2\xB9\xC2\xBA\xC2\xBB"
        "\xC2\xBC\xC2\xBD\xC2\xBE\xC2\xBF"
        "\xC3\x80\xC3\x81\xC3\x82\xC3\x83"
        "\xC3\x84\xC3\x85\xC3\x86\xC3\x87"
        "\xC3\x88\xC3\x89\xC3\x8A\xC3\x8B"
        "\xC3\x8C\xC3\x8D\xC3\x8E\xC3\x8F"
        "\xC3\x90\xC3\x91\xC3\x92\xC3\x93"
        "\xC3\x94\xC3\x95\xC3\x96\xC3\x97"
        "\xC3\x98\xC3\x99\xC3\x9A\xC3\x9B"
        "\xC3\x9C\xC3\x9D\xC3\x9E\xC3\x9F"
        "\xC3\xA0\xC3\xA1\xC3\xA2\xC3\xA3"
        "\xC3\xA4\xC3\xA5\xC3\xA6\xC3\xA7"
        "\xC3\xA8\xC3\xA9\xC3\xAA\xC3\xAB"
        "\xC3\xAC\xC3\xAD\xC3\xAE\xC3\xAF"
        "\xC3\xB0\xC3\xB1\xC3\xB2\xC3\xB3"
        "\xC3\xB4\xC3\xB5\xC3\xB6\xC3\xB7"
        "\xC3\xB8\xC3\xB9\xC3\xBA\xC3\xBB"
        "\xC3\xBC\xC3\xBD\xC3\xBE\xC3\xBF";
    const uint8_t expected[] = {
        0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB,
        0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
        0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3,
        0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
        0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB,
        0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
        0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3,
        0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
    };
    const String& str = String::Handle(String::New(src));
    EXPECT(str.IsOneByteString());
    intptr_t expected_length = sizeof(expected);
    EXPECT_EQ(expected_length, str.Length());
    for (int i = 0; i < str.Length(); ++i) {
      EXPECT_EQ(expected[i], str.CharAt(i));
    }
  }
 
  // Create a 2-byte string from a UTF-8 encoded string literal.
  {
    const char* src =
        "\xD7\x92\xD7\x9C\xD7\xA2\xD7\x93"
        "\xD7\x91\xD7\xA8\xD7\x9B\xD7\x94";
    const uint16_t expected[] = {0x5D2, 0x5DC, 0x5E2, 0x5D3,
                                 0x5D1, 0x5E8, 0x5DB, 0x5D4};
    const String& str = String::Handle(String::New(src));
    EXPECT(str.IsTwoByteString());
    intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
    EXPECT_EQ(expected_size, str.Length());
    for (int i = 0; i < str.Length(); ++i) {
      EXPECT_EQ(expected[i], str.CharAt(i));
    }
  }
 
  // Create a BMP 2-byte string from UTF-8 encoded 1- and 2-byte
  // characters.
  {
    const char* src =
        "\x0A\x0B\x0D\x0C\x0E\x0F\xC2\xA0"
        "\xC2\xB0\xC3\x80\xC3\x90\xC3\xA0"
        "\xC3\xB0\xE0\xA8\x80\xE0\xAC\x80"
        "\xE0\xB0\x80\xE0\xB4\x80\xE0\xB8"
        "\x80\xE0\xBC\x80\xEA\x80\x80\xEB"
        "\x80\x80\xEC\x80\x80\xED\x80\x80"
        "\xEE\x80\x80\xEF\x80\x80";
    const intptr_t expected[] = {
        0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0,
        0x00C0, 0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00,
        0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000};
    const String& str = String::Handle(String::New(src));
    EXPECT(str.IsTwoByteString());
    intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
    EXPECT_EQ(expected_size, str.Length());
    for (int i = 0; i < str.Length(); ++i) {
      EXPECT_EQ(expected[i], str.CharAt(i));
    }
  }
 
  // Create a 2-byte string with supplementary characters from a UTF-8
  // string literal.
  {
    const char* src =
        "\xF0\x9D\x91\xA0\xF0\x9D\x91\xA1"
        "\xF0\x9D\x91\xA2\xF0\x9D\x91\xA3";
    const intptr_t expected[] = {0xd835, 0xdc60, 0xd835, 0xdc61,
                                 0xd835, 0xdc62, 0xd835, 0xdc63};
    const String& str = String::Handle(String::New(src));
    EXPECT(str.IsTwoByteString());
    intptr_t expected_size = (sizeof(expected) / sizeof(expected[0]));
    EXPECT_EQ(expected_size, str.Length());
    for (int i = 0; i < str.Length(); ++i) {
      EXPECT_EQ(expected[i], str.CharAt(i));
    }
  }
 
  // Create a 2-byte string from UTF-8 encoded 2- and 4-byte
  // characters.
  {
    const char* src =
        "\xE0\xA8\x80\xE0\xAC\x80\xE0\xB0"
        "\x80\xE0\xB4\x80\xE0\xB8\x80\xE0"
        "\xBC\x80\xEA\x80\x80\xEB\x80\x80"
        "\xEC\x80\x80\xED\x80\x80\xEE\x80"
        "\x80\xEF\x80\x80\xF0\x9A\x80\x80"
        "\xF0\x9B\x80\x80\xF0\x9D\x80\x80"
        "\xF0\x9E\x80\x80\xF0\x9F\x80\x80";
    const intptr_t expected[] = {
        0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00, 0xA000, 0xB000,
        0xC000, 0xD000, 0xE000, 0xF000, 0xD828, 0xDC00, 0xD82c, 0xDC00,
        0xD834, 0xDC00, 0xD838, 0xDC00, 0xD83c, 0xDC00,
    };
    const String& str = String::Handle(String::New(src));
    EXPECT(str.IsTwoByteString());
    intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
    EXPECT_EQ(expected_size, str.Length());
    for (int i = 0; i < str.Length(); ++i) {
      EXPECT_EQ(expected[i], str.CharAt(i));
    }
  }
 
  // Create a 2-byte string from UTF-8 encoded 1-, 2- and 4-byte
  // characters.
  {
    const char* src =
        "\x0A\x0B\x0D\x0C\x0E\x0F\xC2\xA0"
        "\xC2\xB0\xC3\x80\xC3\x90\xC3\xA0"
        "\xC3\xB0\xE0\xA8\x80\xE0\xAC\x80"
        "\xE0\xB0\x80\xE0\xB4\x80\xE0\xB8"
        "\x80\xE0\xBC\x80\xEA\x80\x80\xEB"
        "\x80\x80\xEC\x80\x80\xED\x80\x80"
        "\xEE\x80\x80\xEF\x80\x80\xF0\x9A"
        "\x80\x80\xF0\x9B\x80\x80\xF0\x9D"
        "\x80\x80\xF0\x9E\x80\x80\xF0\x9F"
        "\x80\x80";
    const intptr_t expected[] = {
        0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0, 0x00C0,
        0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00,
        0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000, 0xD828, 0xDC00, 0xD82c,
        0xDC00, 0xD834, 0xDC00, 0xD838, 0xDC00, 0xD83c, 0xDC00,
    };
    const String& str = String::Handle(String::New(src));
    EXPECT(str.IsTwoByteString());
    intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
    EXPECT_EQ(expected_size, str.Length());
    for (int i = 0; i < str.Length(); ++i) {
      EXPECT_EQ(expected[i], str.CharAt(i));
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [394/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringHashConcat

)

Definition at line 1364 of file object_test.cc.

                                         {
  EXPECT_EQ(String::Handle(String::New("onebyte")).Hash(),
            String::HashConcat(String::Handle(String::New("one")),
                               String::Handle(String::New("byte"))));
  uint16_t clef_utf16[] = {0xD834, 0xDD1E};
  const String& clef = String::Handle(String::FromUTF16(clef_utf16, 2));
  int32_t clef_utf32[] = {0x1D11E};
  EXPECT(clef.Equals(clef_utf32, 1));
  uword hash32 = String::Hash(String::FromUTF32(clef_utf32, 1));
  EXPECT_EQ(hash32, clef.Hash());
  EXPECT_EQ(hash32, String::HashConcat(
                        String::Handle(String::FromUTF16(clef_utf16, 1)),
                        String::Handle(String::FromUTF16(clef_utf16 + 1, 1))));
}

ISOLATE_UNIT_TEST_CASE() [395/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringIRITwoByte

)

Definition at line 498 of file object_test.cc.

                                         {
  const intptr_t kInputLen = 3;
  const uint16_t kInput[kInputLen] = {'x', '/', 256};
  const String& input = String::Handle(String::FromUTF16(kInput, kInputLen));
  const intptr_t kOutputLen = 10;
  const uint16_t kOutput[kOutputLen] = {'x', '%', '2', 'F', '%',
                                        'C', '4', '%', '8', '0'};
  const String& output = String::Handle(String::FromUTF16(kOutput, kOutputLen));
  const String& encoded = String::Handle(String::New(String::EncodeIRI(input)));
  EXPECT(output.Equals(encoded));
  const String& decoded = String::Handle(String::DecodeIRI(output));
  EXPECT(input.Equals(decoded));
}

ISOLATE_UNIT_TEST_CASE() [396/463]

dart::ISOLATE_UNIT_TEST_CASE

(

StringSubStringDifferentWidth

)

Definition at line 1379 of file object_test.cc.

                                                      {
  // Create 1-byte substring from a 1-byte source string.
  const char* onechars = "\xC3\xB6\xC3\xB1\xC3\xA9";
 
  const String& onestr = String::Handle(String::New(onechars));
  EXPECT(!onestr.IsNull());
  EXPECT(onestr.IsOneByteString());
  EXPECT(!onestr.IsTwoByteString());
 
  const String& onesub = String::Handle(String::SubString(onestr, 0));
  EXPECT(!onesub.IsNull());
  EXPECT(onestr.IsOneByteString());
  EXPECT(!onestr.IsTwoByteString());
  EXPECT_EQ(onesub.Length(), 3);
 
  // Create 1- and 2-byte substrings from a 2-byte source string.
  const char* twochars =
      "\x1f\x2f\x3f"
      "\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93";
 
  const String& twostr = String::Handle(String::New(twochars));
  EXPECT(!twostr.IsNull());
  EXPECT(twostr.IsTwoByteString());
 
  const String& twosub1 = String::Handle(String::SubString(twostr, 0, 3));
  EXPECT(!twosub1.IsNull());
  EXPECT(twosub1.IsOneByteString());
  EXPECT_EQ(twosub1.Length(), 3);
 
  const String& twosub2 = String::Handle(String::SubString(twostr, 3));
  EXPECT(!twosub2.IsNull());
  EXPECT(twosub2.IsTwoByteString());
  EXPECT_EQ(twosub2.Length(), 3);
 
  // Create substrings from a string built using 1-, 2- and 4-byte elements.
  const char* fourchars =
      "\x1f\x2f\x3f"
      "\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93"
      "\xF0\x9D\x96\xBF\xF0\x9D\x97\x88\xF0\x9D\x97\x8E\xF0\x9D\x97\x8B";
 
  const String& fourstr = String::Handle(String::New(fourchars));
  EXPECT(!fourstr.IsNull());
  EXPECT(fourstr.IsTwoByteString());
 
  const String& foursub1 = String::Handle(String::SubString(fourstr, 0, 3));
  EXPECT(!foursub1.IsNull());
  EXPECT(foursub1.IsOneByteString());
  EXPECT_EQ(foursub1.Length(), 3);
 
  const String& foursub2 = String::Handle(String::SubString(fourstr, 3, 3));
  EXPECT(!foursub2.IsNull());
  EXPECT(foursub2.IsTwoByteString());
  EXPECT_EQ(foursub2.Length(), 3);
 
  const String& foursub4 = String::Handle(String::SubString(fourstr, 6));
  EXPECT_EQ(foursub4.Length(), 8);
  EXPECT(!foursub4.IsNull());
  EXPECT(foursub4.IsTwoByteString());
}

ISOLATE_UNIT_TEST_CASE() [397/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SubtypeTestCache

)

Definition at line 3103 of file object_test.cc.

                                         {
  SafepointMutexLocker ml(thread->isolate_group()->subtype_test_cache_mutex());
 
  String& class1_name = String::Handle(Symbols::New(thread, "EmptyClass1"));
  Script& script = Script::Handle();
  const Class& empty_class1 =
      Class::Handle(CreateDummyClass(class1_name, script));
  String& class2_name = String::Handle(Symbols::New(thread, "EmptyClass2"));
  const Class& empty_class2 =
      Class::Handle(CreateDummyClass(class2_name, script));
  SubtypeTestCache& cache = SubtypeTestCache::Handle(
      SubtypeTestCache::New(SubtypeTestCache::kMaxInputs));
  EXPECT(!cache.IsNull());
  EXPECT_EQ(0, cache.NumberOfChecks());
  const Object& class_id_or_fun = Object::Handle(Smi::New(empty_class1.id()));
  const AbstractType& dest_type =
      AbstractType::Handle(Type::NewNonParameterizedType(empty_class2));
  const TypeArguments& targ_0 = TypeArguments::Handle(TypeArguments::New(2));
  const TypeArguments& targ_1 = TypeArguments::Handle(TypeArguments::New(3));
  const TypeArguments& targ_2 = TypeArguments::Handle(TypeArguments::New(4));
  const TypeArguments& targ_3 = TypeArguments::Handle(TypeArguments::New(5));
  const TypeArguments& targ_4 = TypeArguments::Handle(TypeArguments::New(6));
  cache.AddCheck(class_id_or_fun, dest_type, targ_0, targ_1, targ_2, targ_3,
                 targ_4, Bool::True());
  EXPECT_EQ(1, cache.NumberOfChecks());
  Object& test_class_id_or_fun = Object::Handle();
  AbstractType& test_dest_type = AbstractType::Handle();
  TypeArguments& test_targ_0 = TypeArguments::Handle();
  TypeArguments& test_targ_1 = TypeArguments::Handle();
  TypeArguments& test_targ_2 = TypeArguments::Handle();
  TypeArguments& test_targ_3 = TypeArguments::Handle();
  TypeArguments& test_targ_4 = TypeArguments::Handle();
  Bool& test_result = Bool::Handle();
  cache.GetCheck(0, &test_class_id_or_fun, &test_dest_type, &test_targ_0,
                 &test_targ_1, &test_targ_2, &test_targ_3, &test_targ_4,
                 &test_result);
  EXPECT_EQ(class_id_or_fun.ptr(), test_class_id_or_fun.ptr());
  EXPECT_EQ(dest_type.ptr(), test_dest_type.ptr());
  EXPECT_EQ(targ_0.ptr(), test_targ_0.ptr());
  EXPECT_EQ(targ_1.ptr(), test_targ_1.ptr());
  EXPECT_EQ(targ_2.ptr(), test_targ_2.ptr());
  EXPECT_EQ(targ_3.ptr(), test_targ_3.ptr());
  EXPECT_EQ(targ_4.ptr(), test_targ_4.ptr());
  EXPECT_EQ(Bool::True().ptr(), test_result.ptr());
}

ISOLATE_UNIT_TEST_CASE() [398/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Symbol

)

Definition at line 1686 of file object_test.cc.

                               {
  const String& one = String::Handle(Symbols::New(thread, "Eins"));
  EXPECT(one.IsSymbol());
  const String& two = String::Handle(Symbols::New(thread, "Zwei"));
  const String& three = String::Handle(Symbols::New(thread, "Drei"));
  const String& four = String::Handle(Symbols::New(thread, "Vier"));
  const String& five = String::Handle(Symbols::New(thread, "Fuenf"));
  const String& six = String::Handle(Symbols::New(thread, "Sechs"));
  const String& seven = String::Handle(Symbols::New(thread, "Sieben"));
  const String& eight = String::Handle(Symbols::New(thread, "Acht"));
  const String& nine = String::Handle(Symbols::New(thread, "Neun"));
  const String& ten = String::Handle(Symbols::New(thread, "Zehn"));
  String& eins = String::Handle(Symbols::New(thread, "Eins"));
  EXPECT_EQ(one.ptr(), eins.ptr());
  EXPECT(one.ptr() != two.ptr());
  EXPECT(two.Equals(String::Handle(String::New("Zwei"))));
  EXPECT_EQ(two.ptr(), Symbols::New(thread, "Zwei"));
  EXPECT_EQ(three.ptr(), Symbols::New(thread, "Drei"));
  EXPECT_EQ(four.ptr(), Symbols::New(thread, "Vier"));
  EXPECT_EQ(five.ptr(), Symbols::New(thread, "Fuenf"));
  EXPECT_EQ(six.ptr(), Symbols::New(thread, "Sechs"));
  EXPECT_EQ(seven.ptr(), Symbols::New(thread, "Sieben"));
  EXPECT_EQ(eight.ptr(), Symbols::New(thread, "Acht"));
  EXPECT_EQ(nine.ptr(), Symbols::New(thread, "Neun"));
  EXPECT_EQ(ten.ptr(), Symbols::New(thread, "Zehn"));
 
  // Make sure to cause symbol table overflow.
  for (int i = 0; i < 1024; i++) {
    char buf[256];
    Utils::SNPrint(buf, sizeof(buf), "%d", i);
    Symbols::New(thread, buf);
  }
  eins = Symbols::New(thread, "Eins");
  EXPECT_EQ(one.ptr(), eins.ptr());
  EXPECT_EQ(two.ptr(), Symbols::New(thread, "Zwei"));
  EXPECT_EQ(three.ptr(), Symbols::New(thread, "Drei"));
  EXPECT_EQ(four.ptr(), Symbols::New(thread, "Vier"));
  EXPECT_EQ(five.ptr(), Symbols::New(thread, "Fuenf"));
  EXPECT_EQ(six.ptr(), Symbols::New(thread, "Sechs"));
  EXPECT_EQ(seven.ptr(), Symbols::New(thread, "Sieben"));
  EXPECT_EQ(eight.ptr(), Symbols::New(thread, "Acht"));
  EXPECT_EQ(nine.ptr(), Symbols::New(thread, "Neun"));
  EXPECT_EQ(ten.ptr(), Symbols::New(thread, "Zehn"));
 
  // Symbols from Strings.
  eins = String::New("Eins");
  EXPECT(!eins.IsSymbol());
  String& ein_symbol = String::Handle(Symbols::New(thread, eins));
  EXPECT_EQ(one.ptr(), ein_symbol.ptr());
  EXPECT(one.ptr() != eins.ptr());
 
  uint16_t char16[] = {'E', 'l', 'f'};
  String& elf1 = String::Handle(Symbols::FromUTF16(thread, char16, 3));
  int32_t char32[] = {'E', 'l', 'f'};
  String& elf2 = String::Handle(
      Symbols::New(thread, String::Handle(String::FromUTF32(char32, 3))));
  EXPECT(elf1.IsSymbol());
  EXPECT(elf2.IsSymbol());
  EXPECT_EQ(elf1.ptr(), Symbols::New(thread, "Elf"));
  EXPECT_EQ(elf2.ptr(), Symbols::New(thread, "Elf"));
}

ISOLATE_UNIT_TEST_CASE() [399/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Symbols_FromConcatAll

)

Definition at line 7308 of file object_test.cc.

                              {
    pieces.Add(*data[i]);
    array.SetAt(i, *data[i]);
  }
  const String& res1 =
      String::Handle(zone, Symbols::FromConcatAll(thread, pieces));
  const String& res2 = String::Handle(zone, String::ConcatAll(array));
  EXPECT(res1.Equals(res2));
}
 
ISOLATE_UNIT_TEST_CASE(Symbols_FromConcatAll) {
  {
    const String* data[3] = {&Symbols::TypeError(), &Symbols::Dot(),
                             &Symbols::isPaused()};
    CheckConcatAll(data, 3);
  }
 
  {
    const intptr_t kWideCharsLen = 7;
    uint16_t wide_chars[kWideCharsLen] = {'H', 'e', 'l', 'l', 'o', 256, '!'};
    const String& two_str =
        String::Handle(String::FromUTF16(wide_chars, kWideCharsLen));
 

ISOLATE_UNIT_TEST_CASE() [400/463]

dart::ISOLATE_UNIT_TEST_CASE

(

SymbolUnicode

)

Definition at line 1748 of file object_test.cc.

                                      {
  uint16_t monkey_utf16[] = {0xd83d, 0xdc35};  // Unicode Monkey Face.
  String& monkey = String::Handle(Symbols::FromUTF16(thread, monkey_utf16, 2));
  EXPECT(monkey.IsSymbol());
  const char monkey_utf8[] = {'\xf0', '\x9f', '\x90', '\xb5', 0};
  EXPECT_EQ(monkey.ptr(), Symbols::New(thread, monkey_utf8));
 
  int32_t kMonkeyFace = 0x1f435;
  String& monkey2 = String::Handle(
      Symbols::New(thread, String::Handle(String::FromUTF32(&kMonkeyFace, 1))));
  EXPECT_EQ(monkey.ptr(), monkey2.ptr());
 
  // Unicode cat face with tears of joy.
  int32_t kCatFaceWithTearsOfJoy = 0x1f639;
  String& cat = String::Handle(Symbols::New(
      thread, String::Handle(String::FromUTF32(&kCatFaceWithTearsOfJoy, 1))));
 
  uint16_t cat_utf16[] = {0xd83d, 0xde39};
  String& cat2 = String::Handle(Symbols::FromUTF16(thread, cat_utf16, 2));
  EXPECT(cat2.IsSymbol());
  EXPECT_EQ(cat2.ptr(), cat.ptr());
}

ISOLATE_UNIT_TEST_CASE() [401/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ThreadIterator_Count

)

Definition at line 701 of file thread_test.cc.

                                             {
  intptr_t thread_count_0 = 0;
  intptr_t thread_count_1 = 0;
 
  {
    OSThreadIterator ti;
    while (ti.HasNext()) {
      OSThread* thread = ti.Next();
      EXPECT(thread != nullptr);
      thread_count_0++;
    }
  }
 
  {
    OSThreadIterator ti;
    while (ti.HasNext()) {
      OSThread* thread = ti.Next();
      EXPECT(thread != nullptr);
      thread_count_1++;
    }
  }
 
  EXPECT(thread_count_0 > 0);
  EXPECT(thread_count_1 > 0);
  EXPECT(thread_count_0 >= thread_count_1);
}

ISOLATE_UNIT_TEST_CASE() [402/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ThreadIterator_FindSelf

)

Definition at line 728 of file thread_test.cc.

                                                {
  OSThread* current = OSThread::Current();
  EXPECT(OSThread::IsThreadInList(current->id()));
}

ISOLATE_UNIT_TEST_CASE() [403/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ToCString

)

Definition at line 5874 of file object_test.cc.

                                               {
      return;
    }
    objects_->Add(&handle);
  }
 
 private:
  GrowableArray<Object*>* objects_;
};
 
ISOLATE_UNIT_TEST_CASE(ToCString) {
  // Set native resolvers in case we need to read native methods.
  {
    TransitionVMToNative transition(thread);
    bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
    bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
    bin::Builtin::SetNativeResolver(bin::Builtin::kCLILibrary);
    bin::VmService::SetNativeResolver();
  }
 
  GCTestHelper::CollectAllGarbage();
  GrowableArray<Object*> objects;
  {
    HeapIterationScope iteration(Thread::Current());
    ObjectAccumulator acc(&objects);
    iteration.IterateObjects(&acc);

ISOLATE_UNIT_TEST_CASE() [404/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TryCatchOptimizer_DeadParameterElimination_Cyclic1

)

Definition at line 172 of file redundancy_elimination_test.cc.

                                                                           {
  const char* script_chars = R"(
      @pragma("vm:external-name", "BlackholeNative")
      external dynamic blackhole([dynamic val]);
      foo(int p) {
        var a = blackhole(), b;
        for (var i = 0; i < 42; i++) {
          b = blackhole();
          try {
            blackhole([a, b]);
          } catch (e) {
            // a and i should be synchronized
          }
        }
      }
      main() {
        foo(42);
      }
  )";
 
  TryCatchOptimizerTest(thread, script_chars, /*synchronized=*/{"a", "i"});
}

ISOLATE_UNIT_TEST_CASE() [405/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TryCatchOptimizer_DeadParameterElimination_Cyclic2

)

Definition at line 195 of file redundancy_elimination_test.cc.

                                                                           {
  const char* script_chars = R"(
      @pragma("vm:external-name", "BlackholeNative")
      external dynamic blackhole([dynamic val]);
      foo(int p) {
        var a = blackhole(), b = blackhole();
        for (var i = 0; i < 42; i++) {
          try {
            blackhole([a, b]);
          } catch (e) {
            // a, b and i should be synchronized
          }
        }
      }
      main() {
        foo(42);
      }
  )";
 
  TryCatchOptimizerTest(thread, script_chars, /*synchronized=*/{"a", "b", "i"});
}

ISOLATE_UNIT_TEST_CASE() [406/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TryCatchOptimizer_DeadParameterElimination_Simple1

)

Definition at line 131 of file redundancy_elimination_test.cc.

                                                                           {
  const char* script_chars = R"(
      @pragma("vm:external-name", "BlackholeNative")
      external dynamic blackhole([dynamic val]);
      foo(int p) {
        var a = blackhole(), b = blackhole();
        try {
          blackhole([a, b]);
        } catch (e) {
          // nothing is used
        }
      }
      main() {
        foo(42);
      }
  )";
 
  TryCatchOptimizerTest(thread, script_chars, /*synchronized=*/{});
}

ISOLATE_UNIT_TEST_CASE() [407/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TryCatchOptimizer_DeadParameterElimination_Simple2

)

Definition at line 151 of file redundancy_elimination_test.cc.

                                                                           {
  const char* script_chars = R"(
      @pragma("vm:external-name", "BlackholeNative")
      external dynamic blackhole([dynamic val]);
      foo(int p) {
        var a = blackhole(), b = blackhole();
        try {
          blackhole([a, b]);
        } catch (e) {
          // a should be synchronized
          blackhole(a);
        }
      }
      main() {
        foo(42);
      }
  )";
 
  TryCatchOptimizerTest(thread, script_chars, /*synchronized=*/{"a"});
}

ISOLATE_UNIT_TEST_CASE() [408/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Double

)

Definition at line 1878 of file type_testing_stubs_test.cc.

                       {Smi::Handle(Smi::New(0)), tav_null, tav_null});
  RunTTSTest(type_int,
             {Integer::Handle(Integer::New(kMaxInt64)), tav_null, tav_null});
  RunTTSTest(type_int,
             Failure({Double::Handle(Double::New(1.0)), tav_null, tav_null}));
  RunTTSTest(type_int, Failure({Symbols::Empty(), tav_null, tav_null}));
  RunTTSTest(type_int,
             Failure({Array::Handle(Array::New(1)), tav_null, tav_null}));
}

ISOLATE_UNIT_TEST_CASE() [409/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Function

)

Definition at line 1919 of file type_testing_stubs_test.cc.

                     {Array::Handle(Array::New(1)), tav_null, tav_null}));
}
 
// Check that we generate correct TTS for Object type.
ISOLATE_UNIT_TEST_CASE(TTS_Object) {
  const auto& type_obj =
      Type::Handle(IsolateGroup::Current()->object_store()->object_type());
  const auto& tav_null = Object::null_type_arguments();
 
  // Non-nullable Object is not a top type,
  // so its TTS specializes the first time it is invoked.
  const bool should_specialize = true;
  auto make_test_case = [&](const Instance& instance) -> TTSTestCase {
    return {instance, tav_null, tav_null};
  };
 
  // Test on some easy-to-make instances.
  RunTTSTest(type_obj, make_test_case(Smi::Handle(Smi::New(0))),
             should_specialize);
  RunTTSTest(type_obj, make_test_case(Integer::Handle(Integer::New(kMaxInt64))),
             should_specialize);
  RunTTSTest(type_obj, make_test_case(Double::Handle(Double::New(1.0))),
             should_specialize);
  RunTTSTest(type_obj, make_test_case(Symbols::Empty()), should_specialize);
  RunTTSTest(type_obj, make_test_case(Array::Handle(Array::New(1))),
             should_specialize);
}
 
// Check that we generate correct TTS for type Function (the non-FunctionType
// version).

ISOLATE_UNIT_TEST_CASE() [410/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Future

)

Definition at line 1317 of file type_testing_stubs_test.cc.

                                     {obj_b_int, tav_string, tav_null}));
}
 
ISOLATE_UNIT_TEST_CASE(TTS_Future) {
  const char* kScript =
      R"(
      import "dart:async";
 
      Future<int> createFutureInt() async => 3;
      Future<int Function()> createFutureFunction() async => () => 3;
      Future<int Function()?> createFutureNullableFunction() async =>
          (() => 3) as int Function()?;
)";
 
  SetupCoreLibrariesForUnitTest();
 
  const auto& class_future =
      Class::Handle(IsolateGroup::Current()->object_store()->future_class());
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& class_closure =
      Class::Handle(IsolateGroup::Current()->object_store()->closure_class());
  const auto& obj_futureint =
      Object::Handle(Invoke(root_library, "createFutureInt"));
  const auto& obj_futurefunction =
      Object::Handle(Invoke(root_library, "createFutureFunction"));
  const auto& obj_futurenullablefunction =
      Object::Handle(Invoke(root_library, "createFutureNullableFunction"));
 
  const auto& tav_null = Object::null_type_arguments();
  const auto& type_object = Type::Handle(
      IsolateGroup::Current()->object_store()->non_nullable_object_type());
  const auto& type_legacy_object = Type::Handle(
      IsolateGroup::Current()->object_store()->legacy_object_type());
  const auto& type_nullable_object = Type::Handle(
      IsolateGroup::Current()->object_store()->nullable_object_type());
  const auto& type_int = Type::Handle(
      IsolateGroup::Current()->object_store()->non_nullable_int_type());
 
  auto& type_string = Type::Handle(Type::StringType());
  type_string =
      type_string.ToNullability(Nullability::kNonNullable, Heap::kNew);
  FinalizeAndCanonicalize(&type_string);
  auto& type_num = Type::Handle(Type::Number());
  type_num = type_num.ToNullability(Nullability::kNonNullable, Heap::kNew);
  FinalizeAndCanonicalize(&type_num);
 
  auto& tav_dynamic = TypeArguments::Handle(TypeArguments::New(1));
  tav_dynamic.SetTypeAt(0, Object::dynamic_type());
  CanonicalizeTAV(&tav_dynamic);
  auto& tav_object = TypeArguments::Handle(TypeArguments::New(1));
  tav_object.SetTypeAt(0, type_object);
  CanonicalizeTAV(&tav_object);
  auto& tav_legacy_object = TypeArguments::Handle(TypeArguments::New(1));
  tav_legacy_object.SetTypeAt(0, type_legacy_object);
  CanonicalizeTAV(&tav_legacy_object);
  auto& tav_nullable_object = TypeArguments::Handle(TypeArguments::New(1));
  tav_nullable_object.SetTypeAt(0, type_nullable_object);
  CanonicalizeTAV(&tav_nullable_object);
  auto& tav_int = TypeArguments::Handle(TypeArguments::New(1));
  tav_int.SetTypeAt(0, type_int);
  CanonicalizeTAV(&tav_int);
  auto& tav_num = TypeArguments::Handle(TypeArguments::New(1));
  tav_num.SetTypeAt(0, type_num);
  CanonicalizeTAV(&tav_num);
  auto& tav_string = TypeArguments::Handle(TypeArguments::New(1));
  tav_string.SetTypeAt(0, type_string);
  CanonicalizeTAV(&tav_string);
 
  auto& type_future = Type::Handle(
      Type::New(class_future, tav_null, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future);
  auto& type_future_dynamic = Type::Handle(
      Type::New(class_future, tav_dynamic, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_dynamic);
  auto& type_future_object = Type::Handle(
      Type::New(class_future, tav_object, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_object);
  auto& type_future_legacy_object = Type::Handle(
      Type::New(class_future, tav_legacy_object, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_legacy_object);
  auto& type_future_nullable_object = Type::Handle(
      Type::New(class_future, tav_nullable_object, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_nullable_object);
  auto& type_future_int =
      Type::Handle(Type::New(class_future, tav_int, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_int);
  auto& type_future_string = Type::Handle(
      Type::New(class_future, tav_string, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_string);
  auto& type_future_num =
      Type::Handle(Type::New(class_future, tav_num, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_num);
  const auto& type_future_t = Type::Handle(class_future.DeclarationType());
 
  THR_Print("********************************************************\n");
  THR_Print("               Testing Future<int>\n");
  THR_Print("********************************************************\n\n");
 
  // Some more tests of generic implemented classes, using Future. Here,
  // obj is an object of type Future<int>.
  //
  // True positives from TTS:
  //   obj as Future          : Null type args
  //   obj as Future<dynamic> : Canonicalized to same as previous case.
  //   obj as Future<Object?> : Type arg is top type
  //   obj as Future<Object*> : Type arg is top type
  //   obj as Future<Object>  : Type arg is certain supertype
  //   obj as Future<int>     : Type arg is the same type
  //   obj as Future<num>     : Type arg is a supertype that can be matched
  //                            with cid range
  //   obj as Future<X>,      : Type arg is a type parameter instantiated with
  //       X = int            :    ... the same type
  //
  RunTTSTest(type_future, {obj_futureint, tav_null, tav_null});
  RunTTSTest(type_future_dynamic, {obj_futureint, tav_null, tav_null});
  RunTTSTest(type_future_object, {obj_futureint, tav_null, tav_null});
  RunTTSTest(type_future_legacy_object, {obj_futureint, tav_null, tav_null});
  RunTTSTest(type_future_nullable_object, {obj_futureint, tav_null, tav_null});
  RunTTSTest(type_future_int, {obj_futureint, tav_null, tav_null});
  RunTTSTest(type_future_num, {obj_futureint, tav_null, tav_null});
  RunTTSTest(type_future_t, {obj_futureint, tav_int, tav_null});
 
  // False negatives from TTS (caught by STC/runtime):
  //   obj as Future<X>,      : Type arg is a type parameter instantiated with
  //       X = num            :    ... a supertype
  RunTTSTest(type_future_t, FalseNegative({obj_futureint, tav_num, tav_null}));
 
  // Errors:
  //   obj as Future<String>  : Type arg is not a supertype
  //   obj as Future<X>,      : Type arg is a type parameter instantiated with
  //       X = String         :    ... an unrelated type
  //
  RunTTSTest(type_future_string, Failure({obj_futureint, tav_null, tav_null}));
  RunTTSTest(type_future_t, Failure({obj_futureint, tav_string, tav_null}));
 
  auto& type_function = Type::Handle(Type::DartFunctionType());
  type_function =
      type_function.ToNullability(Nullability::kNonNullable, Heap::kNew);
  FinalizeAndCanonicalize(&type_function);
  auto& type_legacy_function = Type::Handle(
      type_function.ToNullability(Nullability::kLegacy, Heap::kNew));
  FinalizeAndCanonicalize(&type_legacy_function);
  auto& type_nullable_function = Type::Handle(
      type_function.ToNullability(Nullability::kNullable, Heap::kOld));
  FinalizeAndCanonicalize(&type_nullable_function);
  auto& type_closure = Type::Handle(
      Type::New(class_closure, tav_null, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_closure);
  auto& type_legacy_closure = Type::Handle(
      type_closure.ToNullability(Nullability::kLegacy, Heap::kOld));
  FinalizeAndCanonicalize(&type_legacy_closure);
  auto& type_nullable_closure = Type::Handle(
      type_closure.ToNullability(Nullability::kNullable, Heap::kOld));
  FinalizeAndCanonicalize(&type_nullable_closure);
  auto& type_function_int_nullary =
      FunctionType::Handle(FunctionType::New(0, Nullability::kNonNullable));
  // Testing with a closure, so it has an implicit parameter, and we want a
  // type that is canonically equal to the type of the closure.
  type_function_int_nullary.set_num_implicit_parameters(1);
  type_function_int_nullary.set_num_fixed_parameters(1);
  type_function_int_nullary.set_parameter_types(Array::Handle(Array::New(1)));
  type_function_int_nullary.SetParameterTypeAt(0, Type::dynamic_type());
  type_function_int_nullary.set_result_type(type_int);
  FinalizeAndCanonicalize(&type_function_int_nullary);
  auto& type_legacy_function_int_nullary =
      FunctionType::Handle(type_function_int_nullary.ToNullability(
          Nullability::kLegacy, Heap::kOld));
  FinalizeAndCanonicalize(&type_legacy_function_int_nullary);
  auto& type_nullable_function_int_nullary =
      FunctionType::Handle(type_function_int_nullary.ToNullability(
          Nullability::kNullable, Heap::kOld));
  FinalizeAndCanonicalize(&type_nullable_function_int_nullary);
 
  auto& tav_function = TypeArguments::Handle(TypeArguments::New(1));
  tav_function.SetTypeAt(0, type_function);
  CanonicalizeTAV(&tav_function);
  auto& tav_legacy_function = TypeArguments::Handle(TypeArguments::New(1));
  tav_legacy_function.SetTypeAt(0, type_legacy_function);
  CanonicalizeTAV(&tav_legacy_function);
  auto& tav_nullable_function = TypeArguments::Handle(TypeArguments::New(1));
  tav_nullable_function.SetTypeAt(0, type_nullable_function);
  CanonicalizeTAV(&tav_nullable_function);
  auto& tav_closure = TypeArguments::Handle(TypeArguments::New(1));
  tav_closure.SetTypeAt(0, type_closure);
  CanonicalizeTAV(&tav_closure);
  auto& tav_legacy_closure = TypeArguments::Handle(TypeArguments::New(1));
  tav_legacy_closure.SetTypeAt(0, type_legacy_closure);
  CanonicalizeTAV(&tav_legacy_closure);
  auto& tav_nullable_closure = TypeArguments::Handle(TypeArguments::New(1));
  tav_nullable_closure.SetTypeAt(0, type_nullable_closure);
  CanonicalizeTAV(&tav_nullable_closure);
  auto& tav_function_int_nullary = TypeArguments::Handle(TypeArguments::New(1));
  tav_function_int_nullary.SetTypeAt(0, type_function_int_nullary);
  CanonicalizeTAV(&tav_function_int_nullary);
  auto& tav_legacy_function_int_nullary =
      TypeArguments::Handle(TypeArguments::New(1));
  tav_legacy_function_int_nullary.SetTypeAt(0,
                                            type_legacy_function_int_nullary);
  CanonicalizeTAV(&tav_legacy_function_int_nullary);
  auto& tav_nullable_function_int_nullary =
      TypeArguments::Handle(TypeArguments::New(1));
  tav_nullable_function_int_nullary.SetTypeAt(
      0, type_nullable_function_int_nullary);
  CanonicalizeTAV(&tav_nullable_function_int_nullary);
 
  auto& type_future_function = Type::Handle(
      Type::New(class_future, tav_function, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_function);
  auto& type_future_legacy_function = Type::Handle(
      Type::New(class_future, tav_legacy_function, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_legacy_function);
  auto& type_future_nullable_function = Type::Handle(Type::New(
      class_future, tav_nullable_function, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_nullable_function);
  auto& type_future_closure = Type::Handle(
      Type::New(class_future, tav_closure, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_closure);
  auto& type_future_legacy_closure = Type::Handle(
      Type::New(class_future, tav_legacy_closure, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_legacy_closure);
  auto& type_future_nullable_closure = Type::Handle(
      Type::New(class_future, tav_nullable_closure, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_future_nullable_closure);
  auto& type_future_function_int_nullary =
      Type::Handle(Type::New(class_future, tav_function_int_nullary));
  FinalizeAndCanonicalize(&type_future_function_int_nullary);
  auto& type_future_legacy_function_int_nullary =
      Type::Handle(Type::New(class_future, tav_legacy_function_int_nullary));
  FinalizeAndCanonicalize(&type_future_legacy_function_int_nullary);
  auto& type_future_nullable_function_int_nullary =
      Type::Handle(Type::New(class_future, tav_nullable_function_int_nullary));
  FinalizeAndCanonicalize(&type_future_nullable_function_int_nullary);
 
  THR_Print("\n********************************************************\n");
  THR_Print("            Testing Future<int Function()>\n");
  THR_Print("********************************************************\n\n");
 
  // And here, obj is an object of type Future<int Function()>. Note that
  // int Function() <: Function, but int Function() </: _Closure. That is,
  // _Closure is a separate subtype of Function from FunctionTypes.
  //
  // True positive from TTS:
  //   obj as Future            : Null type args
  //   obj as Future<dynamic>   : Canonicalized to same as previous case.
  //   obj as Future<Object?>   : Type arg is top type
  //   obj as Future<Object*>   : Type arg is top typ
  //   obj as Future<Object>    : Type arg is certain supertype
  //   obj as Future<Function?> : Type arg is certain supertype
  //   obj as Future<Function*> : Type arg is certain supertype
  //   obj as Future<Function>  : Type arg is certain supertype
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = dynamic          :    ... a top type
  //       X = Object?          :    ... a top type
  //       X = Object*          :    ... a top type
  //       X = Object           :    ... a certain supertype
  //       X = int Function()   :    ... the same type.
  //
  RunTTSTest(type_future, {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_dynamic, {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_nullable_object,
             {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_legacy_object,
             {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_object, {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_nullable_object,
             {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_legacy_object,
             {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_object, {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_nullable_function,
             {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_legacy_function,
             {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_function, {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_t, {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_t,
             {obj_futurefunction, tav_nullable_object, tav_null});
  RunTTSTest(type_future_t, {obj_futurefunction, tav_legacy_object, tav_null});
  RunTTSTest(type_future_t, {obj_futurefunction, tav_object, tav_null});
  RunTTSTest(type_future_t,
             {obj_futurefunction, tav_function_int_nullary, tav_null});
 
  // False negative from TTS (caught by runtime or STC):
  //   obj as Future<int Function()?> : No specialization.
  //   obj as Future<int Function()*> : No specialization.
  //   obj as Future<int Function()>  : No specialization.
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = Function?        :    ... a certain supertype (but not checked)
  //       X = Function*        :    ... a certain supertype (but not checked)
  //       X = Function         :    ... a certain supertype (but not checked)
  //       X = int Function()?  :    ... a canonically different type.
  //       X = int Function()*  :    ... a canonically different type.
  //
  RunTTSTest(type_future_nullable_function_int_nullary,
             FalseNegative({obj_futurefunction, tav_null, tav_null}));
  RunTTSTest(type_future_legacy_function_int_nullary,
             FalseNegative({obj_futurefunction, tav_null, tav_null}));
  RunTTSTest(type_future_function_int_nullary,
             FalseNegative({obj_futurefunction, tav_null, tav_null}));
  RunTTSTest(type_future_t, FalseNegative({obj_futurefunction,
                                           tav_nullable_function, tav_null}));
  RunTTSTest(type_future_t, FalseNegative({obj_futurefunction,
                                           tav_legacy_function, tav_null}));
  RunTTSTest(type_future_t,
             FalseNegative({obj_futurefunction, tav_function, tav_null}));
  RunTTSTest(type_future_t,
             FalseNegative({obj_futurefunction,
                            tav_nullable_function_int_nullary, tav_null}));
  RunTTSTest(type_future_t,
             FalseNegative({obj_futurefunction, tav_legacy_function_int_nullary,
                            tav_null}));
 
  // Errors:
  //   obj as Future<_Closure?> : Type arg is not a supertype
  //   obj as Future<_Closure*> : Type arg is not a supertype
  //   obj as Future<_Closure>  : Type arg is not a supertype
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = _Closure?        :    ... an unrelated type.
  //       X = _Closure*        :    ... an unrelated type.
  //       X = _Closure         :    ... an unrelated type.
  //
  RunTTSTest(type_future_nullable_closure,
             Failure({obj_futurefunction, tav_null, tav_null}));
  RunTTSTest(type_future_legacy_closure,
             Failure({obj_futurefunction, tav_null, tav_null}));
  RunTTSTest(type_future_closure,
             Failure({obj_futurefunction, tav_null, tav_null}));
  RunTTSTest(type_future_t,
             Failure({obj_futurefunction, tav_nullable_closure, tav_null}));
  RunTTSTest(type_future_t,
             Failure({obj_futurefunction, tav_legacy_closure, tav_null}));
  RunTTSTest(type_future_t,
             Failure({obj_futurefunction, tav_closure, tav_null}));
 
  THR_Print("\n********************************************************\n");
  THR_Print("            Testing Future<int Function()?>\n");
  THR_Print("********************************************************\n\n");
 
  // And here, obj is an object of type Future<int Function()?>.
  //
  // True positive from TTS:
  //   obj as Future            : Null type args
  //   obj as Future<dynamic>   : Canonicalized to same as previous case.
  //   obj as Future<Object?>   : Type arg is top type
  //   obj as Future<Object*>   : Type arg is top typ
  //   obj as Future<Function?> : Type arg is certain supertype
  //   obj as Future<Function*> : Type arg is certain supertype
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = dynamic          :    ... a top type
  //       X = Object?          :    ... a top type
  //       X = Object*          :    ... a top type
  //       X = int Function()?  :    ... the same type.
  //
  // If not null safe:
  //   obj as Future<Object>    : Type arg is certain supertype
  //   obj as Future<Function>  : Type arg is certain supertype
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = Object           :    ... a certain supertype
  RunTTSTest(type_future, {obj_futurenullablefunction, tav_null, tav_null});
  RunTTSTest(type_future_dynamic,
             {obj_futurenullablefunction, tav_null, tav_null});
  RunTTSTest(type_future_nullable_object,
             {obj_futurenullablefunction, tav_null, tav_null});
  RunTTSTest(type_future_legacy_object,
             {obj_futurenullablefunction, tav_null, tav_null});
  RunTTSTest(type_future_nullable_object,
             {obj_futurefunction, tav_null, tav_null});
  RunTTSTest(type_future_legacy_object,
             {obj_futurenullablefunction, tav_null, tav_null});
  RunTTSTest(type_future_nullable_function,
             {obj_futurenullablefunction, tav_null, tav_null});
  RunTTSTest(type_future_legacy_function,
             {obj_futurenullablefunction, tav_null, tav_null});
  RunTTSTest(type_future_t, {obj_futurenullablefunction, tav_null, tav_null});
  RunTTSTest(type_future_t,
             {obj_futurenullablefunction, tav_nullable_object, tav_null});
  RunTTSTest(type_future_t,
             {obj_futurenullablefunction, tav_legacy_object, tav_null});
  RunTTSTest(type_future_t, {obj_futurenullablefunction,
                             tav_nullable_function_int_nullary, tav_null});
 
  // False negative from TTS (caught by runtime or STC):
  //   obj as Future<int Function()?> : No specialization.
  //   obj as Future<int Function()*> : No specialization.
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = Function?        :    ... a certain supertype (but not checked)
  //       X = Function*        :    ... a certain supertype (but not checked)
  //       X = int Function()*  :    ... a canonically different type.
  //
  // If not null safe:
  //   obj as Future<int Function()>  : No specialization.
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = Function         :    ... a certain supertype (but not checked)
  //       X = int Function()   :    ... a canonically different type.
 
  RunTTSTest(type_future_nullable_function_int_nullary,
             FalseNegative({obj_futurenullablefunction, tav_null, tav_null}));
  RunTTSTest(type_future_legacy_function_int_nullary,
             FalseNegative({obj_futurenullablefunction, tav_null, tav_null}));
  RunTTSTest(type_future_t, FalseNegative({obj_futurenullablefunction,
                                           tav_nullable_function, tav_null}));
  RunTTSTest(type_future_t, FalseNegative({obj_futurenullablefunction,
                                           tav_legacy_function, tav_null}));
  RunTTSTest(type_future_t,
             FalseNegative({obj_futurenullablefunction,
                            tav_legacy_function_int_nullary, tav_null}));
 
  // Errors:
  //   obj as Future<_Closure?> : Type arg is not a supertype
  //   obj as Future<_Closure*> : Type arg is not a supertype
  //   obj as Future<_Closure>  : Type arg is not a supertype
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = _Closure?        :    ... an unrelated type.
  //       X = _Closure*        :    ... an unrelated type.
  //       X = _Closure         :    ... an unrelated type.
  //
  // If null safe:
  //   obj as Future<int Function()>  : Nullable type cannot be subtype of a
  //                                    non-nullable type.
  //   obj as Future<Object>    : Nullable type cannot be subtype of a
  //                              non-nullable type.
  //   obj as Future<Function>  : Nullable type cannot be subtype of a
  //                              non-nullable type.
  //   obj as Future<X>,        : Type arg is a type parameter instantiated with
  //       X = Object           :    ... a non-nullable type.
  //       X = Function         :    ... a non-nullable type.
  //       X = int Function()   :    ... a non-nullable type.
 
  RunTTSTest(type_future_nullable_closure,
             Failure({obj_futurenullablefunction, tav_null, tav_null}));
  RunTTSTest(type_future_legacy_closure,
             Failure({obj_futurenullablefunction, tav_null, tav_null}));
  RunTTSTest(type_future_closure,
             Failure({obj_futurenullablefunction, tav_null, tav_null}));
  RunTTSTest(type_future_t, Failure({obj_futurenullablefunction,
                                     tav_nullable_closure, tav_null}));
  RunTTSTest(type_future_t, Failure({obj_futurenullablefunction,
                                     tav_legacy_closure, tav_null}));
  RunTTSTest(type_future_t,
             Failure({obj_futurenullablefunction, tav_closure, tav_null}));
 
  RunTTSTest(type_future_function_int_nullary,

ISOLATE_UNIT_TEST_CASE() [411/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Generic_Implements_Instantiated_Interface

)

Definition at line 1293 of file type_testing_stubs_test.cc.

                                                                      {
  const char* kScript =
      R"(
      abstract class I<T> {}
      class B<R> implements I<String> {}
 
      createBInt() => B<int>();
)";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& class_i = Class::Handle(GetClass(root_library, "I"));
  const auto& obj_b_int = Object::Handle(Invoke(root_library, "createBInt"));
 
  const auto& tav_null = Object::null_type_arguments();
  auto& tav_string = TypeArguments::Handle(TypeArguments::New(1));
  tav_string.SetTypeAt(0, Type::Handle(Type::StringType()));
  CanonicalizeTAV(&tav_string);
 
  auto& type_i_string = Type::Handle(Type::New(class_i, tav_string));
  FinalizeAndCanonicalize(&type_i_string);
  const auto& type_i_t = Type::Handle(class_i.DeclarationType());
 
  RunTTSTest(type_i_string, {obj_b_int, tav_null, tav_null});

ISOLATE_UNIT_TEST_CASE() [412/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_GenericSubtypeRangeCheck

)

Definition at line 1050 of file type_testing_stubs_test.cc.

                                                     {
  const auto& root_library =
      Library::Handle(LoadTestScript(kSubtypeRangeCheckScript));
  const auto& class_a1 = Class::Handle(GetClass(root_library, "A1"));
  const auto& class_a2 = Class::Handle(GetClass(root_library, "A2"));
  const auto& class_base = Class::Handle(GetClass(root_library, "Base"));
  const auto& class_i = Class::Handle(GetClass(root_library, "I"));
  const auto& fun_generic =
      Function::Handle(GetFunction(root_library, "genericFun"));
 
  const auto& obj_i = Object::Handle(Invoke(root_library, "createI"));
  const auto& obj_i2 = Object::Handle(Invoke(root_library, "createI2"));
  const auto& obj_base_int =
      Object::Handle(Invoke(root_library, "createBaseInt"));
  const auto& obj_a = Object::Handle(Invoke(root_library, "createA"));
  const auto& obj_a1 = Object::Handle(Invoke(root_library, "createA1"));
  const auto& obj_a2 = Object::Handle(Invoke(root_library, "createA2"));
  const auto& obj_b = Object::Handle(Invoke(root_library, "createB"));
  const auto& obj_b1 = Object::Handle(Invoke(root_library, "createB1"));
  const auto& obj_b2 = Object::Handle(Invoke(root_library, "createB2"));
  const auto& obj_basea2int =
      Object::Handle(Invoke(root_library, "createBaseA2Int"));
  const auto& obj_basea2a1 =
      Object::Handle(Invoke(root_library, "createBaseA2A1"));
  const auto& obj_baseb2int =
      Object::Handle(Invoke(root_library, "createBaseB2Int"));
  const auto& obj_baseistringdouble =
      Object::Handle(Invoke(root_library, "createBaseIStringDouble"));
 
  const auto& type_dynamic = Type::Handle(Type::DynamicType());
  auto& type_int = Type::Handle(Type::IntType());
  if (!TestCase::IsNNBD()) {
    type_int = type_int.ToNullability(Nullability::kLegacy, Heap::kNew);
  }
  auto& type_string = Type::Handle(Type::StringType());
  if (!TestCase::IsNNBD()) {
    type_string = type_string.ToNullability(Nullability::kLegacy, Heap::kNew);
  }
  auto& type_object = Type::Handle(Type::ObjectType());
  type_object = type_object.ToNullability(
      TestCase::IsNNBD() ? Nullability::kNullable : Nullability::kLegacy,
      Heap::kNew);
  auto& type_a1 = Type::Handle(class_a1.DeclarationType());
  if (!TestCase::IsNNBD()) {
    type_a1 = type_a1.ToNullability(Nullability::kLegacy, Heap::kNew);
  }
  FinalizeAndCanonicalize(&type_a1);
 
  const auto& tav_null = TypeArguments::Handle(TypeArguments::null());
 
  auto& tav_object_dynamic = TypeArguments::Handle(TypeArguments::New(2));
  tav_object_dynamic.SetTypeAt(0, type_object);
  tav_object_dynamic.SetTypeAt(1, type_dynamic);
  CanonicalizeTAV(&tav_object_dynamic);
 
  auto& tav_dynamic_int = TypeArguments::Handle(TypeArguments::New(2));
  tav_dynamic_int.SetTypeAt(0, type_dynamic);
  tav_dynamic_int.SetTypeAt(1, type_int);
  CanonicalizeTAV(&tav_dynamic_int);
 
  auto& tav_dynamic_string = TypeArguments::Handle(TypeArguments::New(2));
  tav_dynamic_string.SetTypeAt(0, type_dynamic);
  tav_dynamic_string.SetTypeAt(1, type_string);
  CanonicalizeTAV(&tav_dynamic_string);
 
  auto& tav_int = TypeArguments::Handle(TypeArguments::New(1));
  tav_int.SetTypeAt(0, type_int);
  CanonicalizeTAV(&tav_int);
 
  auto& type_i_object_dynamic =
      AbstractType::Handle(Type::New(class_i, tav_object_dynamic));
  FinalizeAndCanonicalize(&type_i_object_dynamic);
  const auto& tav_iod = TypeArguments::Handle(TypeArguments::New(1));
  tav_iod.SetTypeAt(0, type_i_object_dynamic);
 
  // We will generate specialized TTS for instantiated interface types
  // where there are no type arguments or the type arguments are top
  // types.
  //
  //   obj as Base<I<Object, dynamic>>   // Subclass ranges for Base, subtype
  //                                     // ranges tav arguments.
  //   obj as Base<T>                    // Subclass ranges for Base, type
  //                                     // equality for instantiator type arg T
  //   obj as Base<B>                    // Subclass ranges for Base, type
  //                                     // equality for function type arg B.
  //
 
  // <...> as Base<I<Object, dynamic>>
  auto& type_base_i_object_dynamic =
      AbstractType::Handle(Type::New(class_base, tav_iod));
  FinalizeAndCanonicalize(&type_base_i_object_dynamic);
  RunTTSTest(type_base_i_object_dynamic, {obj_baseb2int, tav_null, tav_null});
  RunTTSTest(type_base_i_object_dynamic,
             {obj_baseistringdouble, tav_null, tav_null});
  RunTTSTest(type_base_i_object_dynamic, Failure({obj_a, tav_null, tav_null}));
  RunTTSTest(type_base_i_object_dynamic, Failure({obj_a1, tav_null, tav_null}));
  RunTTSTest(type_base_i_object_dynamic, Failure({obj_a2, tav_null, tav_null}));
  RunTTSTest(type_base_i_object_dynamic, Failure({obj_b, tav_null, tav_null}));
  RunTTSTest(type_base_i_object_dynamic, Failure({obj_b1, tav_null, tav_null}));
  RunTTSTest(type_base_i_object_dynamic, Failure({obj_b2, tav_null, tav_null}));
 
  // <...> as Base<T>  with T instantiantiator type parameter (T == int)
  const auto& tav_baset = TypeArguments::Handle(TypeArguments::New(1));
  tav_baset.SetTypeAt(
      0, TypeParameter::Handle(GetClassTypeParameter(class_base, 0)));
  auto& type_base_t = AbstractType::Handle(Type::New(class_base, tav_baset));
  FinalizeAndCanonicalize(&type_base_t);
  RunTTSTest(type_base_t, {obj_base_int, tav_int, tav_null});
  RunTTSTest(type_base_t, Failure({obj_baseistringdouble, tav_int, tav_null}));
 
  // <...> as Base<B>  with B function type parameter
  const auto& tav_baseb = TypeArguments::Handle(TypeArguments::New(1));
  tav_baseb.SetTypeAt(
      0, TypeParameter::Handle(GetFunctionTypeParameter(fun_generic, 1)));
  auto& type_base_b = AbstractType::Handle(Type::New(class_base, tav_baseb));
  FinalizeAndCanonicalize(&type_base_b);
  // With B == int
  RunTTSTest(type_base_b, {obj_base_int, tav_null, tav_dynamic_int});
  RunTTSTest(type_base_b,
             Failure({obj_baseistringdouble, tav_null, tav_dynamic_int}));
  // With B == dynamic (null vector)
  RunTTSTest(type_base_b, {obj_base_int, tav_null, tav_null});
  RunTTSTest(type_base_b, Failure({obj_i2, tav_null, tav_null}));
 
  // We generate TTS for implemented classes and uninstantiated types, but
  // any class that implements the type class but does not match in both
  // instance TAV offset and type argument indices is guaranteed to be a
  // false negative.
  //
  //   obj as I<dynamic, String>       // I is generic & implemented.
  //   obj as Base<A2<T>>              // A2<T> is not instantiated.
  //   obj as Base<A2<A1>>             // A2<A1> is not a rare type.
  //
 
  //   <...> as I<dynamic, String>
  RELEASE_ASSERT(class_i.is_implemented());
  auto& type_i_dynamic_string =
      Type::Handle(Type::New(class_i, tav_dynamic_string));
  type_i_dynamic_string = type_i_dynamic_string.ToNullability(
      Nullability::kNonNullable, Heap::kNew);
  FinalizeAndCanonicalize(&type_i_dynamic_string);
  RunTTSTest(type_i_dynamic_string, {obj_i, tav_null, tav_null});
  RunTTSTest(type_i_dynamic_string,
             Failure({obj_base_int, tav_null, tav_null}));
 
  //   <...> as Base<A2<T>>
  const auto& tav_t = TypeArguments::Handle(TypeArguments::New(1));
  tav_t.SetTypeAt(0,
                  TypeParameter::Handle(GetClassTypeParameter(class_base, 0)));
  auto& type_a2_t = Type::Handle(Type::New(class_a2, tav_t));
  type_a2_t = type_a2_t.ToNullability(Nullability::kLegacy, Heap::kNew);
  FinalizeAndCanonicalize(&type_a2_t);
  const auto& tav_a2_t = TypeArguments::Handle(TypeArguments::New(1));
  tav_a2_t.SetTypeAt(0, type_a2_t);
  auto& type_base_a2_t = Type::Handle(Type::New(class_base, tav_a2_t));
  type_base_a2_t =
      type_base_a2_t.ToNullability(Nullability::kNonNullable, Heap::kNew);
  FinalizeAndCanonicalize(&type_base_a2_t);
  RunTTSTest(type_base_a2_t,
             FalseNegative({obj_basea2int, tav_null, tav_null}));
  RunTTSTest(type_base_a2_t, Failure({obj_base_int, tav_null, tav_null}));
 
  //   <...> as Base<A2<A1>>
  const auto& tav_a1 = TypeArguments::Handle(TypeArguments::New(1));
  tav_a1.SetTypeAt(0, type_a1);
  auto& type_a2_a1 = Type::Handle(Type::New(class_a2, tav_a1));
  type_a2_a1 = type_a2_a1.ToNullability(Nullability::kLegacy, Heap::kNew);
  FinalizeAndCanonicalize(&type_a2_a1);
  const auto& tav_a2_a1 = TypeArguments::Handle(TypeArguments::New(1));
  tav_a2_a1.SetTypeAt(0, type_a2_a1);
  auto& type_base_a2_a1 = Type::Handle(Type::New(class_base, tav_a2_a1));
  type_base_a2_a1 =
      type_base_a2_a1.ToNullability(Nullability::kNonNullable, Heap::kNew);
  FinalizeAndCanonicalize(&type_base_a2_a1);
  RunTTSTest(type_base_a2_a1,
             FalseNegative({obj_basea2a1, tav_null, tav_null}));
  RunTTSTest(type_base_a2_a1, Failure({obj_basea2int, tav_null, tav_null}));
}

ISOLATE_UNIT_TEST_CASE() [413/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Int

)

Definition at line 1847 of file type_testing_stubs_test.cc.

                         {int_instance, int_tav, string_tav});
  THR_Print("\nTesting string instance, class parameter instantiated to int\n");
  RunTTSTest(dst_type_t, Failure({string_instance, int_tav, string_tav}));
 
  THR_Print(
      "\nTesting string instance, function parameter instantiated to string\n");
  RunTTSTest(dst_type_h, {string_instance, int_tav, string_tav});
  RunTTSTest(dst_type_h, Failure({int_instance, int_tav, string_tav}));
}
 
// Check that we generate correct TTS for _Smi type.

ISOLATE_UNIT_TEST_CASE() [414/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Num

)

Definition at line 1863 of file type_testing_stubs_test.cc.

                       {Smi::Handle(Smi::New(0)), tav_null, tav_null});
  RunTTSTest(type_smi, Failure({Integer::Handle(Integer::New(kMaxInt64)),
                                tav_null, tav_null}));
  RunTTSTest(type_smi,
             Failure({Double::Handle(Double::New(1.0)), tav_null, tav_null}));
  RunTTSTest(type_smi, Failure({Symbols::Empty(), tav_null, tav_null}));
  RunTTSTest(type_smi,
             Failure({Array::Handle(Array::New(1)), tav_null, tav_null}));
}
 

ISOLATE_UNIT_TEST_CASE() [415/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Object

)

Definition at line 1893 of file type_testing_stubs_test.cc.

                                {
  const auto& type_num = Type::Handle(Type::Number());
  const auto& tav_null = Object::null_type_arguments();
 
  // Test on some easy-to-make instances.
  RunTTSTest(type_num, {Smi::Handle(Smi::New(0)), tav_null, tav_null});
  RunTTSTest(type_num,
             {Integer::Handle(Integer::New(kMaxInt64)), tav_null, tav_null});
  RunTTSTest(type_num, {Double::Handle(Double::New(1.0)), tav_null, tav_null});
  RunTTSTest(type_num, Failure({Symbols::Empty(), tav_null, tav_null}));
  RunTTSTest(type_num,
             Failure({Array::Handle(Array::New(1)), tav_null, tav_null}));
}
 
// Check that we generate correct TTS for Double type.
ISOLATE_UNIT_TEST_CASE(TTS_Double) {
  const auto& type_num = Type::Handle(Type::Double());
  const auto& tav_null = Object::null_type_arguments();
 
  // Test on some easy-to-make instances.
  RunTTSTest(type_num, Failure({Smi::Handle(Smi::New(0)), tav_null, tav_null}));
  RunTTSTest(type_num, Failure({Integer::Handle(Integer::New(kMaxInt64)),
                                tav_null, tav_null}));

ISOLATE_UNIT_TEST_CASE() [416/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Partial

)

Definition at line 1950 of file type_testing_stubs_test.cc.

                     {}
 
          createF() => (){};
          createG() => () => 3;
          createH() => (int x, String y, {int z = 0}) =>  x + z;
 
          createAInt() => A<int>();
          createAFunction() => A<Function>();
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& obj_f = Object::Handle(Invoke(root_library, "createF"));
  const auto& obj_g = Object::Handle(Invoke(root_library, "createG"));
  const auto& obj_h = Object::Handle(Invoke(root_library, "createH"));
 
  const auto& tav_null = TypeArguments::Handle(TypeArguments::null());
  const auto& type_function = Type::Handle(Type::DartFunctionType());
 
  RunTTSTest(type_function, {obj_f, tav_null, tav_null});
  RunTTSTest(type_function, {obj_g, tav_null, tav_null});
  RunTTSTest(type_function, {obj_h, tav_null, tav_null});
 
  const auto& class_a = Class::Handle(GetClass(root_library, "A"));
  const auto& obj_a_int = Object::Handle(Invoke(root_library, "createAInt"));
  const auto& obj_a_function =
      Object::Handle(Invoke(root_library, "createAFunction"));
 
  auto& tav_function = TypeArguments::Handle(TypeArguments::New(1));
  tav_function.SetTypeAt(0, type_function);
  CanonicalizeTAV(&tav_function);
  auto& type_a_function = Type::Handle(Type::New(class_a, tav_function));
  FinalizeAndCanonicalize(&type_a_function);
 
  RunTTSTest(type_a_function, {obj_a_function, tav_null, tav_null});
  RunTTSTest(type_a_function, Failure({obj_a_int, tav_null, tav_null}));
}
 
ISOLATE_UNIT_TEST_CASE(TTS_Partial) {
  const char* kScript =
      R"(
      class B<T> {}
 
      class C {}
      class D extends C {}
      class E extends D {}
 
      F<A>() {}
      createBE() => B<E>();
      createBENullable() => B<E?>();
      createBNull() => B<Null>();
      createBNever() => B<Never>();
)";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& class_b = Class::Handle(GetClass(root_library, "B"));
  const auto& class_c = Class::Handle(GetClass(root_library, "C"));
  const auto& class_d = Class::Handle(GetClass(root_library, "D"));
  const auto& class_e = Class::Handle(GetClass(root_library, "E"));
  const auto& fun_f = Function::Handle(GetFunction(root_library, "F"));
  const auto& obj_b_e = Object::Handle(Invoke(root_library, "createBE"));
  const auto& obj_b_e_nullable =
      Object::Handle(Invoke(root_library, "createBENullable"));
  const auto& obj_b_null = Object::Handle(Invoke(root_library, "createBNull"));
  const auto& obj_b_never =
      Object::Handle(Invoke(root_library, "createBNever"));
 
  const auto& tav_null = Object::null_type_arguments();
  auto& tav_nullable_object = TypeArguments::Handle(TypeArguments::New(1));
  tav_nullable_object.SetTypeAt(
      0, Type::Handle(
             IsolateGroup::Current()->object_store()->nullable_object_type()));
  CanonicalizeTAV(&tav_nullable_object);
  auto& tav_legacy_object = TypeArguments::Handle(TypeArguments::New(1));
  tav_legacy_object.SetTypeAt(
      0, Type::Handle(
             IsolateGroup::Current()->object_store()->legacy_object_type()));
  CanonicalizeTAV(&tav_legacy_object);
  auto& tav_object = TypeArguments::Handle(TypeArguments::New(1));
  tav_object.SetTypeAt(
      0, Type::Handle(IsolateGroup::Current()->object_store()->object_type()));
  CanonicalizeTAV(&tav_object);
 
  auto& type_e =
      Type::Handle(Type::New(class_e, tav_null, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_e);
  auto& type_d =
      Type::Handle(Type::New(class_d, tav_null, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_d);
  auto& type_c =
      Type::Handle(Type::New(class_c, tav_null, Nullability::kNonNullable));
  FinalizeAndCanonicalize(&type_c);
  auto& type_c_nullable =
      Type::Handle(Type::New(class_c, tav_null, Nullability::kNullable));
  FinalizeAndCanonicalize(&type_c_nullable);
  auto& type_c_legacy =
      Type::Handle(Type::New(class_c, tav_null, Nullability::kLegacy));
  FinalizeAndCanonicalize(&type_c_legacy);
 
  auto& tav_e = TypeArguments::Handle(TypeArguments::New(1));
  tav_e.SetTypeAt(0, type_e);
  CanonicalizeTAV(&tav_e);
  auto& tav_d = TypeArguments::Handle(TypeArguments::New(1));
  tav_d.SetTypeAt(0, type_d);
  CanonicalizeTAV(&tav_d);
  auto& tav_c = TypeArguments::Handle(TypeArguments::New(1));
  tav_c.SetTypeAt(0, type_c);
  CanonicalizeTAV(&tav_c);
  auto& tav_nullable_c = TypeArguments::Handle(TypeArguments::New(1));
  tav_nullable_c.SetTypeAt(0, type_c_nullable);
  CanonicalizeTAV(&tav_nullable_c);
  auto& tav_legacy_c = TypeArguments::Handle(TypeArguments::New(1));
  tav_legacy_c.SetTypeAt(0, type_c_legacy);
  CanonicalizeTAV(&tav_legacy_c);
 
  // One case where optimized TTSes can be partial is if the type is
  // uninstantiated with a type parameter at the same position as one of the

ISOLATE_UNIT_TEST_CASE() [417/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Partial_Incremental

)

Definition at line 2069 of file type_testing_stubs_test.cc.

ISOLATE_UNIT_TEST_CASE() [418/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_RecordSubtypeRangeCheck

)

Definition at line 1251 of file type_testing_stubs_test.cc.

                                                    {
  const auto& root_library =
      Library::Handle(LoadTestScript(kRecordSubtypeRangeCheckScript));
 
  const auto& type1 = AbstractType::Cast(
      Object::Handle(Invoke(root_library, "getRecordType1")));
  const auto& type2 = AbstractType::Cast(
      Object::Handle(Invoke(root_library, "getRecordType2")));
  const auto& type3 = AbstractType::Cast(
      Object::Handle(Invoke(root_library, "getRecordType3")));
 
  const auto& obj1 = Object::Handle(Invoke(root_library, "createObj1"));
  const auto& obj2 = Object::Handle(Invoke(root_library, "createObj2"));
  const auto& obj3 = Object::Handle(Invoke(root_library, "createObj3"));
  const auto& obj4 = Object::Handle(Invoke(root_library, "createObj4"));
  const auto& obj5 = Object::Handle(Invoke(root_library, "createObj5"));
  const auto& obj6 = Object::Handle(Invoke(root_library, "createObj6"));
  const auto& obj7 = Object::Handle(Invoke(root_library, "createObj7"));
  const auto& obj8 = Object::Handle(Invoke(root_library, "createObj8"));
 
  const auto& tav_null = TypeArguments::Handle(TypeArguments::null());
 
  // (1, B())      as (int, A)
  // (1, 'bye')    as (int, A)
  // (1, foo: B()) as (int, A)
  // (1, B(), 2)   as (int, A)
  RunTTSTest(type1, {obj1, tav_null, tav_null});
  RunTTSTest(type1, Failure({obj2, tav_null, tav_null}));
  RunTTSTest(type1, Failure({obj3, tav_null, tav_null}));
  RunTTSTest(type1, Failure({obj4, tav_null, tav_null}));
 
  // (C(), 2, 'hi') as (A, int, String)
  // (D(), 2, 'hi') as (A, int, String)
  RunTTSTest(type2, {obj5, tav_null, tav_null});
  RunTTSTest(type2, Failure({obj6, tav_null, tav_null}));
 
  // (3, D<int>()) as (int, D)
  // (D<int>(), 3) as (int, D)
  RunTTSTest(type3, {obj7, tav_null, tav_null});
  RunTTSTest(type3, Failure({obj8, tav_null, tav_null}));
}

ISOLATE_UNIT_TEST_CASE() [419/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Regress40964

)

Definition at line 1763 of file type_testing_stubs_test.cc.

                     {obj_futurenullablefunction, tav_null, tav_null}));
  RunTTSTest(type_future_function,
             Failure({obj_futurenullablefunction, tav_null, tav_null}));
  RunTTSTest(type_future_t,
             Failure({obj_futurenullablefunction, tav_object, tav_null}));
  RunTTSTest(type_future_t,
             Failure({obj_futurenullablefunction, tav_function, tav_null}));
  RunTTSTest(type_future_t, Failure({obj_futurenullablefunction,
                                     tav_function_int_nullary, tav_null}));
}
 
ISOLATE_UNIT_TEST_CASE(TTS_Regress40964) {
  const char* kScript =
      R"(
          class A<T> {
            test(x) => x as B<T>;
          }
          class B<T> {}
          class C<T> {}
 
          createACint() => A<C<int>>();
          createBCint() => B<C<int>>();
          createBCnum() => B<C<num>>();
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));

ISOLATE_UNIT_TEST_CASE() [420/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_Smi

)

Definition at line 1831 of file type_testing_stubs_test.cc.

ISOLATE_UNIT_TEST_CASE() [421/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_SubtypeRangeCheck

)

Definition at line 885 of file type_testing_stubs_test.cc.

                                              {
  const auto& root_library =
      Library::Handle(LoadTestScript(kSubtypeRangeCheckScript));
  const auto& class_a = Class::Handle(GetClass(root_library, "A"));
  const auto& class_base = Class::Handle(GetClass(root_library, "Base"));
  const auto& class_i = Class::Handle(GetClass(root_library, "I"));
  const auto& class_i2 = Class::Handle(GetClass(root_library, "I2"));
 
  const auto& obj_i = Object::Handle(Invoke(root_library, "createI"));
  const auto& obj_i2 = Object::Handle(Invoke(root_library, "createI2"));
  const auto& obj_base_int =
      Object::Handle(Invoke(root_library, "createBaseInt"));
  const auto& obj_base_null =
      Object::Handle(Invoke(root_library, "createBaseNull"));
  const auto& obj_base_never =
      Object::Handle(Invoke(root_library, "createBaseNever"));
  const auto& obj_a = Object::Handle(Invoke(root_library, "createA"));
  const auto& obj_a1 = Object::Handle(Invoke(root_library, "createA1"));
  const auto& obj_a2 = Object::Handle(Invoke(root_library, "createA2"));
  const auto& obj_b = Object::Handle(Invoke(root_library, "createB"));
  const auto& obj_b1 = Object::Handle(Invoke(root_library, "createB1"));
  const auto& obj_b2 = Object::Handle(Invoke(root_library, "createB2"));
 
  const auto& type_dynamic = Type::Handle(Type::DynamicType());
  auto& type_object = Type::Handle(Type::ObjectType());
  type_object = type_object.ToNullability(Nullability::kNullable, Heap::kNew);
 
  const auto& tav_null = TypeArguments::Handle(TypeArguments::null());
 
  auto& tav_object = TypeArguments::Handle(TypeArguments::New(1));
  tav_object.SetTypeAt(0, type_object);
  CanonicalizeTAV(&tav_object);
 
  auto& tav_object_dynamic = TypeArguments::Handle(TypeArguments::New(2));
  tav_object_dynamic.SetTypeAt(0, type_object);
  tav_object_dynamic.SetTypeAt(1, type_dynamic);
  CanonicalizeTAV(&tav_object_dynamic);
 
  auto& tav_dynamic_t = TypeArguments::Handle(TypeArguments::New(2));
  tav_dynamic_t.SetTypeAt(0, type_dynamic);
  tav_dynamic_t.SetTypeAt(
      1, TypeParameter::Handle(GetClassTypeParameter(class_base, 0)));
  CanonicalizeTAV(&tav_dynamic_t);
 
  // We will generate specialized TTS for instantiated interface types
  // where there are no type arguments or the type arguments are top
  // types.
  //
  //   obj as A                   // Subclass ranges
  //   obj as Base<Object?>       // Subclass ranges with top-type tav
  //   obj as I2                  // Subtype ranges
  //   obj as I<Object?, dynamic> // Subtype ranges with top-type tav
  //
 
  // <...> as A
  const auto& type_a = AbstractType::Handle(class_a.RareType());
  RunTTSTest(type_a, Failure({obj_i, tav_null, tav_null}));
  RunTTSTest(type_a, Failure({obj_i2, tav_null, tav_null}));
  RunTTSTest(type_a, Failure({obj_base_int, tav_null, tav_null}));
  RunTTSTest(type_a, {obj_a, tav_null, tav_null});
  RunTTSTest(type_a, {obj_a1, tav_null, tav_null});
  RunTTSTest(type_a, {obj_a2, tav_null, tav_null});
  RunTTSTest(type_a, Failure({obj_b, tav_null, tav_null}));
  RunTTSTest(type_a, Failure({obj_b1, tav_null, tav_null}));
  RunTTSTest(type_a, Failure({obj_b2, tav_null, tav_null}));
 
  // <...> as Base<Object?>
  auto& type_base = AbstractType::Handle(Type::New(class_base, tav_object));
  FinalizeAndCanonicalize(&type_base);
  RunTTSTest(type_base, Failure({obj_i, tav_null, tav_null}));
  RunTTSTest(type_base, Failure({obj_i2, tav_null, tav_null}));
  RunTTSTest(type_base, {obj_base_int, tav_null, tav_null});
  RunTTSTest(type_base, {obj_base_null, tav_null, tav_null});
  RunTTSTest(type_base, {obj_a, tav_null, tav_null});
  RunTTSTest(type_base, {obj_a1, tav_null, tav_null});
  RunTTSTest(type_base, {obj_a2, tav_null, tav_null});
  RunTTSTest(type_base, {obj_b, tav_null, tav_null});
  RunTTSTest(type_base, {obj_b1, tav_null, tav_null});
  RunTTSTest(type_base, {obj_b2, tav_null, tav_null});
 
  // Base<Null|Never> as Base<int?>
  // This is a regression test verifying that we don't fall through into
  // runtime for Null and Never.
  auto& type_nullable_int = Type::Handle(Type::IntType());
  type_nullable_int = type_nullable_int.ToNullability(
      TestCase::IsNNBD() ? Nullability::kNullable : Nullability::kLegacy,
      Heap::kNew);
  auto& tav_nullable_int = TypeArguments::Handle(TypeArguments::New(1));
  tav_nullable_int.SetTypeAt(0, type_nullable_int);
  CanonicalizeTAV(&tav_nullable_int);
  auto& type_base_nullable_int =
      AbstractType::Handle(Type::New(class_base, tav_nullable_int));
  FinalizeAndCanonicalize(&type_base_nullable_int);
  RunTTSTest(type_base_nullable_int, {obj_base_null, tav_null, tav_null});
  RunTTSTest(type_base_nullable_int, {obj_base_never, tav_null, tav_null});
 
  if (TestCase::IsNNBD()) {
    // Base<Null|Never> as Base<int>
    auto& type_int = Type::Handle(Type::IntType());
    type_int = type_int.ToNullability(Nullability::kNonNullable, Heap::kNew);
    auto& tav_int = TypeArguments::Handle(TypeArguments::New(1));
    tav_int.SetTypeAt(0, type_int);
    CanonicalizeTAV(&tav_int);
    auto& type_base_int = Type::Handle(Type::New(class_base, tav_int));
    type_base_int =
        type_base_int.ToNullability(Nullability::kNonNullable, Heap::kNew);
    FinalizeAndCanonicalize(&type_base_int);
    RunTTSTest(type_base_int, Failure({obj_base_null, tav_null, tav_null}));
    RunTTSTest(type_base_int, {obj_base_never, tav_null, tav_null});
  }
 
  // <...> as I2
  const auto& type_i2 = AbstractType::Handle(class_i2.RareType());
  RunTTSTest(type_i2, Failure({obj_i, tav_null, tav_null}));
  RunTTSTest(type_i2, {obj_i2, tav_null, tav_null});
  RunTTSTest(type_i2, Failure({obj_base_int, tav_null, tav_null}));
  RunTTSTest(type_i2, Failure({obj_a, tav_null, tav_null}));
  RunTTSTest(type_i2, {obj_a1, tav_null, tav_null});
  RunTTSTest(type_i2, Failure({obj_a2, tav_null, tav_null}));
  RunTTSTest(type_i2, Failure({obj_b, tav_null, tav_null}));
  RunTTSTest(type_i2, {obj_b1, tav_null, tav_null});
  RunTTSTest(type_i2, Failure({obj_b2, tav_null, tav_null}));
 
  // <...> as I<Object, dynamic>
  auto& type_i_object_dynamic =
      AbstractType::Handle(Type::New(class_i, tav_object_dynamic));
  FinalizeAndCanonicalize(&type_i_object_dynamic);
  RunTTSTest(type_i_object_dynamic, {obj_i, tav_null, tav_null});
  RunTTSTest(type_i_object_dynamic, Failure({obj_i2, tav_null, tav_null}));
  RunTTSTest(type_i_object_dynamic,
             Failure({obj_base_int, tav_null, tav_null}));
  RunTTSTest(type_i_object_dynamic, Failure({obj_a, tav_null, tav_null}));
  RunTTSTest(type_i_object_dynamic, Failure({obj_a1, tav_null, tav_null}));
  RunTTSTest(type_i_object_dynamic, {obj_a2, tav_null, tav_null});
  RunTTSTest(type_i_object_dynamic, Failure({obj_b, tav_null, tav_null}));
  RunTTSTest(type_i_object_dynamic, Failure({obj_b1, tav_null, tav_null}));
  RunTTSTest(type_i_object_dynamic, {obj_b2, tav_null, tav_null});
 
  // We do generate TTSes for uninstantiated types when we need to use
  // subtype range checks for the class of the interface type, but the TTS
  // may be partial (returns a false negative in some cases that means going
  // to the STC/runtime).
  //
  //   obj as I<dynamic, T>
  //
  auto& type_dynamic_t =
      AbstractType::Handle(Type::New(class_i, tav_dynamic_t));
  FinalizeAndCanonicalize(&type_dynamic_t);
  RunTTSTest(type_dynamic_t, {obj_i, tav_object, tav_null});
  RunTTSTest(type_dynamic_t, Failure({obj_i2, tav_object, tav_null}));
  RunTTSTest(type_dynamic_t, Failure({obj_base_int, tav_object, tav_null}));
  RunTTSTest(type_dynamic_t, Failure({obj_a, tav_object, tav_null}));
  RunTTSTest(type_dynamic_t, Failure({obj_a1, tav_object, tav_null}));
  RunTTSTest(type_dynamic_t, {obj_a2, tav_object, tav_null});
  RunTTSTest(type_dynamic_t, Failure({obj_b, tav_object, tav_null}));
  RunTTSTest(type_dynamic_t, Failure({obj_b1, tav_object, tav_null}));
  RunTTSTest(type_dynamic_t, FalseNegative({obj_b2, tav_object, tav_null}));
 
  // obj as Object (with null safety)
  auto isolate_group = IsolateGroup::Current();
  auto& type_non_nullable_object =
      Type::Handle(isolate_group->object_store()->non_nullable_object_type());
  RunTTSTest(type_non_nullable_object, {obj_a, tav_null, tav_null});
}

ISOLATE_UNIT_TEST_CASE() [422/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TTS_TypeParameter

)

Definition at line 1791 of file type_testing_stubs_test.cc.

                       {bcint, cint_tav, function_tav});
 
  // a as B<T> -- a==B<C<num>, T==<C<int>>
  RunTTSTest(dst_type, Failure({bcnum, cint_tav, function_tav}));
}
 
ISOLATE_UNIT_TEST_CASE(TTS_TypeParameter) {
  const char* kScript =
      R"(
          class A<T> {
            T test(dynamic x) => x as T;
          }
          H genericFun<H>(dynamic x) => x as H;
 
          createAInt() => A<int>();
          createAString() => A<String>();
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& class_a = Class::Handle(GetClass(root_library, "A"));
  ClassFinalizer::FinalizeTypesInClass(class_a);
 

ISOLATE_UNIT_TEST_CASE() [423/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TwoWayInduction

)

Definition at line 176 of file loops_test.cc.

            {
        for (int i = 0; i < 100; i++) {
          for (int j = 1; j < 100; j++) {
            for (int k = 2; k < 100; k++) {
            }
          }
        }
      }
      main() {
        foo();
      }
    )";

ISOLATE_UNIT_TEST_CASE() [424/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TypeArguments

)

Definition at line 263 of file object_test.cc.

                                      {
  const Type& type1 = Type::Handle(Type::Double());
  const Type& type2 = Type::Handle(Type::StringType());
  const TypeArguments& type_arguments1 =
      TypeArguments::Handle(TypeArguments::New(2));
  type_arguments1.SetTypeAt(0, type1);
  type_arguments1.SetTypeAt(1, type2);
  const TypeArguments& type_arguments2 =
      TypeArguments::Handle(TypeArguments::New(2));
  type_arguments2.SetTypeAt(0, type1);
  type_arguments2.SetTypeAt(1, type2);
  EXPECT_NE(type_arguments1.ptr(), type_arguments2.ptr());
  OS::PrintErr("1: %s\n", type_arguments1.ToCString());
  OS::PrintErr("2: %s\n", type_arguments2.ToCString());
  EXPECT(type_arguments1.Equals(type_arguments2));
  TypeArguments& type_arguments3 = TypeArguments::Handle();
  type_arguments1.Canonicalize(thread);
  type_arguments3 ^= type_arguments2.Canonicalize(thread);
  EXPECT_EQ(type_arguments1.ptr(), type_arguments3.ptr());
}

ISOLATE_UNIT_TEST_CASE() [425/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TypedData_Grow

)

Definition at line 2206 of file object_test.cc.

                                       {
  const intptr_t kSmallSize = 42;
  const intptr_t kLargeSize = 1000;
 
  Random random(42);
 
  for (classid_t cid = kFirstTypedDataCid; cid <= kLastTypedDataCid;
       cid += kNumTypedDataCidRemainders) {
    ASSERT(IsTypedDataClassId(cid));
 
    const auto& small = TypedData::Handle(TypedData::New(cid, kSmallSize));
    EXPECT_EQ(small.LengthInBytes(), kSmallSize * small.ElementSizeInBytes());
 
    for (intptr_t i = 0; i < TypedData::ElementSizeFor(cid) * kSmallSize; i++) {
      small.SetUint8(i, static_cast<uint8_t>(random.NextUInt64() & 0xff));
    }
 
    const auto& big = TypedData::Handle(TypedData::Grow(small, kLargeSize));
    EXPECT_EQ(small.GetClassId(), big.GetClassId());
    EXPECT_EQ(big.LengthInBytes(), kLargeSize * big.ElementSizeInBytes());
 
    for (intptr_t i = 0; i < TypedData::ElementSizeFor(cid) * kSmallSize; i++) {
      EXPECT_EQ(small.GetUint8(i), big.GetUint8(i));
    }
    for (intptr_t i = TypedData::ElementSizeFor(cid) * kSmallSize;
         i < TypedData::ElementSizeFor(cid) * kLargeSize; i++) {
      EXPECT_EQ(0, big.GetUint8(i));
    }
  }
}

ISOLATE_UNIT_TEST_CASE() [426/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TypePropagator_RecordFieldAccess

)

Definition at line 699 of file type_propagator_test.cc.

                                                         {
  const char* kScript = R"(
    @pragma('vm:never-inline')
    (int, {String foo}) bar() => (42, foo: 'hi');
    @pragma('vm:never-inline')
    baz(x) {}
 
    void main() {
      final x = bar();
      baz(x.$1 + 1);
      baz(x.foo);
    }
  )";
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "main"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                   ParallelMovesHandling::kSkip);
 
  LoadFieldInstr* load1 = nullptr;
  LoadFieldInstr* load2 = nullptr;
 
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      kMatchAndMoveStaticCall,
      {kMatchAndMoveLoadField, &load1},
      kMatchAndMoveCheckSmi,
      kMatchAndMoveBinarySmiOp,
      kMatchAndMoveMoveArgument,
      kMatchAndMoveStaticCall,
      {kMatchAndMoveLoadField, &load2},
      kMatchAndMoveMoveArgument,
      kMatchAndMoveStaticCall,
      kMatchDartReturn,
  }));
 
  EXPECT_PROPERTY(load1->Type()->ToAbstractType(), it.IsIntType());
  EXPECT_PROPERTY(load2->Type()->ToAbstractType(), it.IsStringType());
}

ISOLATE_UNIT_TEST_CASE() [427/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TypePropagator_RedefinitionAfterStrictCompareWithLoadClassId

)

Definition at line 94 of file type_propagator_test.cc.

                                                                  {
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
 
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::DynamicType()));
 
  // We are going to build the following graph:
  //
  // B0[graph_entry]:
  // B1[function_entry]:
  //   v0 <- Parameter(0)
  //   v1 <- LoadClassId(v0)
  //   if v1 == kDoubleCid then B2 else B3
  // B2:
  //   Return(v0)
  // B3:
  //   Return(v0)
 
  Definition* v0;
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
  auto b2 = H.TargetEntry();
  auto b3 = H.TargetEntry();
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    v0 = builder.AddParameter(0, kTagged);
    auto load_cid = builder.AddDefinition(new LoadClassIdInstr(new Value(v0)));
    builder.AddBranch(
        new StrictCompareInstr(
            InstructionSource(), Token::kEQ_STRICT, new Value(load_cid),
            new Value(H.IntConstant(kDoubleCid)),
            /*needs_number_check=*/false, S.GetNextDeoptId()),
        b2, b3);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b2);
    builder.AddReturn(new Value(v0));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b3);
    builder.AddReturn(new Value(v0));
  }
 
  H.FinishGraph();
 
  FlowGraphTypePropagator::Propagate(H.flow_graph());
 
  // There should be no information available about the incoming type of
  // the parameter either on entry or in B3.
  EXPECT_PROPERTY(v0->Type()->ToAbstractType(), it.IsDynamicType());
  auto b3_value = b3->last_instruction()->AsDartReturn()->value();
  EXPECT(b3_value->Type() == v0->Type());
 
  // In B3 v0 is constrained by comparison of its cid with kDoubleCid - it
  // should be non-nullable double. There should be a Redefinition inserted to
  // prevent LICM past the branch.
  auto b2_value = b2->last_instruction()->AsDartReturn()->value();
  EXPECT_PROPERTY(b2_value->Type(), it.IsDouble());
  EXPECT_PROPERTY(b2_value->definition(), it.IsRedefinition());
  EXPECT_PROPERTY(b2_value->definition()->GetBlock(), &it == b2);
}

ISOLATE_UNIT_TEST_CASE() [428/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TypePropagator_RedefinitionAfterStrictCompareWithNull

)

Definition at line 28 of file type_propagator_test.cc.

                                                                              {
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
 
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::IntType()));
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
 
  // We are going to build the following graph:
  //
  // B0[graph_entry]:
  // B1[function_entry]:
  //   v0 <- Parameter(0)
  //   if v0 == null then B2 else B3
  // B2:
  //   Return(v0)
  // B3:
  //   Return(v0)
 
  Definition* v0;
  auto b2 = H.TargetEntry();
  auto b3 = H.TargetEntry();
 
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    v0 = builder.AddParameter(0, kTagged);
    builder.AddBranch(
        new StrictCompareInstr(
            InstructionSource(), Token::kEQ_STRICT, new Value(v0),
            new Value(H.flow_graph()->GetConstant(Object::Handle())),
            /*needs_number_check=*/false, S.GetNextDeoptId()),
        b2, b3);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b2);
    builder.AddReturn(new Value(v0));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b3);
    builder.AddReturn(new Value(v0));
  }
 
  H.FinishGraph();
 
  FlowGraphTypePropagator::Propagate(H.flow_graph());
 
  // We expect that v0 is inferred to be nullable int because that is what
  // static type of an associated variable tells us.
  EXPECT(v0->Type()->IsNullableInt());
 
  // In B2 v0 should not have any additional type information so reaching
  // type should be still nullable int.
  auto b2_value = b2->last_instruction()->AsDartReturn()->value();
  EXPECT(b2_value->Type()->IsNullableInt());
 
  // In B3 v0 is constrained by comparison with null - it should be non-nullable
  // integer. There should be a Redefinition inserted to prevent LICM past
  // the branch.
  auto b3_value = b3->last_instruction()->AsDartReturn()->value();
  EXPECT(b3_value->Type()->IsInt());
  EXPECT(b3_value->definition()->IsRedefinition());
  EXPECT(b3_value->definition()->GetBlock() == b3);
}

ISOLATE_UNIT_TEST_CASE() [429/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TypePropagator_Refinement

)

Definition at line 159 of file type_propagator_test.cc.

                                                  {
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
 
  const Class& object_class =
      Class::Handle(thread->isolate_group()->object_store()->object_class());
 
  const FunctionType& signature = FunctionType::Handle(FunctionType::New());
  const Function& target_func = Function::ZoneHandle(Function::New(
      signature, String::Handle(Symbols::New(thread, "dummy2")),
      UntaggedFunction::kRegularFunction,
      /*is_static=*/true,
      /*is_const=*/false,
      /*is_abstract=*/false,
      /*is_external=*/false,
      /*is_native=*/true, object_class, TokenPosition::kNoSource));
  signature.set_result_type(AbstractType::Handle(Type::IntType()));
 
  const Field& field = Field::ZoneHandle(
      Field::New(String::Handle(Symbols::New(thread, "dummy")),
                 /*is_static=*/true,
                 /*is_final=*/false,
                 /*is_const=*/false,
                 /*is_reflectable=*/true,
                 /*is_late=*/false, object_class, Object::dynamic_type(),
                 TokenPosition::kNoSource, TokenPosition::kNoSource));
  {
    SafepointWriteRwLocker locker(thread,
                                  thread->isolate_group()->program_lock());
    thread->isolate_group()->RegisterStaticField(field, Object::Handle());
  }
 
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::DynamicType()));
 
  // We are going to build the following graph:
  //
  // B0[graph_entry]
  // B1[function_entry]:
  //   v0 <- Parameter(0)
  //   v1 <- Constant(0)
  //   if v0 == 1 then B3 else B2
  // B2:
  //   v2 <- StaticCall(target_func)
  //   goto B4
  // B3:
  //   goto B4
  // B4:
  //  v3 <- phi(v1, v2)
  //  return v5
 
  Definition* v0;
  Definition* v2;
  PhiInstr* v3;
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
  auto b2 = H.TargetEntry();
  auto b3 = H.TargetEntry();
  auto b4 = H.JoinEntry();
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    v0 = builder.AddParameter(0, kTagged);
    builder.AddBranch(new StrictCompareInstr(
                          InstructionSource(), Token::kEQ_STRICT, new Value(v0),
                          new Value(H.IntConstant(1)),
                          /*needs_number_check=*/false, S.GetNextDeoptId()),
                      b2, b3);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b2);
    v2 = builder.AddDefinition(
        new StaticCallInstr(InstructionSource(), target_func,
                            /*type_args_len=*/0,
                            /*argument_names=*/Array::empty_array(),
                            InputsArray(0), S.GetNextDeoptId(),
                            /*call_count=*/0, ICData::RebindRule::kStatic));
    builder.AddInstruction(new GotoInstr(b4, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b3);
    builder.AddInstruction(new GotoInstr(b4, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b4);
    v3 = H.Phi(b4, {{b2, v2}, {b3, H.IntConstant(0)}});
    builder.AddPhi(v3);
    builder.AddReturn(new Value(v3));
  }
 
  H.FinishGraph();
  FlowGraphTypePropagator::Propagate(H.flow_graph());
 
  EXPECT_PROPERTY(v2->Type(), it.IsNullableInt());
  EXPECT_PROPERTY(v3->Type(), it.IsNullableInt());
 
  auto v4 = new LoadStaticFieldInstr(field, InstructionSource());
  H.flow_graph()->InsertBefore(v2, v4, nullptr, FlowGraph::kValue);
  v2->ReplaceUsesWith(v4);
  v2->RemoveFromGraph();
 
  FlowGraphTypePropagator::Propagate(H.flow_graph());
 
  EXPECT_PROPERTY(v3->Type(), it.IsNullableInt());
}

ISOLATE_UNIT_TEST_CASE() [430/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TypePropagator_Regress36156

)

Definition at line 268 of file type_propagator_test.cc.

                                                    {
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::DynamicType()));
 
  // We are going to build the following graph:
  //
  // B0[graph_entry]
  // B1[function_entry]:
  //   v0 <- Parameter(0)
  //   v1 <- Constant(42)
  //   v2 <- Constant(24)
  //   v4 <- Constant(1.0)
  //   if v0 == 1 then B6 else B2
  // B2:
  //   if v0 == 2 then B3 else B4
  // B3:
  //   goto B5
  // B4:
  //   goto B5
  // B5:
  //   v3 <- phi(v1, v2)
  //   goto B7
  // B6:
  //   goto B7
  // B7:
  //  v5 <- phi(v4, v3)
  //  return v5
 
  Definition* v0;
  PhiInstr* v3;
  PhiInstr* v5;
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
  auto b2 = H.TargetEntry();
  auto b3 = H.TargetEntry();
  auto b4 = H.TargetEntry();
  auto b5 = H.JoinEntry();
  auto b6 = H.TargetEntry();
  auto b7 = H.JoinEntry();
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    v0 = builder.AddParameter(0, kTagged);
    builder.AddBranch(new StrictCompareInstr(
                          InstructionSource(), Token::kEQ_STRICT, new Value(v0),
                          new Value(H.IntConstant(1)),
                          /*needs_number_check=*/false, S.GetNextDeoptId()),
                      b6, b2);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b2);
    builder.AddBranch(new StrictCompareInstr(
                          InstructionSource(), Token::kEQ_STRICT, new Value(v0),
                          new Value(H.IntConstant(2)),
                          /*needs_number_check=*/false, S.GetNextDeoptId()),
                      b3, b4);
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b3);
    builder.AddInstruction(new GotoInstr(b5, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b4);
    builder.AddInstruction(new GotoInstr(b5, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b5);
    v3 = H.Phi(b5, {{b3, H.IntConstant(42)}, {b4, H.IntConstant(24)}});
    builder.AddPhi(v3);
    builder.AddInstruction(new GotoInstr(b7, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b6);
    builder.AddInstruction(new GotoInstr(b7, S.GetNextDeoptId()));
  }
 
  {
    BlockBuilder builder(H.flow_graph(), b7);
    v5 = H.Phi(b7, {{b5, v3}, {b6, H.DoubleConstant(1.0)}});
    builder.AddPhi(v5);
    builder.AddInstruction(new DartReturnInstr(
        InstructionSource(), new Value(v5), S.GetNextDeoptId()));
  }
 
  H.FinishGraph();
 
  FlowGraphTypePropagator::Propagate(H.flow_graph());
 
  // We expect that v3 has an integer type, and v5 is either T{Object} or
  // T{num}.
  EXPECT_PROPERTY(v3->Type(), it.IsInt());
  EXPECT_PROPERTY(v5->Type()->ToAbstractType(),
                  it.IsObjectType() || it.IsNumberType());
 
  // Now unbox v3 phi by inserting unboxing for both inputs and boxing
  // for the result.
  {
    v3->set_representation(kUnboxedInt64);
    for (intptr_t i = 0; i < v3->InputCount(); i++) {
      auto input = v3->InputAt(i);
      auto unbox =
          new UnboxInt64Instr(input->CopyWithType(), S.GetNextDeoptId(),
                              Instruction::kNotSpeculative);
      H.flow_graph()->InsertBefore(
          v3->block()->PredecessorAt(i)->last_instruction(), unbox, nullptr,
          FlowGraph::kValue);
      input->BindTo(unbox);
    }
 
    auto box = new BoxInt64Instr(new Value(v3));
    v3->ReplaceUsesWith(box);
    H.flow_graph()->InsertBefore(b4->last_instruction(), box, nullptr,
                                 FlowGraph::kValue);
  }
 
  // Run type propagation again.
  FlowGraphTypePropagator::Propagate(H.flow_graph());
 
  // If CompileType of v3 would be cached as a reaching type at its use in
  // v5 then we will be incorrect type propagation results.
  // We expect that v3 has an integer type, and v5 is either T{Object} or
  // T{num}.
  EXPECT_PROPERTY(v3->Type(), it.IsInt());
  EXPECT_PROPERTY(v5->Type()->ToAbstractType(),
                  it.IsObjectType() || it.IsNumberType());
}

ISOLATE_UNIT_TEST_CASE() [431/463]

dart::ISOLATE_UNIT_TEST_CASE

(

TypePropagator_RegressFlutter76919

)

Definition at line 493 of file type_propagator_test.cc.

                                                           {
  CompilerState S(thread, /*is_aot=*/true, /*is_optimizing=*/true);
 
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::DynamicType()));
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
 
  // We are going to build the following graph:
  //
  // B0[graph_entry]:
  // B1[function_entry]:
  //   v0 <- Parameter(0)
  //   AssertAssignable(v0, 'int')
  //   CheckSmi(v0)
  //   Return(v0)
 
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    Definition* v0 = builder.AddParameter(0, kTagged);
    auto null_value = builder.AddNullDefinition();
    builder.AddDefinition(new AssertAssignableInstr(
        InstructionSource(), new Value(v0),
        new Value(
            H.flow_graph()->GetConstant(Type::ZoneHandle(Type::IntType()))),
        new Value(null_value), new Value(null_value), Symbols::Value(),
        S.GetNextDeoptId()));
    builder.AddInstruction(new CheckSmiInstr(new Value(v0), S.GetNextDeoptId(),
                                             InstructionSource()));
    builder.AddReturn(new Value(v0));
  }
 
  H.FinishGraph();
 
  H.flow_graph()->EliminateEnvironments();
  FlowGraphTypePropagator::Propagate(H.flow_graph());  // Should not crash.
}

ISOLATE_UNIT_TEST_CASE() [432/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Utf8Decode

)

Definition at line 64 of file unicode_test.cc.

                                   {
  // Examples from the Unicode specification, chapter 3
  {
    const char* src = "\x41\xC3\xB1\x42";
    int32_t expected[] = {0x41, 0xF1, 0x42};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  {
    const char* src = "\x4D";
    int32_t expected[] = {0x4D};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  {
    const char* src = "\xD0\xB0";
    int32_t expected[] = {0x430};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  {
    const char* src = "\xE4\xBA\x8C";
    int32_t expected[] = {0x4E8C};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  {
    const char* src = "\xF0\x90\x8C\x82";
    int32_t expected[] = {0x10302};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  {
    const char* src = "\x4D\xD0\xB0\xE4\xBA\x8C\xF0\x90\x8C\x82";
    int32_t expected[] = {0x4D, 0x430, 0x4E8C, 0x10302};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // Mixture of non-ASCII and ASCII characters
  {
    const char* src =
        "\xD7\x92\xD7\x9C\xD7\xA2\xD7\x93"
        "\x20"
        "\xD7\x91\xD7\xA8\xD7\x9B\xD7\x94";
    int32_t expected[] = {0x5D2, 0x5DC, 0x5E2, 0x5D3, 0x20,
                          0x5D1, 0x5E8, 0x5DB, 0x5D4};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
 
  // 1 - Some correct UTF-8 text
  {
    const char* src = "\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5";
    int32_t expected[] = {0x3BA, 0x1F79, 0x3C3, 0x3BC, 0x3B5};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2 - Boundary condition test cases
 
  // 2.1 - First possible sequence of a certain length
 
  // 2.1.1 - 1 byte (U-00000000):        "\x00"
  {
    const char* src = "\x00";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.1.2 - 2 bytes (U-00000080):        "\xC2\x80"
  {
    const char* src = "\xC2\x80";
    int32_t expected[] = {0x80};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.1.3 - 3 bytes (U-00000800):        "\xE0\xA0\x80"
  {
    const char* src = "\xE0\xA0\x80";
    int32_t expected[] = {0x800};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.1.4 - 4 bytes (U-00010000):        "\xF0\x90\x80\x80"
  {
    const char* src = "\xF0\x90\x80\x80";
    int32_t expected[] = {0x10000};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.1.5 - 5 bytes (U-00200000):        "\xF8\x88\x80\x80\x80"
  {
    const char* src = "\xF8\x88\x80\x80\x80";
    int32_t expected[] = {0x200000};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.1.6 - 6 bytes (U-04000000):        "\xFC\x84\x80\x80\x80\x80"
  {
    const char* src = "\xFC\x84\x80\x80\x80\x80";
    int32_t expected[] = {0x400000};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.2 - Last possible sequence of a certain length
 
  // 2.2.1 - 1 byte (U-0000007F):        "\x7F"
  {
    const char* src = "\x7F";
    int32_t expected[] = {0x7F};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.2.2 - 2 bytes (U-000007FF):        "\xDF\xBF"
  {
    const char* src = "\xDF\xBF";
    int32_t expected[] = {0x7FF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.2.3 - 3 bytes (U-0000FFFF):        "\xEF\xBF\xBF"
  {
    const char* src = "\xEF\xBF\xBF";
    int32_t expected[] = {0xFFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.2.4 - 4 bytes (U-001FFFFF):        "\xF7\xBF\xBF\xBF"
  {
    const char* src = "\xF7\xBF\xBF\xBF";
    int32_t expected[] = {0x1FFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.2.5 - 5 bytes (U-03FFFFFF):        "\xFB\xBF\xBF\xBF\xBF"
  {
    const char* src = "\xFB\xBF\xBF\xBF\xBF";
    int32_t expected[] = {0x3FFFFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.2.6 - 6 bytes (U-7FFFFFFF):        "\xFD\xBF\xBF\xBF\xBF\xBF"
  {
    const char* src = "\xFD\xBF\xBF\xBF\xBF\xBF";
    int32_t expected[] = {0x7FFFFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.3 - Other boundary conditions
 
  // 2.3.1 - U-0000D7FF = ed 9f bf = "\xED\x9F\xBF"
  {
    const char* src = "\xED\x9F\xBF";
    int32_t expected[] = {0xD7FF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.3.2 - U-0000E000 = ee 80 80 = "\xEE\x80\x80"
  {
    const char* src = "\xEE\x80\x80";
    int32_t expected[] = {0xE000};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.3.3 - U-0000FFFD = ef bf bd = "\xEF\xBF\xBD"
  {
    const char* src = "\xEF\xBF\xBD";
    int32_t expected[] = {0xFFFD};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.3.4 - U-0010FFFF = f4 8f bf bf = "\xF4\x8F\xBF\xBF"
  {
    const char* src = "\xF4\x8F\xBF\xBF";
    int32_t expected[] = {0x10FFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 2.3.5 - U-00110000 = f4 90 80 80 = "\xF4\x90\x80\x80"
  {
    const char* src = "\xF4\x90\x80\x80";
    int32_t expected[] = {0x110000};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3 - Malformed sequences
 
  // 3.1 - Unexpected continuation bytes
 
  // 3.1.1 - First continuation byte 0x80: "\x80"
  {
    const char* src = "\x80";
    int32_t expected[] = {0x80};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.1.2 - Last continuation byte 0xbf: "\xBF"
  {
    const char* src = "\xBF";
    int32_t expected[] = {0xBF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.1.3 - 2 continuation bytes: "\x80\xBF"
  {
    const char* src = "\x80\xBF";
    int32_t expected[] = {0x80, 0xBF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.1.4 - 3 continuation bytes: "\x80\xBF\x80"
  {
    const char* src = "\x80\xBF\x80";
    int32_t expected[] = {0x80, 0xBF, 0x80};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.1.5 - 4 continuation bytes: "\x80\xBF\x80\xBF"
  {
    const char* src = "\x80\xBF\x80\xBF";
    int32_t expected[] = {0x80, 0xBF, 0x80, 0xBF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.1.6 - 5 continuation bytes: "\x80\xBF\x80\xBF\x80"
  {
    const char* src = "\x80\xBF\x80\xBF\x80";
    int32_t expected[] = {0x80, 0xBF, 0x80, 0xBF, 0x80};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.1.7 - 6 continuation bytes: "\x80\xBF\x80\xBF\x80\xBF"
  {
    const char* src = "\x80\xBF\x80\xBF\x80\xBF";
    int32_t expected[] = {0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.1.8 - 7 continuation bytes: "\x80\xBF\x80\xBF\x80\xBF\x80"
  {
    const char* src = "\x80\xBF\x80\xBF\x80\xBF\x80";
    int32_t expected[] = {0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF, 0x80};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.1.9 - Sequence of all 64 possible continuation bytes (0x80-0xbf):
  {
    const char* src =
        "\x80\x81\x82\x83\x84\x85\x86\x87"
        "\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
        "\x90\x91\x92\x93\x94\x95\x96\x97"
        "\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
        "\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
        "\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
        "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
        "\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    for (size_t i = 0; i < strlen(src); ++i) {
      memset(dst, 0xFF, sizeof(dst));
      bool is_valid = Utf8::DecodeCStringToUTF32(&src[i], dst, ARRAY_SIZE(dst));
      EXPECT(!is_valid);
      EXPECT(memcmp(expected, dst, sizeof(expected)));
    }
  }
 
  // 3.2 - Lonely start character
 
  // 3.2.1 - All 32 first bytes of 2-byte sequences (0xc0-0xdf), each
  //         followed by a space character:
  {
    const char* src =
        "\xC0\x20\xC1\x20\xC2\x20\xC3\x20"
        "\xC4\x20\xC5\x20\xC6\x20\xC7\x20"
        "\xC8\x20\xC9\x20\xCA\x20\xCB\x20"
        "\xCC\x20\xCD\x20\xCE\x20\xCF\x20"
        "\xD0\x20\xD1\x20\xD2\x20\xD3\x20"
        "\xD4\x20\xD5\x20\xD6\x20\xD7\x20"
        "\xD8\x20\xD9\x20\xDA\x20\xDB\x20"
        "\xDC\x20\xDD\x20\xDE\x20\xDF\x20";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    for (size_t i = 0; i < strlen(src); i += 2) {
      memset(dst, 0xFF, sizeof(dst));
      bool is_valid = Utf8::DecodeCStringToUTF32(&src[i], dst, ARRAY_SIZE(dst));
      EXPECT(!is_valid);
      EXPECT(memcmp(expected, dst, sizeof(expected)));
    }
  }
 
  // 3.2.2 - All 16 first bytes of 3-byte sequences (0xe0-0xef), each
  //         followed by a space character:
  {
    const char* src =
        "\xE0\x20\xE1\x20\xE2\x20\xE3\x20"
        "\xE4\x20\xE5\x20\xE6\x20\xE7\x20"
        "\xE8\x20\xE9\x20\xEA\x20\xEB\x20"
        "\xEC\x20\xED\x20\xEE\x20\xEF\x20";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    for (size_t i = 0; i < strlen(src); i += 2) {
      memset(dst, 0xFF, sizeof(dst));
      bool is_valid = Utf8::DecodeCStringToUTF32(&src[i], dst, ARRAY_SIZE(dst));
      EXPECT(!is_valid);
      EXPECT(memcmp(expected, dst, sizeof(expected)));
    }
  }
 
  // 3.2.3 - All 8 first bytes of 4-byte sequences (0xf0-0xf7), each
  //         followed by a space character:
  {
    const char* src =
        "\xF0\x20\xF1\x20\xF2\x20\xF3\x20"
        "\xF4\x20\xF5\x20\xF6\x20\xF7\x20";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    for (size_t i = 0; i < strlen(src); i += 2) {
      memset(dst, 0xFF, sizeof(dst));
      bool is_valid = Utf8::DecodeCStringToUTF32(&src[i], dst, ARRAY_SIZE(dst));
      EXPECT(!is_valid);
      EXPECT(memcmp(expected, dst, sizeof(expected)));
    }
  }
 
  // 3.2.4 - All 4 first bytes of 5-byte sequences (0xf8-0xfb), each
  //         followed by a space character:
  {
    const char* src = "\xF8\x20\xF9\x20\xFA\x20\xFB\x20";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    for (size_t i = 0; i < strlen(src); i += 2) {
      memset(dst, 0xFF, sizeof(dst));
      bool is_valid = Utf8::DecodeCStringToUTF32(&src[i], dst, ARRAY_SIZE(dst));
      EXPECT(!is_valid);
      EXPECT(memcmp(expected, dst, sizeof(expected)));
    }
  }
 
  // 3.2.5 - All 2 first bytes of 6-byte sequences (0xfc-0xfd), each
  //         followed by a space character:
  {
    const char* src = "\xFC\x20\xFD\x20";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    for (size_t i = 0; i < strlen(src); i += 2) {
      memset(dst, 0xFF, sizeof(dst));
      bool is_valid = Utf8::DecodeCStringToUTF32(&src[i], dst, ARRAY_SIZE(dst));
      EXPECT(!is_valid);
      EXPECT(memcmp(expected, dst, sizeof(expected)));
    }
  }
 
  // 3.3 - Sequences with last continuation byte missing
 
  // 3.3.1 - 2-byte sequence with last byte missing (U+0000): "\xC0"
  {
    const char* src = "\xC0";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.2 - 3-byte sequence with last byte missing (U+0000): "\xE0\x80"
  {
    const char* src = "\xE0\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.3 - 4-byte sequence with last byte missing (U+0000): "\xF0\x80\x80"
  {
    const char* src = "\xF0\x80\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.4 - 5-byte sequence with last byte missing (U+0000): "\xF8\x80\x80\x80"
  {
    const char* src = "\xF8\x80\x80\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.5 - 6-byte sequence with last byte missing (U+0000):
  // "\xFC\x80\x80\x80\x80"
  {
    const char* src = "\xFC\x80\x80\x80\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.6 - 2-byte sequence with last byte missing (U-000007FF): "\xDF"
  {
    const char* src = "\xDF";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.7 - 3-byte sequence with last byte missing (U-0000FFFF): "\xEF\xBF"
  {
    const char* src = "\xEF\xBF";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.8 - 4-byte sequence with last byte missing (U-001FFFFF): "\xF7\xBF\xBF"
  {
    const char* src = "\xF7\xBF\xBF";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.9 - 5-byte sequence with last byte missing (U-03FFFFFF):
  // "\xFB\xBF\xBF\xBF"
  {
    const char* src = "\xFB\xBF\xBF\xBF";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.3.10 - 6-byte sequence with last byte missing (U-7FFFFFFF):
  // "\xFD\xBF\xBF\xBF\xBF"
  {
    const char* src = "\xFD\xBF\xBF\xBF\xBF";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.4 - Concatenation of incomplete sequences
  {
    const char* src =
        "\xC0\xE0\x80\xF0\x80\x80"
        "\xF8\x80\x80\x80\xFC\x80"
        "\x80\x80\x80\xDF\xEF\xBF"
        "\xF7\xBF\xBF\xFB\xBF\xBF"
        "\xBF\xFD\xBF\xBF\xBF\xBF";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    for (size_t i = 0; i < strlen(src); ++i) {
      for (size_t j = 1; j < (strlen(src) - i); ++j) {
        memset(dst, 0xFF, sizeof(dst));
        bool is_valid =
            Utf8::DecodeCStringToUTF32(&src[i], dst, ARRAY_SIZE(dst));
        EXPECT(!is_valid);
        EXPECT(memcmp(expected, dst, sizeof(expected)));
      }
    }
  }
 
  // 3.5 - Impossible bytes
 
  // 3.5.1 - fe = "\xFE"
  {
    const char* src = "\xFE";
    int32_t expected[] = {0xFE};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.5.2 - ff = "\xFF"
  {
    const char* src = "\xFF";
    int32_t expected[] = {0xFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 3.5.3 - fe fe ff ff = "\xFE\xFE\xFF\xFF"
  {
    const char* src = "\xFE\xFE\xFF\xFF";
    int32_t expected[] = {0xFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4 - Overlong sequences
 
  // 4.1 - Examples of an overlong ASCII character
 
  // 4.1.1 - U+002F = c0 af             = "\xC0\xAF"
  {
    const char* src = "\xC0\xAF";
    int32_t expected[] = {0x2F};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.1.2 - U+002F = e0 80 af          = "\xE0\x80\xAF"
  {
    const char* src = "\xE0\x80\xAF";
    int32_t expected[] = {0x2F};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.1.3 - U+002F = f0 80 80 af       = "\xF0\x80\x80\xAF"
  {
    const char* src = "\xF0\x80\x80\xAF";
    int32_t expected[] = {0x2F};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.1.4 - U+002F = f8 80 80 80 af    = "\xF8\x80\x80\x80\xAF"
  {
    const char* src = "\xF8\x80\x80\x80\xAF";
    int32_t expected[] = {0x2F};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.1.5 - U+002F = fc 80 80 80 80 af = "\xFC\x80\x80\x80\x80\xAF"
  {
    const char* src = "\xFC\x80\x80\x80\x80\xAF";
    int32_t expected[] = {0x2F};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.2  Maximum overlong sequences
 
  // 4.2.1 - U-0000007F = c1 bf             = "\xC1\xBF"
  {
    const char* src = "\xC1\xBF";
    int32_t expected[] = {0x7F};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.2.2 U+000007FF = e0 9f bf          = "\xE0\x9F\xBF"
  {
    const char* src = "\xE0\x9F\xBF";
    int32_t expected[] = {0x7FF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.2.3 - U+0000FFFF = f0 8f bf bf       = "\xF0\x8F\xBF\xBF"
  {
    const char* src = "\xF0\x8F\xBF\xBF";
    int32_t expected[] = {0xFFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.2.4  U-001FFFFF = f8 87 bf bf bf    = "\xF8\x87\xBF\xBF\xBF"
  {
    const char* src = "\xF8\x87\xBF\xBF\xBF";
    int32_t expected[] = {0x1FFFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.2.5  U-03FFFFFF = fc 83 bf bf bf bf = "\xFC\x83\xBF\xBF\xBF\xBF"
  {
    const char* src = "\xFC\x83\xBF\xBF\xBF\xBF";
    int32_t expected[] = {0x3FFFFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.3 - Overlong representation of the NUL character
 
  // 4.3.1 - U+0000 = "\xC0\x80"
  {
    const char* src = "\xC0\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.3.2  U+0000 = e0 80 80 = "\xE0\x80\x80"
  {
    const char* src = "\xE0\x80\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.3.3  U+0000 = f0 80 80 80 = "\xF0\x80\x80\x80"
  {
    const char* src = "\xF0\x80\x80\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.3.4  U+0000 = f8 80 80 80 80 = "\xF8\x80\x80\x80\x80"
  {
    const char* src = "\xF8\x80\x80\x80\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 4.3.5  U+0000 = fc 80 80 80 80 80 = "\xFC\x80\x80\x80\x80\x80"
  {
    const char* src = "\xFC\x80\x80\x80\x80\x80";
    int32_t expected[] = {0x0};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0xFF, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(!is_valid);
    EXPECT(memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.1 - Single UTF-16 surrogates
  // UTF-8 suggests single surrogates are invalid, but both JS and
  // Dart allow them and make use of them.
 
  // 5.1.1 - U+D800 = ed a0 80 = "\xED\xA0\x80"
  {
    const char* src = "\xED\xA0\x80";
    int32_t expected[] = {0xD800};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.1.2 - U+DB7F = ed ad bf = "\xED\xAD\xBF"
  {
    const char* src = "\xED\xAD\xBF";
    int32_t expected[] = {0xDB7F};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.1.3 - U+DB80 = ed ae 80 = "\xED\xAE\x80"
  {
    const char* src = "\xED\xAE\x80";
    int32_t expected[] = {0xDB80};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.1.4 - U+DBFF = ed af bf = "\xED\xAF\xBF"
  {
    const char* src = "\xED\xAF\xBF";
    int32_t expected[] = {0xDBFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.1.5 - U+DC00 = ed b0 80 = "\xED\xB0\x80"
  {
    const char* src = "\xED\xB0\x80";
    int32_t expected[] = {0xDC00};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.1.6 - U+DF80 = ed be 80 = "\xED\xBE\x80"
  {
    const char* src = "\xED\xBE\x80";
    int32_t expected[] = {0xDF80};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.1.7 - U+DFFF = ed bf bf = "\xED\xBF\xBF"
  {
    const char* src = "\xED\xBF\xBF";
    int32_t expected[] = {0xDFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.2 Paired UTF-16 surrogates
  // Also not a valid string, but accepted in Dart, even if it doesn't make
  // sense. e.g.
  // var s =  new String.fromCharCodes([0xd800, 0xDC00]);
  // print(s.runes);  // (65536) (0x10000)
  // print(s.codeUnits); // [55296, 56320]
 
  // 5.2.1 - U+D800 U+DC00 = ed a0 80 ed b0 80 = "\xED\xA0\x80\xED\xB0\x80"
  {
    const char* src = "\xED\xA0\x80\xED\xB0\x80";
    int32_t expected[] = {0xD800, 0xDC00};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.2.2 - U+D800 U+DFFF = ed a0 80 ed bf bf = "\xED\xA0\x80\xED\xBF\xBF"
  {
    const char* src = "\xED\xA0\x80\xED\xBF\xBF";
    int32_t expected[] = {0xD800, 0xDFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.2.3 - U+DB7F U+DC00 = ed a0 80 ed bf bf = "\xED\xAD\xBF\xED\xB0\x80"
  {
    const char* src = "\xED\xAD\xBF\xED\xB0\x80";
    int32_t expected[] = {0xDB7F, 0xDC00};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.2.4 - U+DB7F U+DFFF = ed ad bf ed bf bf = "\xED\xAD\xBF\xED\xBF\xBF"
  {
    const char* src = "\xED\xAD\xBF\xED\xBF\xBF";
    int32_t expected[] = {0xDB7F, 0xDFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.2.5 - U+DB80 U+DC00 = ed ae 80 ed b0 80 = "\xED\xAE\x80\xED\xB0\x80"
  {
    const char* src = "\xED\xAE\x80\xED\xB0\x80";
    int32_t expected[] = {0xDB80, 0xDC00};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.2.6 - U+DB80 U+DFFF = ed ae 80 ed bf bf = "\xED\xAE\x80\xED\xBF\xBF"
  {
    const char* src = "\xED\xAE\x80\xED\xBF\xBF";
    int32_t expected[] = {0xDB80, 0xDFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.2.7 - U+DBFF U+DC00 = ed af bf ed b0 80 = "\xED\xAF\xBF\xED\xB0\x80"
  {
    const char* src = "\xED\xAF\xBF\xED\xB0\x80";
    int32_t expected[] = {0xDBFF, 0xDC00};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.2.8 - U+DBFF U+DFFF = ed af bf ed bf bf = "\xED\xAF\xBF\xED\xBF\xBF"
  {
    const char* src = "\xED\xAF\xBF\xED\xBF\xBF";
    int32_t expected[] = {0xDBFF, 0xDFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.3 - Other illegal code positions
 
  // 5.3.1 - U+FFFE = ef bf be = "\xEF\xBF\xBE"
  {
    const char* src = "\xEF\xBF\xBE";
    int32_t expected[] = {0xFFFE};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
 
  // 5.3.2 - U+FFFF = ef bf bf = "\xEF\xBF\xBF"
  {
    const char* src = "\xEF\xBF\xBF";
    int32_t expected[] = {0xFFFF};
    int32_t dst[ARRAY_SIZE(expected)];
    memset(dst, 0, sizeof(dst));
    bool is_valid = Utf8::DecodeCStringToUTF32(src, dst, ARRAY_SIZE(dst));
    EXPECT(is_valid);
    EXPECT(!memcmp(expected, dst, sizeof(expected)));
  }
}

ISOLATE_UNIT_TEST_CASE() [433/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Utf8Encode

)

Definition at line 11 of file unicode_test.cc.

                                   {
  const intptr_t kInputLen = 3;
  const uint16_t kInput[kInputLen] = {0xe6, 0xe7, 0xe8};  // æøå
  const String& input = String::Handle(String::FromUTF16(kInput, kInputLen));
  const uintptr_t kBufferLength = 10;
  unsigned char buffer[kBufferLength];
  for (uintptr_t i = 0; i < kBufferLength; i++) {
    buffer[i] = 42;
  }
  Utf8::Encode(input, reinterpret_cast<char*>(&buffer[0]), 10);
  uintptr_t i;
  for (i = 0; i < static_cast<uintptr_t>(Utf8::Length(input)); i++) {
    EXPECT(buffer[i] > 127);
  }
  for (; i < kBufferLength; i++) {
    EXPECT(buffer[i] == 42);
  }
}

ISOLATE_UNIT_TEST_CASE() [434/463]

dart::ISOLATE_UNIT_TEST_CASE

(

Utf8InvalidByte

)

Definition at line 30 of file unicode_test.cc.

                                        {
  {
    uint8_t array[] = {0x41, 0xF0, 0x92};
    intptr_t encode_len = 3;
    intptr_t decode_len = 3;
    intptr_t pos = Utf8::ReportInvalidByte(array, encode_len, decode_len);
    EXPECT(pos == 1);
  }
 
  {
    uint8_t array[] = {0x81, 0x40, 0x42};
    intptr_t encode_len = 3;
    intptr_t decode_len = 3;
    intptr_t pos = Utf8::ReportInvalidByte(array, encode_len, decode_len);
    EXPECT(pos == 0);
  }
 
  {
    uint8_t array[] = {0x42, 0x40, 0x80};
    intptr_t encode_len = 3;
    intptr_t decode_len = 3;
    intptr_t pos = Utf8::ReportInvalidByte(array, encode_len, decode_len);
    EXPECT(pos == 2);
  }
 
  {
    uint8_t array[] = {0x41, 0xF0, 0x92, 0x92, 0x91};
    intptr_t encode_len = 5;
    intptr_t decode_len = 2;
    intptr_t pos = Utf8::ReportInvalidByte(array, encode_len, decode_len);
    EXPECT(pos == encode_len);
  }
}

ISOLATE_UNIT_TEST_CASE() [435/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakArray_Generations

)

Definition at line 1132 of file heap_test.cc.

                                              {
  FLAG_early_tenuring_threshold = 100;  // I.e., off.
 
  intptr_t length = 1;
  WeakArray_Generations(length, kNew, kNew, true, true, true);
  WeakArray_Generations(length, kNew, kOld, false, true, true);
  WeakArray_Generations(length, kNew, kImm, false, false, false);
  WeakArray_Generations(length, kOld, kNew, true, true, true);
  WeakArray_Generations(length, kOld, kOld, false, true, true);
  WeakArray_Generations(length, kOld, kImm, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [436/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakArray_Large_Generations

)

Definition at line 1144 of file heap_test.cc.

                                                    {
  FLAG_early_tenuring_threshold = 100;  // I.e., off.
 
  intptr_t length = kNewAllocatableSize / kCompressedWordSize;
  WeakArray_Generations(length, kNew, kNew, true, true, true);
  WeakArray_Generations(length, kNew, kOld, false, true, true);
  WeakArray_Generations(length, kNew, kImm, false, false, false);
  WeakArray_Generations(length, kOld, kNew, true, true, true);
  WeakArray_Generations(length, kOld, kOld, false, true, true);
  WeakArray_Generations(length, kOld, kImm, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [437/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakArray_New

)

Definition at line 3799 of file object_test.cc.

                                      {
  WeakArray& array = WeakArray::Handle(WeakArray::New(2, Heap::kNew));
  Object& target0 = Object::Handle();
  {
    HANDLESCOPE(thread);
    target0 = String::New("0", Heap::kNew);
    Object& target1 = Object::Handle(String::New("1", Heap::kNew));
    array.SetAt(0, target0);
    array.SetAt(1, target1);
  }
 
  EXPECT(array.Length() == 2);
  EXPECT(array.At(0) != Object::null());
  EXPECT(array.At(1) != Object::null());
 
  GCTestHelper::CollectNewSpace();
 
  EXPECT(array.Length() == 2);
  EXPECT(array.At(0) != Object::null());  // Survives
  EXPECT(array.At(1) == Object::null());  // Cleared
}

ISOLATE_UNIT_TEST_CASE() [438/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakArray_Old

)

Definition at line 3821 of file object_test.cc.

                                      {
  WeakArray& array = WeakArray::Handle(WeakArray::New(2, Heap::kOld));
  Object& target0 = Object::Handle();
  {
    HANDLESCOPE(thread);
    target0 = String::New("0", Heap::kOld);
    Object& target1 = Object::Handle(String::New("1", Heap::kOld));
    array.SetAt(0, target0);
    array.SetAt(1, target1);
  }
 
  EXPECT(array.Length() == 2);
  EXPECT(array.At(0) != Object::null());
  EXPECT(array.At(1) != Object::null());
 
  GCTestHelper::CollectAllGarbage();
 
  EXPECT(array.Length() == 2);
  EXPECT(array.At(0) != Object::null());  // Survives
  EXPECT(array.At(1) == Object::null());  // Cleared
}

ISOLATE_UNIT_TEST_CASE() [439/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_ClearOne_NewSpace

)

Definition at line 3563 of file object_test.cc.

                                                       {
  WeakProperty& weak = WeakProperty::Handle();
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key");
    String& value = String::Handle();
    value ^= OneByteString::New("value");
    weak ^= WeakProperty::New();
    weak.set_key(key);
    weak.set_value(value);
    key ^= OneByteString::null();
    value ^= OneByteString::null();
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak.key() == Object::null());
  EXPECT(weak.value() == Object::null());
}

ISOLATE_UNIT_TEST_CASE() [440/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_ClearOne_OldSpace

)

Definition at line 3607 of file object_test.cc.

                                                       {
  WeakProperty& weak = WeakProperty::Handle();
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key", Heap::kOld);
    String& value = String::Handle();
    value ^= OneByteString::New("value", Heap::kOld);
    weak ^= WeakProperty::New(Heap::kOld);
    weak.set_key(key);
    weak.set_value(value);
    key ^= OneByteString::null();
    value ^= OneByteString::null();
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak.key() == Object::null());
  EXPECT(weak.value() == Object::null());
}

ISOLATE_UNIT_TEST_CASE() [441/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_ClearTwoShared_NewSpace

)

Definition at line 3582 of file object_test.cc.

                                                             {
  WeakProperty& weak1 = WeakProperty::Handle();
  WeakProperty& weak2 = WeakProperty::Handle();
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key");
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1");
    weak1 ^= WeakProperty::New();
    weak1.set_key(key);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2");
    weak2 ^= WeakProperty::New();
    weak2.set_key(key);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak1.key() == Object::null());
  EXPECT(weak1.value() == Object::null());
  EXPECT(weak2.key() == Object::null());
  EXPECT(weak2.value() == Object::null());
}

ISOLATE_UNIT_TEST_CASE() [442/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_ClearTwoShared_OldSpace

)

Definition at line 3626 of file object_test.cc.

                                                             {
  WeakProperty& weak1 = WeakProperty::Handle();
  WeakProperty& weak2 = WeakProperty::Handle();
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key", Heap::kOld);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1");
    weak1 ^= WeakProperty::New(Heap::kOld);
    weak1.set_key(key);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2", Heap::kOld);
    weak2 ^= WeakProperty::New(Heap::kOld);
    weak2.set_key(key);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak1.key() == Object::null());
  EXPECT(weak1.value() == Object::null());
  EXPECT(weak2.key() == Object::null());
  EXPECT(weak2.value() == Object::null());
}

ISOLATE_UNIT_TEST_CASE() [443/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_Generations

)

Definition at line 977 of file heap_test.cc.

                                                 {
  FLAG_early_tenuring_threshold = 100;  // I.e., off.
 
  WeakProperty_Generations(kNew, kNew, kNew, true, true, true);
  WeakProperty_Generations(kNew, kNew, kOld, true, true, true);
  WeakProperty_Generations(kNew, kNew, kImm, true, true, true);
  WeakProperty_Generations(kNew, kOld, kNew, false, true, true);
  WeakProperty_Generations(kNew, kOld, kOld, false, true, true);
  WeakProperty_Generations(kNew, kOld, kImm, false, true, true);
  WeakProperty_Generations(kNew, kImm, kNew, false, false, false);
  WeakProperty_Generations(kNew, kImm, kOld, false, false, false);
  WeakProperty_Generations(kNew, kImm, kImm, false, false, false);
  WeakProperty_Generations(kOld, kNew, kNew, true, true, true);
  WeakProperty_Generations(kOld, kNew, kOld, true, true, true);
  WeakProperty_Generations(kOld, kNew, kImm, true, true, true);
  WeakProperty_Generations(kOld, kOld, kNew, false, true, true);
  WeakProperty_Generations(kOld, kOld, kOld, false, true, true);
  WeakProperty_Generations(kOld, kOld, kImm, false, true, true);
  WeakProperty_Generations(kOld, kImm, kNew, false, false, false);
  WeakProperty_Generations(kOld, kImm, kOld, false, false, false);
  WeakProperty_Generations(kOld, kImm, kImm, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [444/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_PreserveOne_NewSpace

)

Definition at line 3425 of file object_test.cc.

                                                          {
  WeakProperty& weak = WeakProperty::Handle();
  String& key = String::Handle();
  key ^= OneByteString::New("key");
  {
    HANDLESCOPE(thread);
    String& value = String::Handle();
    value ^= OneByteString::New("value");
    weak ^= WeakProperty::New();
    weak.set_key(key);
    weak.set_value(value);
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak.key() != Object::null());
  EXPECT(weak.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE() [445/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_PreserveOne_OldSpace

)

Definition at line 3494 of file object_test.cc.

                                                          {
  WeakProperty& weak = WeakProperty::Handle();
  String& key = String::Handle();
  key ^= OneByteString::New("key", Heap::kOld);
  {
    HANDLESCOPE(thread);
    String& value = String::Handle();
    value ^= OneByteString::New("value", Heap::kOld);
    weak ^= WeakProperty::New(Heap::kOld);
    weak.set_key(key);
    weak.set_value(value);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak.key() != Object::null());
  EXPECT(weak.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE() [446/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_PreserveRecurse

)

Definition at line 3404 of file object_test.cc.

                                                     {
  // This used to end in an infinite recursion. Caused by scavenging the weak
  // property before scavenging the key.
  WeakProperty& weak = WeakProperty::Handle();
  Array& arr = Array::Handle(Array::New(1));
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key");
    arr.SetAt(0, key);
    String& value = String::Handle();
    value ^= OneByteString::New("value");
    weak ^= WeakProperty::New();
    weak.set_key(key);
    weak.set_value(value);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak.key() != Object::null());
  EXPECT(weak.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE() [447/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_PreserveTwo_NewSpace

)

Definition at line 3442 of file object_test.cc.

                                                          {
  WeakProperty& weak1 = WeakProperty::Handle();
  String& key1 = String::Handle();
  key1 ^= OneByteString::New("key1");
  WeakProperty& weak2 = WeakProperty::Handle();
  String& key2 = String::Handle();
  key2 ^= OneByteString::New("key2");
  {
    HANDLESCOPE(thread);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1");
    weak1 ^= WeakProperty::New();
    weak1.set_key(key1);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2");
    weak2 ^= WeakProperty::New();
    weak2.set_key(key2);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak1.key() != Object::null());
  EXPECT(weak1.value() != Object::null());
  EXPECT(weak2.key() != Object::null());
  EXPECT(weak2.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE() [448/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_PreserveTwo_OldSpace

)

Definition at line 3511 of file object_test.cc.

                                                          {
  WeakProperty& weak1 = WeakProperty::Handle();
  String& key1 = String::Handle();
  key1 ^= OneByteString::New("key1", Heap::kOld);
  WeakProperty& weak2 = WeakProperty::Handle();
  String& key2 = String::Handle();
  key2 ^= OneByteString::New("key2", Heap::kOld);
  {
    HANDLESCOPE(thread);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1", Heap::kOld);
    weak1 ^= WeakProperty::New(Heap::kOld);
    weak1.set_key(key1);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2", Heap::kOld);
    weak2 ^= WeakProperty::New(Heap::kOld);
    weak2.set_key(key2);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak1.key() != Object::null());
  EXPECT(weak1.value() != Object::null());
  EXPECT(weak2.key() != Object::null());
  EXPECT(weak2.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE() [449/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_PreserveTwoShared_NewSpace

)

Definition at line 3469 of file object_test.cc.

                                                                {
  WeakProperty& weak1 = WeakProperty::Handle();
  WeakProperty& weak2 = WeakProperty::Handle();
  String& key = String::Handle();
  key ^= OneByteString::New("key");
  {
    HANDLESCOPE(thread);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1");
    weak1 ^= WeakProperty::New();
    weak1.set_key(key);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2");
    weak2 ^= WeakProperty::New();
    weak2.set_key(key);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak1.key() != Object::null());
  EXPECT(weak1.value() != Object::null());
  EXPECT(weak2.key() != Object::null());
  EXPECT(weak2.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE() [450/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakProperty_PreserveTwoShared_OldSpace

)

Definition at line 3538 of file object_test.cc.

                                                                {
  WeakProperty& weak1 = WeakProperty::Handle();
  WeakProperty& weak2 = WeakProperty::Handle();
  String& key = String::Handle();
  key ^= OneByteString::New("key", Heap::kOld);
  {
    HANDLESCOPE(thread);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1", Heap::kOld);
    weak1 ^= WeakProperty::New(Heap::kOld);
    weak1.set_key(key);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2", Heap::kOld);
    weak2 ^= WeakProperty::New(Heap::kOld);
    weak2.set_key(key);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak1.key() != Object::null());
  EXPECT(weak1.value() != Object::null());
  EXPECT(weak2.key() != Object::null());
  EXPECT(weak2.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE() [451/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_Clear_ReachableThroughWeakProperty_NewSpace

)

Definition at line 3746 of file object_test.cc.

                                                               {
  WeakReference_Clear_ReachableThroughWeakProperty(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE() [452/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_Clear_ReachableThroughWeakProperty_OldSpace

)

Definition at line 3751 of file object_test.cc.

                                                               {
  WeakReference_Clear_ReachableThroughWeakProperty(thread, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE() [453/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_ClearOne_NewSpace

)

Definition at line 3705 of file object_test.cc.

                                                        {
  WeakReference_ClearOne(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE() [454/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_ClearOne_OldSpace

)

Definition at line 3709 of file object_test.cc.

                                                        {
  WeakReference_ClearOne(thread, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE() [455/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_Generations

)

Definition at line 1060 of file heap_test.cc.

                                                  {
  FLAG_early_tenuring_threshold = 100;  // I.e., off.
 
  WeakReference_Generations(kNew, kNew, true, true, true);
  WeakReference_Generations(kNew, kOld, false, true, true);
  WeakReference_Generations(kNew, kImm, false, false, false);
  WeakReference_Generations(kOld, kNew, true, true, true);
  WeakReference_Generations(kOld, kOld, false, true, true);
  WeakReference_Generations(kOld, kImm, false, false, false);
}

ISOLATE_UNIT_TEST_CASE() [456/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_Preserve_ReachableThroughWeakProperty_NewSpace

)

Definition at line 3789 of file object_test.cc.

                                                                  {
  WeakReference_Preserve_ReachableThroughWeakProperty(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE() [457/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_Preserve_ReachableThroughWeakProperty_OldSpace

)

Definition at line 3794 of file object_test.cc.

                                                                  {
  WeakReference_Preserve_ReachableThroughWeakProperty(thread, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE() [458/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_PreserveOne_NewSpace

)

Definition at line 3674 of file object_test.cc.

                                                           {
  WeakReference_PreserveOne(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE() [459/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakReference_PreserveOne_OldSpace

)

Definition at line 3678 of file object_test.cc.

                                                           {
  WeakReference_PreserveOne(thread, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE() [460/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakSmi

)

Definition at line 844 of file heap_test.cc.

                                {
  // Weaklings are prevented from referencing Smis by the public Dart library
  // interface, but the VM internally can do this and the implementation should
  // just handle it. Immediate objects are effectively immortal.
 
  WeakProperty& new_ephemeron =
      WeakProperty::Handle(WeakProperty::New(Heap::kNew));
  WeakProperty& old_ephemeron =
      WeakProperty::Handle(WeakProperty::New(Heap::kOld));
  WeakReference& new_weakref =
      WeakReference::Handle(WeakReference::New(Heap::kNew));
  WeakReference& old_weakref =
      WeakReference::Handle(WeakReference::New(Heap::kOld));
  WeakArray& new_weakarray = WeakArray::Handle(WeakArray::New(1, Heap::kNew));
  WeakArray& old_weakarray = WeakArray::Handle(WeakArray::New(1, Heap::kOld));
  FinalizerEntry& new_finalizer = FinalizerEntry::Handle(
      FinalizerEntry::New(FinalizerBase::Handle(), Heap::kNew));
  FinalizerEntry& old_finalizer = FinalizerEntry::Handle(
      FinalizerEntry::New(FinalizerBase::Handle(), Heap::kOld));
 
  {
    HANDLESCOPE(thread);
    Smi& smi = Smi::Handle(Smi::New(42));
    new_ephemeron.set_key(smi);
    old_ephemeron.set_key(smi);
    new_weakref.set_target(smi);
    old_weakref.set_target(smi);
    new_weakarray.SetAt(0, smi);
    old_weakarray.SetAt(0, smi);
    new_finalizer.set_value(smi);
    old_finalizer.set_value(smi);
  }
 
  GCTestHelper::CollectNewSpace();
  GCTestHelper::CollectAllGarbage();
 
  EXPECT(new_ephemeron.key() == Smi::New(42));
  EXPECT(old_ephemeron.key() == Smi::New(42));
  EXPECT(new_weakref.target() == Smi::New(42));
  EXPECT(old_weakref.target() == Smi::New(42));
  EXPECT(new_weakarray.At(0) == Smi::New(42));
  EXPECT(old_weakarray.At(0) == Smi::New(42));
  EXPECT(new_finalizer.value() == Smi::New(42));
  EXPECT(old_finalizer.value() == Smi::New(42));
}

ISOLATE_UNIT_TEST_CASE() [461/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WeakTables

)

Definition at line 15 of file weak_table_test.cc.

                                   {
  const Object& old_obj = Object::Handle(String::New("old", Heap::kOld));
  const Object& new_obj = Object::Handle(String::New("new", Heap::kNew));
  const Object& imm_obj = Object::Handle(Smi::New(0));
 
  // Initially absent.
  Heap* heap = thread->heap();
  const intptr_t kNoValue = WeakTable::kNoValue;
  EXPECT_EQ(kNoValue, heap->GetObjectId(old_obj.ptr()));
  EXPECT_EQ(kNoValue, heap->GetObjectId(new_obj.ptr()));
  EXPECT_EQ(kNoValue, heap->GetObjectId(imm_obj.ptr()));
 
  // Found after insert.
  heap->SetObjectId(old_obj.ptr(), 100);
  heap->SetObjectId(new_obj.ptr(), 200);
  heap->SetObjectId(imm_obj.ptr(), 300);
  EXPECT_EQ(100, heap->GetObjectId(old_obj.ptr()));
  EXPECT_EQ(200, heap->GetObjectId(new_obj.ptr()));
  EXPECT_EQ(300, heap->GetObjectId(imm_obj.ptr()));
 
  // Found after update.
  heap->SetObjectId(old_obj.ptr(), 400);
  heap->SetObjectId(new_obj.ptr(), 500);
  heap->SetObjectId(imm_obj.ptr(), 600);
  EXPECT_EQ(400, heap->GetObjectId(old_obj.ptr()));
  EXPECT_EQ(500, heap->GetObjectId(new_obj.ptr()));
  EXPECT_EQ(600, heap->GetObjectId(imm_obj.ptr()));
 
  // Found after GC.
  GCTestHelper::CollectNewSpace();
  EXPECT_EQ(400, heap->GetObjectId(old_obj.ptr()));
  EXPECT_EQ(500, heap->GetObjectId(new_obj.ptr()));
  EXPECT_EQ(600, heap->GetObjectId(imm_obj.ptr()));
 
  // Found after GC.
  GCTestHelper::CollectOldSpace();
  EXPECT_EQ(400, heap->GetObjectId(old_obj.ptr()));
  EXPECT_EQ(500, heap->GetObjectId(new_obj.ptr()));
  EXPECT_EQ(600, heap->GetObjectId(imm_obj.ptr()));
 
  // Absent after reset.
  heap->ResetObjectIdTable();
  EXPECT_EQ(kNoValue, heap->GetObjectId(old_obj.ptr()));
  EXPECT_EQ(kNoValue, heap->GetObjectId(new_obj.ptr()));
  EXPECT_EQ(kNoValue, heap->GetObjectId(imm_obj.ptr()));
}

ISOLATE_UNIT_TEST_CASE() [462/463]

dart::ISOLATE_UNIT_TEST_CASE

(

WrapAroundAndDerived

)

Definition at line 206 of file loops_test.cc.

                                       {
  const char* script_chars =
      R"(
      foo() {
        int j = 1;
        for (int i = 0; i < 100; i++) {
          j += 5;
          j += 7;
        }
      }
      main() {
        foo();
      }
    )";
  const char* expected =

ISOLATE_UNIT_TEST_CASE() [463/463]

dart::ISOLATE_UNIT_TEST_CASE

(

ZoneVerificationScaling

)

Definition at line 272 of file zone_test.cc.

                                                {
  // This ought to complete in O(n), not O(n^2).
  const intptr_t n = 1000000;
 
  StackZone stack_zone(thread);
  Zone* zone = stack_zone.GetZone();
 
  {
    HANDLESCOPE(thread);
    for (intptr_t i = 0; i < n; i++) {
      const Object& a = Object::Handle(zone);
      DEBUG_ASSERT(!a.IsNotTemporaryScopedHandle());
      USE(a);
      const Object& b = Object::ZoneHandle(zone);
      DEBUG_ASSERT(b.IsNotTemporaryScopedHandle());
      USE(b);
    }
    // Leaves lots of HandleBlocks for recycling.
  }
 
  for (intptr_t i = 0; i < n; i++) {
    HANDLESCOPE(thread);
    const Object& a = Object::Handle(zone);
    DEBUG_ASSERT(!a.IsNotTemporaryScopedHandle());
    USE(a);
    const Object& b = Object::ZoneHandle(zone);
    DEBUG_ASSERT(b.IsNotTemporaryScopedHandle());
    USE(b);
    // Should not visit those recyclable blocks over and over again.
  }
}

ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION() [1/3]

dart::ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION	(	ArrayNew_Overflow_Crash	,
		"Crash"
	)

Definition at line 3334 of file object_test.cc.

                                                                          {
  Array::Handle(Array::New(Array::kMaxElements + 1));
}

ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION() [2/3]

dart::ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION	(	CodeImmutability	,
		"Crash"
	)

Definition at line 2679 of file object_test.cc.

                                                                   {
  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  const Function& function = Function::Handle(CreateFunction("Test_Code"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  function.AttachCode(code);
  Instructions& instructions = Instructions::Handle(code.instructions());
  uword payload_start = instructions.PayloadStart();
  EXPECT_EQ(instructions.ptr(), Instructions::FromPayloadStart(payload_start));
  // Try writing into the generated code, expected to crash.
  *(reinterpret_cast<char*>(payload_start) + 1) = 1;
  if (!FLAG_write_protect_code) {
    // Since this test is expected to crash, crash if write protection of code
    // is switched off.
    FATAL("Test requires --write-protect-code; skip by forcing expected crash");
  }
}

ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION() [3/3]

dart::ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION	(	SafepointOperation_NonDeoptAndDeoptNesting	,
		"Crash"
	)

Definition at line 635 of file safepoint_test.cc.

             {
  GcSafepointOperationScope safepoint_scope(thread);
  DeoptSafepointOperationScope safepoint_scope2(thread);
}

IsolateCleanupTestCallback()

static void dart::IsolateCleanupTestCallback ( void *  group_data, void *  isolate_data  )

static

Definition at line 8529 of file dart_api_impl_test.cc.

IsolateExitTest_LookupAndCallIsolateExit()

DART_EXPORT void dart::IsolateExitTest_LookupAndCallIsolateExit

(

int

i

)

Definition at line 920 of file ffi_test_functions_vmspecific.cc.

                                                                 {
  Dart_Handle root_lib = Dart_RootLibrary();
  fprintf(stderr, "IsolateExitTest_LookupAndCallIsolateExit i:%d\n", i);
  if (i > 0) {
    Dart_Handle method_name =
        Dart_NewStringFromCString("recurseLookupAndCallWorker");
    Dart_Handle dart_args[1];
    dart_args[0] = Dart_NewInteger(i - 1);
    Dart_Handle result = Dart_Invoke(root_lib, method_name, 1, dart_args);
    ENSURE(Dart_IsError(result));
  } else {
    Dart_Handle method_name = Dart_NewStringFromCString("callIsolateExit");
    Dart_Handle result = Dart_Invoke(root_lib, method_name, 0, nullptr);
    if (Dart_IsError(result)) {
      fprintf(stderr,
              "%d failed to invoke %s in child isolate: %s, carrying on..\n", i,
              "callIsolateExit", Dart_GetError(result));
    }
    ENSURE(Dart_IsError(result));
  }
}

IsolateGroupCleanupTestCallback()

static void dart::IsolateGroupCleanupTestCallback ( void *  callback_data )

static

Definition at line 8543 of file dart_api_impl_test.cc.

                                                                             {
  // Cleanup runs after shutdown.
  EXPECT(shutdown_isolate_group_data != nullptr);

IsolateMessageTypedDataFinalizer()

static void dart::IsolateMessageTypedDataFinalizer ( void *  isolate_callback_data, void *  buffer  )

static

Definition at line 1280 of file message_snapshot.cc.

                                                           {
  free(buffer);
}

IsolatePauseEvent()

static ServiceEvent dart::IsolatePauseEvent ( Isolate *  isolate )

static

Definition at line 2991 of file isolate.cc.

                                                        {
  if (!isolate->is_runnable()) {
    // Isolate is not yet runnable.
    ASSERT((isolate->debugger() == nullptr) ||
           (isolate->debugger()->PauseEvent() == nullptr));
    return ServiceEvent(isolate, ServiceEvent::kNone);
  } else if (isolate->message_handler()->should_pause_on_start()) {
    if (isolate->message_handler()->is_paused_on_start()) {
      ASSERT((isolate->debugger() == nullptr) ||
             (isolate->debugger()->PauseEvent() == nullptr));
      return ServiceEvent(isolate, ServiceEvent::kPauseStart);
    } else {
      // Isolate is runnable but not paused on start.
      // Some service clients get confused if they see:
      // NotRunnable -> Runnable -> PausedAtStart
      // Treat Runnable+ShouldPauseOnStart as NotRunnable so they see:
      // NonRunnable -> PausedAtStart
      // The should_pause_on_start flag is set to false after resume.
      ASSERT((isolate->debugger() == nullptr) ||
             (isolate->debugger()->PauseEvent() == nullptr));
      return ServiceEvent(isolate, ServiceEvent::kNone);
    }
  } else if (isolate->message_handler()->is_paused_on_exit() &&
             ((isolate->debugger() == nullptr) ||
              (isolate->debugger()->PauseEvent() == nullptr))) {
    return ServiceEvent(isolate, ServiceEvent::kPauseExit);
  } else if ((isolate->debugger() != nullptr) &&
             (isolate->debugger()->PauseEvent() != nullptr) &&
             !isolate->ResumeRequest()) {
    return *(isolate->debugger()->PauseEvent());
  } else {
    ServiceEvent pause_event(isolate, ServiceEvent::kResume);
 
#if !defined(DART_PRECOMPILED_RUNTIME)
    if (isolate->debugger() != nullptr) {
      // TODO(turnidge): Don't compute a full stack trace.
      DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
      if (stack->Length() > 0) {
        pause_event.set_top_frame(stack->FrameAt(0));
      }
    }
#endif
 
    return pause_event;
  }
}

IsolateReloadTestLibUri()

static const char * dart::IsolateReloadTestLibUri ( )

static

Definition at line 231 of file unit_test.cc.

                                             {
  return "test:isolate_reload_helper";
}

IsolateReloadTestNativeResolver()

static Dart_NativeFunction dart::IsolateReloadTestNativeResolver ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 248 of file unit_test.cc.

                            {
  const char* function_name = nullptr;
  Dart_Handle result = Dart_StringToCString(name, &function_name);
  ASSERT(!Dart_IsError(result));
  ASSERT(function_name != nullptr);
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  int num_entries = sizeof(ReloadEntries) / sizeof(struct NativeEntries);
  for (int i = 0; i < num_entries; i++) {
    struct NativeEntries* entry = &(ReloadEntries[i]);
    if ((strcmp(function_name, entry->name_) == 0) &&
        (entry->argument_count_ == argument_count)) {
      return reinterpret_cast<Dart_NativeFunction>(entry->function_);
    }
  }
  return nullptr;
}

IsolateShutdownRunDartCodeTestCallback()

static void dart::IsolateShutdownRunDartCodeTestCallback ( void *  isolate_group_data, void *  isolate_data  )

static

Definition at line 8591 of file dart_api_impl_test.cc.

                                                                       {
  Dart_Isolate isolate = Dart_CurrentIsolate();
  if (Dart_IsKernelIsolate(isolate) || Dart_IsServiceIsolate(isolate)) {
    return;
  } else {
    ASSERT(add_result == 0);
  }

IsolateShutdownTestCallback()

static void dart::IsolateShutdownTestCallback ( void *  group_data, void *  isolate_data  )

static

Definition at line 8512 of file dart_api_impl_test.cc.

                                           {
  RunLoopTest(false);
}
 
VM_UNIT_TEST_CASE(DartAPI_RunLoop_Exception) {
  RunLoopTest(true);
}
 
static void* shutdown_isolate_group_data;
static void* shutdown_isolate_data;
static void* cleanup_isolate_group_data;
static void* cleanup_isolate_data;
 
// Called on isolate shutdown time (which is still allowed to run Dart code)

IsolateSpawn()

void dart::IsolateSpawn

(

const char *

platform_script_value

)

Definition at line 28 of file isolate_test.cc.

                                                     {
  char* scriptChars = OS::SCreate(
      nullptr,
      "import 'dart:isolate';\n"
      // Ignores printed lines.
      "var _nullPrintClosure = (String line) {};\n"
      "var _platformScript = () => Uri.parse(\"%s\");\n"
      "void entry(message) {}\n"
      "void testMain() {\n"
      "  Isolate.spawn(entry, null);\n"
      // TODO(floitsch): the following code is only to bump the event loop
      // so it executes asynchronous microtasks.
      "  var rp = RawReceivePort();\n"
      "  rp.sendPort.send(null);\n"
      "  rp.handler = (_) { rp.close(); };\n"
      "}\n",
      platform_script_value);
 
  Dart_Handle test_lib = TestCase::LoadTestScript(scriptChars, nullptr);
 
  free(scriptChars);
 
  // Setup the internal library's 'internalPrint' function.
  // Necessary because asynchronous errors use "print" to print their
  // stack trace.
  Dart_Handle url = NewString("dart:_internal");
  EXPECT_VALID(url);
  Dart_Handle internal_lib = Dart_LookupLibrary(url);
  EXPECT_VALID(internal_lib);
  Dart_Handle print = Dart_GetField(test_lib, NewString("_nullPrintClosure"));
  EXPECT_VALID(print);
  Dart_Handle result =
      Dart_SetField(internal_lib, NewString("_printClosure"), print);
  EXPECT_VALID(result);
 
  Dart_Handle platform_script =
      Dart_GetField(test_lib, NewString("_platformScript"));
  EXPECT_VALID(platform_script);
  Dart_Handle vmlibraryhooks_class =
      Dart_GetClass(internal_lib, NewString("VMLibraryHooks"));
  EXPECT_VALID(vmlibraryhooks_class);
  result = Dart_SetField(vmlibraryhooks_class, NewString("platformScript"),
                         platform_script);
  EXPECT_VALID(result);
 
  // Setup the 'scheduleImmediate' closure.
  url = NewString("dart:isolate");
  EXPECT_VALID(url);
  Dart_Handle isolate_lib = Dart_LookupLibrary(url);
  EXPECT_VALID(isolate_lib);
  Dart_Handle schedule_immediate_closure =
      Dart_Invoke(isolate_lib, NewString("_getIsolateScheduleImmediateClosure"),
                  0, nullptr);
  Dart_Handle args[1];
  args[0] = schedule_immediate_closure;
  url = NewString("dart:async");
  EXPECT_VALID(url);
  Dart_Handle async_lib = Dart_LookupLibrary(url);
  EXPECT_VALID(async_lib);
  EXPECT_VALID(Dart_Invoke(async_lib, NewString("_setScheduleImmediateClosure"),
                           1, args));
 
  result = Dart_Invoke(test_lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
  // Run until all ports to isolate are closed.
  result = Dart_RunLoop();
  EXPECT_ERROR(
      result,
      "Lightweight isolate spawn is not supported by this Dart embedder");
  EXPECT(Dart_ErrorHasException(result));
  Dart_Handle exception_result = Dart_ErrorGetException(result);
  EXPECT_VALID(exception_result);
}

IsOneByteStringClassId()

bool dart::IsOneByteStringClassId ( intptr_t  index )

inline

Definition at line 354 of file class_id.h.

                                                   {
  return (index == kOneByteStringCid);
}

IsPercent()

static bool dart::IsPercent ( int32_t  c )

static

Definition at line 23948 of file object.cc.

                                 {
  return c == '%';
}

IsPhiDependentPlace()

static bool dart::IsPhiDependentPlace ( Place *  place )

static

Definition at line 1306 of file redundancy_elimination.cc.

                                              {
  return (place->kind() == Place::kInstanceField) &&
         (place->instance() != nullptr) && place->instance()->IsPhi();
}

IsPopper()

static bool dart::IsPopper ( Instruction *  instr )

static

Definition at line 597 of file flow_graph_compiler.cc.

                                         {
  // TODO(ajcbik): even allow deopt targets by making environment aware?
  if (!instr->CanBecomeDeoptimizationTarget()) {
    return instr->ArgumentCount() == 0 && instr->InputCount() > 0;
  }
  return false;
}

IsPositiveOrZeroSmiConst()

static bool dart::IsPositiveOrZeroSmiConst ( Definition *  d )

static

Definition at line 2907 of file flow_graph.cc.

                                                    {
  ConstantInstr* const_instr = d->AsConstant();
  if ((const_instr != nullptr) && (const_instr->value().IsSmi())) {
    return Smi::Cast(const_instr->value()).Value() >= 0;
  }
  return false;
}

IsPotentialExactGeneric()

static bool dart::IsPotentialExactGeneric ( const AbstractType &  type )

static

Definition at line 455 of file class_finalizer.cc.

                                                              {
  return false;
}

IsPrivateVariableName()

static bool dart::IsPrivateVariableName ( const String &  var_name )

static

Definition at line 1067 of file debugger.cc.

                                                          {
  return (var_name.Length() >= 1) && (var_name.CharAt(0) == '_');
}

IsPusher()

static bool dart::IsPusher ( Instruction *  instr )

static

Definition at line 590 of file flow_graph_compiler.cc.

                                         {
  if (auto def = instr->AsDefinition()) {
    return def->HasTemp() && (instr->representation() == kTagged);
  }
  return false;
}

IsReachableReference()

static constexpr bool dart::IsReachableReference ( intptr_t  ref )

staticconstexpr

Definition at line 300 of file app_snapshot.cc.

                                                         {
  return ref == kUnallocatedReference || IsAllocatedReference(ref);
}

IsRedundantBasedOnRangeInformation()

static bool dart::IsRedundantBasedOnRangeInformation ( Value *  index, Value *  length  )

static

Definition at line 3150 of file range_analysis.cc.

                                                                            {
  if (index->BindsToSmiConstant() && length->BindsToSmiConstant()) {
    const auto index_val = index->BoundSmiConstant();
    const auto length_val = length->BoundSmiConstant();
    return (0 <= index_val && index_val < length_val);
  }
 
  // Range of the index is unknown can't decide if the check is redundant.
  Definition* index_defn = index->definition();
  Range* index_range = index_defn->range();
  if (index_range == nullptr) {
    if (!index->BindsToSmiConstant()) {
      return false;
    }
    // index_defn itself is not necessarily the constant.
    index_defn = index_defn->OriginalDefinition();
    Range range;
    index_defn->InferRange(nullptr, &range);
    ASSERT(!Range::IsUnknown(&range));
    index_defn->set_range(range);
    index_range = index_defn->range();
  }
 
  // Range of the index is not positive. Check can't be redundant.
  if (Range::ConstantMinSmi(index_range).ConstantValue() < 0) {
    return false;
  }
 
  RangeBoundary max = RangeBoundary::FromDefinition(index_defn);
  RangeBoundary max_upper = max.UpperBound();
  RangeBoundary array_length =
      RangeBoundary::FromDefinition(length->definition());
  RangeBoundary length_lower = array_length.LowerBound();
  if (max_upper.OverflowedSmi() || length_lower.OverflowedSmi()) {
    return false;
  }
 
  // Try to compare constant boundaries.
  if (max_upper.ConstantValue() < length_lower.ConstantValue()) {
    return true;
  }
 
  RangeBoundary canonical_length = CanonicalizeBoundary(
      array_length,
      RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64));
  if (canonical_length.OverflowedSmi()) {
    return false;
  }
 
  // Try symbolic comparison.
  do {
    if (DependOnSameSymbol(max, canonical_length)) {
      return max.offset() < canonical_length.offset();
    }
  } while (CanonicalizeMaxBoundary(&max) ||
           CanonicalizeMinBoundary(&canonical_length));
 
  // Failed to prove that maximum is bounded with array length.
  return false;
}

IsRoughly1337()

DART_EXPORT uint8_t dart::IsRoughly1337

(

float *

a

)

Definition at line 814 of file ffi_test_functions.cc.

                                            {
  std::cout << "IsRoughly1337(" << a[0] << ")\n";
  uint8_t retval = (1336.0f < a[0] && a[0] < 1338.0f) ? 1 : 0;
  std::cout << "returning " << static_cast<int>(retval) << "\n";
  return retval;
}

IsScavengeSurvivor()

static bool dart::IsScavengeSurvivor ( ObjectPtr  obj )

static

Definition at line 1342 of file scavenger.cc.

                                              {
  if (obj->IsImmediateOrOldObject()) return true;
  return IsForwarding(ReadHeaderRelaxed(obj));
}

IsShallowlyImmutableCid()

bool dart::IsShallowlyImmutableCid ( intptr_t  predefined_cid )

inline

Definition at line 500 of file class_id.h.

                                                             {
  ASSERT(predefined_cid < kNumPredefinedCids);
  // TODO(https://dartbug.com/55136): Mark kClosureCid as shallowly imutable.
  return IsUnmodifiableTypedDataViewClassId(predefined_cid);
}

IsSingleUseUnboxOrConstant()

static bool dart::IsSingleUseUnboxOrConstant ( Value *  use )

static

Definition at line 3731 of file il.cc.

                                                   {
  return (use->definition()->IsUnbox() && use->IsSingleUse()) ||
         use->definition()->IsConstant();
}

IsSmallLeafOrReduction()

static bool dart::IsSmallLeafOrReduction ( int  inlining_depth, intptr_t  call_site_instructions, FlowGraph *  graph  )

static

Definition at line 666 of file inliner.cc.

                                                     {
  intptr_t instruction_count = 0;
  intptr_t call_count = 0;
  for (BlockIterator block_it = graph->postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    BlockEntryInstr* entry = block_it.Current();
    for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
      Instruction* current = it.Current();
      if (current->IsDartReturn()) continue;
      ASSERT(!current->IsNativeReturn());
      ++instruction_count;
      if (current->IsInstanceCall() || current->IsPolymorphicInstanceCall() ||
          current->IsClosureCall()) {
        return false;
      }
      if (current->IsStaticCall()) {
        const Function& function = current->AsStaticCall()->function();
        const intptr_t inl_size = function.optimized_instruction_count();
        const bool always_inline =
            FlowGraphInliner::FunctionHasPreferInlinePragma(function);
        // Accept a static call that is always inlined in some way and add the
        // cached size to the total instruction count. A reasonable guess is
        // made if the count has not been collected yet (listed methods are
        // never very large).
        if (always_inline || function.IsRecognized()) {
          if (!always_inline) {
            const intptr_t kAvgListedMethodSize = 20;
            instruction_count +=
                (inl_size == 0 ? kAvgListedMethodSize : inl_size);
          }
        } else {
          ++call_count;
          instruction_count += current->AsStaticCall()->ArgumentCount();
          instruction_count += 1;  // pop the call frame.
        }
        continue;
      }
    }
  }
  if (call_count > 0) {
    return instruction_count <= call_site_instructions;
  }
  return instruction_count <= FLAG_inlining_small_leaf_size_threshold;
}

IsSmiValue()

static bool dart::IsSmiValue ( Value *  val, intptr_t *  int_val  )

static

Definition at line 1695 of file call_specializer.cc.

                                                      {
  if (val->BindsToConstant() && val->BoundConstant().IsSmi()) {
    *int_val = Smi::Cast(val->BoundConstant()).Value();
    return true;
  }
  return false;
}

IsSnapshotCompatible()

static bool dart::IsSnapshotCompatible ( Snapshot::Kind  vm_kind, Snapshot::Kind  isolate_kind  )

inlinestatic

Definition at line 108 of file snapshot.h.

                                                                   {
  if (vm_kind == isolate_kind) return true;
  if (((vm_kind == Snapshot::kFull) || (vm_kind == Snapshot::kFullCore)) &&
      isolate_kind == Snapshot::kFullJIT)
    return true;
  return Snapshot::IsFull(isolate_kind);
}

IsSpecialCharacter()

template<typename type >

static bool dart::IsSpecialCharacter ( type  value )

static

Definition at line 510 of file object.cc.

                                           {
  return ((value == '"') || (value == '\n') || (value == '\f') ||
          (value == '\b') || (value == '\t') || (value == '\v') ||
          (value == '\r') || (value == '\\') || (value == '$'));
}

IsStringClassId()

bool dart::IsStringClassId ( intptr_t  index )

inline

Definition at line 350 of file class_id.h.

                                            {
  return (index >= kStringCid && index <= kTwoByteStringCid);
}

IsSTypeImm()

bool dart::IsSTypeImm ( intptr_t  imm )

inline

Definition at line 1072 of file constants_riscv.h.

                                     {
  return Utils::IsInt(12, imm);
}

IsSupportedAllocation()

static bool dart::IsSupportedAllocation ( Instruction *  instr )

static

Definition at line 3290 of file redundancy_elimination.cc.

                                                      {
  return instr->IsAllocation() &&
         (!instr->IsArrayAllocation() ||
          IsValidLengthForAllocationSinking(instr->AsArrayAllocation()));
}

IsSuspendedFrame()

static bool dart::IsSuspendedFrame ( Zone *  zone, const Function &  function, StackFrame *  frame  )

static

Definition at line 3382 of file runtime_entry.cc.

                                                {
  if (!function.IsSuspendableFunction()) {
    return false;
  }
  auto& suspend_state = Object::Handle(
      zone, *reinterpret_cast<ObjectPtr*>(LocalVarAddress(
                frame->fp(), runtime_frame_layout.FrameSlotForVariableIndex(
                                 SuspendState::kSuspendStateVarIndex))));
  return suspend_state.IsSuspendState() &&
         (SuspendState::Cast(suspend_state).pc() != 0);
}

IsSyntheticVariableName()

static bool dart::IsSyntheticVariableName ( const String &  var_name )

static

Definition at line 1063 of file debugger.cc.

                                                            {
  return (var_name.Length() >= 1) && (var_name.CharAt(0) == ':');
}

IsThreadInGenerated()

DART_EXPORT uint8_t dart::IsThreadInGenerated

(

)

Definition at line 115 of file ffi_test_functions_vmspecific.cc.

                                          {
  return Dart_ExecuteInternalCommand("is-thread-in-generated", nullptr) !=
                 nullptr
             ? 1
             : 0;
}

IsTrivialBlock()

static bool dart::IsTrivialBlock ( BlockEntryInstr *  block, Definition *  defn  )

static

Definition at line 222 of file branch_optimizer.cc.

                                                                     {
  return (block->IsTargetEntry() && (block->PredecessorCount() == 1)) &&
         ((block->next() == block->last_instruction()) ||
          ((block->next() == defn) &&
           (defn->next() == block->last_instruction())));
}

IsTypeClassId()

bool dart::IsTypeClassId ( intptr_t  index )

inline

Definition at line 370 of file class_id.h.

                                          {
  // Only Type, FunctionType and RecordType can be encountered as instance
  // types at runtime.
  return index == kTypeCid || index == kFunctionTypeCid ||
         index == kRecordTypeCid;
}

IsTypedDataBaseClassId()

bool dart::IsTypedDataBaseClassId ( intptr_t  index )

inline

Definition at line 429 of file class_id.h.

                                                   {
  return index >= kFirstTypedDataCid && index <= kLastTypedDataCid;
}

IsTypedDataClassId()

bool dart::IsTypedDataClassId ( intptr_t  index )

inline

Definition at line 433 of file class_id.h.

                                               {
  return IsTypedDataBaseClassId(index) &&
         ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) ==
             kTypedDataCidRemainderInternal;
}

IsTypedDataUint8ArrayClassId()

static bool dart::IsTypedDataUint8ArrayClassId ( intptr_t  cid )

static

Definition at line 37 of file typed_data.cc.

                                                       {
  if (!IsTypedDataBaseClassId(cid)) return false;
  const intptr_t internal_cid =
      cid - ((cid - kFirstTypedDataCid) % kNumTypedDataCidRemainders) +
      kTypedDataCidRemainderInternal;
  return internal_cid == kTypedDataUint8ArrayCid ||
         internal_cid == kTypedDataUint8ClampedArrayCid;
}

IsTypedDataViewClassId()

bool dart::IsTypedDataViewClassId ( intptr_t  index )

inline

Definition at line 439 of file class_id.h.

                                                   {
  const bool is_byte_data_view = index == kByteDataViewCid;
  return is_byte_data_view ||
         (IsTypedDataBaseClassId(index) &&
          ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) ==
              kTypedDataCidRemainderView);
}

IsUnboxedInteger()

static bool dart::IsUnboxedInteger ( Representation  rep )

static

Definition at line 1927 of file flow_graph.cc.

                                                 {
  return (rep == kUnboxedInt32) || (rep == kUnboxedUint32) ||
         (rep == kUnboxedInt64);
}

IsUnmodifiableTypedDataViewClassId()

bool dart::IsUnmodifiableTypedDataViewClassId ( intptr_t  index )

inline

Definition at line 453 of file class_id.h.

                                                               {
  const bool is_byte_data_view = index == kUnmodifiableByteDataViewCid;
  return is_byte_data_view ||
         (IsTypedDataBaseClassId(index) &&
          ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) ==
              kTypedDataCidRemainderUnmodifiable);
}

IsUnreachable() [1/2]

static bool dart::IsUnreachable ( const ObjectPtr  obj )

static

Definition at line 547 of file marker.cc.

                                               {
  if (obj->IsImmediateObject()) {
    return false;
  }
  return !obj->untag()->IsMarked();
}

IsUnreachable() [2/2]

static bool dart::IsUnreachable ( ObjectPtr *  ptr )

static

Definition at line 588 of file scavenger.cc.

                                          {
  ObjectPtr obj = *ptr;
  if (obj->IsImmediateOrOldObject()) {
    return false;
  }
  uword raw_addr = UntaggedObject::ToAddr(obj);
  uword header = *reinterpret_cast<uword*>(raw_addr);
  if (IsForwarding(header)) {
    *ptr = ForwardedObj(header);
    return false;
  }
  return true;
}

IsUnreservedChar()

static bool dart::IsUnreservedChar ( intptr_t  value )

static

Definition at line 11 of file uri.cc.

                                             {
  return ((value >= 'a' && value <= 'z') || (value >= 'A' && value <= 'Z') ||
          (value >= '0' && value <= '9') || value == '-' || value == '.' ||
          value == '_' || value == '~');
}

IsURISafeCharacter()

static bool dart::IsURISafeCharacter ( int32_t  c )

static

Definition at line 23962 of file object.cc.

                                          {
  if ((c >= '0') && (c <= '9')) {
    return true;
  }
  if ((c >= 'a') && (c <= 'z')) {
    return true;
  }
  if ((c >= 'A') && (c <= 'Z')) {
    return true;
  }
  return (c == '-') || (c == '_') || (c == '.') || (c == '~');
}

IsUTypeImm()

bool dart::IsUTypeImm ( intptr_t  imm )

inline

Definition at line 1061 of file constants_riscv.h.

                                     {
  return Utils::IsInt(32, imm) && Utils::IsAligned(imm, 1 << 12);
}

IsValidClassId()

static bool dart::IsValidClassId ( Isolate *  isolate, intptr_t  cid  )

static

Definition at line 667 of file service.cc.

                                                           {
  ASSERT(isolate != nullptr);
  ClassTable* class_table = isolate->group()->class_table();
  ASSERT(class_table != nullptr);
  return class_table->IsValidIndex(cid) && class_table->HasValidClassAt(cid);
}

IsValidFlag()

static bool dart::IsValidFlag ( const char *  name, const char *  prefix, intptr_t  prefix_length  )

static

Definition at line 419 of file flags.cc.

                                                {
  intptr_t name_length = strlen(name);
  return ((name_length > prefix_length) &&
          (strncmp(name, prefix, prefix_length) == 0));
}

IsValidLengthForAllocationSinking()

static bool dart::IsValidLengthForAllocationSinking ( ArrayAllocationInstr *  array_alloc )

static

Definition at line 3278 of file redundancy_elimination.cc.

                                       {
  const intptr_t kMaxAllocationSinkingNumElements = 32;
  if (!array_alloc->HasConstantNumElements()) {
    return false;
  }
  const intptr_t length = array_alloc->GetConstantNumElements();
  return (length >= 0) && (length <= kMaxAllocationSinkingNumElements);
}

IsVisibleAsFutureListener()

static bool dart::IsVisibleAsFutureListener ( const Function &  function )

static

Definition at line 26299 of file object.cc.

                                                                {
  if (function.is_visible()) {
    return true;
  }
 
  if (function.IsImplicitClosureFunction()) {
    return function.parent_function() == Function::null() ||
           Function::is_visible(function.parent_function());
  }
 
  return false;
}

IsWhitespace()

static bool dart::IsWhitespace ( char  c )

static

Definition at line 2774 of file service.cc.

                                 {
  return c <= ' ';
}

IsZero()

bool dart::IsZero	(	char *	begin,
		char *	end
	)

Definition at line 13 of file virtual_memory_test.cc.

                                    {
  for (char* current = begin; current < end; ++current) {
    if (*current != 0) {
      return false;
    }
  }
  return true;
}

Join()

static void dart::Join ( Range *  range, Definition *  defn, const Range *  defn_range, RangeBoundary::RangeSize  size  )

static

Definition at line 2682 of file range_analysis.cc.

                                              {
  if (Range::IsUnknown(defn_range)) {
    return;
  }
 
  if (Range::IsUnknown(range)) {
    *range = *defn_range;
    return;
  }
 
  Range other = *defn_range;
 
  // Handle patterns where range already depends on defn as a symbol:
  //
  //    (..., S+o] U range(S) and [S+o, ...) U range(S)
  //
  // To improve precision of the computed join use [S, S] instead of
  // using range(S). It will be canonicalized away by JoinMin/JoinMax
  // functions.
  Definition* unwrapped = UnwrapConstraint(defn);
  if (DependsOnSymbol(range->min(), unwrapped) ||
      DependsOnSymbol(range->max(), unwrapped)) {
    other = Range(RangeBoundary::FromDefinition(defn, 0),
                  RangeBoundary::FromDefinition(defn, 0));
  }
 
  // First try to compare ranges based on their upper and lower bounds.
  const int64_t inf_range = range->min().LowerBound(size);
  const int64_t inf_other = other.min().LowerBound(size);
  const int64_t sup_range = range->max().UpperBound(size);
  const int64_t sup_other = other.max().UpperBound(size);
 
  if (sup_range <= inf_other) {
    // The range is fully below defn's range. Keep the minimum and
    // expand the maximum.
    range->set_max(other.max());
  } else if (sup_other <= inf_range) {
    // The range is fully above defn's range. Keep the maximum and
    // expand the minimum.
    range->set_min(other.min());
  } else {
    // Can't compare ranges as whole. Join minimum and maximum separately.
    *range = Range(RangeBoundary::JoinMin(range->min(), other.min(), size),
                   RangeBoundary::JoinMax(range->max(), other.max(), size));
  }
}

JumpToExceptionHandler()

static void dart::JumpToExceptionHandler ( Thread *  thread, uword  program_counter, uword  stack_pointer, uword  frame_pointer, const Object &  exception_object, const Object &  stacktrace_object  )

static

Definition at line 612 of file exceptions.cc.

                                                                    {
  bool clear_deopt = false;
  uword remapped_pc = thread->pending_deopts().RemapExceptionPCForDeopt(
      program_counter, frame_pointer, &clear_deopt);
  thread->set_active_exception(exception_object);
  thread->set_active_stacktrace(stacktrace_object);
  thread->set_resume_pc(remapped_pc);
  uword run_exception_pc = StubCode::RunExceptionHandler().EntryPoint();
  Exceptions::JumpToFrame(thread, run_exception_pc, stack_pointer,
                          frame_pointer, clear_deopt);
}

JustPropagateError_lookup()

static Dart_NativeFunction dart::JustPropagateError_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 719 of file dart_api_impl_test.cc.

                                                                             {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  return JustPropagateErrorNative;
}

JustPropagateErrorNative()

void dart::JustPropagateErrorNative

(

Dart_NativeArguments

args

)

Definition at line 710 of file dart_api_impl_test.cc.

                                                         {
  Dart_Handle closure = Dart_GetNativeArgument(args, 0);
  EXPECT(Dart_IsClosure(closure));
  Dart_Handle result = Dart_InvokeClosure(closure, 0, nullptr);
  EXPECT(Dart_IsError(result));
  Dart_PropagateError(result);
  UNREACHABLE();
}

Kill()

static void dart::Kill ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4400 of file service.cc.

                                                 {
  const String& msg =
      String::Handle(String::New("isolate terminated by Kill service request"));
  const UnwindError& error = UnwindError::Handle(UnwindError::New(msg));
  error.set_is_user_initiated(true);
  Thread::Current()->set_sticky_error(error);
  PrintSuccess(js);
}

KillNonMainIsolatesSlow()

static void dart::KillNonMainIsolatesSlow ( Thread *  thread, Isolate *  main_isolate  )

static

Definition at line 6760 of file dart_api_impl.cc.

                                                                           {
  auto group = main_isolate->group();
  while (true) {
    bool non_main_isolates_alive = false;
    {
      DeoptSafepointOperationScope safepoint(thread);
      group->ForEachIsolate(
          [&](Isolate* isolate) {
            if (isolate != main_isolate) {
              Isolate::KillIfExists(isolate, Isolate::kKillMsg);
              non_main_isolates_alive = true;
            }
          },
          /*at_safepoint=*/true);
      if (!non_main_isolates_alive) {
        break;
      }
    }
    OS::SleepMicros(10 * 1000);
  }
}

LargePointer()

DART_EXPORT void * dart::LargePointer

(

)

Definition at line 83 of file ffi_test_functions_vmspecific.cc.

                                 {
  Dart_ExecuteInternalCommand("gc-on-nth-allocation",
                              reinterpret_cast<void*>(1));
  uint64_t origin = 0x8100000082000000;
  return reinterpret_cast<void*>(origin);
}

LibraryTagHandler()

static Dart_Handle dart::LibraryTagHandler ( Dart_LibraryTag  tag, Dart_Handle  library, Dart_Handle  url  )

static

Definition at line 378 of file unit_test.cc.

                                                      {
  if (tag == Dart_kCanonicalizeUrl) {
    Dart_Handle library_url = Dart_LibraryUrl(library);
    if (Dart_IsError(library_url)) {
      return library_url;
    }
    return Dart_DefaultCanonicalizeUrl(library_url, url);
  }
  UNREACHABLE();
  return Dart_Null();
}

LinkedHashBaseEqual()

template<class LinkedHashBase >

static bool dart::LinkedHashBaseEqual ( const LinkedHashBase &  map1, const LinkedHashBase &  map2, bool  print_diff, bool  check_data = true  )

static

Definition at line 6656 of file object_test.cc.

                                                        {
  if (check_data) {
    // Check data, only for non-nested.
    const auto& data1 = Array::Handle(map1.data());
    const auto& data2 = Array::Handle(map2.data());
    const intptr_t data1_length = Smi::Value(map1.used_data());
    const intptr_t data2_length = Smi::Value(map2.used_data());
    const bool data_length_equal = data1_length == data2_length;
    bool data_equal = data_length_equal;
    if (data_length_equal) {
      auto& object1 = Instance::Handle();
      auto& object2 = Instance::Handle();
      for (intptr_t i = 0; i < data1_length; i++) {
        object1 ^= data1.At(i);
        object2 ^= data2.At(i);
        data_equal &= object1.CanonicalizeEquals(object2);
      }
    }
    if (!data_equal) {
      if (print_diff) {
        THR_Print("LinkedHashBaseEqual Data not equal.\n");
        THR_Print("LinkedHashBaseEqual data1.length %" Pd " data1.length %" Pd
                  " \n",
                  data1_length, data2_length);
        auto& object1 = Instance::Handle();
        for (intptr_t i = 0; i < data1_length; i++) {
          object1 ^= data1.At(i);
          THR_Print("LinkedHashBaseEqual data1[%" Pd "] %s\n", i,
                    object1.ToCString());
        }
        for (intptr_t i = 0; i < data2_length; i++) {
          object1 ^= data2.At(i);
          THR_Print("LinkedHashBaseEqual data2[%" Pd "] %s\n", i,
                    object1.ToCString());
        }
      }
      return false;
    }
  }
 
  // Check hashing.
  intptr_t hash_mask1 = Smi::Value(map1.hash_mask());
  EXPECT(!Integer::Handle(map2.hash_mask()).IsNull());
  intptr_t hash_mask2 = Smi::Value(map2.hash_mask());
  const bool hash_masks_equal = hash_mask1 == hash_mask2;
  if (!hash_masks_equal) {
    if (print_diff) {
      THR_Print("LinkedHashBaseEqual Hash masks not equal.\n");
      THR_Print("LinkedHashBaseEqual hash_mask1 %" Px " hash_mask2 %" Px " \n",
                hash_mask1, hash_mask2);
    }
  }
 
  // Check indices.
  const auto& index1 = TypedData::Handle(map1.index());
  const auto& index2 = TypedData::Handle(map2.index());
  EXPECT(!index2.IsNull());
  ASSERT(index1.ElementType() == kUint32ArrayElement);
  ASSERT(index2.ElementType() == kUint32ArrayElement);
  const intptr_t kElementSize = 4;
  ASSERT(kElementSize == index1.ElementSizeInBytes());
  const bool index_length_equal = index1.Length() == index2.Length();
  bool index_equal = index_length_equal;
  if (index_length_equal) {
    for (intptr_t i = 0; i < index1.Length(); i++) {
      const uint32_t index1_val = index1.GetUint32(i * kElementSize);
      const uint32_t index2_val = index2.GetUint32(i * kElementSize);
      index_equal &= index1_val == index2_val;
    }
  }
  if (!index_equal && print_diff) {
    THR_Print("LinkedHashBaseEqual Indices not equal.\n");
    THR_Print("LinkedHashBaseEqual index1.length %" Pd " index2.length %" Pd
              " \n",
              index1.Length(), index2.Length());
    for (intptr_t i = 0; i < index1.Length(); i++) {
      const uint32_t index_val = index1.GetUint32(i * kElementSize);

ListCaptureRegisters()

static Interval dart::ListCaptureRegisters ( ZoneGrowableArray< RegExpTree * > *  children )

static

Definition at line 39 of file regexp_ast.cc.

                                                                               {
  Interval result = Interval::Empty();
  for (intptr_t i = 0; i < children->length(); i++)
    result = result.Union(children->At(i)->CaptureRegisters());
  return result;
}

Load16Aligned()

static int32_t dart::Load16Aligned ( const uint8_t *  pc )

static

Definition at line 131 of file regexp_interpreter.cc.

                                                {
  ASSERT((reinterpret_cast<intptr_t>(pc) & 1) == 0);
  return *reinterpret_cast<const uint16_t*>(pc);
}

Load32Aligned()

static int32_t dart::Load32Aligned ( const uint8_t *  pc )

static

Definition at line 126 of file regexp_interpreter.cc.

                                                {
  ASSERT((reinterpret_cast<intptr_t>(pc) & 3) == 0);
  return *reinterpret_cast<const int32_t*>(pc);
}

LoadDynamicLibrary()

static void * dart::LoadDynamicLibrary ( const char *  library_file, char **  error = nullptr  )

static

Definition at line 74 of file ffi_dynamic_library.cc.

                                                        {
  char* utils_error = nullptr;
  void* handle = Utils::LoadDynamicLibrary(library_file, &utils_error);
  if (utils_error != nullptr) {
    if (error != nullptr) {
      *error = OS::SCreate(
          /*use malloc*/ nullptr, "Failed to load dynamic library '%s': %s",
          library_file != nullptr ? library_file : "<process>", utils_error);
    }
    free(utils_error);
  }
  return handle;
}

LoadExpressionEvaluationFunction()

static ObjectPtr dart::LoadExpressionEvaluationFunction ( Zone *  zone, const ExternalTypedData &  kernel_buffer, const String &  library_url, const String &  klass  )

static

Definition at line 4804 of file object.cc.

                         {
  std::unique_ptr<kernel::Program> kernel_pgm =
      kernel::Program::ReadFromTypedData(kernel_buffer);
 
  if (kernel_pgm == nullptr) {
    return ApiError::New(String::Handle(
        zone, String::New("Kernel isolate returned ill-formed kernel.")));
  }
 
  auto& result = Object::Handle(zone);
  {
    kernel::KernelLoader loader(kernel_pgm.get(),
                                /*uri_to_source_table=*/nullptr);
    result = loader.LoadExpressionEvaluationFunction(library_url, klass);
    kernel_pgm.reset();
  }
  if (result.IsError()) return result.ptr();
  return Function::Cast(result).ptr();
}

LoadIsolateReloadTestLibIfNeeded()

static void dart::LoadIsolateReloadTestLibIfNeeded ( const char *  script )

static

Definition at line 289 of file unit_test.cc.

                                                                 {
#ifndef PRODUCT
  if (strstr(script, IsolateReloadTestLibUri()) != nullptr) {
    Dart_Handle result = TestCase::LoadTestLibrary(
        IsolateReloadTestLibUri(), kIsolateReloadTestLibSource,
        IsolateReloadTestNativeResolver);
    EXPECT_VALID(result);
  }
#endif  // ifndef PRODUCT
}

LoadLibrary()

static Dart_Handle dart::LoadLibrary ( Thread *  T, const ExternalTypedData &  td  )

static

Definition at line 5750 of file dart_api_impl.cc.

                                                                       {
  const char* error = nullptr;
  std::unique_ptr<kernel::Program> program =
      kernel::Program::ReadFromTypedData(td, &error);
  if (program == nullptr) {
    return Api::NewError("Can't load Kernel binary: %s.", error);
  }
  const Object& result =
      kernel::KernelLoader::LoadEntireProgram(program.get(), false);
  program.reset();
 
  IsolateGroupSource* source = Isolate::Current()->source();
  source->add_loaded_blob(Z, td);
 
  return Api::NewHandle(T, result.ptr());
}

LoadRelaxed()

template<typename T >

static T dart::LoadRelaxed ( const T *  ptr )

inlinestatic

Definition at line 150 of file atomic.h.

                                          {
  static_assert(sizeof(std::atomic<T>) == sizeof(T));
  return reinterpret_cast<const std::atomic<T>*>(ptr)->load(
      std::memory_order_relaxed);
}

LoadScript()

static Dart_Handle dart::LoadScript ( const char *  url_str, const char *  source  )

static

Definition at line 4828 of file dart_api_impl_test.cc.

                                                                       {
  const uint8_t* kernel_buffer = nullptr;
  intptr_t kernel_buffer_size = 0;
  char* error = TestCase::CompileTestScriptWithDFE(
      url_str, source, &kernel_buffer, &kernel_buffer_size);
  if (error != nullptr) {
    return Dart_NewApiError(error);
  }
  TestCaseBase::AddToKernelBuffers(kernel_buffer);
  return Dart_LoadScriptFromKernel(kernel_buffer, kernel_buffer_size);
}

LoadSource()

static Definition * dart::LoadSource ( Definition *  instr )

static

Definition at line 3413 of file redundancy_elimination.cc.

                                                 {
  if (auto load = instr->AsLoadField()) {
    return load->instance()->definition();
  }
  if (auto load = instr->AsLoadIndexed()) {
    return load->array()->definition();
  }
  return nullptr;
}

LoadTestScript() [1/2]

static LibraryPtr dart::LoadTestScript ( const char *  script )

static

Definition at line 210 of file profiler_test.cc.

                                                     {
  Dart_Handle api_lib;
  {
    TransitionVMToNative transition(Thread::Current());
    api_lib = TestCase::LoadTestScript(script, nullptr);
    EXPECT_VALID(api_lib);
  }
  Library& lib = Library::Handle();
  lib ^= Api::UnwrapHandle(api_lib);
  return lib.ptr();
}

LoadTestScript() [2/2]

LibraryPtr dart::LoadTestScript	(	const char *	script,
		Dart_NativeEntryResolver	resolver,
		const char *	lib_uri
	)

Definition at line 26 of file il_test_helper.cc.

                                               {
  Dart_Handle api_lib;
  {
    TransitionVMToNative transition(Thread::Current());
    api_lib = TestCase::LoadTestScript(script, resolver, lib_uri);
    EXPECT_VALID(api_lib);
  }
  auto& lib = Library::Handle();
  lib ^= Api::UnwrapHandle(api_lib);
  EXPECT(!lib.IsNull());
  return lib.ptr();
}

LoadUnaligned()

template<typename T >

static T dart::LoadUnaligned ( const T *  ptr )

inlinestatic

Definition at line 14 of file unaligned.h.

                                            {
  T value;
  memcpy(reinterpret_cast<void*>(&value),  // NOLINT
         reinterpret_cast<const void*>(ptr), sizeof(value));
  return value;
}

LocalVarAddress()

static DART_FORCE_INLINE uword dart::LocalVarAddress ( uword  fp, intptr_t  index  )

static

Definition at line 429 of file stack_frame.h.

                                                                         {
  return fp + LocalVarIndex(0, index) * kWordSize;
}

LocalVarIndex()

static DART_FORCE_INLINE intptr_t dart::LocalVarIndex ( intptr_t  fp_offset, intptr_t  var_index  )

static

Definition at line 412 of file stack_frame.h.

                                                                    {
  return fp_offset + var_index;
}

LocationAnyOrConstant()

Location dart::LocationAnyOrConstant

(

Value *

value

)

Definition at line 357 of file locations.cc.

                                             {
  ConstantInstr* constant = value->definition()->AsConstant();
  return ((constant != nullptr) &&
          compiler::Assembler::IsSafe(constant->value()))
             ? Location::Constant(constant)
             : Location::Any();
}

LocationArgumentsDescriptorLocation()

Location dart::LocationArgumentsDescriptorLocation

(

)

Definition at line 480 of file locations.cc.

                                               {
  return Location::RegisterLocation(ARGS_DESC_REG);
}

LocationCount()

intptr_t dart::LocationCount ( Representation  rep )

inline

Definition at line 75 of file locations.h.

                                                  {
  switch (rep) {
    case kPairOfTagged:
      return 2;
    case kUnboxedInt64:
      return compiler::target::kWordSize == 8 ? 1 : 2;
    default:
      return 1;
  }
}

LocationExceptionLocation()

Location dart::LocationExceptionLocation

(

)

Definition at line 484 of file locations.cc.

                                     {
  return Location::RegisterLocation(kExceptionObjectReg);
}

LocationFixedRegisterOrConstant()

Location dart::LocationFixedRegisterOrConstant	(	Value *	value,
		Register	reg
	)

Definition at line 339 of file locations.cc.

                                                                     {
  ASSERT(((1 << reg) & kDartAvailableCpuRegs) != 0);
  ConstantInstr* constant = value->definition()->AsConstant();
  return ((constant != nullptr) &&
          compiler::Assembler::IsSafe(constant->value()))
             ? Location::Constant(constant)
             : Location::RegisterLocation(reg);
}

LocationFixedRegisterOrSmiConstant()

Location dart::LocationFixedRegisterOrSmiConstant	(	Value *	value,
		Register	reg
	)

Definition at line 348 of file locations.cc.

                                                                        {
  ASSERT(((1 << reg) & kDartAvailableCpuRegs) != 0);
  ConstantInstr* constant = value->definition()->AsConstant();
  return ((constant != nullptr) &&
          compiler::Assembler::IsSafeSmi(constant->value()))
             ? Location::Constant(constant)
             : Location::RegisterLocation(reg);
}

LocationRegisterOrConstant()

Location dart::LocationRegisterOrConstant

(

Value *

value

)

Definition at line 289 of file locations.cc.

                                                  {
  ConstantInstr* constant = value->definition()->AsConstant();
  return ((constant != nullptr) &&
          compiler::Assembler::IsSafe(constant->value()))
             ? Location::Constant(constant)
             : Location::RequiresRegister();
}

LocationRegisterOrSmiConstant()

Location dart::LocationRegisterOrSmiConstant	(	Value *	value,
		intptr_t	min_value,
		intptr_t	max_value
	)

Definition at line 297 of file locations.cc.

                                                           {
  ConstantInstr* constant = value->definition()->AsConstant();
  if (constant == nullptr) {
    return Location::RequiresRegister();
  }
  if (!compiler::Assembler::IsSafeSmi(constant->value())) {
    return Location::RequiresRegister();
  }
  const intptr_t smi_value = value->BoundSmiConstant();
  if (smi_value < min_value || smi_value > max_value) {
    return Location::RequiresRegister();
  }
  return Location::Constant(constant);
}

LocationRemapForSlowPath()

Location dart::LocationRemapForSlowPath	(	Location	loc,
		Definition *	def,
		intptr_t *	cpu_reg_slots,
		intptr_t *	fpu_reg_slots
	)

Definition at line 492 of file locations.cc.

                                                           {
  if (loc.IsRegister()) {
    intptr_t index = cpu_reg_slots[loc.reg()];
    ASSERT(index >= 0);
    return Location::StackSlot(
        compiler::target::frame_layout.FrameSlotForVariableIndex(-index),
        FPREG);
  } else if (loc.IsFpuRegister()) {
    intptr_t index = fpu_reg_slots[loc.fpu_reg()];
    ASSERT(index >= 0);
    switch (def->representation()) {
      case kUnboxedDouble:  // SlowPathEnvironmentFor sees _one_ register
      case kUnboxedFloat:   // both for doubles and floats.
        return Location::DoubleStackSlot(
            compiler::target::frame_layout.FrameSlotForVariableIndex(-index),
            FPREG);
 
      case kUnboxedFloat32x4:
      case kUnboxedInt32x4:
      case kUnboxedFloat64x2:
        return Location::QuadStackSlot(
            compiler::target::frame_layout.FrameSlotForVariableIndex(-index),
            FPREG);
 
      default:
        UNREACHABLE();
    }
  } else if (loc.IsPairLocation()) {
    ASSERT(def->representation() == kUnboxedInt64);
    PairLocation* value_pair = loc.AsPairLocation();
    intptr_t index_lo;
    intptr_t index_hi;
 
    if (value_pair->At(0).IsRegister()) {
      index_lo = compiler::target::frame_layout.FrameSlotForVariableIndex(
          -cpu_reg_slots[value_pair->At(0).reg()]);
    } else {
      ASSERT(value_pair->At(0).IsStackSlot());
      index_lo = value_pair->At(0).stack_index();
    }
 
    if (value_pair->At(1).IsRegister()) {
      index_hi = compiler::target::frame_layout.FrameSlotForVariableIndex(
          -cpu_reg_slots[value_pair->At(1).reg()]);
    } else {
      ASSERT(value_pair->At(1).IsStackSlot());
      index_hi = value_pair->At(1).stack_index();
    }
 
    return Location::Pair(Location::StackSlot(index_lo, FPREG),
                          Location::StackSlot(index_hi, FPREG));
  } else if (loc.IsInvalid() && def->IsMaterializeObject()) {
    def->AsMaterializeObject()->RemapRegisters(cpu_reg_slots, fpu_reg_slots);
    return loc;
  }
 
  return loc;
}

LocationStackTraceLocation()

Location dart::LocationStackTraceLocation

(

)

Definition at line 488 of file locations.cc.

                                      {
  return Location::RegisterLocation(kStackTraceObjectReg);
}

LocationToStackSlotAddress()

compiler::Address dart::LocationToStackSlotAddress

(

Location

loc

)

Definition at line 365 of file locations.cc.

                                                         {
  return compiler::Address(loc.base_reg(), loc.ToStackSlotOffset());
}

LocationWritableRegisterOrConstant()

Location dart::LocationWritableRegisterOrConstant

(

Value *

value

)

Definition at line 314 of file locations.cc.

                                                          {
  ConstantInstr* constant = value->definition()->AsConstant();
  return ((constant != nullptr) &&
          compiler::Assembler::IsSafe(constant->value()))
             ? Location::Constant(constant)
             : Location::WritableRegister();
}

LocationWritableRegisterOrSmiConstant()

Location dart::LocationWritableRegisterOrSmiConstant	(	Value *	value,
		intptr_t	min_value,
		intptr_t	max_value
	)

Definition at line 322 of file locations.cc.

                                                                   {
  ConstantInstr* constant = value->definition()->AsConstant();
  if (constant == nullptr) {
    return Location::WritableRegister();
  }
  if (!compiler::Assembler::IsSafeSmi(constant->value())) {
    return Location::WritableRegister();
  }
  const intptr_t smi_value = value->BoundSmiConstant();
  if (smi_value < min_value || smi_value > max_value) {
    return Location::WritableRegister();
  }
  return Location::Constant(constant);
}

LongJumpHelper()

static void dart::LongJumpHelper ( LongJumpScope *  jump )

static

Definition at line 11 of file longjump_test.cc.

                                                {
  const Error& error = Error::Handle(
      LanguageError::New(String::Handle(String::New("LongJumpHelper"))));
  jump->Jump(1, error);
  UNREACHABLE();
}

LookupBreakpoint()

static Breakpoint * dart::LookupBreakpoint ( Isolate *  isolate, const char *  id, ObjectIdRing::LookupResult *  result  )

static

Definition at line 2238 of file service.cc.

                                                                      {
  *result = ObjectIdRing::kInvalid;
  size_t end_pos = strcspn(id, "/");
  if (end_pos == strlen(id)) {
    return nullptr;
  }
  const char* rest = id + end_pos + 1;  // +1 for '/'.
  if (strncmp("breakpoints", id, end_pos) == 0) {
    intptr_t bpt_id = 0;
    Breakpoint* bpt = nullptr;
    if (GetIntegerId(rest, &bpt_id)) {
      bpt = isolate->debugger()->GetBreakpointById(bpt_id);
      if (bpt != nullptr) {
        *result = ObjectIdRing::kValid;
        return bpt;
      }
      if (bpt_id < isolate->debugger()->limitBreakpointId()) {
        *result = ObjectIdRing::kCollected;
        return nullptr;
      }
    }
  }
  return nullptr;
}

LookupClassMembers()

static ObjectPtr dart::LookupClassMembers ( Thread *  thread, const Class &  klass, char **  parts, int  num_parts  )

static

Definition at line 1847 of file service.cc.

                                                   {
  auto zone = thread->zone();
 
  if (num_parts != 4) {
    return Object::sentinel().ptr();
  }
 
  const char* encoded_id = parts[3];
  auto& id = String::Handle(String::New(encoded_id));
  id = String::DecodeIRI(id);
  if (id.IsNull()) {
    return Object::sentinel().ptr();
  }
 
  if (strcmp(parts[2], "fields") == 0) {
    // Field ids look like: "classes/17/fields/name"
    const auto& field = Field::Handle(klass.LookupField(id));
    if (field.IsNull()) {
      return Object::sentinel().ptr();
    }
    return field.ptr();
  }
  if (strcmp(parts[2], "field_inits") == 0) {
    // Field initializer ids look like: "classes/17/field_inits/name"
    const auto& field = Field::Handle(klass.LookupField(id));
    if (field.IsNull() || (field.is_late() && !field.has_initializer())) {
      return Object::sentinel().ptr();
    }
    const auto& function = Function::Handle(field.EnsureInitializerFunction());
    if (function.IsNull()) {
      return Object::sentinel().ptr();
    }
    return function.ptr();
  }
  if (strcmp(parts[2], "functions") == 0) {
    // Function ids look like: "classes/17/functions/name"
 
    const auto& function =
        Function::Handle(Resolver::ResolveFunction(zone, klass, id));
    if (function.IsNull()) {
      return Object::sentinel().ptr();
    }
    return function.ptr();
  }
  if (strcmp(parts[2], "implicit_closures") == 0) {
    // Function ids look like: "classes/17/implicit_closures/11"
    intptr_t id;
    if (!GetIntegerId(parts[3], &id)) {
      return Object::sentinel().ptr();
    }
    const auto& func =
        Function::Handle(zone, klass.ImplicitClosureFunctionFromIndex(id));
    if (func.IsNull()) {
      return Object::sentinel().ptr();
    }
    return func.ptr();
  }
  if (strcmp(parts[2], "dispatchers") == 0) {
    // Dispatcher Function ids look like: "classes/17/dispatchers/11"
    intptr_t id;
    if (!GetIntegerId(parts[3], &id)) {
      return Object::sentinel().ptr();
    }
    const auto& func =
        Function::Handle(zone, klass.InvocationDispatcherFunctionFromIndex(id));
    if (func.IsNull()) {
      return Object::sentinel().ptr();
    }
    return func.ptr();
  }
  if (strcmp(parts[2], "closures") == 0) {
    // Closure ids look like: "classes/17/closures/11"
    intptr_t id;
    if (!GetIntegerId(parts[3], &id)) {
      return Object::sentinel().ptr();
    }
    Function& func = Function::Handle(zone);
    func = ClosureFunctionsCache::ClosureFunctionFromIndex(id);
    if (func.IsNull()) {
      return Object::sentinel().ptr();
    }
    return func.ptr();
  }
 
  UNREACHABLE();
  return Object::sentinel().ptr();
}

LookupField()

FieldPtr dart::LookupField	(	Dart_Handle	library,
		const char *	class_name,
		const char *	field_name
	)

Definition at line 13 of file guard_field_test.cc.

                                             {
  LibraryPtr raw_library = Library::RawCast(Api::UnwrapHandle(library));
  Library& lib = Library::ZoneHandle(raw_library);
  const String& classname =
      String::Handle(Symbols::New(Thread::Current(), class_name));
  Class& cls = Class::Handle(lib.LookupClass(classname));
  EXPECT(!cls.IsNull());  // No ambiguity error expected.
 
  String& fieldname = String::Handle(String::New(field_name));
  Field& field =
      Field::ZoneHandle(cls.LookupInstanceFieldAllowPrivate(fieldname));
  EXPECT(!field.IsNull());
  return field.ptr();
}

LookupHeapObject()

static ObjectPtr dart::LookupHeapObject ( Thread *  thread, const char *  id_original, ObjectIdRing::LookupResult *  result  )

static

Definition at line 2177 of file service.cc.

                                                                    {
  char* id = thread->zone()->MakeCopyOfString(id_original);
 
  // Parse the id by splitting at each '/'.
  const int MAX_PARTS = 8;
  char* parts[MAX_PARTS];
  int num_parts = 0;
  int i = 0;
  int start_pos = 0;
  while (id[i] != '\0') {
    if (id[i] == '/') {
      id[i++] = '\0';
      parts[num_parts++] = &id[start_pos];
      if (num_parts == MAX_PARTS) {
        break;
      }
      start_pos = i;
    } else {
      i++;
    }
  }
  if (num_parts < MAX_PARTS) {
    parts[num_parts++] = &id[start_pos];
  }
 
  if (result != nullptr) {
    *result = ObjectIdRing::kValid;
  }
 
  Isolate* isolate = thread->isolate();
  if (strcmp(parts[0], "objects") == 0) {
    // Object ids look like "objects/1123"
    Object& obj = Object::Handle(thread->zone());
    ObjectIdRing::LookupResult lookup_result;
    obj = LookupObjectId(thread, parts[1], &lookup_result);
    if (lookup_result != ObjectIdRing::kValid) {
      if (result != nullptr) {
        *result = lookup_result;
      }
      return Object::sentinel().ptr();
    }
    return obj.ptr();
 
  } else if (strcmp(parts[0], "libraries") == 0) {
    return LookupHeapObjectLibraries(isolate->group(), parts, num_parts);
  } else if (strcmp(parts[0], "classes") == 0) {
    return LookupHeapObjectClasses(thread, parts, num_parts);
  } else if (strcmp(parts[0], "typearguments") == 0) {
    return LookupHeapObjectTypeArguments(thread, parts, num_parts);
  } else if (strcmp(parts[0], "code") == 0) {
    return LookupHeapObjectCode(parts, num_parts);
  } else if (strcmp(parts[0], "messages") == 0) {
    return LookupHeapObjectMessage(thread, parts, num_parts);
  }
 
  // Not found.
  return Object::sentinel().ptr();
}

LookupHeapObjectClasses()

static ObjectPtr dart::LookupHeapObjectClasses ( Thread *  thread, char **  parts, int  num_parts  )

static

Definition at line 2029 of file service.cc.

                                                        {
  // Class ids look like: "classes/17"
  if (num_parts < 2) {
    return Object::sentinel().ptr();
  }
  Zone* zone = thread->zone();
  auto table = thread->isolate_group()->class_table();
  intptr_t id;
  if (!GetIntegerId(parts[1], &id) || !table->IsValidIndex(id)) {
    return Object::sentinel().ptr();
  }
  Class& cls = Class::Handle(zone, table->At(id));
  if (num_parts == 2) {
    return cls.ptr();
  }
  if (strcmp(parts[2], "closures") == 0) {
    // Closure ids look like: "classes/17/closures/11"
    return LookupClassMembers(thread, cls, parts, num_parts);
  } else if (strcmp(parts[2], "field_inits") == 0) {
    // Field initializer ids look like: "classes/17/field_inits/name"
    return LookupClassMembers(thread, cls, parts, num_parts);
  } else if (strcmp(parts[2], "fields") == 0) {
    // Field ids look like: "classes/17/fields/name"
    return LookupClassMembers(thread, cls, parts, num_parts);
  } else if (strcmp(parts[2], "functions") == 0) {
    // Function ids look like: "classes/17/functions/name"
    return LookupClassMembers(thread, cls, parts, num_parts);
  } else if (strcmp(parts[2], "implicit_closures") == 0) {
    // Function ids look like: "classes/17/implicit_closures/11"
    return LookupClassMembers(thread, cls, parts, num_parts);
  } else if (strcmp(parts[2], "dispatchers") == 0) {
    // Dispatcher Function ids look like: "classes/17/dispatchers/11"
    return LookupClassMembers(thread, cls, parts, num_parts);
  } else if (strcmp(parts[2], "types") == 0) {
    // Type ids look like: "classes/17/types/11"
    if (num_parts != 4) {
      return Object::sentinel().ptr();
    }
    intptr_t id;
    if (!GetIntegerId(parts[3], &id)) {
      return Object::sentinel().ptr();
    }
    if (id != 0) {
      return Object::sentinel().ptr();
    }
    const Type& type = Type::Handle(zone, cls.DeclarationType());
    if (!type.IsNull()) {
      return type.ptr();
    }
  }
 
  // Not found.
  return Object::sentinel().ptr();
}

LookupHeapObjectCode()

static ObjectPtr dart::LookupHeapObjectCode ( char **  parts, int  num_parts  )

static

Definition at line 2108 of file service.cc.

                                                                   {
  if (num_parts != 2) {
    return Object::sentinel().ptr();
  }
  uword pc;
  const char* const kCollectedPrefix = "collected-";
  const intptr_t kCollectedPrefixLen = strlen(kCollectedPrefix);
  const char* const kNativePrefix = "native-";
  const intptr_t kNativePrefixLen = strlen(kNativePrefix);
  const char* const kReusedPrefix = "reused-";
  const intptr_t kReusedPrefixLen = strlen(kReusedPrefix);
  const char* id = parts[1];
  if (strncmp(kCollectedPrefix, id, kCollectedPrefixLen) == 0) {
    if (!GetUnsignedIntegerId(&id[kCollectedPrefixLen], &pc, 16)) {
      return Object::sentinel().ptr();
    }
    // TODO(turnidge): Return "collected" instead.
    return Object::null();
  }
  if (strncmp(kNativePrefix, id, kNativePrefixLen) == 0) {
    if (!GetUnsignedIntegerId(&id[kNativePrefixLen], &pc, 16)) {
      return Object::sentinel().ptr();
    }
    // TODO(johnmccutchan): Support native Code.
    return Object::null();
  }
  if (strncmp(kReusedPrefix, id, kReusedPrefixLen) == 0) {
    if (!GetUnsignedIntegerId(&id[kReusedPrefixLen], &pc, 16)) {
      return Object::sentinel().ptr();
    }
    // TODO(turnidge): Return "expired" instead.
    return Object::null();
  }
  int64_t timestamp = 0;
  if (!GetCodeId(id, &timestamp, &pc) || (timestamp < 0)) {
    return Object::sentinel().ptr();
  }
  Code& code = Code::Handle(Code::FindCode(pc, timestamp));
  if (!code.IsNull()) {
    return code.ptr();
  }
 
  // Not found.
  return Object::sentinel().ptr();
}

LookupHeapObjectLibraries()

static ObjectPtr dart::LookupHeapObjectLibraries ( IsolateGroup *  isolate_group, char **  parts, int  num_parts  )

static

Definition at line 1938 of file service.cc.

                                                          {
  // Library ids look like "libraries/35"
  if (num_parts < 2) {
    return Object::sentinel().ptr();
  }
  const auto& libs =
      GrowableObjectArray::Handle(isolate_group->object_store()->libraries());
  ASSERT(!libs.IsNull());
  const String& id = String::Handle(String::New(parts[1]));
  // Scan for private key.
  String& private_key = String::Handle();
  Library& lib = Library::Handle();
  bool lib_found = false;
  for (intptr_t i = 0; i < libs.Length(); i++) {
    lib ^= libs.At(i);
    ASSERT(!lib.IsNull());
    private_key = lib.private_key();
    if (private_key.Equals(id)) {
      lib_found = true;
      break;
    }
  }
  if (!lib_found) {
    return Object::sentinel().ptr();
  }
 
  const auto& klass = Class::Handle(lib.toplevel_class());
  ASSERT(!klass.IsNull());
 
  if (num_parts == 2) {
    return lib.ptr();
  }
  if (strcmp(parts[2], "fields") == 0) {
    // Library field ids look like: "libraries/17/fields/name"
    return LookupClassMembers(Thread::Current(), klass, parts, num_parts);
  }
  if (strcmp(parts[2], "field_inits") == 0) {
    // Library field ids look like: "libraries/17/field_inits/name"
    return LookupClassMembers(Thread::Current(), klass, parts, num_parts);
  }
  if (strcmp(parts[2], "functions") == 0) {
    // Library function ids look like: "libraries/17/functions/name"
    return LookupClassMembers(Thread::Current(), klass, parts, num_parts);
  }
  if (strcmp(parts[2], "closures") == 0) {
    // Library function ids look like: "libraries/17/closures/name"
    return LookupClassMembers(Thread::Current(), klass, parts, num_parts);
  }
  if (strcmp(parts[2], "implicit_closures") == 0) {
    // Library function ids look like: "libraries/17/implicit_closures/name"
    return LookupClassMembers(Thread::Current(), klass, parts, num_parts);
  }
 
  if (strcmp(parts[2], "scripts") == 0) {
    // Script ids look like "libraries/35/scripts/library%2Furl.dart/12345"
    if (num_parts != 5) {
      return Object::sentinel().ptr();
    }
    const String& id = String::Handle(String::New(parts[3]));
    ASSERT(!id.IsNull());
    // The id is the url of the script % encoded, decode it.
    const String& requested_url = String::Handle(String::DecodeIRI(id));
 
    // Each script id is tagged with a load time.
    int64_t timestamp;
    if (!GetInteger64Id(parts[4], &timestamp, 16) || (timestamp < 0)) {
      return Object::sentinel().ptr();
    }
 
    Script& script = Script::Handle();
    String& script_url = String::Handle();
    const Array& loaded_scripts = Array::Handle(lib.LoadedScripts());
    ASSERT(!loaded_scripts.IsNull());
    intptr_t i;
    for (i = 0; i < loaded_scripts.Length(); i++) {
      script ^= loaded_scripts.At(i);
      ASSERT(!script.IsNull());
      script_url = script.url();
      if (script_url.Equals(requested_url) &&
          (timestamp == script.load_timestamp())) {
        return script.ptr();
      }
    }
  }
 
  // Not found.
  return Object::sentinel().ptr();
}

LookupHeapObjectMessage()

static ObjectPtr dart::LookupHeapObjectMessage ( Thread *  thread, char **  parts, int  num_parts  )

static

Definition at line 2154 of file service.cc.

                                                        {
  if (num_parts != 2) {
    return Object::sentinel().ptr();
  }
  uword message_id = 0;
  if (!GetUnsignedIntegerId(parts[1], &message_id, 16)) {
    return Object::sentinel().ptr();
  }
  MessageHandler::AcquiredQueues aq(thread->isolate()->message_handler());
  Message* message = aq.queue()->FindMessageById(message_id);
  if (message == nullptr) {
    // The user may try to load an expired message.
    return Object::sentinel().ptr();
  }
  if (message->IsRaw()) {
    return message->raw_obj();
  } else {
    return ReadMessage(thread, message);
  }
}

LookupHeapObjectTypeArguments()

static ObjectPtr dart::LookupHeapObjectTypeArguments ( Thread *  thread, char **  parts, int  num_parts  )

static

Definition at line 2086 of file service.cc.

                                                              {
  // TypeArguments ids look like: "typearguments/17"
  if (num_parts < 2) {
    return Object::sentinel().ptr();
  }
  intptr_t id;
  if (!GetIntegerId(parts[1], &id)) {
    return Object::sentinel().ptr();
  }
  ObjectStore* object_store = thread->isolate_group()->object_store();
  const Array& table =
      Array::Handle(thread->zone(), object_store->canonical_type_arguments());
  ASSERT(table.Length() > 0);
  const intptr_t table_size = table.Length() - 1;
  if ((id < 0) || (id >= table_size) || (table.At(id) == Object::null())) {
    return Object::sentinel().ptr();
  }
  return table.At(id);
}

LookupObjectId()

static ObjectPtr dart::LookupObjectId ( Thread *  thread, const char *  arg, ObjectIdRing::LookupResult *  kind  )

static

Definition at line 1816 of file service.cc.

                                                                {
  *kind = ObjectIdRing::kValid;
  if (strncmp(arg, "int-", 4) == 0) {
    arg += 4;
    int64_t value = 0;
    if (!OS::StringToInt64(arg, &value) || !Smi::IsValid(value)) {
      *kind = ObjectIdRing::kInvalid;
      return Object::null();
    }
    const Integer& obj =
        Integer::Handle(thread->zone(), Smi::New(static_cast<intptr_t>(value)));
    return obj.ptr();
  } else if (strcmp(arg, "bool-true") == 0) {
    return Bool::True().ptr();
  } else if (strcmp(arg, "bool-false") == 0) {
    return Bool::False().ptr();
  } else if (strcmp(arg, "null") == 0) {
    return Object::null();
  }
 
  ObjectIdRing* ring = thread->isolate()->EnsureObjectIdRing();
  intptr_t id = -1;
  if (!GetIntegerId(arg, &id)) {
    *kind = ObjectIdRing::kInvalid;
    return Object::null();
  }
  return ring->GetObjectForId(id, kind);
}

LookupPackageUris()

static void dart::LookupPackageUris ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5481 of file service.cc.

                                                              {
  LookupScriptUrisImpl(thread, js, false);
}

LookupResolvedPackageUris()

static void dart::LookupResolvedPackageUris ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5472 of file service.cc.

                                                                      {
  LookupScriptUrisImpl(thread, js, true);
}

LookupRewindPc()

static uword dart::LookupRewindPc ( const Code &  code, uword  return_address  )

static

Definition at line 3234 of file debugger.cc.

                                                                    {
  ASSERT(!code.is_optimized());
  ASSERT(code.ContainsInstructionAt(return_address));
 
  uword pc_offset = return_address - code.PayloadStart();
  const PcDescriptors& descriptors =
      PcDescriptors::Handle(code.pc_descriptors());
  PcDescriptors::Iterator iter(descriptors,
                               UntaggedPcDescriptors::kRewind |
                                   UntaggedPcDescriptors::kIcCall |
                                   UntaggedPcDescriptors::kUnoptStaticCall);
  intptr_t rewind_deopt_id = -1;
  uword rewind_pc = 0;
  while (iter.MoveNext()) {
    if (iter.Kind() == UntaggedPcDescriptors::kRewind) {
      // Remember the last rewind so we don't need to iterator twice.
      rewind_pc = code.PayloadStart() + iter.PcOffset();
      rewind_deopt_id = iter.DeoptId();
    }
    if ((pc_offset == iter.PcOffset()) && (iter.DeoptId() == rewind_deopt_id)) {
      return rewind_pc;
    }
  }
  return 0;
}

LookupScriptUrisImpl()

static void dart::LookupScriptUrisImpl ( Thread *  thread, JSONStream *  js, bool  lookup_resolved  )

static

Definition at line 5407 of file service.cc.

                                                       {
  Zone* zone = thread->zone();
  auto object_store = thread->isolate_group()->object_store();
 
  const auto& libs =
      GrowableObjectArray::Handle(zone, object_store->libraries());
  Smi& last_libraries_count =
      Smi::Handle(zone, object_store->last_libraries_count());
  if ((object_store->uri_to_resolved_uri_map() == Array::null()) ||
      (object_store->resolved_uri_to_uri_map() == Array::null()) ||
      (last_libraries_count.Value() != libs.Length())) {
    PopulateUriMappings(thread);
  }
  const char* uris_arg = js->LookupParam("uris");
  if (uris_arg == nullptr) {
    PrintMissingParamError(js, "uris");
    return;
  }
 
  const GrowableObjectArray& uris =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
  intptr_t uris_length = ParseJSONArray(thread, uris_arg, uris);
  if (uris_length < 0) {
    PrintInvalidParamError(js, "uris");
    return;
  }
 
  UriMapping map(lookup_resolved ? object_store->uri_to_resolved_uri_map()
                                 : object_store->resolved_uri_to_uri_map());
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "UriList");
 
  {
    JSONArray uris_array(&jsobj, "uris");
    String& uri = String::Handle(zone);
    String& res = String::Handle(zone);
    for (intptr_t i = 0; i < uris.Length(); ++i) {
      uri ^= uris.At(i);
      res ^= map.GetOrNull(uri);
#if defined(DART_HOST_OS_WINDOWS) || defined(DART_HOST_OS_MACOS)
      // Windows and MacOS paths can be case insensitive, so we should allow for
      // case insensitive URI mappings on Windows and MacOS.
      if (res.IsNull()) {
        String& lower_case_uri = thread->StringHandle();
        lower_case_uri = String::ToLowerCase(uri);
        res ^= map.GetOrNull(lower_case_uri);
      }
#endif  // defined(DART_HOST_OS_WINDOWS) || defined(DART_HOST_OS_MACOS)
      if (res.IsNull()) {
        uris_array.AddValueNull();
      } else {
        uris_array.AddValue(res.ToCString());
      }
    }
  }
  map.Release();
}

LookupStackTraceField()

static FieldPtr dart::LookupStackTraceField ( const Instance &  instance )

static

Definition at line 700 of file exceptions.cc.

                                                                {
  if (instance.GetClassId() < kNumPredefinedCids) {
    // 'class Error' is not a predefined class.
    return Field::null();
  }
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  auto isolate_group = thread->isolate_group();
  const auto& error_class =
      Class::Handle(zone, isolate_group->object_store()->error_class());
  // If instance class extends 'class Error' return '_stackTrace' field.
  Class& test_class = Class::Handle(zone, instance.clazz());
  AbstractType& type = AbstractType::Handle(zone, AbstractType::null());
  while (true) {
    if (test_class.ptr() == error_class.ptr()) {
      return error_class.LookupInstanceFieldAllowPrivate(
          Symbols::_stackTrace());
    }
    type = test_class.super_type();
    if (type.IsNull()) return Field::null();
    test_class = type.type_class();
  }
  UNREACHABLE();
  return Field::null();
}

LowestFirst()

int dart::LowestFirst	(	const TokenPosition *	a,
		const TokenPosition *	b
	)

Definition at line 17 of file yield_position_test.cc.

                                                                {
  return a->Pos() - b->Pos();
}

Main()

static int dart::Main ( int  argc, const char **  argv  )

static

Definition at line 299 of file run_vm_tests.cc.

                                             {
#if !defined(DART_HOST_OS_WINDOWS)
  // Very early so any crashes during startup can also be symbolized.
  bin::EXEUtils::LoadDartProfilerSymbols(argv[0]);
#endif
 
  // Flags being passed to the Dart VM.
  int dart_argc = 0;
  const char** dart_argv = nullptr;
 
  // Perform platform specific initialization.
  if (!dart::bin::Platform::Initialize()) {
    Syslog::PrintErr("Initialization failed\n");
    return 1;
  }
 
  // Save the console state so we can restore it later.
  dart::bin::Console::SaveConfig();
 
  // Store the executable name.
  dart::bin::Platform::SetExecutableName(argv[0]);
 
  if (argc < 2) {
    // Bad parameter count.
    PrintUsage();
    return 1;
  }
 
  if (argc == 2 && strcmp(argv[1], "--list") == 0) {
    run_filter = kList;
    // List all tests and benchmarks and exit without initializing the VM.
    TestCaseBase::RunAll();
    Benchmark::RunAll(argv[0]);
    TestCaseBase::RunAllRaw();
    fflush(stdout);
    return 0;
  }
 
  int arg_pos = 1;
  bool start_kernel_isolate = false;
  bool suppress_core_dump = false;
  if (strcmp(argv[arg_pos], "--suppress-core-dump") == 0) {
    suppress_core_dump = true;
    ShiftArgs(&argc, argv);
  }
 
  if (suppress_core_dump) {
    bin::Platform::SetCoreDumpResourceLimit(0);
  } else {
    bin::InitializeCrashpadClient();
  }
 
  if (strncmp(argv[arg_pos], "--dfe", strlen("--dfe")) == 0) {
    const char* delim = strstr(argv[arg_pos], "=");
    if (delim == nullptr || strlen(delim + 1) == 0) {
      Syslog::PrintErr("Invalid value for the option: %s\n", argv[arg_pos]);
      PrintUsage();
      return 1;
    }
    kernel_snapshot = Utils::StrDup(delim + 1);
    start_kernel_isolate = true;
    ShiftArgs(&argc, argv);
  }
 
  if (arg_pos == argc - 1 && strcmp(argv[arg_pos], "--benchmarks") == 0) {
    // "--benchmarks" is the last argument.
    run_filter = kAllBenchmarks;
  } else {
    // Last argument is the test name, the rest are vm flags.
    run_filter = argv[argc - 1];
    // Remove the first value (executable) from the arguments and
    // exclude the last argument which is the test name.
    dart_argc = argc - 2;
    dart_argv = &argv[1];
  }
 
  bin::TimerUtils::InitOnce();
  bin::Process::Init();
  bin::EventHandler::Start();
 
  char* error = Flags::ProcessCommandLineFlags(dart_argc, dart_argv);
  if (error != nullptr) {
    Syslog::PrintErr("Failed to parse flags: %s\n", error);
    free(error);
    return 1;
  }
 
  TesterState::vm_snapshot_data = dart::bin::vm_snapshot_data;
  TesterState::create_callback = CreateIsolateAndSetup;
  TesterState::group_cleanup_callback = CleanupIsolateGroup;
  TesterState::argv = dart_argv;
  TesterState::argc = dart_argc;
 
  Dart_InitializeParams init_params;
  memset(&init_params, 0, sizeof(init_params));
  init_params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
  init_params.vm_snapshot_data = dart::bin::vm_snapshot_data;
  init_params.vm_snapshot_instructions = dart::bin::vm_snapshot_instructions;
  init_params.create_group = CreateIsolateAndSetup;
  init_params.cleanup_group = CleanupIsolateGroup;
  init_params.file_open = dart::bin::DartUtils::OpenFile;
  init_params.file_read = dart::bin::DartUtils::ReadFile;
  init_params.file_write = dart::bin::DartUtils::WriteFile;
  init_params.file_close = dart::bin::DartUtils::CloseFile;
  init_params.start_kernel_isolate = start_kernel_isolate;
#if defined(DART_HOST_OS_FUCHSIA)
  init_params.vmex_resource = dart::bin::Platform::GetVMEXResource();
#endif
  error = Dart::Init(&init_params);
  if (error != nullptr) {
    Syslog::PrintErr("Failed to initialize VM: %s\n", error);
    free(error);
    return 1;
  }
 
  Dart_SetEmbedderInformationCallback(&EmbedderInformationCallback);
 
  // Apply the filter to all registered tests.
  TestCaseBase::RunAll();
  // Apply the filter to all registered benchmarks.
  Benchmark::RunAll(argv[0]);
 
  bin::Process::TerminateExitCodeHandler();
  error = Dart::Cleanup();
  if (error != nullptr) {
    Syslog::PrintErr("Failed shutdown VM: %s\n", error);
    free(error);
    return 1;
  }
 
  TestCaseBase::RunAllRaw();
 
  bin::EventHandler::Stop();
  bin::Process::Cleanup();
 
  // Print a warning message if no tests or benchmarks were matched.
  if (run_matches == 0) {
    Syslog::PrintErr("No tests matched: %s\n", run_filter);
    return 1;
  }
  if (Expect::failed()) {
    return 255;
  }
  return 0;
}

MainModifiedCallback()

static bool dart::MainModifiedCallback ( const char *  url, int64_t  since  )

static

Definition at line 4480 of file isolate_reload_test.cc.

              {\n"
      "  hash2 = foo.hashCode;\n"
      "  return (hash1 == hash2).toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);

MakeAssertAssignable()

static Definition * dart::MakeAssertAssignable ( CompilerState *  S, FlowGraph *  flow_graph, Definition *  defn  )

static

Definition at line 338 of file redundancy_elimination_test.cc.

                                                          {
  const auto& dst_type = AbstractType::ZoneHandle(Type::ObjectType());
  return new AssertAssignableInstr(InstructionSource(), new Value(defn),
                                   new Value(flow_graph->GetConstant(dst_type)),
                                   new Value(flow_graph->constant_null()),
                                   new Value(flow_graph->constant_null()),
                                   Symbols::Empty(), S->GetNextDeoptId());
}

MakeCheckNull()

static Definition * dart::MakeCheckNull ( CompilerState *  S, FlowGraph *  flow_graph, Definition *  defn  )

static

Definition at line 325 of file redundancy_elimination_test.cc.

                                                   {
  return new CheckNullInstr(new Value(defn), String::ZoneHandle(),
                            S->GetNextDeoptId(), InstructionSource());
}

MakeLocationArray() [1/3]

static LocationArray * dart::MakeLocationArray ( )

static

Definition at line 22 of file locations_helpers_test.cc.

                                          {
  LocationArray* arr = new LocationArray();
  return arr;
}

MakeLocationArray() [2/3]

static LocationArray * dart::MakeLocationArray ( Location  loc0 )

static

Definition at line 27 of file locations_helpers_test.cc.

                                                       {
  LocationArray* arr = new LocationArray();
  arr->Add(loc0);
  return arr;
}

MakeLocationArray() [3/3]

static LocationArray * dart::MakeLocationArray ( Location  loc0, Location  loc1  )

static

Definition at line 33 of file locations_helpers_test.cc.

                                                                      {
  LocationArray* arr = new LocationArray();
  arr->Add(loc0);
  arr->Add(loc1);
  return arr;
}

MakeLocationSummaryFromEmitter()

template<typename Instr , typename Out >

LocationSummary * dart::MakeLocationSummaryFromEmitter	(	Zone *	zone,
		const Instr *	instr,
		void(*)(FlowGraphCompiler *, Instr *, Out)	Emit
	)

Definition at line 284 of file locations_helpers.h.

                                                                   {
  typedef SIGNATURE_TRAIT(0, ()) S;
  ASSERT(instr->InputCount() == S::kInputCount);
  LocationSummary* summary = new (zone) LocationSummary(
      zone, S::kInputCount, S::kTempCount, LocationSummary::kNoCall);
  summary->set_out(0, LocationTrait<Out>::ToConstraint());
  return summary;
}

MakeRedefinition()

static Definition * dart::MakeRedefinition ( CompilerState *  S, FlowGraph *  flow_graph, Definition *  defn  )

static

Definition at line 332 of file redundancy_elimination_test.cc.

                                                      {
  return new RedefinitionInstr(new Value(defn));
}

MakeServerControlMessage()

static ArrayPtr dart::MakeServerControlMessage ( const SendPort &  sp, intptr_t  code, bool  enable, const Bool &  silenceOutput  )

static

Definition at line 88 of file service_isolate.cc.

                                                                    {
  const Array& list = Array::Handle(Array::New(4));
  ASSERT(!list.IsNull());
  list.SetAt(0, Integer::Handle(Integer::New(code)));
  list.SetAt(1, sp);
  list.SetAt(2, Bool::Get(enable));
  list.SetAt(3, silenceOutput);
  return list.ptr();
}

malloc()

void * dart::malloc

(

size_t

size

)

Definition at line 19 of file allocation.cc.

                          {
  void* result = ::malloc(size);
  if (result == nullptr) {
    OUT_OF_MEMORY();
  }
  return result;
}

MallocFinalizer() [1/2]

static void dart::MallocFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 1912 of file snapshot_test.cc.

                                                                     {
  free(peer);
}

MallocFinalizer() [2/2]

static void dart::MallocFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 437 of file unit_test.cc.

                                                                     {
  free(peer);
}

ManyHandles()

DART_EXPORT void dart::ManyHandles	(	Dart_Handle	o0,
		Dart_Handle	o1,
		Dart_Handle	o2,
		Dart_Handle	o3,
		Dart_Handle	o4,
		Dart_Handle	o5,
		Dart_Handle	o6,
		Dart_Handle	o7,
		Dart_Handle	o8,
		Dart_Handle	o9,
		Dart_Handle	o10,
		Dart_Handle	o11,
		Dart_Handle	o12,
		Dart_Handle	o13,
		Dart_Handle	o14,
		Dart_Handle	o15,
		Dart_Handle	o16,
		Dart_Handle	o17,
		Dart_Handle	o18,
		Dart_Handle	o19
	)

Definition at line 1419 of file ffi_test_functions_vmspecific.cc.

                                              {
#define CHECK_STRING(o)                                                        \
  if (!Dart_IsString(o)) {                                                     \
    FATAL("expected Dart_IsString");                                           \
  }
  CHECK_STRING(o0);
  CHECK_STRING(o1);
  CHECK_STRING(o2);
  CHECK_STRING(o3);
  CHECK_STRING(o4);
  CHECK_STRING(o5);
  CHECK_STRING(o6);
  CHECK_STRING(o7);
  CHECK_STRING(o8);
  CHECK_STRING(o9);
  CHECK_STRING(o10);
  CHECK_STRING(o11);
  CHECK_STRING(o12);
  CHECK_STRING(o13);
  CHECK_STRING(o14);
  CHECK_STRING(o15);
  CHECK_STRING(o16);
  CHECK_STRING(o17);
  CHECK_STRING(o18);
  CHECK_STRING(o19);
}

MapsFromBuilder()

static CompressedStackMapsPtr dart::MapsFromBuilder ( Zone *  zone, BitmapBuilder *  bmap  )

static

Definition at line 19 of file bitmap_test.cc.

                                                                               {
  CompressedStackMapsBuilder builder(zone);
  builder.AddEntry(kTestPcOffset, bmap, kTestSpillSlotBitCount);
  return builder.Finalize();
}

MarkClasses()

static void dart::MarkClasses ( const Class &  root, bool  include_subclasses, bool  include_implementors  )

static

Definition at line 3449 of file service.cc.

                                                   {
  Thread* thread = Thread::Current();
  HANDLESCOPE(thread);
  ClassTable* table = thread->isolate()->group()->class_table();
  GrowableArray<const Class*> worklist;
  table->SetCollectInstancesFor(root.id(), true);
  worklist.Add(&root);
  GrowableObjectArray& subclasses = GrowableObjectArray::Handle();
  GrowableObjectArray& implementors = GrowableObjectArray::Handle();
  while (!worklist.is_empty()) {
    const Class& cls = *worklist.RemoveLast();
    // All subclasses are implementors, but they are not included in
    // `direct_implementors`.
    if (include_subclasses || include_implementors) {
      subclasses = cls.direct_subclasses_unsafe();
      if (!subclasses.IsNull()) {
        for (intptr_t j = 0; j < subclasses.Length(); j++) {
          Class& subclass = Class::Handle();
          subclass ^= subclasses.At(j);
          if (!table->CollectInstancesFor(subclass.id())) {
            table->SetCollectInstancesFor(subclass.id(), true);
            worklist.Add(&subclass);
          }
        }
      }
    }
    if (include_implementors) {
      implementors = cls.direct_implementors_unsafe();
      if (!implementors.IsNull()) {
        for (intptr_t j = 0; j < implementors.Length(); j++) {
          Class& implementor = Class::Handle();
          implementor ^= implementors.At(j);
          if (!table->CollectInstancesFor(implementor.id())) {
            table->SetCollectInstancesFor(implementor.id(), true);
            worklist.Add(&implementor);
          }
        }
      }
    }
  }
}

Marker()

static DART_FORCE_INLINE ObjectPtr dart::Marker ( )

static

Definition at line 144 of file object_graph_copy.cc.

                          {
  return Object::unknown_constant().ptr();
}

MarkImplemented()

static void dart::MarkImplemented ( Zone *  zone, const Class &  iface  )

static

Definition at line 530 of file class_finalizer.cc.

                                                            {
  if (iface.is_implemented()) {
    return;
  }
 
  Class& cls = Class::Handle(zone, iface.ptr());
  AbstractType& type = AbstractType::Handle(zone);
 
  while (!cls.is_implemented()) {
    cls.set_is_implemented();
 
    type = cls.super_type();
    if (type.IsNull() || type.IsObjectType()) {
      break;
    }
    cls = type.type_class();
  }
}

Match()

static ArrayPtr dart::Match ( const String &  pat, const String &  str  )

static

Definition at line 15 of file regexp_test.cc.

                                                            {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const RegExp& regexp =
      RegExp::Handle(RegExpEngine::CreateRegExp(thread, pat, RegExpFlags()));
  const Smi& idx = Object::smi_zero();
  return IRRegExpMacroAssembler::Execute(regexp, str, idx, /*sticky=*/false,
                                         zone);
}

MatchAndNegativeLookaroundInReadDirection()

RegExpNode * dart::MatchAndNegativeLookaroundInReadDirection	(	RegExpCompiler *	compiler,
		ZoneGrowableArray< CharacterRange > *	match,
		ZoneGrowableArray< CharacterRange > *	lookahead,
		RegExpNode *	on_success,
		bool	read_backward,
		RegExpFlags	flags
	)

Definition at line 4048 of file regexp.cc.

                       {
  int stack_register = compiler->UnicodeLookaroundStackRegister();
  int position_register = compiler->UnicodeLookaroundPositionRegister();
  RegExpLookaround::Builder lookaround(false, on_success, stack_register,
                                       position_register);
  RegExpNode* negative_match = TextNode::CreateForCharacterRanges(
      lookahead, read_backward, lookaround.on_match_success(), flags);
  return TextNode::CreateForCharacterRanges(
      match, read_backward, lookaround.ForMatch(negative_match), flags);
}

MatchesAccessorName()

static bool dart::MatchesAccessorName ( const String &  name, const char *  prefix, intptr_t  prefix_length, const String &  accessor_name  )

static

Definition at line 6231 of file object.cc.

                                                             {
  intptr_t name_len = name.Length();
  intptr_t accessor_name_len = accessor_name.Length();
 
  if (name_len != (accessor_name_len + prefix_length)) {
    return false;
  }
  for (intptr_t i = 0; i < prefix_length; i++) {
    if (name.CharAt(i) != prefix[i]) {
      return false;
    }
  }
  for (intptr_t i = 0, j = prefix_length; i < accessor_name_len; i++, j++) {
    if (name.CharAt(j) != accessor_name.CharAt(i)) {
      return false;
    }
  }
  return true;
}

MatchesPattern()

bool dart::MatchesPattern	(	uword	end,
		const int16_t *	pattern,
		intptr_t	size
	)

Definition at line 46 of file code_patcher.cc.

                                                                      {
  // When breaking within generated code in GDB, it may overwrite individual
  // instructions with trap instructions, which can cause this test to fail.
  //
  // Ignoring trap instructions would work well enough within GDB alone, but it
  // doesn't work in RR, because the check for the trap instruction itself will
  // cause replay to diverge from the original record.
  if (FLAG_support_rr) return true;
 
  uint8_t* bytes = reinterpret_cast<uint8_t*>(end - size);
  for (intptr_t i = 0; i < size; i++) {
    int16_t val = pattern[i];
    if ((val >= 0) && (val != bytes[i])) {
      return false;
    }
  }
  return true;
}

MayBeBoxableNumber()

static bool dart::MayBeBoxableNumber ( intptr_t  cid )

static

Definition at line 3534 of file il.cc.

                                             {
  return (cid == kDynamicCid) || (cid == kMintCid) || (cid == kDoubleCid);
}

MayBeNumber()

static bool dart::MayBeNumber ( CompileType *  type )

static

Definition at line 3538 of file il.cc.

                                           {
  if (type->IsNone()) {
    return false;
  }
  const AbstractType& unwrapped_type =
      AbstractType::Handle(type->ToAbstractType()->UnwrapFutureOr());
  // Note that type 'Number' is a subtype of itself.
  return unwrapped_type.IsTopTypeForSubtyping() ||
         unwrapped_type.IsObjectType() || unwrapped_type.IsTypeParameter() ||
         unwrapped_type.IsSubtypeOf(Type::Handle(Type::NullableNumber()),
                                    Heap::kOld);
}

MergeHexCharacters()

static int32_t dart::MergeHexCharacters ( int32_t  c1, int32_t  c2  )

static

Definition at line 23993 of file object.cc.

                                                          {
  return GetHexValue(c1) << 4 | GetHexValue(c2);
}

MergePaths()

static const char * dart::MergePaths ( const char *  base_path, const char *  ref_path  )

static

Definition at line 344 of file uri.cc.

                                                                           {
  Zone* zone = ThreadState::Current()->zone();
  if (base_path[0] == '\0') {
    // If the base_path is empty, we prepend '/'.
    return zone->PrintToString("/%s", ref_path);
  }
 
  // We need to find the last '/' in base_path.
  const char* last_slash = strrchr(base_path, '/');
  if (last_slash == nullptr) {
    // There is no slash in the base_path.  Return the ref_path unchanged.
    return ref_path;
  }
 
  // We found a '/' in the base_path.  Cut off everything after it and
  // add the ref_path.
  intptr_t truncated_base_len = last_slash - base_path;
  intptr_t ref_path_len = strlen(ref_path);
  intptr_t len = truncated_base_len + ref_path_len + 1;  // +1 for '/'
  char* buffer = zone->Alloc<char>(len + 1);             // +1 for '\0'
 
  // Copy truncated base.
  strncpy(buffer, base_path, truncated_base_len);
 
  // Add a slash.
  buffer[truncated_base_len] = '/';
 
  // Copy the ref_path.
  strncpy((buffer + truncated_base_len + 1), ref_path, ref_path_len + 1);
 
  return buffer;
}

MicrosecondsToMilliseconds()

constexpr double dart::MicrosecondsToMilliseconds ( int64_t  micros )

constexpr

Definition at line 574 of file globals.h.

                                                            {
  return static_cast<double>(micros) / kMicrosecondsPerMillisecond;
}

MicrosecondsToSeconds()

constexpr double dart::MicrosecondsToSeconds ( int64_t  micros )

constexpr

Definition at line 571 of file globals.h.

                                                       {
  return static_cast<double>(micros) / kMicrosecondsPerSecond;
}

MightNeedReHashing()

static DART_FORCE_INLINE bool dart::MightNeedReHashing ( ObjectPtr  object )

static

Definition at line 189 of file object_graph_copy.cc.

                                                 {
  const uword tags = TagsFromUntaggedObject(object.untag());
  const auto cid = UntaggedObject::ClassIdTag::decode(tags);
  // These use structural hash codes and will therefore always result in the
  // same hash codes.
  if (cid == kOneByteStringCid) return false;
  if (cid == kTwoByteStringCid) return false;
  if (cid == kMintCid) return false;
  if (cid == kDoubleCid) return false;
  if (cid == kBoolCid) return false;
  if (cid == kSendPortCid) return false;
  if (cid == kCapabilityCid) return false;
  if (cid == kNullCid) return false;
 
  // These are shared and use identity hash codes. If they are used as a key in
  // a map or a value in a set, they will already have the identity hash code
  // set.
  if (cid == kRegExpCid) return false;
  if (cid == kInt32x4Cid) return false;
 
  // If the [tags] indicates this is a canonical object we'll share it instead
  // of copying it. That would suggest we don't have to re-hash maps/sets
  // containing this object on the receiver side.
  //
  // Though the object can be a constant of a user-defined class with a
  // custom hash code that is misbehaving (e.g one that depends on global field
  // state, ...). To be on the safe side we'll force re-hashing if such objects
  // are encountered in maps/sets.
  //
  // => We might want to consider changing the implementation to avoid rehashing
  // in such cases in the future and disambiguate the documentation.
  return true;
}

MinInt32()

DART_EXPORT int64_t dart::MinInt32

(

)

Definition at line 69 of file ffi_test_functions_vmspecific.cc.

                               {
  Dart_ExecuteInternalCommand("gc-on-nth-allocation",
                              reinterpret_cast<void*>(1));
  return 0x80000000;
}

MinInt64()

DART_EXPORT int64_t dart::MinInt64

(

)

Definition at line 63 of file ffi_test_functions_vmspecific.cc.

                               {
  Dart_ExecuteInternalCommand("gc-on-nth-allocation",
                              reinterpret_cast<void*>(1));
  return 0x8000000000000000;
}

MinPosition()

static intptr_t dart::MinPosition ( intptr_t  a, intptr_t  b  )

static

Definition at line 38 of file linearscan.cc.

                                                    {
  return (a < b) ? a : b;
}

MournFinalizerEntry()

template<typename GCVisitorType >

void dart::MournFinalizerEntry	(	GCVisitorType *	visitor,
		FinalizerEntryPtr	current_entry
	)

Definition at line 162 of file gc_shared.h.

                                                          {
  TRACE_FINALIZER("Processing Entry %p", current_entry->untag());
 
  const Heap::Space before_gc_space = SpaceForExternal(current_entry);
  const bool value_collected_this_gc =
      GCVisitorType::ForwardOrSetNullIfCollected(
          current_entry, &current_entry->untag()->value_);
  if (!value_collected_this_gc && before_gc_space == Heap::kNew) {
    const Heap::Space after_gc_space = SpaceForExternal(current_entry);
    if (after_gc_space == Heap::kOld) {
      const intptr_t external_size = current_entry->untag()->external_size_;
      TRACE_FINALIZER("Promoting external size %" Pd
                      " bytes from new to old space",
                      external_size);
      visitor->isolate_group()->heap()->PromotedExternal(external_size);
    }
  }
  GCVisitorType::ForwardOrSetNullIfCollected(current_entry,
                                             &current_entry->untag()->detach_);
  GCVisitorType::ForwardOrSetNullIfCollected(
      current_entry, &current_entry->untag()->finalizer_);
 
  ObjectPtr token_object = current_entry->untag()->token();
  // See sdk/lib/_internal/vm/lib/internal_patch.dart FinalizerBase.detach.
  const bool is_detached = token_object == current_entry;
 
  if (!value_collected_this_gc) return;
  if (is_detached) return;
 
  FinalizerBasePtr finalizer = current_entry->untag()->finalizer();
 
  if (finalizer.IsRawNull()) {
    TRACE_FINALIZER("Value collected entry %p finalizer null",
                    current_entry->untag());
 
    // Do nothing, the finalizer has been GCed.
    return;
  }
 
  TRACE_FINALIZER("Value collected entry %p finalizer %p",
                  current_entry->untag(), finalizer->untag());
 
  FinalizerPtr finalizer_dart = static_cast<FinalizerPtr>(finalizer);
  // Move entry to entries collected and current head of that list as
  // the next element. Using a atomic exchange satisfies concurrency
  // between the parallel GC tasks.
  // We rely on the fact that the mutator thread is not running to avoid
  // races between GC and mutator modifying Finalizer.entries_collected.
  //
  // We only run in serial marker or in the finalize step in the marker,
  // both are in safepoint.
  // The main scavenger worker is at safepoint, the other scavenger
  // workers are not, but they bypass safepoint because the main
  // worker is at a safepoint already.
  ASSERT(Thread::Current()->OwnsGCSafepoint() ||
         Thread::Current()->BypassSafepoints());
 
  if (finalizer.IsNativeFinalizer()) {
    NativeFinalizerPtr native_finalizer =
        static_cast<NativeFinalizerPtr>(finalizer);
 
    // Immediately call native callback.
    RunNativeFinalizerCallback(native_finalizer, current_entry, before_gc_space,
                               visitor);
 
    // Fall-through sending a message to clear the entries and remove
    // from detachments.
  }
 
  FinalizerEntryPtr previous_head =
      finalizer_dart->untag()->exchange_entries_collected(current_entry);
  current_entry->untag()->set_next(previous_head);
  const bool first_entry = previous_head.IsRawNull();
 
  // If we're in the marker, we need to ensure that we release the store
  // buffer afterwards.
  // If we're in the scavenger and have the finalizer in old space and
  // a new space entry, we don't need to release the store buffer.
  if (!first_entry && previous_head->IsNewObject() &&
      current_entry->IsOldObject()) {
    TRACE_FINALIZER("Entry %p (old) next is %p (new)", current_entry->untag(),
                    previous_head->untag());
    // We must release the thread's store buffer block.
  }
 
  // Schedule calling Dart finalizer.
  if (first_entry) {
    Isolate* isolate = finalizer->untag()->isolate_;
    if (isolate == nullptr) {
      TRACE_FINALIZER("Not scheduling finalizer %p callback on isolate null",
                      finalizer->untag());
    } else {
      TRACE_FINALIZER("Scheduling finalizer %p callback on isolate %p",
                      finalizer->untag(), isolate);
 
      PersistentHandle* handle =
          isolate->group()->api_state()->AllocatePersistentHandle();
      handle->set_ptr(finalizer);
      MessageHandler* message_handler = isolate->message_handler();
      message_handler->PostMessage(
          Message::New(handle, Message::kNormalPriority),
          /*before_events*/ false);
    }
  }
}

MoveRanges()

static void dart::MoveRanges ( ZoneGrowableArray< CharacterRange > *  list, intptr_t  from, intptr_t  to, intptr_t  count  )

static

Definition at line 4795 of file regexp.cc.

                                       {
  // Ranges are potentially overlapping.
  if (from < to) {
    for (intptr_t i = count - 1; i >= 0; i--) {
      (*list)[to + i] = list->At(from + i);
    }
  } else {
    for (intptr_t i = 0; i < count; i++) {
      (*list)[to + i] = list->At(from + i);
    }
  }
}

Multiply64Hash()

uint32_t dart::Multiply64Hash

(

int64_t

ivalue

)

Definition at line 276 of file integers.cc.

                                        {
  const uint64_t magic_constant = /*0x1b873593cc9e*/ 0x2d51;
  uint64_t value = static_cast<uint64_t>(ivalue);
#if defined(ARCH_IS_64_BIT)
#ifdef _MSC_VER
  __int64 hi = __umulh(value, magic_constant);
  uint64_t lo = value * magic_constant;
  uint64_t hash = lo ^ hi;
#else
  const __int128 res = static_cast<__int128>(value) * magic_constant;
  uint64_t hash = res ^ static_cast<int64_t>(res >> 64);
#endif
  hash = hash ^ (hash >> 32);
#else
  uint64_t prod_lo64 = value * magic_constant;
 
  uint64_t value_lo32 = value & 0xffffffff;
  uint64_t value_hi32 = value >> 32;
  uint64_t carry = (((value_hi32 * magic_constant) & 0xffffffff) +
                    ((value_lo32 * magic_constant) >> 32)) >>
                   32;
  uint64_t prod_hi64 = ((value_hi32 * magic_constant) >> 32) + carry;
  uint64_t hash = prod_hi64 ^ prod_lo64;
  hash = hash ^ (hash >> 32);
#endif
  return hash & 0x3fffffff;
}

MyCallback1()

uint8_t dart::MyCallback1

(

uint8_t

a

)

Definition at line 706 of file ffi_test_functions_vmspecific.cc.

                               {
  const char* methodname = "myCallback1";
  size_t request_length = sizeof(uint8_t) * 1;
  void* request_buffer = malloc(request_length);      // FreeFinalizer.
  reinterpret_cast<uint8_t*>(request_buffer)[0] = a;  // Populate buffer.
  void* response_buffer = nullptr;
  size_t response_length = 0;
 
  PendingCall pending_call(&response_buffer, &response_length);
 
  Dart_CObject c_send_port;
  c_send_port.type = Dart_CObject_kSendPort;
  c_send_port.value.as_send_port.id = pending_call.port();
  c_send_port.value.as_send_port.origin_id = ILLEGAL_PORT;
 
  Dart_CObject c_pending_call;
  c_pending_call.type = Dart_CObject_kInt64;
  c_pending_call.value.as_int64 = reinterpret_cast<int64_t>(&pending_call);
 
  Dart_CObject c_method_name;
  c_method_name.type = Dart_CObject_kString;
  c_method_name.value.as_string = const_cast<char*>(methodname);
 
  Dart_CObject c_request_data;
  c_request_data.type = Dart_CObject_kExternalTypedData;
  c_request_data.value.as_external_typed_data.type = Dart_TypedData_kUint8;
  c_request_data.value.as_external_typed_data.length = request_length;
  c_request_data.value.as_external_typed_data.data =
      static_cast<uint8_t*>(request_buffer);
  c_request_data.value.as_external_typed_data.peer = request_buffer;
  c_request_data.value.as_external_typed_data.callback = FreeFinalizer;
 
  Dart_CObject* c_request_arr[] = {&c_send_port, &c_pending_call,
                                   &c_method_name, &c_request_data};
  Dart_CObject c_request;
  c_request.type = Dart_CObject_kArray;
  c_request.value.as_array.values = c_request_arr;
  c_request.value.as_array.length =
      sizeof(c_request_arr) / sizeof(c_request_arr[0]);
 
  printf("C   :  Dart_PostCObject_(request: %" Px ", call: %" Px ").\n",
         reinterpret_cast<intptr_t>(&c_request),
         reinterpret_cast<intptr_t>(&c_pending_call));
  pending_call.PostAndWait(send_port_, &c_request);
  printf("C   :  Received result.\n");
 
  const intptr_t result = reinterpret_cast<uint8_t*>(response_buffer)[0];
  free(response_buffer);
 
  return result;
}

MyCallback2()

void dart::MyCallback2

(

uint8_t

a

)

Definition at line 761 of file ffi_test_functions_vmspecific.cc.

                            {
  const char* methodname = "myCallback2";
  void* request_buffer = malloc(sizeof(uint8_t) * 1);  // FreeFinalizer.
  reinterpret_cast<uint8_t*>(request_buffer)[0] = a;   // Populate buffer.
  const size_t request_length = sizeof(uint8_t) * 1;
 
  Dart_CObject c_send_port;
  c_send_port.type = Dart_CObject_kNull;
 
  Dart_CObject c_pending_call;
  c_pending_call.type = Dart_CObject_kNull;
 
  Dart_CObject c_method_name;
  c_method_name.type = Dart_CObject_kString;
  c_method_name.value.as_string = const_cast<char*>(methodname);
 
  Dart_CObject c_request_data;
  c_request_data.type = Dart_CObject_kExternalTypedData;
  c_request_data.value.as_external_typed_data.type = Dart_TypedData_kUint8;
  c_request_data.value.as_external_typed_data.length = request_length;
  c_request_data.value.as_external_typed_data.data =
      static_cast<uint8_t*>(request_buffer);
  c_request_data.value.as_external_typed_data.peer = request_buffer;
  c_request_data.value.as_external_typed_data.callback = FreeFinalizer;
 
  Dart_CObject* c_request_arr[] = {&c_send_port, &c_pending_call,
                                   &c_method_name, &c_request_data};
  Dart_CObject c_request;
  c_request.type = Dart_CObject_kArray;
  c_request.value.as_array.values = c_request_arr;
  c_request.value.as_array.length =
      sizeof(c_request_arr) / sizeof(c_request_arr[0]);
 
  printf("C   :  Dart_PostCObject_(request: %" Px ", call: %" Px ").\n",
         reinterpret_cast<intptr_t>(&c_request),
         reinterpret_cast<intptr_t>(&c_pending_call));
  Dart_PostCObject_DL(send_port_, &c_request);
}

MyCallbackBlocking()

intptr_t dart::MyCallbackBlocking

(

intptr_t

a

)

Definition at line 476 of file ffi_test_functions_vmspecific.cc.

                                        {
  std::mutex mutex;
  std::unique_lock<std::mutex> lock(mutex);
  intptr_t result;
  auto callback = my_callback_blocking_fp_;  // Define storage duration.
  std::condition_variable cv;
  bool notified = false;
  const Work work = [a, &result, callback, &cv, &notified]() {
    result = callback(a);
    printf("C Da:     Notify result ready.\n");
    notified = true;
    cv.notify_one();
  };
  const Work* work_ptr = new Work(work);  // Copy to heap.
  NotifyDart(my_callback_blocking_send_port_, work_ptr);
  printf("C   :  Waiting for result.\n");
  while (!notified) {
    cv.wait(lock);
  }
  printf("C   :  Received result.\n");
  return result;
}

MyCallbackNonBlocking()

void dart::MyCallbackNonBlocking

(

intptr_t

a

)

Definition at line 502 of file ffi_test_functions_vmspecific.cc.

                                       {
  auto callback = my_callback_non_blocking_fp_;  // Define storage duration.
  const Work work = [a, callback]() { callback(a); };
  // Copy to heap to make it outlive the function scope.
  const Work* work_ptr = new Work(work);
  NotifyDart(my_callback_non_blocking_send_port_, work_ptr);
}

MyMessageNotifyCallback()

static void dart::MyMessageNotifyCallback ( Dart_Isolate  dest_isolate )

static

Definition at line 4855 of file dart_api_impl_test.cc.

{}

MyNativeClosureResolver()

static Dart_NativeFunction dart::MyNativeClosureResolver ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 8715 of file dart_api_impl_test.cc.

                                                  {
  Dart_EnterScope();
  intptr_t i = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(4, i);
  Dart_Handle arg1 = Dart_GetNativeArgument(args, 1);
  Dart_Handle arg2 = Dart_GetNativeArgument(args, 2);
  Dart_Handle arg3 = Dart_GetNativeArgument(args, 3);
  Dart_SetReturnValue(
      args, Dart_NewInteger(GetValue(arg1) + GetValue(arg2) + GetValue(arg3)));
  Dart_ExitScope();
}
 
static Dart_NativeFunction MyNativeClosureResolver(Dart_Handle name,
                                                   int arg_count,
                                                   bool* auto_setup_scope) {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = false;
  TransitionNativeToVM transition(Thread::Current());
  const Object& obj = Object::Handle(Api::UnwrapHandle(name));
  if (!obj.IsString()) {
    return nullptr;
  }
  const char* function_name = obj.ToCString();
  const char* kNativeFoo1 = "NativeFoo1";
  const char* kNativeFoo2 = "NativeFoo2";
  const char* kNativeFoo3 = "NativeFoo3";

MyNativeFunction1()

static void dart::MyNativeFunction1 ( Dart_NativeArguments  args )

static

Definition at line 7657 of file dart_api_impl_test.cc.

                                                         {
  Dart_EnterScope();

MyNativeFunction2()

static void dart::MyNativeFunction2 ( Dart_NativeArguments  args )

static

Definition at line 7663 of file dart_api_impl_test.cc.

                                                         {
  Dart_EnterScope();

MyNativeResolver1()

static Dart_NativeFunction dart::MyNativeResolver1 ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 7669 of file dart_api_impl_test.cc.

                                                                     {
  ASSERT(auto_setup_scope != nullptr);

MyNativeResolver2()

static Dart_NativeFunction dart::MyNativeResolver2 ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 7677 of file dart_api_impl_test.cc.

                                                                     {
  ASSERT(auto_setup_scope != nullptr);

MyStaticNativeClosureResolver()

static Dart_NativeFunction dart::MyStaticNativeClosureResolver ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 8806 of file dart_api_impl_test.cc.

NarrowBinaryInt64Op()

static void dart::NarrowBinaryInt64Op ( BinaryInt64OpInstr *  int64_op )

static

Definition at line 1415 of file range_analysis.cc.

                                                              {
  if (RangeUtils::Fits(int64_op->range(), RangeBoundary::kRangeBoundaryInt32) &&
      RangeUtils::Fits(int64_op->left()->definition()->range(),
                       RangeBoundary::kRangeBoundaryInt32) &&
      RangeUtils::Fits(int64_op->right()->definition()->range(),
                       RangeBoundary::kRangeBoundaryInt32) &&
      BinaryInt32OpInstr::IsSupported(int64_op->op_kind(), int64_op->left(),
                                      int64_op->right())) {
    BinaryInt32OpInstr* int32_op = new BinaryInt32OpInstr(
        int64_op->op_kind(), int64_op->left()->CopyWithType(),
        int64_op->right()->CopyWithType(), int64_op->DeoptimizationTarget());
    int32_op->set_range(*int64_op->range());
    int32_op->set_can_overflow(false);
    int64_op->ReplaceWith(int32_op, nullptr);
  }
}

NarrowMax()

static RangeBoundary dart::NarrowMax ( const Range *  range, const Range *  new_range, RangeBoundary::RangeSize  size  )

static

Definition at line 412 of file range_analysis.cc.

                                                            {
  const RangeBoundary max = Range::ConstantMax(range, size);
  const RangeBoundary new_max = Range::ConstantMax(new_range, size);
  if (max.ConstantValue() < new_max.ConstantValue()) return range->max();
 
  // TODO(vegorov): consider using positive infinity to indicate widened bound.
  return range->max().IsMaximumOrAbove(size) ? new_range->max() : range->max();
}

NarrowMin()

static RangeBoundary dart::NarrowMin ( const Range *  range, const Range *  new_range, RangeBoundary::RangeSize  size  )

static

Definition at line 395 of file range_analysis.cc.

                                                            {
  const RangeBoundary min = Range::ConstantMin(range, size);
  const RangeBoundary new_min = Range::ConstantMin(new_range, size);
  if (min.ConstantValue() > new_min.ConstantValue()) return range->min();
 
  // TODO(vegorov): consider using negative infinity to indicate widened bound.
  return range->min().IsMinimumOrBelow(size) ? new_range->min() : range->min();
}

NarrowShiftInt64Op()

static void dart::NarrowShiftInt64Op ( ShiftIntegerOpInstr *  int64_op )

static

Definition at line 1432 of file range_analysis.cc.

                                                              {
  if (RangeUtils::Fits(int64_op->range(), RangeBoundary::kRangeBoundaryInt32) &&
      RangeUtils::Fits(int64_op->left()->definition()->range(),
                       RangeBoundary::kRangeBoundaryInt32) &&
      RangeUtils::Fits(int64_op->right()->definition()->range(),
                       RangeBoundary::kRangeBoundaryInt32) &&
      BinaryInt32OpInstr::IsSupported(int64_op->op_kind(), int64_op->left(),
                                      int64_op->right())) {
    BinaryInt32OpInstr* int32_op = new BinaryInt32OpInstr(
        int64_op->op_kind(), int64_op->left()->CopyWithType(),
        int64_op->right()->CopyWithType(), int64_op->DeoptimizationTarget());
    int32_op->set_range(*int64_op->range());
    int32_op->set_can_overflow(false);
    int64_op->ReplaceWith(int32_op, nullptr);
  }
}

native_args_lookup()

static Dart_NativeFunction dart::native_args_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_scope_setup  )

static

Definition at line 7192 of file dart_api_impl_test.cc.

                                                                      {
  TransitionNativeToVM transition(Thread::Current());
  const Object& obj = Object::Handle(Api::UnwrapHandle(name));
  if (!obj.IsString()) {
    return nullptr;
  }
  ASSERT(auto_scope_setup != nullptr);
  *auto_scope_setup = true;
  const char* function_name = obj.ToCString();
  ASSERT(function_name != nullptr);
  if (strcmp(function_name, "NativeArgument_Create") == 0) {
    return NativeArgumentCreate;
  } else if (strcmp(function_name, "NativeArgument_Access") == 0) {
    return NativeArgumentAccess;

native_echo()

static void dart::native_echo ( Dart_NativeArguments  args )

static

Definition at line 241 of file custom_isolate_test.cc.

                                                   {
  Dart_EnterScope();
  Dart_Handle arg = Dart_GetNativeArgument(args, 0);
  Dart_Handle toString = Dart_ToString(arg);
  EXPECT_VALID(toString);
  const char* c_str = nullptr;
  EXPECT_VALID(Dart_StringToCString(toString, &c_str));
  if (saved_echo != nullptr) {
    free(saved_echo);
  }
  saved_echo = Utils::StrDup(c_str);
  OS::PrintErr("-- (isolate=%p) %s\n", Dart_CurrentIsolate(), c_str);
  Dart_ExitScope();
}

native_field_lookup()

static Dart_NativeFunction dart::native_field_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 5444 of file dart_api_impl_test.cc.

                                                                       {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = false;
  return NativeFieldLookup;
}

native_lookup() [1/3]

static Dart_NativeFunction dart::native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 7034 of file dart_api_impl_test.cc.

                                                                 {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  return ExceptionNative;
}

native_lookup() [2/3]

static Dart_NativeFunction dart::native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 66 of file exceptions_test.cc.

                                                                 {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  TransitionNativeToVM transition(Thread::Current());
  const Object& obj = Object::Handle(Api::UnwrapHandle(name));
  ASSERT(obj.IsString());
  const char* function_name = obj.ToCString();
  ASSERT(function_name != nullptr);
  int num_entries = sizeof(BuiltinEntries) / sizeof(struct NativeEntries);
  for (int i = 0; i < num_entries; i++) {
    struct NativeEntries* entry = &(BuiltinEntries[i]);
    if ((strcmp(function_name, entry->name_) == 0) &&
        (argument_count == entry->argument_count_)) {
      return reinterpret_cast<Dart_NativeFunction>(entry->function_);
    }
  }
  return nullptr;
}

native_lookup() [3/3]

static Dart_NativeFunction dart::native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 139 of file stack_frame_test.cc.

                                                                 {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = false;
  TransitionNativeToVM transition(Thread::Current());
  const Object& obj = Object::Handle(Api::UnwrapHandle(name));
  ASSERT(obj.IsString());
  const char* function_name = obj.ToCString();
  ASSERT(function_name != nullptr);
  int num_entries = sizeof(BuiltinEntries) / sizeof(struct NativeEntries);
  for (int i = 0; i < num_entries; i++) {
    struct NativeEntries* entry = &(BuiltinEntries[i]);
    if ((strcmp(function_name, entry->name_) == 0) &&
        (entry->argument_count_ == argument_count)) {
      return reinterpret_cast<Dart_NativeFunction>(entry->function_);
    }
  }
  return nullptr;
}

native_resolver()

static Dart_NativeFunction dart::native_resolver ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 34 of file code_descriptors_test.cc.

                                                                   {
  ASSERT(auto_setup_scope);
  *auto_setup_scope = false;
  return NativeFunc;
}

NativeArgumentAccess()

static void dart::NativeArgumentAccess ( Dart_NativeArguments  args )

static

Definition at line 7089 of file dart_api_impl_test.cc.

                                                            {
  const int kNumNativeFields = 2;
 
  // Test different argument types with a valid descriptor set.
  {
    const char* cstr = nullptr;
    intptr_t native_fields1[kNumNativeFields];
    intptr_t native_fields2[kNumNativeFields];
    const Dart_NativeArgument_Descriptor arg_descriptors[9] = {
        {Dart_NativeArgument_kNativeFields, 0},
        {Dart_NativeArgument_kInt32, 1},
        {Dart_NativeArgument_kUint64, 2},
        {Dart_NativeArgument_kBool, 3},
        {Dart_NativeArgument_kDouble, 4},
        {Dart_NativeArgument_kString, 5},
        {Dart_NativeArgument_kString, 6},
        {Dart_NativeArgument_kNativeFields, 7},
        {Dart_NativeArgument_kInstance, 7},
    };
    Dart_NativeArgument_Value arg_values[9];
    arg_values[0].as_native_fields.num_fields = kNumNativeFields;
    arg_values[0].as_native_fields.values = native_fields1;
    arg_values[7].as_native_fields.num_fields = kNumNativeFields;
    arg_values[7].as_native_fields.values = native_fields2;
    Dart_Handle result =
        Dart_GetNativeArguments(args, 9, arg_descriptors, arg_values);
    EXPECT_VALID(result);
 
    EXPECT(arg_values[0].as_native_fields.values[0] == 30);
    EXPECT(arg_values[0].as_native_fields.values[1] == 40);
 
    EXPECT(arg_values[1].as_int32 == 77);
 
    // When wrapped-around, this value should not fit into int32, because this
    // unit test verifies that getting it as int32 produces error.
    EXPECT(arg_values[2].as_uint64 == 0x8000000000000000LL);
 
    EXPECT(arg_values[3].as_bool == true);
 
    EXPECT(arg_values[4].as_double == 3.14);
 
    EXPECT_VALID(arg_values[5].as_string.dart_str);
    EXPECT(Dart_IsString(arg_values[5].as_string.dart_str));
    EXPECT_VALID(Dart_StringToCString(arg_values[5].as_string.dart_str, &cstr));
    EXPECT_STREQ("abcdefg", cstr);
    EXPECT(arg_values[5].as_string.peer == nullptr);
 
    EXPECT_VALID(arg_values[6].as_string.dart_str);
    EXPECT(Dart_IsString(arg_values[6].as_string.dart_str));
    EXPECT_VALID(Dart_StringToCString(arg_values[6].as_string.dart_str, &cstr));
    EXPECT_STREQ("string", cstr);
    EXPECT(arg_values[6].as_string.peer == nullptr);
 
    EXPECT(arg_values[7].as_native_fields.values[0] == 60);
    EXPECT(arg_values[7].as_native_fields.values[1] == 80);
 
    EXPECT_VALID(arg_values[8].as_instance);
    EXPECT(Dart_IsInstance(arg_values[8].as_instance));
    int field_count = 0;
    EXPECT_VALID(Dart_GetNativeInstanceFieldCount(arg_values[8].as_instance,
                                                  &field_count));
    EXPECT(field_count == 2);
  }
 
  // Test with an invalid descriptor set (invalid type).
  {
    const Dart_NativeArgument_Descriptor arg_descriptors[8] = {
        {Dart_NativeArgument_kInt32, 1},
        {Dart_NativeArgument_kUint64, 2},
        {Dart_NativeArgument_kString, 3},
        {Dart_NativeArgument_kDouble, 4},
        {Dart_NativeArgument_kString, 5},
        {Dart_NativeArgument_kString, 6},
        {Dart_NativeArgument_kNativeFields, 0},
        {Dart_NativeArgument_kNativeFields, 7},
    };
    Dart_NativeArgument_Value arg_values[8];
    Dart_Handle result =
        Dart_GetNativeArguments(args, 8, arg_descriptors, arg_values);
    EXPECT(Dart_IsError(result));
  }
 
  // Test with an invalid range error.
  {
    const Dart_NativeArgument_Descriptor arg_descriptors[8] = {
        {Dart_NativeArgument_kInt32, 2},
        {Dart_NativeArgument_kUint64, 2},
        {Dart_NativeArgument_kBool, 3},
        {Dart_NativeArgument_kDouble, 4},
        {Dart_NativeArgument_kString, 5},
        {Dart_NativeArgument_kString, 6},
        {Dart_NativeArgument_kNativeFields, 0},
        {Dart_NativeArgument_kNativeFields, 7},
    };
    Dart_NativeArgument_Value arg_values[8];
    Dart_Handle result =
        Dart_GetNativeArguments(args, 8, arg_descriptors, arg_values);
    EXPECT(Dart_IsError(result));
  }

NativeArgumentCounter()

static void dart::NativeArgumentCounter ( Dart_NativeArguments  args )

static

Definition at line 7254 of file dart_api_impl_test.cc.

                                                             {
  Dart_EnterScope();
  int count = Dart_GetNativeArgumentCount(args);

NativeArgumentCreate()

static void dart::NativeArgumentCreate ( Dart_NativeArguments  args )

static

Definition at line 7069 of file dart_api_impl_test.cc.

                                                            {
  Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("MyObject"), 0, nullptr);
  EXPECT_VALID(type);
 
  // Allocate without a constructor.
  const int num_native_fields = 2;
  const intptr_t native_fields[] = {kNativeArgumentNativeField1Value,
                                    kNativeArgumentNativeField2Value};
  // Allocate and Setup native fields.
  Dart_Handle obj =
      Dart_AllocateWithNativeFields(type, num_native_fields, native_fields);
  EXPECT_VALID(obj);
 
  kNativeArgumentNativeField1Value *= 2;

NativeFieldLookup()

void dart::NativeFieldLookup

(

Dart_NativeArguments

args

)

Definition at line 5440 of file dart_api_impl_test.cc.

                                                  {
  UNREACHABLE();
}

NativeFinalizer_TwoEntriesCrossGen() [1/2]

static void dart::NativeFinalizer_TwoEntriesCrossGen ( Thread *  thread, Heap::Space *  spaces, bool  collect_new_space, bool  evacuate_new_space_and_collect_old_space, bool  clear_value_1, bool  clear_value_2, bool  clear_detach_1, bool  clear_detach_2  )

static

Definition at line 4962 of file object_test.cc.

                         {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif
 
  intptr_t token1_memory = 0;
  intptr_t token2_memory = 0;
 
  MessageHandler* handler = thread->isolate()->message_handler();
  // We're reusing the isolate in a loop, so there are messages from previous
  // runs of this test.
  intptr_t queue_length_start = 0;
  {
    MessageHandler::AcquiredQueues aq(handler);
    queue_length_start = aq.queue()->Length();
  }
 
  const auto& callback = Pointer::Handle(Pointer::New(
      reinterpret_cast<uword>(&NativeFinalizer_TwoEntriesCrossGen_Finalizer),
      spaces[3]));
 
  const auto& finalizer =
      NativeFinalizer::Handle(NativeFinalizer::New(spaces[0]));
  finalizer.set_callback(callback);
  finalizer.set_isolate(thread->isolate());
 
  const auto& isolate_finalizers =
      GrowableObjectArray::Handle(GrowableObjectArray::New());
  const auto& weak1 = WeakReference::Handle(WeakReference::New());
  weak1.set_target(finalizer);
  isolate_finalizers.Add(weak1);
  thread->isolate()->set_finalizers(isolate_finalizers);
 
  const auto& all_entries = Set::Handle(Set::NewDefault());
  finalizer.set_all_entries(all_entries);
  const auto& all_entries_data = Array::Handle(all_entries.data());
  THR_Print("entry1 space: %s\n", spaces[1] == Heap::kNew ? "new" : "old");
  const auto& entry1 =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, spaces[1]));
  all_entries_data.SetAt(0, entry1);
  THR_Print("entry2 space: %s\n", spaces[2] == Heap::kNew ? "new" : "old");
  const auto& entry2 =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, spaces[2]));
  all_entries_data.SetAt(1, entry2);
  all_entries.set_used_data(2);  // Don't bother setting the index.
 
  const intptr_t external_size1 = 1024;
  const intptr_t external_size2 = 2048;
  entry1.set_external_size(external_size1);
  entry2.set_external_size(external_size2);
  IsolateGroup::Current()->heap()->AllocatedExternal(external_size1, spaces[5]);
  IsolateGroup::Current()->heap()->AllocatedExternal(external_size2, spaces[7]);
 
  auto& value1 = String::Handle();
  auto& detach1 = String::Handle();
  const auto& token1 = Pointer::Handle(
      Pointer::New(reinterpret_cast<uword>(&token1_memory), spaces[3]));
  entry1.set_token(token1);
 
  auto& value2 = String::Handle();
  auto& detach2 = String::Handle();
  const auto& token2 = Pointer::Handle(
      Pointer::New(reinterpret_cast<uword>(&token2_memory), spaces[4]));
  entry2.set_token(token2);
  entry2.set_detach(detach2);
 
  {
    HANDLESCOPE(thread);
    auto& object = String::Handle();
 
    THR_Print("value1 space: %s\n", spaces[5] == Heap::kNew ? "new" : "old");
    object ^= OneByteString::New("value1", spaces[5]);
    entry1.set_value(object);
    if (!clear_value_1) {
      value1 = object.ptr();
    }
 
    object ^= OneByteString::New("detach", spaces[6]);
    entry1.set_detach(object);
    if (!clear_detach_1) {
      detach1 = object.ptr();
    }
 
    THR_Print("value2 space: %s\n", spaces[7] == Heap::kNew ? "new" : "old");
    object ^= OneByteString::New("value2", spaces[7]);
    entry2.set_value(object);
    if (!clear_value_2) {
      value2 = object.ptr();
    }
 
    object ^= OneByteString::New("detach", spaces[8]);
    entry2.set_detach(object);
    if (!clear_detach_2) {
      detach2 = object.ptr();
    }
  }
 
  THR_Print("CollectOldSpace\n");
  GCTestHelper::CollectOldSpace();
  if (collect_new_space) {
    THR_Print("CollectNewSpace\n");
    GCTestHelper::CollectNewSpace();
  }
  if (evacuate_new_space_and_collect_old_space) {
    THR_Print("CollectAllGarbage\n");
    GCTestHelper::CollectAllGarbage();
  }
 
  EXPECT((entry1.value() == Object::null()) ^ !clear_value_1);
  EXPECT((entry2.value() == Object::null()) ^ !clear_value_2);
  EXPECT((entry1.detach() == Object::null()) ^ !clear_detach_1);
  EXPECT((entry2.detach() == Object::null()) ^ !clear_detach_2);
  EXPECT_NE(Object::null(), entry1.token());
  EXPECT_NE(Object::null(), entry2.token());
 
  const intptr_t expect_num_cleared =
      (clear_value_1 ? 1 : 0) + (clear_value_2 ? 1 : 0);
  EXPECT_EQ(expect_num_cleared,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));
 
  EXPECT_EQ(clear_value_1 ? 1 : 0, token1_memory);
  EXPECT_EQ(clear_value_2 ? 1 : 0, token2_memory);
 
  const intptr_t expect_num_messages = expect_num_cleared == 0 ? 0 : 1;
  {
    // Acquire ownership of message handler queues.
    MessageHandler::AcquiredQueues aq(handler);
    EXPECT_EQ(expect_num_messages + queue_length_start, aq.queue()->Length());
  }
 
  // Simulate detachments.
  entry1.set_token(entry1);
  entry2.set_token(entry2);
  all_entries_data.SetAt(0, Object::Handle(Object::null()));
  all_entries_data.SetAt(1, Object::Handle(Object::null()));
  all_entries.set_used_data(0);
}

NativeFinalizer_TwoEntriesCrossGen() [2/2]

static void dart::NativeFinalizer_TwoEntriesCrossGen ( Thread *  thread, intptr_t  test_i  )

static

Definition at line 5108 of file object_test.cc.

                                                                {
  ASSERT(test_i < (1 << kFinalizerTwoEntriesNumObjects));
  Heap::Space spaces[kFinalizerTwoEntriesNumObjects];
  for (intptr_t i = 0; i < kFinalizerTwoEntriesNumObjects; i++) {
    spaces[i] = ((test_i >> i) & 0x1) == 0x1 ? Heap::kOld : Heap::kNew;
  }
  // Either collect or evacuate new space.
  for (const bool collect_new_space : {true, false}) {
    // Always run old space collection after new space.
    const bool evacuate_new_space_and_collect_old_space = true;
    const bool clear_value_1 = true;
    const bool clear_value_2 = true;
    const bool clear_detach_1 = false;
    const bool clear_detach_2 = false;
    THR_Print(
        "collect_new_space: %s evacuate_new_space_and_collect_old_space: %s\n",
        collect_new_space ? "true" : "false",
        evacuate_new_space_and_collect_old_space ? "true" : "false");
    NativeFinalizer_TwoEntriesCrossGen(thread, spaces, collect_new_space,
                                       evacuate_new_space_and_collect_old_space,
                                       clear_value_1, clear_value_2,
                                       clear_detach_1, clear_detach_2);
  }
}

NativeFinalizer_TwoEntriesCrossGen_Finalizer()

void dart::NativeFinalizer_TwoEntriesCrossGen_Finalizer

(

void *

peer

)

Definition at line 4957 of file object_test.cc.

                                                              {
  intptr_t* token = reinterpret_cast<intptr_t*>(peer);
  (*token)++;
}

NativeFoo1()

static void dart::NativeFoo1 ( Dart_NativeArguments  args )

static

Definition at line 8661 of file dart_api_impl_test.cc.

                                         {
  EXPECT_VALID(arg);
  EXPECT(Dart_IsInteger(arg));

NativeFoo2()

static void dart::NativeFoo2 ( Dart_NativeArguments  args )

static

Definition at line 8671 of file dart_api_impl_test.cc.

                                                  {
  Dart_EnterScope();
  intptr_t i = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(1, i);
  Dart_Handle arg = Dart_GetNativeArgument(args, 0);
  EXPECT_VALID(arg);
  Dart_SetReturnValue(args, Dart_NewInteger(1));
  Dart_ExitScope();
}
 
static void NativeFoo2(Dart_NativeArguments args) {
  Dart_EnterScope();
  intptr_t i = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(2, i);
  Dart_Handle arg1 = Dart_GetNativeArgument(args, 1);
  EXPECT_VALID(arg1);
  int64_t value = 0;

NativeFoo3()

static void dart::NativeFoo3 ( Dart_NativeArguments  args )

static

Definition at line 8693 of file dart_api_impl_test.cc.

NativeFoo4()

static void dart::NativeFoo4 ( Dart_NativeArguments  args )

static

Definition at line 8703 of file dart_api_impl_test.cc.

                                                  {
  Dart_EnterScope();
  intptr_t i = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(3, i);
  Dart_Handle arg1 = Dart_GetNativeArgument(args, 1);
  Dart_Handle arg2 = Dart_GetNativeArgument(args, 2);
  Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg1) + GetValue(arg2)));

NativeFunc()

static void dart::NativeFunc ( Dart_NativeArguments  args )

static

Definition at line 20 of file code_descriptors_test.cc.

                                                  {
  Dart_Handle i = Dart_GetNativeArgument(args, 0);
  Dart_Handle k = Dart_GetNativeArgument(args, 1);
  int64_t value = -1;
  EXPECT_VALID(Dart_IntegerToInt64(i, &value));
  EXPECT_EQ(10, value);
  EXPECT_VALID(Dart_IntegerToInt64(k, &value));
  EXPECT_EQ(20, value);
  {
    TransitionNativeToVM transition(Thread::Current());
    IsolateGroup::Current()->heap()->CollectAllGarbage();
  }
}

NativeLookup()

static Dart_NativeFunction dart::NativeLookup ( Dart_Handle  name, int  argc, bool *  auto_setup_scope  )

static

Definition at line 224 of file custom_isolate_test.cc.

                                                                {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  const char* name_str = nullptr;
  EXPECT(Dart_IsString(name));
  EXPECT_VALID(Dart_StringToCString(name, &name_str));
  if (strcmp(name_str, "native_echo") == 0) {
    return &native_echo;
  } else if (strcmp(name_str, "CustomIsolateImpl_start") == 0) {
    return &CustomIsolateImpl_start;
  }
  return nullptr;
}

NativeResolver()

static Dart_NativeFunction dart::NativeResolver ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 210 of file benchmark_test.cc.

                                                                  {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = false;
  return &vmservice_resolver;
}

NativeTypePointerParam()

DART_EXPORT void dart::NativeTypePointerParam

(

void *

p

)

Definition at line 1160 of file ffi_test_functions.cc.

                                                 {
  uint8_t* p2 = reinterpret_cast<uint8_t*>(p);
  p2[0] = 42;
}

NativeTypePointerReturn()

DART_EXPORT void * dart::NativeTypePointerReturn

(

)

Definition at line 1166 of file ffi_test_functions.cc.

                                            {
  uint64_t bogus_address = 0x13370000;
  return reinterpret_cast<void*>(bogus_address);
}

NeedsRecordBoxing()

static bool dart::NeedsRecordBoxing ( Definition *  def )

static

Definition at line 2056 of file flow_graph.cc.

                                               {
  if (def->env_use_list() != nullptr) return true;
  for (Value::Iterator it(def->input_use_list()); !it.Done(); it.Advance()) {
    Value* use = it.Current();
    if (use->instruction()->RequiredInputRepresentation(use->use_index()) !=
        kPairOfTagged) {
      return true;
    }
  }
  return false;
}

NegativeLookaroundAgainstReadDirectionAndMatch()

RegExpNode * dart::NegativeLookaroundAgainstReadDirectionAndMatch	(	RegExpCompiler *	compiler,
		ZoneGrowableArray< CharacterRange > *	lookbehind,
		ZoneGrowableArray< CharacterRange > *	match,
		RegExpNode *	on_success,
		bool	read_backward,
		RegExpFlags	flags
	)

Definition at line 4030 of file regexp.cc.

                       {
  RegExpNode* match_node = TextNode::CreateForCharacterRanges(
      match, read_backward, on_success, flags);
  int stack_register = compiler->UnicodeLookaroundStackRegister();
  int position_register = compiler->UnicodeLookaroundPositionRegister();
  RegExpLookaround::Builder lookaround(false, match_node, stack_register,
                                       position_register);
  RegExpNode* negative_match = TextNode::CreateForCharacterRanges(
      lookbehind, !read_backward, lookaround.on_match_success(), flags);
  return lookaround.ForMatch(negative_match);
}

NewBranch()

static BranchInstr * dart::NewBranch ( FlowGraph *  graph, ComparisonInstr *  cmp, Instruction *  inherit  )

static

Definition at line 3068 of file flow_graph.cc.

                                                    {
  BranchInstr* bra = new (graph->zone()) BranchInstr(cmp, DeoptId::kNone);
  bra->InheritDeoptTarget(graph->zone(), inherit);
  return bra;
}

NewByteData()

static Dart_Handle dart::NewByteData ( Thread *  thread, intptr_t  length  )

static

Definition at line 3732 of file dart_api_impl.cc.

                                                                {
  CHECK_LENGTH(length, TypedData::MaxElements(kTypedDataUint8ArrayCid));
  const TypedData& array =
      TypedData::Handle(TypedData::New(kTypedDataUint8ArrayCid, length));
  return Api::NewHandle(thread,
                        TypedDataView::New(kByteDataViewCid, array, 0, length));
}

NewConstChar()

static const char * dart::NewConstChar ( const char *  chars )

static

Definition at line 421 of file isolate.cc.

                                                   {
  size_t len = strlen(chars);
  char* mem = new char[len + 1];
  memmove(mem, chars, len + 1);
  return mem;
}

NewDictionary()

static ArrayPtr dart::NewDictionary ( intptr_t  initial_size )

static

Definition at line 14251 of file object.cc.

                                                     {
  const Array& dict = Array::Handle(Array::New(initial_size + 1, Heap::kOld));
  // The last element of the dictionary specifies the number of in use slots.
  dict.SetAt(initial_size, Object::smi_zero());
  return dict.ptr();
}

NewExternalByteData()

static Dart_Handle dart::NewExternalByteData ( Thread *  thread, void *  data, intptr_t  length, void *  peer, intptr_t  external_allocation_size, Dart_HandleFinalizer  callback, bool  unmodifiable  )

static

Definition at line 3774 of file dart_api_impl.cc.

                                                          {
  Zone* zone = thread->zone();
  Dart_Handle ext_data = NewExternalTypedData(
      thread, kExternalTypedDataUint8ArrayCid, data, length, peer,
      external_allocation_size, callback, false);
  if (Api::IsError(ext_data)) {
    return ext_data;
  }
  const ExternalTypedData& array =
      Api::UnwrapExternalTypedDataHandle(zone, ext_data);
  if (unmodifiable) {
    array.SetImmutable();  // Can pass by reference.
  }
  return Api::NewHandle(
      thread, TypedDataView::New(unmodifiable ? kUnmodifiableByteDataViewCid
                                              : kByteDataViewCid,
                                 array, 0, length));
}

NewExternalTypedData()

static Dart_Handle dart::NewExternalTypedData ( Thread *  thread, intptr_t  cid, void *  data, intptr_t  length, void *  peer, intptr_t  external_allocation_size, Dart_HandleFinalizer  callback, bool  unmodifiable  )

static

Definition at line 3745 of file dart_api_impl.cc.

                                                           {
  CHECK_LENGTH(length, ExternalTypedData::MaxElements(cid));
  Zone* zone = thread->zone();
  intptr_t bytes = length * ExternalTypedData::ElementSizeInBytes(cid);
  Object& result = Object::Handle(
      zone,
      ExternalTypedData::New(cid, reinterpret_cast<uint8_t*>(data), length,
                             thread->heap()->SpaceForExternal(bytes)));
  if (callback != nullptr) {
    AllocateFinalizableHandle(thread, result, peer, external_allocation_size,
                              callback);
  }
  if (unmodifiable) {
    result.SetImmutable();  // Can pass by reference.
    const intptr_t view_cid = cid - kTypedDataCidRemainderExternal +
                              kTypedDataCidRemainderUnmodifiable;
    result = TypedDataView::New(view_cid, ExternalTypedData::Cast(result), 0,
                                length);
  }
  return Api::NewHandle(thread, result.ptr());
}

NewExternalTypedDataWithFinalizer()

static Dart_Handle dart::NewExternalTypedDataWithFinalizer ( Dart_TypedData_Type  type, void *  data, intptr_t  length, void *  peer, intptr_t  external_allocation_size, Dart_HandleFinalizer  callback, bool  unmodifiable  )

static

Definition at line 3842 of file dart_api_impl.cc.

                       {
  DARTSCOPE(Thread::Current());
  if (data == nullptr && length != 0) {
    RETURN_NULL_ERROR(data);
  }
  CHECK_CALLBACK_STATE(T);
  switch (type) {
    case Dart_TypedData_kByteData:
      return NewExternalByteData(T, data, length, peer,
                                 external_allocation_size, callback,
                                 unmodifiable);
    case Dart_TypedData_kInt8:
      return NewExternalTypedData(T, kExternalTypedDataInt8ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kUint8:
      return NewExternalTypedData(T, kExternalTypedDataUint8ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kUint8Clamped:
      return NewExternalTypedData(T, kExternalTypedDataUint8ClampedArrayCid,
                                  data, length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kInt16:
      return NewExternalTypedData(T, kExternalTypedDataInt16ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kUint16:
      return NewExternalTypedData(T, kExternalTypedDataUint16ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kInt32:
      return NewExternalTypedData(T, kExternalTypedDataInt32ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kUint32:
      return NewExternalTypedData(T, kExternalTypedDataUint32ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kInt64:
      return NewExternalTypedData(T, kExternalTypedDataInt64ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kUint64:
      return NewExternalTypedData(T, kExternalTypedDataUint64ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kFloat32:
      return NewExternalTypedData(T, kExternalTypedDataFloat32ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kFloat64:
      return NewExternalTypedData(T, kExternalTypedDataFloat64ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kInt32x4:
      return NewExternalTypedData(T, kExternalTypedDataInt32x4ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kFloat32x4:
      return NewExternalTypedData(T, kExternalTypedDataFloat32x4ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    case Dart_TypedData_kFloat64x2:
      return NewExternalTypedData(T, kExternalTypedDataFloat64x2ArrayCid, data,
                                  length, peer, external_allocation_size,
                                  callback, unmodifiable);
    default:
      return Api::NewError(
          "%s expects argument 'type' to be of"
          " 'external TypedData'",
          CURRENT_FUNC);
  }
  UNREACHABLE();
  return Api::Null();
}

NewGoto()

static GotoInstr * dart::NewGoto ( FlowGraph *  graph, JoinEntryInstr *  target, Instruction *  inherit  )

static

Definition at line 3060 of file flow_graph.cc.

                                                {
  GotoInstr* got = new (graph->zone()) GotoInstr(target, DeoptId::kNone);
  got->InheritDeoptTarget(graph->zone(), inherit);
  return got;
}

NewJoin()

static JoinEntryInstr * dart::NewJoin ( FlowGraph *  graph, Instruction *  inherit  )

static

Definition at line 3052 of file flow_graph.cc.

                                                                       {
  JoinEntryInstr* join = new (graph->zone())
      JoinEntryInstr(graph->allocate_block_id(),
                     inherit->GetBlock()->try_index(), DeoptId::kNone);
  join->InheritDeoptTarget(graph->zone(), inherit);
  return join;
}

NewMove()

static CatchEntryMove dart::NewMove ( intptr_t  src, intptr_t  dst  )

static

Definition at line 16 of file catch_entry_moves_test.cc.

                                                          {
  return CatchEntryMove::FromSlot(CatchEntryMove::SourceKind::kTaggedSlot, src,
                                  dst);
}

NewNativePort_ExternalTypedData()

static void dart::NewNativePort_ExternalTypedData ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 8227 of file dart_api_impl_test.cc.

NewNativePort_nativeReceiveInteger()

static void dart::NewNativePort_nativeReceiveInteger ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 8376 of file dart_api_impl_test.cc.

                             : 123\n", Dart_GetError(result));
 
  Dart_ExitScope();
 
  // Delete the native ports.
  EXPECT(Dart_CloseNativePort(port_id1));
}
 

NewNativePort_nativeReceiveNull()

static void dart::NewNativePort_nativeReceiveNull ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 8325 of file dart_api_impl_test.cc.

  {
    Dart_CloseNativePort(port_id);
    Dart_Handle send_port = Dart_NewSendPort(port_id);
    EXPECT_VALID(send_port);
    Dart_Handle dart_args[1];
    dart_args[0] = send_port;
    Dart_Handle result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
    EXPECT_ERROR(result, "Invalid argument");
  }
 
  Dart_ExitScope();
}

NewNativePort_send123()

static void dart::NewNativePort_send123 ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 7958 of file dart_api_impl_test.cc.

      {"file:///bar/.packages", "untitled:/"},
  };
  int sourcefiles_count = sizeof(sourcefiles) / sizeof(Dart_SourceFile);
  lib = TestCase::LoadTestScriptWithDFE(
      sourcefiles_count, sourcefiles, nullptr, /* finalize= */ true,
      /* incrementally= */ true, /* allow_compile_errors= */ false,
      "foo1:///main.dart",
      /* multiroot_filepaths= */ "/bar,/baz",
      /* multiroot_scheme= */ "foo");
  EXPECT_ERROR(lib,
               "Compilation failed Invalid argument(s): Exception when reading "
               "'foo1:///.dart_tool");
}
 
static void NewNativePort_send123(Dart_Port dest_port_id,

NewNativePort_send321()

static void dart::NewNativePort_send321 ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 7974 of file dart_api_impl_test.cc.

NewNativePort_sendInteger123()

static void dart::NewNativePort_sendInteger123 ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 8084 of file dart_api_impl_test.cc.

                             : 321\n", Dart_GetError(result));
 
  Dart_ExitScope();
 
  // Delete the native ports.
  EXPECT(Dart_CloseNativePort(port_id1));

NewNativePort_sendInteger321()

static void dart::NewNativePort_sendInteger321 ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 8096 of file dart_api_impl_test.cc.

                                                                {
  // Gets a send port message.
  EXPECT_NOTNULL(message);
  EXPECT_EQ(Dart_CObject_kArray, message->type);
  EXPECT_EQ(Dart_CObject_kSendPort, message->value.as_array.values[0]->type);
 
  // Post integer value.
  Dart_PostInteger(message->value.as_array.values[0]->value.as_send_port.id,

NewNativePort_Transferrable1()

static void dart::NewNativePort_Transferrable1 ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 8159 of file dart_api_impl_test.cc.

                             : 321\n", Dart_GetError(result));
 
  Dart_ExitScope();
 
  // Delete the native ports.

NewNativePort_Transferrable2()

static void dart::NewNativePort_Transferrable2 ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 8170 of file dart_api_impl_test.cc.

                                                                {
  // Gets a send port message.
  EXPECT_NOTNULL(message);
  EXPECT_EQ(Dart_CObject_kTypedData, message->type);
  EXPECT_EQ(Dart_TypedData_kUint8, message->value.as_typed_data.type);
  EXPECT_EQ(10, message->value.as_typed_data.length);
  EXPECT_EQ(42, message->value.as_typed_data.values[0]);
  free(const_cast<uint8_t*>(message->value.as_typed_data.values));
}

NewRegion()

static void * dart::NewRegion ( uword  size )

static

Definition at line 11 of file memory_region_test.cc.

                                   {
  void* pointer = new uint8_t[size];
  return pointer;
}

NewString()

Dart_Handle dart::NewString ( const char *  str )

inline

Definition at line 50 of file benchmark_test.h.

                                              {
  return Dart_NewStringFromCString(str);
}

NewTarget()

static TargetEntryInstr * dart::NewTarget ( FlowGraph *  graph, Instruction *  inherit  )

static

Definition at line 3044 of file flow_graph.cc.

                                                                           {
  TargetEntryInstr* target = new (graph->zone())
      TargetEntryInstr(graph->allocate_block_id(),
                       inherit->GetBlock()->try_index(), DeoptId::kNone);
  target->InheritDeoptTarget(graph->zone(), inherit);
  return target;
}

NewTypedData()

static Dart_Handle dart::NewTypedData ( Thread *  thread, intptr_t  cid, intptr_t  length  )

static

Definition at line 3740 of file dart_api_impl.cc.

                                                                               {
  CHECK_LENGTH(length, TypedData::MaxElements(cid));
  return Api::NewHandle(thread, TypedData::New(cid, length));
}

NoopCallback()

static void dart::NoopCallback ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 79 of file handles_test.cc.

{}

NoopFinalizer() [1/2]

static void dart::NoopFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 436 of file heap_test.cc.

{}

NoopFinalizer() [2/2]

static void dart::NoopFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 1915 of file snapshot_test.cc.

{}

NoopNative()

static void dart::NoopNative ( Dart_NativeArguments  args )

static

Definition at line 29 of file redundancy_elimination_test.cc.

{}

NoopNativeLookup()

static Dart_NativeFunction dart::NoopNativeLookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 31 of file redundancy_elimination_test.cc.

                                                                    {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = false;
  return NoopNative;
}

NopCallback()

static void dart::NopCallback ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3009 of file dart_api_impl_test.cc.

{}

NopResolver()

static void * dart::NopResolver ( const char *  name, uintptr_t  args_n  )

static

Definition at line 10165 of file dart_api_impl_test.cc.

Normalize()

static void dart::Normalize ( char *  s )

static

Definition at line 276 of file flags.cc.

                               {
  intptr_t len = strlen(s);
  for (intptr_t i = 0; i < len; i++) {
    if (s[i] == '-') {
      s[i] = '_';
    }
  }
}

NormalizeClassIdForSyntacticalTypeEquality()

static classid_t dart::NormalizeClassIdForSyntacticalTypeEquality ( classid_t  cid )

static

Definition at line 22110 of file object.cc.

                                                                           {
  if (IsIntegerClassId(cid)) {
    return Type::Handle(Type::IntType()).type_class_id();
  } else if (IsStringClassId(cid)) {
    return Type::Handle(Type::StringType()).type_class_id();
  } else if (cid == kDoubleCid) {
    return Type::Handle(Type::Double()).type_class_id();
  } else if (IsTypeClassId(cid)) {
    return Type::Handle(Type::DartTypeType()).type_class_id();
  } else if (IsArrayClassId(cid)) {
    return Class::Handle(IsolateGroup::Current()->object_store()->list_class())
        .id();
  }
  return cid;
}

NormalizeEscapes()

static char * dart::NormalizeEscapes ( const char *  str, intptr_t  len  )

static

Definition at line 81 of file uri.cc.

                                                             {
  // Allocate the buffer.
  Zone* zone = ThreadState::Current()->zone();
  // We multiply len by three because a percent-escape sequence is
  // three characters long (e.g. ' ' -> '%20).  +1 for '\0'.  We could
  // take two passes through the string and avoid the excess
  // allocation, but it's zone-memory so it doesn't seem necessary.
  char* buffer = zone->Alloc<char>(len * 3 + 1);
 
  // Copy the string, normalizing as we go.
  intptr_t buffer_pos = 0;
  intptr_t pos = 0;
  while (pos < len) {
    int escaped_value = GetEscapedValue(str, pos, len);
    if (escaped_value >= 0) {
      // If one of the special "unreserved" characters has been
      // escaped, revert the escaping.  Otherwise preserve the
      // escaping.
      if (IsUnreservedChar(escaped_value)) {
        buffer[buffer_pos] = escaped_value;
        buffer_pos++;
      } else {
        Utils::SNPrint(buffer + buffer_pos, 4, "%%%02X", escaped_value);
        buffer_pos += 3;
      }
      pos += 3;
    } else {
      char c = str[pos];
      // If a delimiter or unreserved character is currently not
      // escaped, preserve that.  If there is a busted %-sequence in
      // the input, preserve that too.
      if (c == '%' || IsDelimiter(c) || IsUnreservedChar(c)) {
        buffer[buffer_pos] = c;
        buffer_pos++;
      } else {
        // Escape funky characters.
        Utils::SNPrint(buffer + buffer_pos, 4, "%%%02X", c);
        buffer_pos += 3;
      }
      pos++;
    }
  }
  buffer[buffer_pos] = '\0';
  return buffer;
}

NOT_IN_PRODUCT()

dart::NOT_IN_PRODUCT

(

LibraryPtr

ReloadTestScriptconst char *script

)

NothingModifiedCallback()

static bool dart::NothingModifiedCallback ( const char *  url, int64_t  since  )

static

Definition at line 4444 of file isolate_reload_test.cc.

NotifyDart()

void dart::NotifyDart	(	Dart_Port	send_port,
		const Work *	work
	)

Definition at line 458 of file ffi_test_functions_vmspecific.cc.

                                                       {
  const intptr_t work_addr = reinterpret_cast<intptr_t>(work);
  printf("C   :  Posting message (port: %" Px64 ", work: %" Px ").\n",
         send_port, work_addr);
 
  Dart_CObject dart_object;
  dart_object.type = Dart_CObject_kInt64;
  dart_object.value.as_int64 = work_addr;
 
  const bool result = Dart_PostCObject_DL(send_port, &dart_object);
  if (!result) {
    FATAL("C   :  Posting message to port failed.");
  }
}

NotifyDestroyed_native_lookup()

static Dart_NativeFunction dart::NotifyDestroyed_native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 9735 of file dart_api_impl_test.cc.

  {
    result = Dart_SetEnabledTimelineCategory("GC,API,Compiler");

NotifyDestroyedNative()

static void dart::NotifyDestroyedNative ( Dart_NativeArguments  args )

static

Definition at line 9731 of file dart_api_impl_test.cc.

  {
    result = Dart_SetEnabledTimelineCategory(nullptr);

NotifyIdleLong_native_lookup()

static Dart_NativeFunction dart::NotifyIdleLong_native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 9702 of file dart_api_impl_test.cc.

                                 {
  int64_t micros1 = Dart_TimelineGetMicros();
  int64_t ticks1 = Dart_TimelineGetTicks();
  int64_t frequency1 = Dart_TimelineGetTicksFrequency();

NotifyIdleLongNative()

static void dart::NotifyIdleLongNative ( Dart_NativeArguments  args )

static

Definition at line 9698 of file dart_api_impl_test.cc.

NotifyIdleShort_native_lookup()

static Dart_NativeFunction dart::NotifyIdleShort_native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 9670 of file dart_api_impl_test.cc.

NotifyIdleShortNative()

static void dart::NotifyIdleShortNative ( Dart_NativeArguments  args )

static

Definition at line 9666 of file dart_api_impl_test.cc.

NotifyLowMemory_native_lookup()

static Dart_NativeFunction dart::NotifyLowMemory_native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 9812 of file dart_api_impl_test.cc.

                                    {
      t.add(List.filled(100, null));
    }
    v = t;
    notifyIdle();

NotifyLowMemoryNative()

static void dart::NotifyLowMemoryNative ( Dart_NativeArguments  args )

static

Definition at line 9808 of file dart_api_impl_test.cc.

            {
  var v;

NotifyMessage()

static void dart::NotifyMessage ( Dart_Isolate  dest_isolate )

static

Definition at line 218 of file custom_isolate_test.cc.

                                                     {
  OS::PrintErr("-- Notify isolate(%p) of pending message --\n", dest_isolate);
  OS::PrintErr("-- Adding MessageEvent to queue --\n");
  event_queue->Add(new MessageEvent(dest_isolate));
}

NullableInt64ElemAt1()

DART_EXPORT int64_t * dart::NullableInt64ElemAt1

(

int64_t *

a

)

Definition at line 612 of file ffi_test_functions.cc.

                                                      {
  std::cout << "NullableInt64ElemAt1(" << a << ")\n";
  int64_t* retval;
  if (a != nullptr) {
    std::cout << "not null pointer, address: " << a << "\n";
    retval = a + 1;
  } else {
    std::cout << "null pointer, address: " << a << "\n";
    retval = nullptr;
  }
  std::cout << "returning " << retval << "\n";
  return retval;
}

NullErrorHelper()

static void dart::NullErrorHelper ( Zone *  zone, const String &  selector, bool  is_param_name = false  )

static

Definition at line 186 of file runtime_entry.cc.

                                                        {
  if (is_param_name) {
    const String& error = String::Handle(
        selector.IsNull()
            ? String::New("argument value is null")
            : String::NewFormatted("argument value for '%s' is null",
                                   selector.ToCString()));
    Exceptions::ThrowArgumentError(error);
    return;
  }
 
  // If the selector is null, this must be a null check that wasn't due to a
  // method invocation, so was due to the null check operator.
  if (selector.IsNull()) {
    const Array& args = Array::Handle(zone, Array::New(4));
    args.SetAt(
        3, String::Handle(
               zone, String::New("Null check operator used on a null value")));
    Exceptions::ThrowByType(Exceptions::kType, args);
    return;
  }
 
  InvocationMirror::Kind kind = InvocationMirror::kMethod;
  if (Field::IsGetterName(selector)) {
    kind = InvocationMirror::kGetter;
  } else if (Field::IsSetterName(selector)) {
    kind = InvocationMirror::kSetter;
  }
 
  const Smi& invocation_type = Smi::Handle(
      zone,
      Smi::New(InvocationMirror::EncodeType(InvocationMirror::kDynamic, kind)));
 
  const Array& args = Array::Handle(zone, Array::New(7));
  args.SetAt(0, /* instance */ Object::null_object());
  args.SetAt(1, selector);
  args.SetAt(2, invocation_type);
  args.SetAt(3, /* func_type_args_length */ Object::smi_zero());
  args.SetAt(4, /* func_type_args */ Object::null_object());
  args.SetAt(5, /* func_args */ Object::null_object());
  args.SetAt(6, /* func_arg_names */ Object::null_object());
  Exceptions::ThrowByType(Exceptions::kNoSuchMethod, args);
}

NumberPlaces()

static AliasedSet * dart::NumberPlaces ( FlowGraph *  graph, PointerSet< Place > *  map, CSEMode  mode  )

static

Definition at line 1371 of file redundancy_elimination.cc.

                                              {
  // Loads representing different expression ids will be collected and
  // used to build per offset kill sets.
  Zone* zone = graph->zone();
  ZoneGrowableArray<Place*>* places = new (zone) ZoneGrowableArray<Place*>(10);
 
  bool has_loads = false;
  bool has_stores = false;
  for (BlockIterator it = graph->reverse_postorder_iterator(); !it.Done();
       it.Advance()) {
    BlockEntryInstr* block = it.Current();
 
    for (ForwardInstructionIterator instr_it(block); !instr_it.Done();
         instr_it.Advance()) {
      Instruction* instr = instr_it.Current();
      Place place(instr, &has_loads, &has_stores);
      if (place.kind() == Place::kNone) {
        continue;
      }
 
      Place* result = map->LookupValue(&place);
      if (result == nullptr) {
        result = Place::Wrap(zone, place, places->length());
        map->Insert(result);
        places->Add(result);
 
        if (FLAG_trace_optimization && graph->should_print()) {
          THR_Print("numbering %s as %" Pd "\n", result->ToCString(),
                    result->id());
        }
      }
 
      SetPlaceId(instr, result->id());
    }
  }
 
  if ((mode == kOptimizeLoads) && !has_loads) {
    return nullptr;
  }
  if ((mode == kOptimizeStores) && !has_stores) {
    return nullptr;
  }
 
  PhiPlaceMoves* phi_moves =
      ComputePhiMoves(map, places, graph->should_print());
 
  // Build aliasing sets mapping aliases to loads.
  return new (zone)
      AliasedSet(zone, map, places, phi_moves, graph->should_print());
}

NumEntries()

static int dart::NumEntries ( const FinalizerEntry &  entry, intptr_t  acc = 0  )

static

Definition at line 3843 of file object_test.cc.

                                                                     {
  if (entry.IsNull()) {
    return acc;
  }
  return NumEntries(FinalizerEntry::Handle(entry.next()), acc + 1);
}

objcpy()

static NO_SANITIZE_THREAD void dart::objcpy ( void *  dst, const void *  src, size_t  size  )

static

Definition at line 92 of file scavenger.cc.

                                                            {
  // A mem copy specialized for objects. We can assume:
  //  - dst and src do not overlap
  ASSERT(
      (reinterpret_cast<uword>(dst) + size <= reinterpret_cast<uword>(src)) ||
      (reinterpret_cast<uword>(src) + size <= reinterpret_cast<uword>(dst)));
  //  - dst and src are word aligned
  ASSERT(Utils::IsAligned(reinterpret_cast<uword>(dst), sizeof(uword)));
  ASSERT(Utils::IsAligned(reinterpret_cast<uword>(src), sizeof(uword)));
  //  - size is strictly positive
  ASSERT(size > 0);
  //  - size is a multiple of double words
  ASSERT(Utils::IsAligned(size, 2 * sizeof(uword)));
 
  uword* __restrict dst_cursor = reinterpret_cast<uword*>(dst);
  const uword* __restrict src_cursor = reinterpret_cast<const uword*>(src);
  do {
    uword a = *src_cursor++;
    uword b = *src_cursor++;
    *dst_cursor++ = a;
    *dst_cursor++ = b;
    size -= (2 * sizeof(uword));
  } while (size > 0);
}

ObjectAtPoolIndex()

bool dart::ObjectAtPoolIndex	(	const Code &	code,
		intptr_t	index,
		Object *	obj
	)

Definition at line 14 of file instructions.cc.

                                                                      {
#if defined(DART_PRECOMPILER)
  if (FLAG_precompiled_mode) {
    Precompiler* precompiler = Precompiler::Instance();
    if (precompiler != nullptr) {
      compiler::ObjectPoolBuilder* pool =
          precompiler->global_object_pool_builder();
      if (index < pool->CurrentLength()) {
        compiler::ObjectPoolBuilderEntry& entry = pool->EntryAt(index);
        if (entry.type() == compiler::ObjectPoolBuilderEntry::kTaggedObject) {
          *obj = entry.obj_->ptr();
          return true;
        }
      }
    }
    return false;
  }
#endif
  const ObjectPool& pool = ObjectPool::Handle(code.GetObjectPool());
  if (!pool.IsNull() && (index < pool.Length()) &&
      (pool.TypeAt(index) == ObjectPool::EntryType::kTaggedObject)) {
    *obj = pool.ObjectAt(index);
    return true;
  }
  return false;
}

OddDRegisterOf()

static DRegister dart::OddDRegisterOf ( QRegister  q )

inlinestatic

Definition at line 259 of file constants_arm.h.

                                                    {
  return static_cast<DRegister>((q * 2) + 1);
}

OddSRegisterOf()

static SRegister dart::OddSRegisterOf ( DRegister  d )

inlinestatic

Definition at line 272 of file constants_arm.h.

                                                    {
#if defined(VFPv3_D32)
  ASSERT(d < D16);
#endif
  return static_cast<SRegister>((d * 2) + 1);
}

OnEveryRuntimeEntryCall()

void dart::OnEveryRuntimeEntryCall	(	Thread *	thread,
		const char *	runtime_call_name,
		bool	can_lazy_deopt
	)

Definition at line 3762 of file runtime_entry.cc.

                                                  {
  ASSERT(FLAG_deoptimize_on_runtime_call_every > 0);
  if (FLAG_precompiled_mode) {
    return;
  }
  if (IsolateGroup::IsSystemIsolateGroup(thread->isolate_group())) {
    return;
  }
  const bool is_deopt_related =
      strstr(runtime_call_name, "Deoptimize") != nullptr;
  if (is_deopt_related) {
    return;
  }
  // For --deoptimize-on-every-runtime-call we only consider runtime calls that
  // can lazy-deopt.
  if (can_lazy_deopt) {
    if (FLAG_deoptimize_on_runtime_call_name_filter != nullptr &&
        (strlen(runtime_call_name) !=
             strlen(FLAG_deoptimize_on_runtime_call_name_filter) ||
         strstr(runtime_call_name,
                FLAG_deoptimize_on_runtime_call_name_filter) == nullptr)) {
      return;
    }
    const uint32_t count = thread->IncrementAndGetRuntimeCallCount();
    if ((count % FLAG_deoptimize_on_runtime_call_every) == 0) {
      DeoptimizeLastDartFrameIfOptimized();
    }
  }
}

OnlyVmIsolateLeft()

static bool dart::OnlyVmIsolateLeft ( )

static

Definition at line 554 of file dart.cc.

                                {
  intptr_t count = 0;
  bool found_vm_isolate = false;
  IsolateGroup::ForEach([&](IsolateGroup* group) {
    group->ForEachIsolate([&](Isolate* isolate) {
      count++;
      if (isolate == Dart::vm_isolate()) {
        found_vm_isolate = true;
      }
    });
  });
  return count == 1 && found_vm_isolate;
}

operator!=()

constexpr bool dart::operator!= ( Register  r, LinkRegister  lr  )

constexpr

Definition at line 1328 of file constants_arm.h.

                                                       {
  return !(r == lr);
}

operator==()

constexpr bool dart::operator== ( Register  r, LinkRegister    )

constexpr

Definition at line 1324 of file constants_arm.h.

                                                    {
  return r == LR;
}

OptExternalByteDataNativeFunction()

static void dart::OptExternalByteDataNativeFunction ( Dart_NativeArguments  args )

static

Definition at line 2400 of file dart_api_impl_test.cc.

                                                                         {
  Dart_EnterScope();
  Dart_Handle external_byte_data =
      Dart_NewExternalTypedData(Dart_TypedData_kByteData, opt_data, 16);
  EXPECT_VALID(external_byte_data);
  EXPECT_EQ(Dart_TypedData_kByteData,
            Dart_GetTypeOfTypedData(external_byte_data));
  Dart_SetReturnValue(args, external_byte_data);
  Dart_ExitScope();
}

OptExternalByteDataNativeResolver()

static Dart_NativeFunction dart::OptExternalByteDataNativeResolver ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 2411 of file dart_api_impl_test.cc.

                            {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  return &OptExternalByteDataNativeFunction;
}

OptimizeCatchEntryStates()

void dart::OptimizeCatchEntryStates	(	FlowGraph *	flow_graph,
		bool	is_aot
	)

Definition at line 4303 of file redundancy_elimination.cc.

                                                                  {
  if (flow_graph->graph_entry()->catch_entries().is_empty()) {
    return;
  }
 
  TryCatchAnalyzer analyzer(flow_graph, is_aot);
  analyzer.Optimize();
}

OptionallyStepBackToLeadSurrogate()

RegExpNode * dart::OptionallyStepBackToLeadSurrogate	(	RegExpCompiler *	compiler,
		RegExpNode *	on_success,
		RegExpFlags	flags
	)

Definition at line 5263 of file regexp.cc.

                                                                 {
  // If the regexp matching starts within a surrogate pair, step back
  // to the lead surrogate and start matching from there.
  ASSERT(!compiler->read_backward());
  Zone* zone = compiler->zone();
 
  auto lead_surrogates = CharacterRange::List(
      on_success->zone(), CharacterRange::Range(Utf16::kLeadSurrogateStart,
                                                Utf16::kLeadSurrogateEnd));
  auto trail_surrogates = CharacterRange::List(
      on_success->zone(), CharacterRange::Range(Utf16::kTrailSurrogateStart,
                                                Utf16::kTrailSurrogateEnd));
 
  ChoiceNode* optional_step_back = new (zone) ChoiceNode(2, zone);
 
  int stack_register = compiler->UnicodeLookaroundStackRegister();
  int position_register = compiler->UnicodeLookaroundPositionRegister();
  RegExpNode* step_back = TextNode::CreateForCharacterRanges(
      lead_surrogates, /*read_backward=*/true, on_success, flags);
  RegExpLookaround::Builder builder(/*is_positive=*/true, step_back,
                                    stack_register, position_register);
  RegExpNode* match_trail = TextNode::CreateForCharacterRanges(
      trail_surrogates, /*read_backward=*/false, builder.on_match_success(),
      flags);
 
  optional_step_back->AddAlternative(
      GuardedAlternative(builder.ForMatch(match_trail)));
  optional_step_back->AddAlternative(GuardedAlternative(on_success));
 
  return optional_step_back;
}

OrderByFrequencyThenId()

static int dart::OrderByFrequencyThenId ( CidRange *const *  a, CidRange *const *  b  )

static

Definition at line 642 of file il.cc.

                                                                          {
  const TargetInfo* target_info_a = static_cast<const TargetInfo*>(*a);
  const TargetInfo* target_info_b = static_cast<const TargetInfo*>(*b);
  // Negative if 'a' should sort before 'b'.
  if (target_info_b->count != target_info_a->count) {
    return (target_info_b->count - target_info_a->count);
  } else {
    return (*a)->cid_start - (*b)->cid_start;
  }
}

OrderById()

static int dart::OrderById ( CidRange *const *  a, CidRange *const *  b  )

static

Definition at line 635 of file il.cc.

                                                             {
  // Negative if 'a' should sort before 'b'.
  ASSERT((*a)->IsSingleCid());
  ASSERT((*b)->IsSingleCid());
  return (*a)->cid_start - (*b)->cid_start;
}

ParamAddress()

static DART_FORCE_INLINE uword dart::ParamAddress ( uword  fp, intptr_t  reverse_index  )

static

Definition at line 417 of file stack_frame.h.

                                                                              {
  return fp + (kParamEndSlotFromFp * kWordSize) + (reverse_index * kWordSize);
}

ParseAuthority()

static intptr_t dart::ParseAuthority ( const char *  authority, ParsedUri *  parsed_uri  )

static

Definition at line 158 of file uri.cc.

                                                                             {
  Zone* zone = ThreadState::Current()->zone();
  const char* current = authority;
  intptr_t len = 0;
 
  size_t userinfo_len = strcspn(current, "@/");
  if (current[userinfo_len] == '@') {
    // The '@' character follows the optional userinfo string.
    parsed_uri->userinfo = NormalizeEscapes(current, userinfo_len);
    current += userinfo_len + 1;
    len += userinfo_len + 1;
  } else {
    parsed_uri->userinfo = nullptr;
  }
 
  size_t host_len = strcspn(current, ":/");
  char* host = NormalizeEscapes(current, host_len);
  StringLower(host);
  parsed_uri->host = host;
  len += host_len;
 
  if (current[host_len] == ':') {
    // The ':' character precedes the optional port string.
    const char* port_start = current + host_len + 1;  // +1 for ':'
    size_t port_len = strcspn(port_start, "/");
    parsed_uri->port = zone->MakeCopyOfStringN(port_start, port_len);
    len += 1 + port_len;  // +1 for ':'
  } else {
    parsed_uri->port = nullptr;
  }
  return len;
}

ParseCSVList()

static bool dart::ParseCSVList ( const char *  csv_list, const GrowableObjectArray &  values  )

static

Definition at line 3162 of file service.cc.

                                                            {
  Zone* zone = Thread::Current()->zone();
  String& s = String::Handle(zone);
  const char* c = csv_list;
  if (*c++ != '[') return false;
  while (IsWhitespace(*c) && *c != '\0') {
    c++;
  }
  while (*c != '\0') {
    const char* value = c;
    while (*c != '\0' && *c != ']' && *c != ',' && !IsWhitespace(*c)) {
      c++;
    }
    if (c > value) {
      s = String::New(zone->MakeCopyOfStringN(value, c - value));
      values.Add(s);
    }
    switch (*c) {
      case '\0':
        return false;
      case ',':
        c++;
        break;
      case ']':
        return true;
    }
    while (IsWhitespace(*c) && *c != '\0') {
      c++;
    }
  }
  return false;
}

ParseInteger()

static IntegerPtr dart::ParseInteger ( const String &  value )

static

Definition at line 162 of file integers.cc.

                                                    {
  // Used by both Integer_parse and Integer_fromEnvironment.
  if (value.IsOneByteString()) {
    // Quick conversion for unpadded integers in strings.
    const intptr_t len = value.Length();
    if (len > 0) {
      const char* cstr = value.ToCString();
      ASSERT(cstr != nullptr);
      char* p_end = nullptr;
      const int64_t int_value = strtoll(cstr, &p_end, 10);
      if (p_end == (cstr + len)) {
        if ((int_value != LLONG_MIN) && (int_value != LLONG_MAX)) {
          return Integer::New(int_value);
        }
      }
    }
  }
 
  return Integer::New(value);
}

ParseJSONArray()

intptr_t dart::ParseJSONArray	(	Thread *	thread,
		const char *	str,
		const GrowableObjectArray &	elements
	)

Definition at line 3660 of file service.cc.

                                                             {
  Zone* zone = thread->zone();
  return ParseJSONCollection(
      thread, str, [zone, &elements](const char* start, intptr_t length) {
        String& element = String::Handle(
            zone,
            String::FromUTF8(reinterpret_cast<const uint8_t*>(start), length));
        elements.Add(element);
      });
}

ParseJSONCollection()

template<typename Adder >

static intptr_t dart::ParseJSONCollection ( Thread *  thread, const char *  str, const Adder &  add  )

static

Definition at line 3629 of file service.cc.

                                                      {
  ASSERT(str != nullptr);
  ASSERT(thread != nullptr);
  intptr_t n = strlen(str);
  if (n < 2) {
    return -1;
  } else if (n == 2) {
    return 0;
  }
  // The JSON string array looks like [abc, def]. There are no quotes around the
  // strings, but there is a space after the comma. start points to the first
  // character of the element. end points to the separator after the element
  // (']' or ',').
  intptr_t start = 1;
  while (start < n) {
    intptr_t end = start;
    while (end < n) {
      const char c = str[end];
      if (c == ',' || c == ']') {
        break;
      }
      ++end;
    }
    add(&str[start], end - start);
    start = end + 2;
  }
  return 0;
}

ParseJSONSet()

static intptr_t dart::ParseJSONSet ( Thread *  thread, const char *  str, ZoneCStringSet *  elements  )

static

Definition at line 3674 of file service.cc.

                                                       {
  Zone* zone = thread->zone();
  return ParseJSONCollection(
      thread, str, [zone, elements](const char* start, intptr_t length) {
        elements->Insert(zone->MakeCopyOfStringN(start, length));
      });
}

ParseScope()

static bool dart::ParseScope ( const char *  scope, GrowableArray< const char * > *  names, GrowableArray< const char * > *  ids  )

static

Definition at line 2783 of file service.cc.

                                                        {
  Zone* zone = Thread::Current()->zone();
  const char* c = scope;
  if (*c++ != '{') return false;
 
  for (;;) {
    while (IsWhitespace(*c)) {
      c++;
    }
 
    if (*c == '}') return true;
 
    const char* name = c;
    if (!IsAlphaOrDollar(*c)) return false;
    while (IsAlphaNumOrDollar(*c)) {
      c++;
    }
    names->Add(zone->MakeCopyOfStringN(name, c - name));
 
    while (IsWhitespace(*c)) {
      c++;
    }
 
    if (*c++ != ':') return false;
 
    while (IsWhitespace(*c)) {
      c++;
    }
 
    const char* id = c;
    if (!IsObjectIdChar(*c)) return false;
    while (IsObjectIdChar(*c)) {
      c++;
    }
    ids->Add(zone->MakeCopyOfStringN(id, c - id));
 
    while (IsWhitespace(*c)) {
      c++;
    }
    if (*c == ',') c++;
  }
 
  return false;
}

ParseUri()

bool dart::ParseUri	(	const char *	uri,
		ParsedUri *	parsed_uri
	)

Definition at line 193 of file uri.cc.

                                                      {
  Zone* zone = ThreadState::Current()->zone();
 
  // The first ':' separates the scheme from the rest of the uri.  If
  // a ':' occurs after the first '/' it doesn't count.
  size_t scheme_len = strcspn(uri, ":/");
  const char* rest = uri;
  if (uri[scheme_len] == ':') {
    char* scheme = zone->MakeCopyOfStringN(uri, scheme_len);
    StringLower(scheme);
    parsed_uri->scheme = scheme;
    rest = uri + scheme_len + 1;
  } else {
    parsed_uri->scheme = nullptr;
  }
 
  // The first '#' separates the optional fragment
  const char* hash_pos = rest + strcspn(rest, "#");
  if (*hash_pos == '#') {
    // There is a fragment part.
    const char* fragment_start = hash_pos + 1;
    parsed_uri->fragment =
        NormalizeEscapes(fragment_start, strlen(fragment_start));
  } else {
    parsed_uri->fragment = nullptr;
  }
 
  // The first '?' or '#' separates the hierarchical part from the
  // optional query.
  const char* question_pos = rest + strcspn(rest, "?#");
  if (*question_pos == '?') {
    // There is a query part.
    const char* query_start = question_pos + 1;
    parsed_uri->query = NormalizeEscapes(query_start, (hash_pos - query_start));
  } else {
    parsed_uri->query = nullptr;
  }
 
  const char* path_start = rest;
  if (rest[0] == '/' && rest[1] == '/') {
    // There is an authority part.
    const char* authority_start = rest + 2;  // 2 for '//'.
 
    intptr_t authority_len = ParseAuthority(authority_start, parsed_uri);
    if (authority_len < 0) {
      ClearParsedUri(parsed_uri);
      return false;
    }
    path_start = authority_start + authority_len;
  } else {
    parsed_uri->userinfo = nullptr;
    parsed_uri->host = nullptr;
    parsed_uri->port = nullptr;
  }
 
  // The path is the substring between the authority and the query.
  parsed_uri->path = NormalizeEscapes(path_start, (question_pos - path_start));
  return true;
}

PassAsHandle()

intptr_t dart::PassAsHandle

(

Dart_Handle

handle

)

Definition at line 1145 of file ffi_test_functions_vmspecific.cc.

                                          {
  intptr_t result = 0;
  ENSURE(!Dart_IsError(Dart_GetNativeInstanceField(handle, 0, &result)));
  return result;
}

PassAsPointer()

intptr_t dart::PassAsPointer

(

void *

ptr

)

Definition at line 1151 of file ffi_test_functions_vmspecific.cc.

                                  {
  return reinterpret_cast<intptr_t>(ptr);
}

PassAsPointerAndValue()

intptr_t dart::PassAsPointerAndValue	(	void *	ptr,
		intptr_t	value
	)

Definition at line 1155 of file ffi_test_functions_vmspecific.cc.

                                                          {
  return value;
}

PassAsValueAndPointer()

intptr_t dart::PassAsValueAndPointer	(	intptr_t	value,
		void *	ptr
	)

Definition at line 1159 of file ffi_test_functions_vmspecific.cc.

                                                          {
  return value;
}

PassDoublex6Struct16BytesMixedx4Int32()

DART_EXPORT double dart::PassDoublex6Struct16BytesMixedx4Int32	(	double	a0,
		double	a1,
		double	a2,
		double	a3,
		double	a4,
		double	a5,
		Struct16BytesMixed	a6,
		Struct16BytesMixed	a7,
		Struct16BytesMixed	a8,
		Struct16BytesMixed	a9,
		int32_t	a10
	)

Definition at line 2488 of file ffi_test_functions_generated.cc.

                                                                      {
  std::cout << "PassDoublex6Struct16BytesMixedx4Int32" << "(" << a0 << ", "
            << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", " << a5
            << ", (" << a6.a0 << ", " << a6.a1 << "), (" << a7.a0 << ", "
            << a7.a1 << "), (" << a8.a0 << ", " << a8.a1 << "), (" << a9.a0
            << ", " << a9.a1 << "), " << a10 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
  result += a5;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8.a0;
  result += a8.a1;
  result += a9.a0;
  result += a9.a1;
  result += a10;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassFloatStruct16BytesHomogeneousFloatFloatStruct1()

DART_EXPORT float dart::PassFloatStruct16BytesHomogeneousFloatFloatStruct1	(	float	a0,
		Struct16BytesHomogeneousFloat	a1,
		float	a2,
		Struct16BytesHomogeneousFloat	a3,
		float	a4,
		Struct16BytesHomogeneousFloat	a5,
		float	a6,
		Struct16BytesHomogeneousFloat	a7,
		float	a8
	)

Definition at line 2344 of file ffi_test_functions_generated.cc.

              {
  std::cout << "PassFloatStruct16BytesHomogeneousFloatFloatStruct1" << "(" << a0
            << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", " << a1.a3
            << "), " << a2 << ", (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2
            << ", " << a3.a3 << "), " << a4 << ", (" << a5.a0 << ", " << a5.a1
            << ", " << a5.a2 << ", " << a5.a3 << "), " << a6 << ", (" << a7.a0
            << ", " << a7.a1 << ", " << a7.a2 << ", " << a7.a3 << "), " << a8
            << ")" << "\n";
 
  float result = 0;
 
  result += a0;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a4;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a5.a3;
  result += a6;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a7.a3;
  result += a8;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassFloatStruct32BytesHomogeneousDoubleFloatStruct()

DART_EXPORT double dart::PassFloatStruct32BytesHomogeneousDoubleFloatStruct	(	float	a0,
		Struct32BytesHomogeneousDouble	a1,
		float	a2,
		Struct32BytesHomogeneousDouble	a3,
		float	a4,
		Struct32BytesHomogeneousDouble	a5,
		float	a6,
		Struct32BytesHomogeneousDouble	a7,
		float	a8
	)

Definition at line 2393 of file ffi_test_functions_generated.cc.

              {
  std::cout << "PassFloatStruct32BytesHomogeneousDoubleFloatStruct" << "(" << a0
            << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", " << a1.a3
            << "), " << a2 << ", (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2
            << ", " << a3.a3 << "), " << a4 << ", (" << a5.a0 << ", " << a5.a1
            << ", " << a5.a2 << ", " << a5.a3 << "), " << a6 << ", (" << a7.a0
            << ", " << a7.a1 << ", " << a7.a2 << ", " << a7.a3 << "), " << a8
            << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a4;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a5.a3;
  result += a6;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a7.a3;
  result += a8;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassInt32x4Struct16BytesMixedx4Double()

DART_EXPORT double dart::PassInt32x4Struct16BytesMixedx4Double	(	int32_t	a0,
		int32_t	a1,
		int32_t	a2,
		int32_t	a3,
		Struct16BytesMixed	a4,
		Struct16BytesMixed	a5,
		Struct16BytesMixed	a6,
		Struct16BytesMixed	a7,
		double	a8
	)

Definition at line 2532 of file ffi_test_functions_generated.cc.

                                                                    {
  std::cout << "PassInt32x4Struct16BytesMixedx4Double" << "(" << a0 << ", "
            << a1 << ", " << a2 << ", " << a3 << ", (" << a4.a0 << ", " << a4.a1
            << "), (" << a5.a0 << ", " << a5.a1 << "), (" << a6.a0 << ", "
            << a6.a1 << "), (" << a7.a0 << ", " << a7.a1 << "), " << a8 << ")"
            << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4.a0;
  result += a4.a1;
  result += a5.a0;
  result += a5.a1;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int()

DART_EXPORT double dart::PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int	(	int32_t	a0,
		int32_t	a1,
		int32_t	a2,
		int32_t	a3,
		int32_t	a4,
		int32_t	a5,
		int32_t	a6,
		int32_t	a7,
		double	a8,
		double	a9,
		double	a10,
		double	a11,
		double	a12,
		double	a13,
		double	a14,
		double	a15,
		int64_t	a16,
		int8_t	a17,
		Struct1ByteInt	a18,
		int64_t	a19,
		int8_t	a20,
		Struct4BytesHomogeneousInt16	a21,
		int64_t	a22,
		int8_t	a23,
		Struct8BytesInt	a24,
		int64_t	a25,
		int8_t	a26,
		Struct8BytesHomogeneousFloat	a27,
		int64_t	a28,
		int8_t	a29,
		Struct8BytesMixed	a30,
		int64_t	a31,
		int8_t	a32,
		StructAlignmentInt16	a33,
		int64_t	a34,
		int8_t	a35,
		StructAlignmentInt32	a36,
		int64_t	a37,
		int8_t	a38,
		StructAlignmentInt64	a39
	)

Definition at line 2599 of file ffi_test_functions_generated.cc.

                              {
  std::cout << "PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", "
            << a5 << ", " << a6 << ", " << a7 << ", " << a8 << ", " << a9
            << ", " << a10 << ", " << a11 << ", " << a12 << ", " << a13 << ", "
            << a14 << ", " << a15 << ", " << a16 << ", "
            << static_cast<int>(a17) << ", (" << static_cast<int>(a18.a0)
            << "), " << a19 << ", " << static_cast<int>(a20) << ", (" << a21.a0
            << ", " << a21.a1 << "), " << a22 << ", " << static_cast<int>(a23)
            << ", (" << a24.a0 << ", " << a24.a1 << ", " << a24.a2 << "), "
            << a25 << ", " << static_cast<int>(a26) << ", (" << a27.a0 << ", "
            << a27.a1 << "), " << a28 << ", " << static_cast<int>(a29) << ", ("
            << a30.a0 << ", " << a30.a1 << ", " << a30.a2 << "), " << a31
            << ", " << static_cast<int>(a32) << ", ("
            << static_cast<int>(a33.a0) << ", " << a33.a1 << ", "
            << static_cast<int>(a33.a2) << "), " << a34 << ", "
            << static_cast<int>(a35) << ", (" << static_cast<int>(a36.a0)
            << ", " << a36.a1 << ", " << static_cast<int>(a36.a2) << "), "
            << a37 << ", " << static_cast<int>(a38) << ", ("
            << static_cast<int>(a39.a0) << ", " << a39.a1 << ", "
            << static_cast<int>(a39.a2) << "))" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
  result += a5;
  result += a6;
  result += a7;
  result += a8;
  result += a9;
  result += a10;
  result += a11;
  result += a12;
  result += a13;
  result += a14;
  result += a15;
  result += a16;
  result += a17;
  result += a18.a0;
  result += a19;
  result += a20;
  result += a21.a0;
  result += a21.a1;
  result += a22;
  result += a23;
  result += a24.a0;
  result += a24.a1;
  result += a24.a2;
  result += a25;
  result += a26;
  result += a27.a0;
  result += a27.a1;
  result += a28;
  result += a29;
  result += a30.a0;
  result += a30.a1;
  result += a30.a2;
  result += a31;
  result += a32;
  result += a33.a0;
  result += a33.a1;
  result += a33.a2;
  result += a34;
  result += a35;
  result += a36.a0;
  result += a36.a1;
  result += a36.a2;
  result += a37;
  result += a38;
  result += a39.a0;
  result += a39.a1;
  result += a39.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassInt64x7Struct12BytesHomogeneousInt32()

DART_EXPORT int64_t dart::PassInt64x7Struct12BytesHomogeneousInt32	(	int64_t	a0,
		int64_t	a1,
		int64_t	a2,
		int64_t	a3,
		int64_t	a4,
		int64_t	a5,
		int64_t	a6,
		Struct12BytesHomogeneousInt32	a7
	)

Definition at line 4767 of file ffi_test_functions_generated.cc.

                                                                           {
  std::cout << "PassInt64x7Struct12BytesHomogeneousInt32" << "(" << a0 << ", "
            << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", " << a5
            << ", " << a6 << ", (" << a7.a0 << ", " << a7.a1 << ", " << a7.a2
            << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
  result += a5;
  result += a6;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassInt8Struct16BytesMixedInt8Struct16BytesMixedIn()

DART_EXPORT double dart::PassInt8Struct16BytesMixedInt8Struct16BytesMixedIn	(	int8_t	a0,
		Struct16BytesMixed	a1,
		int8_t	a2,
		Struct16BytesMixed	a3,
		int8_t	a4,
		Struct16BytesMixed	a5,
		int8_t	a6,
		Struct16BytesMixed	a7,
		int8_t	a8
	)

Definition at line 2446 of file ffi_test_functions_generated.cc.

               {
  std::cout << "PassInt8Struct16BytesMixedInt8Struct16BytesMixedIn" << "("
            << static_cast<int>(a0) << ", (" << a1.a0 << ", " << a1.a1 << "), "
            << static_cast<int>(a2) << ", (" << a3.a0 << ", " << a3.a1 << "), "
            << static_cast<int>(a4) << ", (" << a5.a0 << ", " << a5.a1 << "), "
            << static_cast<int>(a6) << ", (" << a7.a0 << ", " << a7.a1 << "), "
            << static_cast<int>(a8) << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1.a0;
  result += a1.a1;
  result += a2;
  result += a3.a0;
  result += a3.a1;
  result += a4;
  result += a5.a0;
  result += a5.a1;
  result += a6;
  result += a7.a0;
  result += a7.a1;
  result += a8;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassObjectToC()

DART_EXPORT Dart_Handle dart::PassObjectToC

(

Dart_Handle

h

)

Definition at line 954 of file ffi_test_functions_vmspecific.cc.

                                                     {
  // Can use "h" until this function returns.
 
  // A persistent handle which outlives this call. Lifetime managed in C.
  auto persistent_handle = Dart_NewPersistentHandle(h);
 
  Dart_Handle handle_2 = Dart_HandleFromPersistent(persistent_handle);
  Dart_DeletePersistentHandle(persistent_handle);
  if (Dart_IsError(handle_2)) {
    Dart_PropagateError(handle_2);
  }
 
  Dart_Handle return_value;
  if (!Dart_IsNull(h) && !Dart_IsInteger(h)) {
    // A weak handle which outlives this call. Lifetime managed in C.
    auto weak_handle = Dart_NewWeakPersistentHandle(
        h, reinterpret_cast<void*>(0x1234), 64, RunFinalizer);
    return_value = Dart_HandleFromWeakPersistent(weak_handle);
 
    // Deleting a weak handle is not required, it deletes itself on
    // finalization.
    // Deleting a weak handle cancels the finalizer.
    Dart_DeleteWeakPersistentHandle(weak_handle);
  } else {
    return_value = h;
  }
 
  return return_value;
}

PassObjectToCUseDynamicLinking()

DART_EXPORT Dart_Handle dart::PassObjectToCUseDynamicLinking

(

Dart_Handle

h

)

Definition at line 1082 of file ffi_test_functions_vmspecific.cc.

                                                                      {
  auto persistent_handle = Dart_NewPersistentHandle_DL(h);
 
  Dart_Handle handle_2 = Dart_HandleFromPersistent_DL(persistent_handle);
  Dart_SetPersistentHandle_DL(persistent_handle, h);
  Dart_DeletePersistentHandle_DL(persistent_handle);
 
  auto weak_handle = Dart_NewWeakPersistentHandle_DL(
      handle_2, reinterpret_cast<void*>(0x1234), 64, RunFinalizer);
  Dart_Handle return_value = Dart_HandleFromWeakPersistent_DL(weak_handle);
 
  Dart_DeleteWeakPersistentHandle_DL(weak_handle);
 
  return return_value;
}

PassStruct()

DART_EXPORT int32_t dart::PassStruct

(

void *

)

Definition at line 1186 of file ffi_test_functions.cc.

                                      {
  return 42;
}

PassStruct1024BytesHomogeneousUint64()

DART_EXPORT uint64_t dart::PassStruct1024BytesHomogeneousUint64

(

Struct1024BytesHomogeneousUint64

a0

)

Definition at line 2166 of file ffi_test_functions_generated.cc.

                                                                          {
  std::cout << "PassStruct1024BytesHomogeneousUint64" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", " << a0.a4 << ", "
            << a0.a5 << ", " << a0.a6 << ", " << a0.a7 << ", " << a0.a8 << ", "
            << a0.a9 << ", " << a0.a10 << ", " << a0.a11 << ", " << a0.a12
            << ", " << a0.a13 << ", " << a0.a14 << ", " << a0.a15 << ", "
            << a0.a16 << ", " << a0.a17 << ", " << a0.a18 << ", " << a0.a19
            << ", " << a0.a20 << ", " << a0.a21 << ", " << a0.a22 << ", "
            << a0.a23 << ", " << a0.a24 << ", " << a0.a25 << ", " << a0.a26
            << ", " << a0.a27 << ", " << a0.a28 << ", " << a0.a29 << ", "
            << a0.a30 << ", " << a0.a31 << ", " << a0.a32 << ", " << a0.a33
            << ", " << a0.a34 << ", " << a0.a35 << ", " << a0.a36 << ", "
            << a0.a37 << ", " << a0.a38 << ", " << a0.a39 << ", " << a0.a40
            << ", " << a0.a41 << ", " << a0.a42 << ", " << a0.a43 << ", "
            << a0.a44 << ", " << a0.a45 << ", " << a0.a46 << ", " << a0.a47
            << ", " << a0.a48 << ", " << a0.a49 << ", " << a0.a50 << ", "
            << a0.a51 << ", " << a0.a52 << ", " << a0.a53 << ", " << a0.a54
            << ", " << a0.a55 << ", " << a0.a56 << ", " << a0.a57 << ", "
            << a0.a58 << ", " << a0.a59 << ", " << a0.a60 << ", " << a0.a61
            << ", " << a0.a62 << ", " << a0.a63 << ", " << a0.a64 << ", "
            << a0.a65 << ", " << a0.a66 << ", " << a0.a67 << ", " << a0.a68
            << ", " << a0.a69 << ", " << a0.a70 << ", " << a0.a71 << ", "
            << a0.a72 << ", " << a0.a73 << ", " << a0.a74 << ", " << a0.a75
            << ", " << a0.a76 << ", " << a0.a77 << ", " << a0.a78 << ", "
            << a0.a79 << ", " << a0.a80 << ", " << a0.a81 << ", " << a0.a82
            << ", " << a0.a83 << ", " << a0.a84 << ", " << a0.a85 << ", "
            << a0.a86 << ", " << a0.a87 << ", " << a0.a88 << ", " << a0.a89
            << ", " << a0.a90 << ", " << a0.a91 << ", " << a0.a92 << ", "
            << a0.a93 << ", " << a0.a94 << ", " << a0.a95 << ", " << a0.a96
            << ", " << a0.a97 << ", " << a0.a98 << ", " << a0.a99 << ", "
            << a0.a100 << ", " << a0.a101 << ", " << a0.a102 << ", " << a0.a103
            << ", " << a0.a104 << ", " << a0.a105 << ", " << a0.a106 << ", "
            << a0.a107 << ", " << a0.a108 << ", " << a0.a109 << ", " << a0.a110
            << ", " << a0.a111 << ", " << a0.a112 << ", " << a0.a113 << ", "
            << a0.a114 << ", " << a0.a115 << ", " << a0.a116 << ", " << a0.a117
            << ", " << a0.a118 << ", " << a0.a119 << ", " << a0.a120 << ", "
            << a0.a121 << ", " << a0.a122 << ", " << a0.a123 << ", " << a0.a124
            << ", " << a0.a125 << ", " << a0.a126 << ", " << a0.a127 << "))"
            << "\n";
 
  uint64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
  result += a0.a5;
  result += a0.a6;
  result += a0.a7;
  result += a0.a8;
  result += a0.a9;
  result += a0.a10;
  result += a0.a11;
  result += a0.a12;
  result += a0.a13;
  result += a0.a14;
  result += a0.a15;
  result += a0.a16;
  result += a0.a17;
  result += a0.a18;
  result += a0.a19;
  result += a0.a20;
  result += a0.a21;
  result += a0.a22;
  result += a0.a23;
  result += a0.a24;
  result += a0.a25;
  result += a0.a26;
  result += a0.a27;
  result += a0.a28;
  result += a0.a29;
  result += a0.a30;
  result += a0.a31;
  result += a0.a32;
  result += a0.a33;
  result += a0.a34;
  result += a0.a35;
  result += a0.a36;
  result += a0.a37;
  result += a0.a38;
  result += a0.a39;
  result += a0.a40;
  result += a0.a41;
  result += a0.a42;
  result += a0.a43;
  result += a0.a44;
  result += a0.a45;
  result += a0.a46;
  result += a0.a47;
  result += a0.a48;
  result += a0.a49;
  result += a0.a50;
  result += a0.a51;
  result += a0.a52;
  result += a0.a53;
  result += a0.a54;
  result += a0.a55;
  result += a0.a56;
  result += a0.a57;
  result += a0.a58;
  result += a0.a59;
  result += a0.a60;
  result += a0.a61;
  result += a0.a62;
  result += a0.a63;
  result += a0.a64;
  result += a0.a65;
  result += a0.a66;
  result += a0.a67;
  result += a0.a68;
  result += a0.a69;
  result += a0.a70;
  result += a0.a71;
  result += a0.a72;
  result += a0.a73;
  result += a0.a74;
  result += a0.a75;
  result += a0.a76;
  result += a0.a77;
  result += a0.a78;
  result += a0.a79;
  result += a0.a80;
  result += a0.a81;
  result += a0.a82;
  result += a0.a83;
  result += a0.a84;
  result += a0.a85;
  result += a0.a86;
  result += a0.a87;
  result += a0.a88;
  result += a0.a89;
  result += a0.a90;
  result += a0.a91;
  result += a0.a92;
  result += a0.a93;
  result += a0.a94;
  result += a0.a95;
  result += a0.a96;
  result += a0.a97;
  result += a0.a98;
  result += a0.a99;
  result += a0.a100;
  result += a0.a101;
  result += a0.a102;
  result += a0.a103;
  result += a0.a104;
  result += a0.a105;
  result += a0.a106;
  result += a0.a107;
  result += a0.a108;
  result += a0.a109;
  result += a0.a110;
  result += a0.a111;
  result += a0.a112;
  result += a0.a113;
  result += a0.a114;
  result += a0.a115;
  result += a0.a116;
  result += a0.a117;
  result += a0.a118;
  result += a0.a119;
  result += a0.a120;
  result += a0.a121;
  result += a0.a122;
  result += a0.a123;
  result += a0.a124;
  result += a0.a125;
  result += a0.a126;
  result += a0.a127;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct12BytesHomogeneousFloatx6()

DART_EXPORT float dart::PassStruct12BytesHomogeneousFloatx6	(	Struct12BytesHomogeneousFloat	a0,
		Struct12BytesHomogeneousFloat	a1,
		Struct12BytesHomogeneousFloat	a2,
		Struct12BytesHomogeneousFloat	a3,
		Struct12BytesHomogeneousFloat	a4,
		Struct12BytesHomogeneousFloat	a5
	)

Definition at line 1396 of file ffi_test_functions_generated.cc.

                                      {
  std::cout << "PassStruct12BytesHomogeneousFloatx6" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << "), (" << a1.a0 << ", " << a1.a1
            << ", " << a1.a2 << "), (" << a2.a0 << ", " << a2.a1 << ", "
            << a2.a2 << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2
            << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2 << "), ("
            << a5.a0 << ", " << a5.a1 << ", " << a5.a2 << "))" << "\n";
 
  float result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct15BytesInlineArrayMixed()

DART_EXPORT double dart::PassStruct15BytesInlineArrayMixed

(

Struct15BytesInlineArrayMixed

a0

)

Definition at line 4321 of file ffi_test_functions_generated.cc.

                                      {
  std::cout << "PassStruct15BytesInlineArrayMixed" << "(([(" << a0.a0[0].a0
            << ", " << static_cast<int>(a0.a0[0].a1) << "), (" << a0.a0[1].a0
            << ", " << static_cast<int>(a0.a0[1].a1) << "), (" << a0.a0[2].a0
            << ", " << static_cast<int>(a0.a0[2].a1) << ")]))" << "\n";
 
  double result = 0;
 
  result += a0.a0[0].a0;
  result += a0.a0[0].a1;
  result += a0.a0[1].a0;
  result += a0.a0[1].a1;
  result += a0.a0[2].a0;
  result += a0.a0[2].a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct16BytesHomogeneousFloatx5()

DART_EXPORT float dart::PassStruct16BytesHomogeneousFloatx5	(	Struct16BytesHomogeneousFloat	a0,
		Struct16BytesHomogeneousFloat	a1,
		Struct16BytesHomogeneousFloat	a2,
		Struct16BytesHomogeneousFloat	a3,
		Struct16BytesHomogeneousFloat	a4
	)

Definition at line 1440 of file ffi_test_functions_generated.cc.

                                      {
  std::cout << "PassStruct16BytesHomogeneousFloatx5" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << "), (" << a1.a0
            << ", " << a1.a1 << ", " << a1.a2 << ", " << a1.a3 << "), ("
            << a2.a0 << ", " << a2.a1 << ", " << a2.a2 << ", " << a2.a3
            << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2 << ", "
            << a3.a3 << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2
            << ", " << a4.a3 << "))" << "\n";
 
  float result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a4.a3;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct16BytesMixed2x10()

DART_EXPORT float dart::PassStruct16BytesMixed2x10	(	Struct16BytesMixed2	a0,
		Struct16BytesMixed2	a1,
		Struct16BytesMixed2	a2,
		Struct16BytesMixed2	a3,
		Struct16BytesMixed2	a4,
		Struct16BytesMixed2	a5,
		Struct16BytesMixed2	a6,
		Struct16BytesMixed2	a7,
		Struct16BytesMixed2	a8,
		Struct16BytesMixed2	a9
	)

Definition at line 1538 of file ffi_test_functions_generated.cc.

                                                                     {
  std::cout << "PassStruct16BytesMixed2x10" << "((" << a0.a0 << ", " << a0.a1
            << ", " << a0.a2 << ", " << a0.a3 << "), (" << a1.a0 << ", "
            << a1.a1 << ", " << a1.a2 << ", " << a1.a3 << "), (" << a2.a0
            << ", " << a2.a1 << ", " << a2.a2 << ", " << a2.a3 << "), ("
            << a3.a0 << ", " << a3.a1 << ", " << a3.a2 << ", " << a3.a3
            << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2 << ", "
            << a4.a3 << "), (" << a5.a0 << ", " << a5.a1 << ", " << a5.a2
            << ", " << a5.a3 << "), (" << a6.a0 << ", " << a6.a1 << ", "
            << a6.a2 << ", " << a6.a3 << "), (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << ", " << a7.a3 << "), (" << a8.a0 << ", "
            << a8.a1 << ", " << a8.a2 << ", " << a8.a3 << "), (" << a9.a0
            << ", " << a9.a1 << ", " << a9.a2 << ", " << a9.a3 << "))" << "\n";
 
  float result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a4.a3;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a5.a3;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a6.a3;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a7.a3;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a8.a3;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
  result += a9.a3;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct16BytesMixedx10()

DART_EXPORT double dart::PassStruct16BytesMixedx10	(	Struct16BytesMixed	a0,
		Struct16BytesMixed	a1,
		Struct16BytesMixed	a2,
		Struct16BytesMixed	a3,
		Struct16BytesMixed	a4,
		Struct16BytesMixed	a5,
		Struct16BytesMixed	a6,
		Struct16BytesMixed	a7,
		Struct16BytesMixed	a8,
		Struct16BytesMixed	a9
	)

Definition at line 1487 of file ffi_test_functions_generated.cc.

                                                                    {
  std::cout << "PassStruct16BytesMixedx10" << "((" << a0.a0 << ", " << a0.a1
            << "), (" << a1.a0 << ", " << a1.a1 << "), (" << a2.a0 << ", "
            << a2.a1 << "), (" << a3.a0 << ", " << a3.a1 << "), (" << a4.a0
            << ", " << a4.a1 << "), (" << a5.a0 << ", " << a5.a1 << "), ("
            << a6.a0 << ", " << a6.a1 << "), (" << a7.a0 << ", " << a7.a1
            << "), (" << a8.a0 << ", " << a8.a1 << "), (" << a9.a0 << ", "
            << a9.a1 << "))" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a1.a0;
  result += a1.a1;
  result += a2.a0;
  result += a2.a1;
  result += a3.a0;
  result += a3.a1;
  result += a4.a0;
  result += a4.a1;
  result += a5.a0;
  result += a5.a1;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8.a0;
  result += a8.a1;
  result += a9.a0;
  result += a9.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct16BytesNestedIntx2()

DART_EXPORT int64_t dart::PassStruct16BytesNestedIntx2	(	Struct16BytesNestedInt	a0,
		Struct16BytesNestedInt	a1
	)

Definition at line 3017 of file ffi_test_functions_generated.cc.

                                                                            {
  std::cout << "PassStruct16BytesNestedIntx2" << "((((" << a0.a0.a0.a0 << ", "
            << a0.a0.a0.a1 << "), (" << a0.a0.a1.a0 << ", " << a0.a0.a1.a1
            << ")), ((" << a0.a1.a0.a0 << ", " << a0.a1.a0.a1 << "), ("
            << a0.a1.a1.a0 << ", " << a0.a1.a1.a1 << "))), (((" << a1.a0.a0.a0
            << ", " << a1.a0.a0.a1 << "), (" << a1.a0.a1.a0 << ", "
            << a1.a0.a1.a1 << ")), ((" << a1.a1.a0.a0 << ", " << a1.a1.a0.a1
            << "), (" << a1.a1.a1.a0 << ", " << a1.a1.a1.a1 << "))))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0.a0.a0;
  result += a0.a0.a0.a1;
  result += a0.a0.a1.a0;
  result += a0.a0.a1.a1;
  result += a0.a1.a0.a0;
  result += a0.a1.a0.a1;
  result += a0.a1.a1.a0;
  result += a0.a1.a1.a1;
  result += a1.a0.a0.a0;
  result += a1.a0.a0.a1;
  result += a1.a0.a1.a0;
  result += a1.a0.a1.a1;
  result += a1.a1.a0.a0;
  result += a1.a1.a0.a1;
  result += a1.a1.a1.a0;
  result += a1.a1.a1.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct17BytesIntx10()

DART_EXPORT int64_t dart::PassStruct17BytesIntx10	(	Struct17BytesInt	a0,
		Struct17BytesInt	a1,
		Struct17BytesInt	a2,
		Struct17BytesInt	a3,
		Struct17BytesInt	a4,
		Struct17BytesInt	a5,
		Struct17BytesInt	a6,
		Struct17BytesInt	a7,
		Struct17BytesInt	a8,
		Struct17BytesInt	a9
	)

Definition at line 1612 of file ffi_test_functions_generated.cc.

                                                                 {
  std::cout << "PassStruct17BytesIntx10" << "((" << a0.a0 << ", " << a0.a1
            << ", " << static_cast<int>(a0.a2) << "), (" << a1.a0 << ", "
            << a1.a1 << ", " << static_cast<int>(a1.a2) << "), (" << a2.a0
            << ", " << a2.a1 << ", " << static_cast<int>(a2.a2) << "), ("
            << a3.a0 << ", " << a3.a1 << ", " << static_cast<int>(a3.a2)
            << "), (" << a4.a0 << ", " << a4.a1 << ", "
            << static_cast<int>(a4.a2) << "), (" << a5.a0 << ", " << a5.a1
            << ", " << static_cast<int>(a5.a2) << "), (" << a6.a0 << ", "
            << a6.a1 << ", " << static_cast<int>(a6.a2) << "), (" << a7.a0
            << ", " << a7.a1 << ", " << static_cast<int>(a7.a2) << "), ("
            << a8.a0 << ", " << a8.a1 << ", " << static_cast<int>(a8.a2)
            << "), (" << a9.a0 << ", " << a9.a1 << ", "
            << static_cast<int>(a9.a2) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct19BytesHomogeneousUint8x10()

DART_EXPORT int64_t dart::PassStruct19BytesHomogeneousUint8x10	(	Struct19BytesHomogeneousUint8	a0,
		Struct19BytesHomogeneousUint8	a1,
		Struct19BytesHomogeneousUint8	a2,
		Struct19BytesHomogeneousUint8	a3,
		Struct19BytesHomogeneousUint8	a4,
		Struct19BytesHomogeneousUint8	a5,
		Struct19BytesHomogeneousUint8	a6,
		Struct19BytesHomogeneousUint8	a7,
		Struct19BytesHomogeneousUint8	a8,
		Struct19BytesHomogeneousUint8	a9
	)

Definition at line 1679 of file ffi_test_functions_generated.cc.

                                                                       {
  std::cout
      << "PassStruct19BytesHomogeneousUint8x10" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << ", " << static_cast<int>(a0.a7) << ", "
      << static_cast<int>(a0.a8) << ", " << static_cast<int>(a0.a9) << ", "
      << static_cast<int>(a0.a10) << ", " << static_cast<int>(a0.a11) << ", "
      << static_cast<int>(a0.a12) << ", " << static_cast<int>(a0.a13) << ", "
      << static_cast<int>(a0.a14) << ", " << static_cast<int>(a0.a15) << ", "
      << static_cast<int>(a0.a16) << ", " << static_cast<int>(a0.a17) << ", "
      << static_cast<int>(a0.a18) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << ", "
      << static_cast<int>(a1.a7) << ", " << static_cast<int>(a1.a8) << ", "
      << static_cast<int>(a1.a9) << ", " << static_cast<int>(a1.a10) << ", "
      << static_cast<int>(a1.a11) << ", " << static_cast<int>(a1.a12) << ", "
      << static_cast<int>(a1.a13) << ", " << static_cast<int>(a1.a14) << ", "
      << static_cast<int>(a1.a15) << ", " << static_cast<int>(a1.a16) << ", "
      << static_cast<int>(a1.a17) << ", " << static_cast<int>(a1.a18) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << ", " << static_cast<int>(a2.a7) << ", "
      << static_cast<int>(a2.a8) << ", " << static_cast<int>(a2.a9) << ", "
      << static_cast<int>(a2.a10) << ", " << static_cast<int>(a2.a11) << ", "
      << static_cast<int>(a2.a12) << ", " << static_cast<int>(a2.a13) << ", "
      << static_cast<int>(a2.a14) << ", " << static_cast<int>(a2.a15) << ", "
      << static_cast<int>(a2.a16) << ", " << static_cast<int>(a2.a17) << ", "
      << static_cast<int>(a2.a18) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << ", "
      << static_cast<int>(a3.a7) << ", " << static_cast<int>(a3.a8) << ", "
      << static_cast<int>(a3.a9) << ", " << static_cast<int>(a3.a10) << ", "
      << static_cast<int>(a3.a11) << ", " << static_cast<int>(a3.a12) << ", "
      << static_cast<int>(a3.a13) << ", " << static_cast<int>(a3.a14) << ", "
      << static_cast<int>(a3.a15) << ", " << static_cast<int>(a3.a16) << ", "
      << static_cast<int>(a3.a17) << ", " << static_cast<int>(a3.a18) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << ", " << static_cast<int>(a4.a7) << ", "
      << static_cast<int>(a4.a8) << ", " << static_cast<int>(a4.a9) << ", "
      << static_cast<int>(a4.a10) << ", " << static_cast<int>(a4.a11) << ", "
      << static_cast<int>(a4.a12) << ", " << static_cast<int>(a4.a13) << ", "
      << static_cast<int>(a4.a14) << ", " << static_cast<int>(a4.a15) << ", "
      << static_cast<int>(a4.a16) << ", " << static_cast<int>(a4.a17) << ", "
      << static_cast<int>(a4.a18) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << ", "
      << static_cast<int>(a5.a7) << ", " << static_cast<int>(a5.a8) << ", "
      << static_cast<int>(a5.a9) << ", " << static_cast<int>(a5.a10) << ", "
      << static_cast<int>(a5.a11) << ", " << static_cast<int>(a5.a12) << ", "
      << static_cast<int>(a5.a13) << ", " << static_cast<int>(a5.a14) << ", "
      << static_cast<int>(a5.a15) << ", " << static_cast<int>(a5.a16) << ", "
      << static_cast<int>(a5.a17) << ", " << static_cast<int>(a5.a18) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << ", " << static_cast<int>(a6.a7) << ", "
      << static_cast<int>(a6.a8) << ", " << static_cast<int>(a6.a9) << ", "
      << static_cast<int>(a6.a10) << ", " << static_cast<int>(a6.a11) << ", "
      << static_cast<int>(a6.a12) << ", " << static_cast<int>(a6.a13) << ", "
      << static_cast<int>(a6.a14) << ", " << static_cast<int>(a6.a15) << ", "
      << static_cast<int>(a6.a16) << ", " << static_cast<int>(a6.a17) << ", "
      << static_cast<int>(a6.a18) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << ", "
      << static_cast<int>(a7.a7) << ", " << static_cast<int>(a7.a8) << ", "
      << static_cast<int>(a7.a9) << ", " << static_cast<int>(a7.a10) << ", "
      << static_cast<int>(a7.a11) << ", " << static_cast<int>(a7.a12) << ", "
      << static_cast<int>(a7.a13) << ", " << static_cast<int>(a7.a14) << ", "
      << static_cast<int>(a7.a15) << ", " << static_cast<int>(a7.a16) << ", "
      << static_cast<int>(a7.a17) << ", " << static_cast<int>(a7.a18) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << ", " << static_cast<int>(a8.a7) << ", "
      << static_cast<int>(a8.a8) << ", " << static_cast<int>(a8.a9) << ", "
      << static_cast<int>(a8.a10) << ", " << static_cast<int>(a8.a11) << ", "
      << static_cast<int>(a8.a12) << ", " << static_cast<int>(a8.a13) << ", "
      << static_cast<int>(a8.a14) << ", " << static_cast<int>(a8.a15) << ", "
      << static_cast<int>(a8.a16) << ", " << static_cast<int>(a8.a17) << ", "
      << static_cast<int>(a8.a18) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << ", "
      << static_cast<int>(a9.a7) << ", " << static_cast<int>(a9.a8) << ", "
      << static_cast<int>(a9.a9) << ", " << static_cast<int>(a9.a10) << ", "
      << static_cast<int>(a9.a11) << ", " << static_cast<int>(a9.a12) << ", "
      << static_cast<int>(a9.a13) << ", " << static_cast<int>(a9.a14) << ", "
      << static_cast<int>(a9.a15) << ", " << static_cast<int>(a9.a16) << ", "
      << static_cast<int>(a9.a17) << ", " << static_cast<int>(a9.a18) << "))"
      << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
  result += a0.a5;
  result += a0.a6;
  result += a0.a7;
  result += a0.a8;
  result += a0.a9;
  result += a0.a10;
  result += a0.a11;
  result += a0.a12;
  result += a0.a13;
  result += a0.a14;
  result += a0.a15;
  result += a0.a16;
  result += a0.a17;
  result += a0.a18;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a1.a4;
  result += a1.a5;
  result += a1.a6;
  result += a1.a7;
  result += a1.a8;
  result += a1.a9;
  result += a1.a10;
  result += a1.a11;
  result += a1.a12;
  result += a1.a13;
  result += a1.a14;
  result += a1.a15;
  result += a1.a16;
  result += a1.a17;
  result += a1.a18;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a2.a4;
  result += a2.a5;
  result += a2.a6;
  result += a2.a7;
  result += a2.a8;
  result += a2.a9;
  result += a2.a10;
  result += a2.a11;
  result += a2.a12;
  result += a2.a13;
  result += a2.a14;
  result += a2.a15;
  result += a2.a16;
  result += a2.a17;
  result += a2.a18;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a3.a4;
  result += a3.a5;
  result += a3.a6;
  result += a3.a7;
  result += a3.a8;
  result += a3.a9;
  result += a3.a10;
  result += a3.a11;
  result += a3.a12;
  result += a3.a13;
  result += a3.a14;
  result += a3.a15;
  result += a3.a16;
  result += a3.a17;
  result += a3.a18;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a4.a3;
  result += a4.a4;
  result += a4.a5;
  result += a4.a6;
  result += a4.a7;
  result += a4.a8;
  result += a4.a9;
  result += a4.a10;
  result += a4.a11;
  result += a4.a12;
  result += a4.a13;
  result += a4.a14;
  result += a4.a15;
  result += a4.a16;
  result += a4.a17;
  result += a4.a18;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a5.a3;
  result += a5.a4;
  result += a5.a5;
  result += a5.a6;
  result += a5.a7;
  result += a5.a8;
  result += a5.a9;
  result += a5.a10;
  result += a5.a11;
  result += a5.a12;
  result += a5.a13;
  result += a5.a14;
  result += a5.a15;
  result += a5.a16;
  result += a5.a17;
  result += a5.a18;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a6.a3;
  result += a6.a4;
  result += a6.a5;
  result += a6.a6;
  result += a6.a7;
  result += a6.a8;
  result += a6.a9;
  result += a6.a10;
  result += a6.a11;
  result += a6.a12;
  result += a6.a13;
  result += a6.a14;
  result += a6.a15;
  result += a6.a16;
  result += a6.a17;
  result += a6.a18;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a7.a3;
  result += a7.a4;
  result += a7.a5;
  result += a7.a6;
  result += a7.a7;
  result += a7.a8;
  result += a7.a9;
  result += a7.a10;
  result += a7.a11;
  result += a7.a12;
  result += a7.a13;
  result += a7.a14;
  result += a7.a15;
  result += a7.a16;
  result += a7.a17;
  result += a7.a18;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a8.a3;
  result += a8.a4;
  result += a8.a5;
  result += a8.a6;
  result += a8.a7;
  result += a8.a8;
  result += a8.a9;
  result += a8.a10;
  result += a8.a11;
  result += a8.a12;
  result += a8.a13;
  result += a8.a14;
  result += a8.a15;
  result += a8.a16;
  result += a8.a17;
  result += a8.a18;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
  result += a9.a3;
  result += a9.a4;
  result += a9.a5;
  result += a9.a6;
  result += a9.a7;
  result += a9.a8;
  result += a9.a9;
  result += a9.a10;
  result += a9.a11;
  result += a9.a12;
  result += a9.a13;
  result += a9.a14;
  result += a9.a15;
  result += a9.a16;
  result += a9.a17;
  result += a9.a18;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct1ByteIntx10()

DART_EXPORT int64_t dart::PassStruct1ByteIntx10	(	Struct1ByteInt	a0,
		Struct1ByteInt	a1,
		Struct1ByteInt	a2,
		Struct1ByteInt	a3,
		Struct1ByteInt	a4,
		Struct1ByteInt	a5,
		Struct1ByteInt	a6,
		Struct1ByteInt	a7,
		Struct1ByteInt	a8,
		Struct1ByteInt	a9
	)

Definition at line 584 of file ffi_test_functions_generated.cc.

                                                             {
  std::cout << "PassStruct1ByteIntx10" << "((" << static_cast<int>(a0.a0)
            << "), (" << static_cast<int>(a1.a0) << "), ("
            << static_cast<int>(a2.a0) << "), (" << static_cast<int>(a3.a0)
            << "), (" << static_cast<int>(a4.a0) << "), ("
            << static_cast<int>(a5.a0) << "), (" << static_cast<int>(a6.a0)
            << "), (" << static_cast<int>(a7.a0) << "), ("
            << static_cast<int>(a8.a0) << "), (" << static_cast<int>(a9.a0)
            << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a1.a0;
  result += a2.a0;
  result += a3.a0;
  result += a4.a0;
  result += a5.a0;
  result += a6.a0;
  result += a7.a0;
  result += a8.a0;
  result += a9.a0;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct20BytesHomogeneousFloat()

DART_EXPORT float dart::PassStruct20BytesHomogeneousFloat

(

Struct20BytesHomogeneousFloat

a0

)

Definition at line 2078 of file ffi_test_functions_generated.cc.

                                      {
  std::cout << "PassStruct20BytesHomogeneousFloat" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", " << a0.a4 << "))"
            << "\n";
 
  float result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct20BytesHomogeneousInt32x10()

DART_EXPORT int32_t dart::PassStruct20BytesHomogeneousInt32x10	(	Struct20BytesHomogeneousInt32	a0,
		Struct20BytesHomogeneousInt32	a1,
		Struct20BytesHomogeneousInt32	a2,
		Struct20BytesHomogeneousInt32	a3,
		Struct20BytesHomogeneousInt32	a4,
		Struct20BytesHomogeneousInt32	a5,
		Struct20BytesHomogeneousInt32	a6,
		Struct20BytesHomogeneousInt32	a7,
		Struct20BytesHomogeneousInt32	a8,
		Struct20BytesHomogeneousInt32	a9
	)

Definition at line 1992 of file ffi_test_functions_generated.cc.

                                                                       {
  std::cout << "PassStruct20BytesHomogeneousInt32x10" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", " << a0.a4
            << "), (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", "
            << a1.a3 << ", " << a1.a4 << "), (" << a2.a0 << ", " << a2.a1
            << ", " << a2.a2 << ", " << a2.a3 << ", " << a2.a4 << "), ("
            << a3.a0 << ", " << a3.a1 << ", " << a3.a2 << ", " << a3.a3 << ", "
            << a3.a4 << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2
            << ", " << a4.a3 << ", " << a4.a4 << "), (" << a5.a0 << ", "
            << a5.a1 << ", " << a5.a2 << ", " << a5.a3 << ", " << a5.a4
            << "), (" << a6.a0 << ", " << a6.a1 << ", " << a6.a2 << ", "
            << a6.a3 << ", " << a6.a4 << "), (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << ", " << a7.a3 << ", " << a7.a4 << "), ("
            << a8.a0 << ", " << a8.a1 << ", " << a8.a2 << ", " << a8.a3 << ", "
            << a8.a4 << "), (" << a9.a0 << ", " << a9.a1 << ", " << a9.a2
            << ", " << a9.a3 << ", " << a9.a4 << "))" << "\n";
 
  int32_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a1.a4;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a2.a4;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a3.a4;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a4.a3;
  result += a4.a4;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a5.a3;
  result += a5.a4;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a6.a3;
  result += a6.a4;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a7.a3;
  result += a7.a4;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a8.a3;
  result += a8.a4;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
  result += a9.a3;
  result += a9.a4;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct32BytesHomogeneousDoublex5()

DART_EXPORT double dart::PassStruct32BytesHomogeneousDoublex5	(	Struct32BytesHomogeneousDouble	a0,
		Struct32BytesHomogeneousDouble	a1,
		Struct32BytesHomogeneousDouble	a2,
		Struct32BytesHomogeneousDouble	a3,
		Struct32BytesHomogeneousDouble	a4
	)

Definition at line 2100 of file ffi_test_functions_generated.cc.

                                       {
  std::cout << "PassStruct32BytesHomogeneousDoublex5" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << "), (" << a1.a0
            << ", " << a1.a1 << ", " << a1.a2 << ", " << a1.a3 << "), ("
            << a2.a0 << ", " << a2.a1 << ", " << a2.a2 << ", " << a2.a3
            << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2 << ", "
            << a3.a3 << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2
            << ", " << a4.a3 << "))" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a4.a3;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct32BytesNestedIntx2()

DART_EXPORT int64_t dart::PassStruct32BytesNestedIntx2	(	Struct32BytesNestedInt	a0,
		Struct32BytesNestedInt	a1
	)

Definition at line 3053 of file ffi_test_functions_generated.cc.

                                                                            {
  std::cout << "PassStruct32BytesNestedIntx2" << "(((((" << a0.a0.a0.a0.a0
            << ", " << a0.a0.a0.a0.a1 << "), (" << a0.a0.a0.a1.a0 << ", "
            << a0.a0.a0.a1.a1 << ")), ((" << a0.a0.a1.a0.a0 << ", "
            << a0.a0.a1.a0.a1 << "), (" << a0.a0.a1.a1.a0 << ", "
            << a0.a0.a1.a1.a1 << "))), (((" << a0.a1.a0.a0.a0 << ", "
            << a0.a1.a0.a0.a1 << "), (" << a0.a1.a0.a1.a0 << ", "
            << a0.a1.a0.a1.a1 << ")), ((" << a0.a1.a1.a0.a0 << ", "
            << a0.a1.a1.a0.a1 << "), (" << a0.a1.a1.a1.a0 << ", "
            << a0.a1.a1.a1.a1 << ")))), ((((" << a1.a0.a0.a0.a0 << ", "
            << a1.a0.a0.a0.a1 << "), (" << a1.a0.a0.a1.a0 << ", "
            << a1.a0.a0.a1.a1 << ")), ((" << a1.a0.a1.a0.a0 << ", "
            << a1.a0.a1.a0.a1 << "), (" << a1.a0.a1.a1.a0 << ", "
            << a1.a0.a1.a1.a1 << "))), (((" << a1.a1.a0.a0.a0 << ", "
            << a1.a1.a0.a0.a1 << "), (" << a1.a1.a0.a1.a0 << ", "
            << a1.a1.a0.a1.a1 << ")), ((" << a1.a1.a1.a0.a0 << ", "
            << a1.a1.a1.a0.a1 << "), (" << a1.a1.a1.a1.a0 << ", "
            << a1.a1.a1.a1.a1 << ")))))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0.a0.a0.a0;
  result += a0.a0.a0.a0.a1;
  result += a0.a0.a0.a1.a0;
  result += a0.a0.a0.a1.a1;
  result += a0.a0.a1.a0.a0;
  result += a0.a0.a1.a0.a1;
  result += a0.a0.a1.a1.a0;
  result += a0.a0.a1.a1.a1;
  result += a0.a1.a0.a0.a0;
  result += a0.a1.a0.a0.a1;
  result += a0.a1.a0.a1.a0;
  result += a0.a1.a0.a1.a1;
  result += a0.a1.a1.a0.a0;
  result += a0.a1.a1.a0.a1;
  result += a0.a1.a1.a1.a0;
  result += a0.a1.a1.a1.a1;
  result += a1.a0.a0.a0.a0;
  result += a1.a0.a0.a0.a1;
  result += a1.a0.a0.a1.a0;
  result += a1.a0.a0.a1.a1;
  result += a1.a0.a1.a0.a0;
  result += a1.a0.a1.a0.a1;
  result += a1.a0.a1.a1.a0;
  result += a1.a0.a1.a1.a1;
  result += a1.a1.a0.a0.a0;
  result += a1.a1.a0.a0.a1;
  result += a1.a1.a0.a1.a0;
  result += a1.a1.a0.a1.a1;
  result += a1.a1.a1.a0.a0;
  result += a1.a1.a1.a0.a1;
  result += a1.a1.a1.a1.a0;
  result += a1.a1.a1.a1.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct3BytesHomogeneousUint8x10()

DART_EXPORT int64_t dart::PassStruct3BytesHomogeneousUint8x10	(	Struct3BytesHomogeneousUint8	a0,
		Struct3BytesHomogeneousUint8	a1,
		Struct3BytesHomogeneousUint8	a2,
		Struct3BytesHomogeneousUint8	a3,
		Struct3BytesHomogeneousUint8	a4,
		Struct3BytesHomogeneousUint8	a5,
		Struct3BytesHomogeneousUint8	a6,
		Struct3BytesHomogeneousUint8	a7,
		Struct3BytesHomogeneousUint8	a8,
		Struct3BytesHomogeneousUint8	a9
	)

Definition at line 625 of file ffi_test_functions_generated.cc.

                                                                     {
  std::cout << "PassStruct3BytesHomogeneousUint8x10" << "(("
            << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1)
            << ", " << static_cast<int>(a0.a2) << "), ("
            << static_cast<int>(a1.a0) << ", " << static_cast<int>(a1.a1)
            << ", " << static_cast<int>(a1.a2) << "), ("
            << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1)
            << ", " << static_cast<int>(a2.a2) << "), ("
            << static_cast<int>(a3.a0) << ", " << static_cast<int>(a3.a1)
            << ", " << static_cast<int>(a3.a2) << "), ("
            << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1)
            << ", " << static_cast<int>(a4.a2) << "), ("
            << static_cast<int>(a5.a0) << ", " << static_cast<int>(a5.a1)
            << ", " << static_cast<int>(a5.a2) << "), ("
            << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1)
            << ", " << static_cast<int>(a6.a2) << "), ("
            << static_cast<int>(a7.a0) << ", " << static_cast<int>(a7.a1)
            << ", " << static_cast<int>(a7.a2) << "), ("
            << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1)
            << ", " << static_cast<int>(a8.a2) << "), ("
            << static_cast<int>(a9.a0) << ", " << static_cast<int>(a9.a1)
            << ", " << static_cast<int>(a9.a2) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct3BytesInt2ByteAlignedx10()

DART_EXPORT int64_t dart::PassStruct3BytesInt2ByteAlignedx10	(	Struct3BytesInt2ByteAligned	a0,
		Struct3BytesInt2ByteAligned	a1,
		Struct3BytesInt2ByteAligned	a2,
		Struct3BytesInt2ByteAligned	a3,
		Struct3BytesInt2ByteAligned	a4,
		Struct3BytesInt2ByteAligned	a5,
		Struct3BytesInt2ByteAligned	a6,
		Struct3BytesInt2ByteAligned	a7,
		Struct3BytesInt2ByteAligned	a8,
		Struct3BytesInt2ByteAligned	a9
	)

Definition at line 700 of file ffi_test_functions_generated.cc.

                                                                   {
  std::cout << "PassStruct3BytesInt2ByteAlignedx10" << "((" << a0.a0 << ", "
            << static_cast<int>(a0.a1) << "), (" << a1.a0 << ", "
            << static_cast<int>(a1.a1) << "), (" << a2.a0 << ", "
            << static_cast<int>(a2.a1) << "), (" << a3.a0 << ", "
            << static_cast<int>(a3.a1) << "), (" << a4.a0 << ", "
            << static_cast<int>(a4.a1) << "), (" << a5.a0 << ", "
            << static_cast<int>(a5.a1) << "), (" << a6.a0 << ", "
            << static_cast<int>(a6.a1) << "), (" << a7.a0 << ", "
            << static_cast<int>(a7.a1) << "), (" << a8.a0 << ", "
            << static_cast<int>(a8.a1) << "), (" << a9.a0 << ", "
            << static_cast<int>(a9.a1) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a1.a0;
  result += a1.a1;
  result += a2.a0;
  result += a2.a1;
  result += a3.a0;
  result += a3.a1;
  result += a4.a0;
  result += a4.a1;
  result += a5.a0;
  result += a5.a1;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8.a0;
  result += a8.a1;
  result += a9.a0;
  result += a9.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct3BytesPackedIntx10()

DART_EXPORT int64_t dart::PassStruct3BytesPackedIntx10	(	Struct3BytesPackedInt	a0,
		Struct3BytesPackedInt	a1,
		Struct3BytesPackedInt	a2,
		Struct3BytesPackedInt	a3,
		Struct3BytesPackedInt	a4,
		Struct3BytesPackedInt	a5,
		Struct3BytesPackedInt	a6,
		Struct3BytesPackedInt	a7,
		Struct3BytesPackedInt	a8,
		Struct3BytesPackedInt	a9
	)

Definition at line 4052 of file ffi_test_functions_generated.cc.

                                                                           {
  std::cout << "PassStruct3BytesPackedIntx10" << "((" << static_cast<int>(a0.a0)
            << ", " << a0.a1 << "), (" << static_cast<int>(a1.a0) << ", "
            << a1.a1 << "), (" << static_cast<int>(a2.a0) << ", " << a2.a1
            << "), (" << static_cast<int>(a3.a0) << ", " << a3.a1 << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a1.a0;
  result += a1.a1;
  result += a2.a0;
  result += a2.a1;
  result += a3.a0;
  result += a3.a1;
  result += a4.a0;
  result += a4.a1;
  result += a5.a0;
  result += a5.a1;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8.a0;
  result += a8.a1;
  result += a9.a0;
  result += a9.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct40BytesHomogeneousDouble()

DART_EXPORT double dart::PassStruct40BytesHomogeneousDouble

(

Struct40BytesHomogeneousDouble

a0

)

Definition at line 2144 of file ffi_test_functions_generated.cc.

                                       {
  std::cout << "PassStruct40BytesHomogeneousDouble" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", " << a0.a4 << "))"
            << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct40BytesHomogeneousDoubleStruct4BytesHomo()

DART_EXPORT double dart::PassStruct40BytesHomogeneousDoubleStruct4BytesHomo	(	Struct40BytesHomogeneousDouble	a0,
		Struct4BytesHomogeneousInt16	a1,
		Struct8BytesHomogeneousFloat	a2
	)

Definition at line 2571 of file ffi_test_functions_generated.cc.

                                     {
  std::cout << "PassStruct40BytesHomogeneousDoubleStruct4BytesHomo" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << "), (" << a1.a0 << ", " << a1.a1 << "), (" << a2.a0
            << ", " << a2.a1 << "))" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
  result += a1.a0;
  result += a1.a1;
  result += a2.a0;
  result += a2.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct4BytesHomogeneousInt16x10()

DART_EXPORT int64_t dart::PassStruct4BytesHomogeneousInt16x10	(	Struct4BytesHomogeneousInt16	a0,
		Struct4BytesHomogeneousInt16	a1,
		Struct4BytesHomogeneousInt16	a2,
		Struct4BytesHomogeneousInt16	a3,
		Struct4BytesHomogeneousInt16	a4,
		Struct4BytesHomogeneousInt16	a5,
		Struct4BytesHomogeneousInt16	a6,
		Struct4BytesHomogeneousInt16	a7,
		Struct4BytesHomogeneousInt16	a8,
		Struct4BytesHomogeneousInt16	a9
	)

Definition at line 754 of file ffi_test_functions_generated.cc.

                                                                     {
  std::cout << "PassStruct4BytesHomogeneousInt16x10" << "((" << a0.a0 << ", "
            << a0.a1 << "), (" << a1.a0 << ", " << a1.a1 << "), (" << a2.a0
            << ", " << a2.a1 << "), (" << a3.a0 << ", " << a3.a1 << "), ("
            << a4.a0 << ", " << a4.a1 << "), (" << a5.a0 << ", " << a5.a1
            << "), (" << a6.a0 << ", " << a6.a1 << "), (" << a7.a0 << ", "
            << a7.a1 << "), (" << a8.a0 << ", " << a8.a1 << "), (" << a9.a0
            << ", " << a9.a1 << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a1.a0;
  result += a1.a1;
  result += a2.a0;
  result += a2.a1;
  result += a3.a0;
  result += a3.a1;
  result += a4.a0;
  result += a4.a1;
  result += a5.a0;
  result += a5.a1;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8.a0;
  result += a8.a1;
  result += a9.a0;
  result += a9.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct5BytesPackedMixed()

DART_EXPORT double dart::PassStruct5BytesPackedMixed

(

Struct5BytesPackedMixed

a0

)

Definition at line 4265 of file ffi_test_functions_generated.cc.

                                                                           {
  std::cout << "PassStruct5BytesPackedMixed" << "((" << a0.a0 << ", "
            << static_cast<int>(a0.a1) << "))" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a0.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct6BytesInlineArrayInt()

DART_EXPORT double dart::PassStruct6BytesInlineArrayInt

(

Struct6BytesInlineArrayInt

a0

)

Definition at line 4300 of file ffi_test_functions_generated.cc.

                                   {
  std::cout << "PassStruct6BytesInlineArrayInt" << "(([("
            << static_cast<int>(a0.a0[0].a0) << ", " << a0.a0[0].a1 << "), ("
            << static_cast<int>(a0.a0[1].a0) << ", " << a0.a0[1].a1 << ")]))"
            << "\n";
 
  double result = 0;
 
  result += a0.a0[0].a0;
  result += a0.a0[0].a1;
  result += a0.a0[1].a0;
  result += a0.a0[1].a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct7BytesHomogeneousUint8x10()

DART_EXPORT int64_t dart::PassStruct7BytesHomogeneousUint8x10	(	Struct7BytesHomogeneousUint8	a0,
		Struct7BytesHomogeneousUint8	a1,
		Struct7BytesHomogeneousUint8	a2,
		Struct7BytesHomogeneousUint8	a3,
		Struct7BytesHomogeneousUint8	a4,
		Struct7BytesHomogeneousUint8	a5,
		Struct7BytesHomogeneousUint8	a6,
		Struct7BytesHomogeneousUint8	a7,
		Struct7BytesHomogeneousUint8	a8,
		Struct7BytesHomogeneousUint8	a9
	)

Definition at line 804 of file ffi_test_functions_generated.cc.

                                                                     {
  std::cout
      << "PassStruct7BytesHomogeneousUint8x10" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << "))"
      << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
  result += a0.a5;
  result += a0.a6;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a1.a4;
  result += a1.a5;
  result += a1.a6;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a2.a4;
  result += a2.a5;
  result += a2.a6;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a3.a4;
  result += a3.a5;
  result += a3.a6;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a4.a3;
  result += a4.a4;
  result += a4.a5;
  result += a4.a6;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a5.a3;
  result += a5.a4;
  result += a5.a5;
  result += a5.a6;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a6.a3;
  result += a6.a4;
  result += a6.a5;
  result += a6.a6;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a7.a3;
  result += a7.a4;
  result += a7.a5;
  result += a7.a6;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a8.a3;
  result += a8.a4;
  result += a8.a5;
  result += a8.a6;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
  result += a9.a3;
  result += a9.a4;
  result += a9.a5;
  result += a9.a6;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct7BytesInt4ByteAlignedx10()

DART_EXPORT int64_t dart::PassStruct7BytesInt4ByteAlignedx10	(	Struct7BytesInt4ByteAligned	a0,
		Struct7BytesInt4ByteAligned	a1,
		Struct7BytesInt4ByteAligned	a2,
		Struct7BytesInt4ByteAligned	a3,
		Struct7BytesInt4ByteAligned	a4,
		Struct7BytesInt4ByteAligned	a5,
		Struct7BytesInt4ByteAligned	a6,
		Struct7BytesInt4ByteAligned	a7,
		Struct7BytesInt4ByteAligned	a8,
		Struct7BytesInt4ByteAligned	a9
	)

Definition at line 936 of file ffi_test_functions_generated.cc.

                                                                   {
  std::cout << "PassStruct7BytesInt4ByteAlignedx10" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << static_cast<int>(a0.a2) << "), (" << a1.a0
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "), ("
            << a2.a0 << ", " << a2.a1 << ", " << static_cast<int>(a2.a2)
            << "), (" << a3.a0 << ", " << a3.a1 << ", "
            << static_cast<int>(a3.a2) << "), (" << a4.a0 << ", " << a4.a1
            << ", " << static_cast<int>(a4.a2) << "), (" << a5.a0 << ", "
            << a5.a1 << ", " << static_cast<int>(a5.a2) << "), (" << a6.a0
            << ", " << a6.a1 << ", " << static_cast<int>(a6.a2) << "), ("
            << a7.a0 << ", " << a7.a1 << ", " << static_cast<int>(a7.a2)
            << "), (" << a8.a0 << ", " << a8.a1 << ", "
            << static_cast<int>(a8.a2) << "), (" << a9.a0 << ", " << a9.a1
            << ", " << static_cast<int>(a9.a2) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesHomogeneousFloatx10()

DART_EXPORT float dart::PassStruct8BytesHomogeneousFloatx10	(	Struct8BytesHomogeneousFloat	a0,
		Struct8BytesHomogeneousFloat	a1,
		Struct8BytesHomogeneousFloat	a2,
		Struct8BytesHomogeneousFloat	a3,
		Struct8BytesHomogeneousFloat	a4,
		Struct8BytesHomogeneousFloat	a5,
		Struct8BytesHomogeneousFloat	a6,
		Struct8BytesHomogeneousFloat	a7,
		Struct8BytesHomogeneousFloat	a8,
		Struct8BytesHomogeneousFloat	a9
	)

Definition at line 1063 of file ffi_test_functions_generated.cc.

                                     {
  std::cout << "PassStruct8BytesHomogeneousFloatx10" << "((" << a0.a0 << ", "
            << a0.a1 << "), (" << a1.a0 << ", " << a1.a1 << "), (" << a2.a0
            << ", " << a2.a1 << "), (" << a3.a0 << ", " << a3.a1 << "), ("
            << a4.a0 << ", " << a4.a1 << "), (" << a5.a0 << ", " << a5.a1
            << "), (" << a6.a0 << ", " << a6.a1 << "), (" << a7.a0 << ", "
            << a7.a1 << "), (" << a8.a0 << ", " << a8.a1 << "), (" << a9.a0
            << ", " << a9.a1 << "))" << "\n";
 
  float result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a1.a0;
  result += a1.a1;
  result += a2.a0;
  result += a2.a1;
  result += a3.a0;
  result += a3.a1;
  result += a4.a0;
  result += a4.a1;
  result += a5.a0;
  result += a5.a1;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8.a0;
  result += a8.a1;
  result += a9.a0;
  result += a9.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesInlineArrayIntx4()

DART_EXPORT int32_t dart::PassStruct8BytesInlineArrayIntx4	(	Struct8BytesInlineArrayInt	a0,
		Struct8BytesInlineArrayInt	a1,
		Struct8BytesInlineArrayInt	a2,
		Struct8BytesInlineArrayInt	a3
	)

Definition at line 3396 of file ffi_test_functions_generated.cc.

                                                                {
  std::cout << "PassStruct8BytesInlineArrayIntx4" << "((["
            << static_cast<int>(a0.a0[0]) << ", " << static_cast<int>(a0.a0[1])
            << ", " << static_cast<int>(a0.a0[2]) << ", "
            << static_cast<int>(a0.a0[3]) << ", " << static_cast<int>(a0.a0[4])
            << ", " << static_cast<int>(a0.a0[5]) << ", "
            << static_cast<int>(a0.a0[6]) << ", " << static_cast<int>(a0.a0[7])
            << "]), ([" << static_cast<int>(a1.a0[0]) << ", "
            << static_cast<int>(a1.a0[1]) << ", " << static_cast<int>(a1.a0[2])
            << ", " << static_cast<int>(a1.a0[3]) << ", "
            << static_cast<int>(a1.a0[4]) << ", " << static_cast<int>(a1.a0[5])
            << ", " << static_cast<int>(a1.a0[6]) << ", "
            << static_cast<int>(a1.a0[7]) << "]), (["
            << static_cast<int>(a2.a0[0]) << ", " << static_cast<int>(a2.a0[1])
            << ", " << static_cast<int>(a2.a0[2]) << ", "
            << static_cast<int>(a2.a0[3]) << ", " << static_cast<int>(a2.a0[4])
            << ", " << static_cast<int>(a2.a0[5]) << ", "
            << static_cast<int>(a2.a0[6]) << ", " << static_cast<int>(a2.a0[7])
            << "]), ([" << static_cast<int>(a3.a0[0]) << ", "
            << static_cast<int>(a3.a0[1]) << ", " << static_cast<int>(a3.a0[2])
            << ", " << static_cast<int>(a3.a0[3]) << ", "
            << static_cast<int>(a3.a0[4]) << ", " << static_cast<int>(a3.a0[5])
            << ", " << static_cast<int>(a3.a0[6]) << ", "
            << static_cast<int>(a3.a0[7]) << "]))" << "\n";
 
  int32_t result = 0;
 
  result += a0.a0[0];
  result += a0.a0[1];
  result += a0.a0[2];
  result += a0.a0[3];
  result += a0.a0[4];
  result += a0.a0[5];
  result += a0.a0[6];
  result += a0.a0[7];
  result += a1.a0[0];
  result += a1.a0[1];
  result += a1.a0[2];
  result += a1.a0[3];
  result += a1.a0[4];
  result += a1.a0[5];
  result += a1.a0[6];
  result += a1.a0[7];
  result += a2.a0[0];
  result += a2.a0[1];
  result += a2.a0[2];
  result += a2.a0[3];
  result += a2.a0[4];
  result += a2.a0[5];
  result += a2.a0[6];
  result += a2.a0[7];
  result += a3.a0[0];
  result += a3.a0[1];
  result += a3.a0[2];
  result += a3.a0[3];
  result += a3.a0[4];
  result += a3.a0[5];
  result += a3.a0[6];
  result += a3.a0[7];
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesIntx10()

DART_EXPORT int64_t dart::PassStruct8BytesIntx10	(	Struct8BytesInt	a0,
		Struct8BytesInt	a1,
		Struct8BytesInt	a2,
		Struct8BytesInt	a3,
		Struct8BytesInt	a4,
		Struct8BytesInt	a5,
		Struct8BytesInt	a6,
		Struct8BytesInt	a7,
		Struct8BytesInt	a8,
		Struct8BytesInt	a9
	)

Definition at line 1001 of file ffi_test_functions_generated.cc.

                                                               {
  std::cout << "PassStruct8BytesIntx10" << "((" << a0.a0 << ", " << a0.a1
            << ", " << a0.a2 << "), (" << a1.a0 << ", " << a1.a1 << ", "
            << a1.a2 << "), (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2
            << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2 << "), ("
            << a4.a0 << ", " << a4.a1 << ", " << a4.a2 << "), (" << a5.a0
            << ", " << a5.a1 << ", " << a5.a2 << "), (" << a6.a0 << ", "
            << a6.a1 << ", " << a6.a2 << "), (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << "), (" << a8.a0 << ", " << a8.a1 << ", "
            << a8.a2 << "), (" << a9.a0 << ", " << a9.a1 << ", " << a9.a2
            << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesMixedx10()

DART_EXPORT float dart::PassStruct8BytesMixedx10	(	Struct8BytesMixed	a0,
		Struct8BytesMixed	a1,
		Struct8BytesMixed	a2,
		Struct8BytesMixed	a3,
		Struct8BytesMixed	a4,
		Struct8BytesMixed	a5,
		Struct8BytesMixed	a6,
		Struct8BytesMixed	a7,
		Struct8BytesMixed	a8,
		Struct8BytesMixed	a9
	)

Definition at line 1113 of file ffi_test_functions_generated.cc.

                                                                 {
  std::cout << "PassStruct8BytesMixedx10" << "((" << a0.a0 << ", " << a0.a1
            << ", " << a0.a2 << "), (" << a1.a0 << ", " << a1.a1 << ", "
            << a1.a2 << "), (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2
            << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2 << "), ("
            << a4.a0 << ", " << a4.a1 << ", " << a4.a2 << "), (" << a5.a0
            << ", " << a5.a1 << ", " << a5.a2 << "), (" << a6.a0 << ", "
            << a6.a1 << ", " << a6.a2 << "), (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << "), (" << a8.a0 << ", " << a8.a1 << ", "
            << a8.a2 << "), (" << a9.a0 << ", " << a9.a1 << ", " << a9.a2
            << "))" << "\n";
 
  float result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesNestedFloat2x10()

DART_EXPORT float dart::PassStruct8BytesNestedFloat2x10	(	Struct8BytesNestedFloat2	a0,
		Struct8BytesNestedFloat2	a1,
		Struct8BytesNestedFloat2	a2,
		Struct8BytesNestedFloat2	a3,
		Struct8BytesNestedFloat2	a4,
		Struct8BytesNestedFloat2	a5,
		Struct8BytesNestedFloat2	a6,
		Struct8BytesNestedFloat2	a7,
		Struct8BytesNestedFloat2	a8,
		Struct8BytesNestedFloat2	a9
	)

Definition at line 2905 of file ffi_test_functions_generated.cc.

                                                                               {
  std::cout << "PassStruct8BytesNestedFloat2x10" << "(((" << a0.a0.a0 << "), "
            << a0.a1 << "), ((" << a1.a0.a0 << "), " << a1.a1 << "), (("
            << a2.a0.a0 << "), " << a2.a1 << "), ((" << a3.a0.a0 << "), "
            << a3.a1 << "), ((" << a4.a0.a0 << "), " << a4.a1 << "), (("
            << a5.a0.a0 << "), " << a5.a1 << "), ((" << a6.a0.a0 << "), "
            << a6.a1 << "), ((" << a7.a0.a0 << "), " << a7.a1 << "), (("
            << a8.a0.a0 << "), " << a8.a1 << "), ((" << a9.a0.a0 << "), "
            << a9.a1 << "))" << "\n";
 
  float result = 0;
 
  result += a0.a0.a0;
  result += a0.a1;
  result += a1.a0.a0;
  result += a1.a1;
  result += a2.a0.a0;
  result += a2.a1;
  result += a3.a0.a0;
  result += a3.a1;
  result += a4.a0.a0;
  result += a4.a1;
  result += a5.a0.a0;
  result += a5.a1;
  result += a6.a0.a0;
  result += a6.a1;
  result += a7.a0.a0;
  result += a7.a1;
  result += a8.a0.a0;
  result += a8.a1;
  result += a9.a0.a0;
  result += a9.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesNestedFloatx10()

DART_EXPORT float dart::PassStruct8BytesNestedFloatx10	(	Struct8BytesNestedFloat	a0,
		Struct8BytesNestedFloat	a1,
		Struct8BytesNestedFloat	a2,
		Struct8BytesNestedFloat	a3,
		Struct8BytesNestedFloat	a4,
		Struct8BytesNestedFloat	a5,
		Struct8BytesNestedFloat	a6,
		Struct8BytesNestedFloat	a7,
		Struct8BytesNestedFloat	a8,
		Struct8BytesNestedFloat	a9
	)

Definition at line 2852 of file ffi_test_functions_generated.cc.

                                                                             {
  std::cout << "PassStruct8BytesNestedFloatx10" << "(((" << a0.a0.a0 << "), ("
            << a0.a1.a0 << ")), ((" << a1.a0.a0 << "), (" << a1.a1.a0
            << ")), ((" << a2.a0.a0 << "), (" << a2.a1.a0 << ")), (("
            << a3.a0.a0 << "), (" << a3.a1.a0 << ")), ((" << a4.a0.a0 << "), ("
            << a4.a1.a0 << ")), ((" << a5.a0.a0 << "), (" << a5.a1.a0
            << ")), ((" << a6.a0.a0 << "), (" << a6.a1.a0 << ")), (("
            << a7.a0.a0 << "), (" << a7.a1.a0 << ")), ((" << a8.a0.a0 << "), ("
            << a8.a1.a0 << ")), ((" << a9.a0.a0 << "), (" << a9.a1.a0 << ")))"
            << "\n";
 
  float result = 0;
 
  result += a0.a0.a0;
  result += a0.a1.a0;
  result += a1.a0.a0;
  result += a1.a1.a0;
  result += a2.a0.a0;
  result += a2.a1.a0;
  result += a3.a0.a0;
  result += a3.a1.a0;
  result += a4.a0.a0;
  result += a4.a1.a0;
  result += a5.a0.a0;
  result += a5.a1.a0;
  result += a6.a0.a0;
  result += a6.a1.a0;
  result += a7.a0.a0;
  result += a7.a1.a0;
  result += a8.a0.a0;
  result += a8.a1.a0;
  result += a9.a0.a0;
  result += a9.a1.a0;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesNestedIntx10()

DART_EXPORT int64_t dart::PassStruct8BytesNestedIntx10	(	Struct8BytesNestedInt	a0,
		Struct8BytesNestedInt	a1,
		Struct8BytesNestedInt	a2,
		Struct8BytesNestedInt	a3,
		Struct8BytesNestedInt	a4,
		Struct8BytesNestedInt	a5,
		Struct8BytesNestedInt	a6,
		Struct8BytesNestedInt	a7,
		Struct8BytesNestedInt	a8,
		Struct8BytesNestedInt	a9
	)

Definition at line 2775 of file ffi_test_functions_generated.cc.

                                                                           {
  std::cout << "PassStruct8BytesNestedIntx10" << "(((" << a0.a0.a0 << ", "
            << a0.a0.a1 << "), (" << a0.a1.a0 << ", " << a0.a1.a1 << ")), (("
            << a1.a0.a0 << ", " << a1.a0.a1 << "), (" << a1.a1.a0 << ", "
            << a1.a1.a1 << ")), ((" << a2.a0.a0 << ", " << a2.a0.a1 << "), ("
            << a2.a1.a0 << ", " << a2.a1.a1 << ")), ((" << a3.a0.a0 << ", "
            << a3.a0.a1 << "), (" << a3.a1.a0 << ", " << a3.a1.a1 << ")), (("
            << a4.a0.a0 << ", " << a4.a0.a1 << "), (" << a4.a1.a0 << ", "
            << a4.a1.a1 << ")), ((" << a5.a0.a0 << ", " << a5.a0.a1 << "), ("
            << a5.a1.a0 << ", " << a5.a1.a1 << ")), ((" << a6.a0.a0 << ", "
            << a6.a0.a1 << "), (" << a6.a1.a0 << ", " << a6.a1.a1 << ")), (("
            << a7.a0.a0 << ", " << a7.a0.a1 << "), (" << a7.a1.a0 << ", "
            << a7.a1.a1 << ")), ((" << a8.a0.a0 << ", " << a8.a0.a1 << "), ("
            << a8.a1.a0 << ", " << a8.a1.a1 << ")), ((" << a9.a0.a0 << ", "
            << a9.a0.a1 << "), (" << a9.a1.a0 << ", " << a9.a1.a1 << ")))"
            << "\n";
 
  int64_t result = 0;
 
  result += a0.a0.a0;
  result += a0.a0.a1;
  result += a0.a1.a0;
  result += a0.a1.a1;
  result += a1.a0.a0;
  result += a1.a0.a1;
  result += a1.a1.a0;
  result += a1.a1.a1;
  result += a2.a0.a0;
  result += a2.a0.a1;
  result += a2.a1.a0;
  result += a2.a1.a1;
  result += a3.a0.a0;
  result += a3.a0.a1;
  result += a3.a1.a0;
  result += a3.a1.a1;
  result += a4.a0.a0;
  result += a4.a0.a1;
  result += a4.a1.a0;
  result += a4.a1.a1;
  result += a5.a0.a0;
  result += a5.a0.a1;
  result += a5.a1.a0;
  result += a5.a1.a1;
  result += a6.a0.a0;
  result += a6.a0.a1;
  result += a6.a1.a0;
  result += a6.a1.a1;
  result += a7.a0.a0;
  result += a7.a0.a1;
  result += a7.a1.a0;
  result += a7.a1.a1;
  result += a8.a0.a0;
  result += a8.a0.a1;
  result += a8.a1.a0;
  result += a8.a1.a1;
  result += a9.a0.a0;
  result += a9.a0.a1;
  result += a9.a1.a0;
  result += a9.a1.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesNestedMixedx10()

DART_EXPORT double dart::PassStruct8BytesNestedMixedx10	(	Struct8BytesNestedMixed	a0,
		Struct8BytesNestedMixed	a1,
		Struct8BytesNestedMixed	a2,
		Struct8BytesNestedMixed	a3,
		Struct8BytesNestedMixed	a4,
		Struct8BytesNestedMixed	a5,
		Struct8BytesNestedMixed	a6,
		Struct8BytesNestedMixed	a7,
		Struct8BytesNestedMixed	a8,
		Struct8BytesNestedMixed	a9
	)

Definition at line 2955 of file ffi_test_functions_generated.cc.

                                                                              {
  std::cout << "PassStruct8BytesNestedMixedx10" << "(((" << a0.a0.a0 << ", "
            << a0.a0.a1 << "), (" << a0.a1.a0 << ")), ((" << a1.a0.a0 << ", "
            << a1.a0.a1 << "), (" << a1.a1.a0 << ")), ((" << a2.a0.a0 << ", "
            << a2.a0.a1 << "), (" << a2.a1.a0 << ")), ((" << a3.a0.a0 << ", "
            << a3.a0.a1 << "), (" << a3.a1.a0 << ")), ((" << a4.a0.a0 << ", "
            << a4.a0.a1 << "), (" << a4.a1.a0 << ")), ((" << a5.a0.a0 << ", "
            << a5.a0.a1 << "), (" << a5.a1.a0 << ")), ((" << a6.a0.a0 << ", "
            << a6.a0.a1 << "), (" << a6.a1.a0 << ")), ((" << a7.a0.a0 << ", "
            << a7.a0.a1 << "), (" << a7.a1.a0 << ")), ((" << a8.a0.a0 << ", "
            << a8.a0.a1 << "), (" << a8.a1.a0 << ")), ((" << a9.a0.a0 << ", "
            << a9.a0.a1 << "), (" << a9.a1.a0 << ")))" << "\n";
 
  double result = 0;
 
  result += a0.a0.a0;
  result += a0.a0.a1;
  result += a0.a1.a0;
  result += a1.a0.a0;
  result += a1.a0.a1;
  result += a1.a1.a0;
  result += a2.a0.a0;
  result += a2.a0.a1;
  result += a2.a1.a0;
  result += a3.a0.a0;
  result += a3.a0.a1;
  result += a3.a1.a0;
  result += a4.a0.a0;
  result += a4.a0.a1;
  result += a4.a1.a0;
  result += a5.a0.a0;
  result += a5.a0.a1;
  result += a5.a1.a0;
  result += a6.a0.a0;
  result += a6.a0.a1;
  result += a6.a1.a0;
  result += a7.a0.a0;
  result += a7.a0.a1;
  result += a7.a1.a0;
  result += a8.a0.a0;
  result += a8.a0.a1;
  result += a8.a1.a0;
  result += a9.a0.a0;
  result += a9.a0.a1;
  result += a9.a1.a0;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct8BytesPackedIntx10()

DART_EXPORT int64_t dart::PassStruct8BytesPackedIntx10	(	Struct8BytesPackedInt	a0,
		Struct8BytesPackedInt	a1,
		Struct8BytesPackedInt	a2,
		Struct8BytesPackedInt	a3,
		Struct8BytesPackedInt	a4,
		Struct8BytesPackedInt	a5,
		Struct8BytesPackedInt	a6,
		Struct8BytesPackedInt	a7,
		Struct8BytesPackedInt	a8,
		Struct8BytesPackedInt	a9
	)

Definition at line 4103 of file ffi_test_functions_generated.cc.

                                                                           {
  std::cout << "PassStruct8BytesPackedIntx10" << "((" << static_cast<int>(a0.a0)
            << ", " << a0.a1 << ", " << static_cast<int>(a0.a2) << ", "
            << static_cast<int>(a0.a3) << ", " << static_cast<int>(a0.a4)
            << "), (" << static_cast<int>(a1.a0) << ", " << a1.a1 << ", "
            << static_cast<int>(a1.a2) << ", " << static_cast<int>(a1.a3)
            << ", " << static_cast<int>(a1.a4) << "), ("
            << static_cast<int>(a2.a0) << ", " << a2.a1 << ", "
            << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3)
            << ", " << static_cast<int>(a2.a4) << "), ("
            << static_cast<int>(a3.a0) << ", " << a3.a1 << ", "
            << static_cast<int>(a3.a2) << ", " << static_cast<int>(a3.a3)
            << ", " << static_cast<int>(a3.a4) << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << ", "
            << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3)
            << ", " << static_cast<int>(a4.a4) << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << ", "
            << static_cast<int>(a5.a2) << ", " << static_cast<int>(a5.a3)
            << ", " << static_cast<int>(a5.a4) << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << ", "
            << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3)
            << ", " << static_cast<int>(a6.a4) << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << ", "
            << static_cast<int>(a7.a2) << ", " << static_cast<int>(a7.a3)
            << ", " << static_cast<int>(a7.a4) << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << ", "
            << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3)
            << ", " << static_cast<int>(a8.a4) << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << ", "
            << static_cast<int>(a9.a2) << ", " << static_cast<int>(a9.a3)
            << ", " << static_cast<int>(a9.a4) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a1.a4;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a2.a4;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a3.a4;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a4.a3;
  result += a4.a4;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a5.a3;
  result += a5.a4;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a6.a3;
  result += a6.a4;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a7.a3;
  result += a7.a4;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a8.a3;
  result += a8.a4;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
  result += a9.a3;
  result += a9.a4;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct9BytesHomogeneousUint8x10()

DART_EXPORT int64_t dart::PassStruct9BytesHomogeneousUint8x10	(	Struct9BytesHomogeneousUint8	a0,
		Struct9BytesHomogeneousUint8	a1,
		Struct9BytesHomogeneousUint8	a2,
		Struct9BytesHomogeneousUint8	a3,
		Struct9BytesHomogeneousUint8	a4,
		Struct9BytesHomogeneousUint8	a5,
		Struct9BytesHomogeneousUint8	a6,
		Struct9BytesHomogeneousUint8	a7,
		Struct9BytesHomogeneousUint8	a8,
		Struct9BytesHomogeneousUint8	a9
	)

Definition at line 1179 of file ffi_test_functions_generated.cc.

                                                                     {
  std::cout
      << "PassStruct9BytesHomogeneousUint8x10" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << ", " << static_cast<int>(a0.a7) << ", "
      << static_cast<int>(a0.a8) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << ", "
      << static_cast<int>(a1.a7) << ", " << static_cast<int>(a1.a8) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << ", " << static_cast<int>(a2.a7) << ", "
      << static_cast<int>(a2.a8) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << ", "
      << static_cast<int>(a3.a7) << ", " << static_cast<int>(a3.a8) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << ", " << static_cast<int>(a4.a7) << ", "
      << static_cast<int>(a4.a8) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << ", "
      << static_cast<int>(a5.a7) << ", " << static_cast<int>(a5.a8) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << ", " << static_cast<int>(a6.a7) << ", "
      << static_cast<int>(a6.a8) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << ", "
      << static_cast<int>(a7.a7) << ", " << static_cast<int>(a7.a8) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << ", " << static_cast<int>(a8.a7) << ", "
      << static_cast<int>(a8.a8) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << ", "
      << static_cast<int>(a9.a7) << ", " << static_cast<int>(a9.a8) << "))"
      << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a0.a3;
  result += a0.a4;
  result += a0.a5;
  result += a0.a6;
  result += a0.a7;
  result += a0.a8;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a1.a4;
  result += a1.a5;
  result += a1.a6;
  result += a1.a7;
  result += a1.a8;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a2.a4;
  result += a2.a5;
  result += a2.a6;
  result += a2.a7;
  result += a2.a8;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a3.a4;
  result += a3.a5;
  result += a3.a6;
  result += a3.a7;
  result += a3.a8;
  result += a4.a0;
  result += a4.a1;
  result += a4.a2;
  result += a4.a3;
  result += a4.a4;
  result += a4.a5;
  result += a4.a6;
  result += a4.a7;
  result += a4.a8;
  result += a5.a0;
  result += a5.a1;
  result += a5.a2;
  result += a5.a3;
  result += a5.a4;
  result += a5.a5;
  result += a5.a6;
  result += a5.a7;
  result += a5.a8;
  result += a6.a0;
  result += a6.a1;
  result += a6.a2;
  result += a6.a3;
  result += a6.a4;
  result += a6.a5;
  result += a6.a6;
  result += a6.a7;
  result += a6.a8;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a7.a3;
  result += a7.a4;
  result += a7.a5;
  result += a7.a6;
  result += a7.a7;
  result += a7.a8;
  result += a8.a0;
  result += a8.a1;
  result += a8.a2;
  result += a8.a3;
  result += a8.a4;
  result += a8.a5;
  result += a8.a6;
  result += a8.a7;
  result += a8.a8;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
  result += a9.a3;
  result += a9.a4;
  result += a9.a5;
  result += a9.a6;
  result += a9.a7;
  result += a9.a8;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct9BytesInt4Or8ByteAlignedx10()

DART_EXPORT int64_t dart::PassStruct9BytesInt4Or8ByteAlignedx10	(	Struct9BytesInt4Or8ByteAligned	a0,
		Struct9BytesInt4Or8ByteAligned	a1,
		Struct9BytesInt4Or8ByteAligned	a2,
		Struct9BytesInt4Or8ByteAligned	a3,
		Struct9BytesInt4Or8ByteAligned	a4,
		Struct9BytesInt4Or8ByteAligned	a5,
		Struct9BytesInt4Or8ByteAligned	a6,
		Struct9BytesInt4Or8ByteAligned	a7,
		Struct9BytesInt4Or8ByteAligned	a8,
		Struct9BytesInt4Or8ByteAligned	a9
	)

Definition at line 1342 of file ffi_test_functions_generated.cc.

                                                                         {
  std::cout << "PassStruct9BytesInt4Or8ByteAlignedx10" << "((" << a0.a0 << ", "
            << static_cast<int>(a0.a1) << "), (" << a1.a0 << ", "
            << static_cast<int>(a1.a1) << "), (" << a2.a0 << ", "
            << static_cast<int>(a2.a1) << "), (" << a3.a0 << ", "
            << static_cast<int>(a3.a1) << "), (" << a4.a0 << ", "
            << static_cast<int>(a4.a1) << "), (" << a5.a0 << ", "
            << static_cast<int>(a5.a1) << "), (" << a6.a0 << ", "
            << static_cast<int>(a6.a1) << "), (" << a7.a0 << ", "
            << static_cast<int>(a7.a1) << "), (" << a8.a0 << ", "
            << static_cast<int>(a8.a1) << "), (" << a9.a0 << ", "
            << static_cast<int>(a9.a1) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a1.a0;
  result += a1.a1;
  result += a2.a0;
  result += a2.a1;
  result += a3.a0;
  result += a3.a1;
  result += a4.a0;
  result += a4.a1;
  result += a5.a0;
  result += a5.a1;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8.a0;
  result += a8.a1;
  result += a9.a0;
  result += a9.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStruct9BytesPackedMixedx10DoubleInt32x2()

DART_EXPORT double dart::PassStruct9BytesPackedMixedx10DoubleInt32x2	(	Struct9BytesPackedMixed	a0,
		Struct9BytesPackedMixed	a1,
		Struct9BytesPackedMixed	a2,
		Struct9BytesPackedMixed	a3,
		Struct9BytesPackedMixed	a4,
		Struct9BytesPackedMixed	a5,
		Struct9BytesPackedMixed	a6,
		Struct9BytesPackedMixed	a7,
		Struct9BytesPackedMixed	a8,
		Struct9BytesPackedMixed	a9,
		double	a10,
		int32_t	a11,
		int32_t	a12
	)

Definition at line 4205 of file ffi_test_functions_generated.cc.

                 {
  std::cout << "PassStruct9BytesPackedMixedx10DoubleInt32x2" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << "), ("
            << static_cast<int>(a1.a0) << ", " << a1.a1 << "), ("
            << static_cast<int>(a2.a0) << ", " << a2.a1 << "), ("
            << static_cast<int>(a3.a0) << ", " << a3.a1 << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << "), " << a10 << ", "
            << a11 << ", " << a12 << ")" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a1.a0;
  result += a1.a1;
  result += a2.a0;
  result += a2.a1;
  result += a3.a0;
  result += a3.a1;
  result += a4.a0;
  result += a4.a1;
  result += a5.a0;
  result += a5.a1;
  result += a6.a0;
  result += a6.a1;
  result += a7.a0;
  result += a7.a1;
  result += a8.a0;
  result += a8.a1;
  result += a9.a0;
  result += a9.a1;
  result += a10;
  result += a11;
  result += a12;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructAlignmentInt16()

DART_EXPORT int64_t dart::PassStructAlignmentInt16

(

StructAlignmentInt16

a0

)

Definition at line 2723 of file ffi_test_functions_generated.cc.

                                                                      {
  std::cout << "PassStructAlignmentInt16" << "((" << static_cast<int>(a0.a0)
            << ", " << a0.a1 << ", " << static_cast<int>(a0.a2) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructAlignmentInt32()

DART_EXPORT int64_t dart::PassStructAlignmentInt32

(

StructAlignmentInt32

a0

)

Definition at line 2740 of file ffi_test_functions_generated.cc.

                                                                      {
  std::cout << "PassStructAlignmentInt32" << "((" << static_cast<int>(a0.a0)
            << ", " << a0.a1 << ", " << static_cast<int>(a0.a2) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructAlignmentInt64()

DART_EXPORT int64_t dart::PassStructAlignmentInt64

(

StructAlignmentInt64

a0

)

Definition at line 2757 of file ffi_test_functions_generated.cc.

                                                                      {
  std::cout << "PassStructAlignmentInt64" << "((" << static_cast<int>(a0.a0)
            << ", " << a0.a1 << ", " << static_cast<int>(a0.a2) << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructInlineArray100Bytes()

DART_EXPORT int32_t dart::PassStructInlineArray100Bytes

(

StructInlineArray100Bytes

a0

)

Definition at line 3516 of file ffi_test_functions_generated.cc.

                                                            {
  std::cout
      << "PassStructInlineArray100Bytes" << "(([" << static_cast<int>(a0.a0[0])
      << ", " << static_cast<int>(a0.a0[1]) << ", "
      << static_cast<int>(a0.a0[2]) << ", " << static_cast<int>(a0.a0[3])
      << ", " << static_cast<int>(a0.a0[4]) << ", "
      << static_cast<int>(a0.a0[5]) << ", " << static_cast<int>(a0.a0[6])
      << ", " << static_cast<int>(a0.a0[7]) << ", "
      << static_cast<int>(a0.a0[8]) << ", " << static_cast<int>(a0.a0[9])
      << ", " << static_cast<int>(a0.a0[10]) << ", "
      << static_cast<int>(a0.a0[11]) << ", " << static_cast<int>(a0.a0[12])
      << ", " << static_cast<int>(a0.a0[13]) << ", "
      << static_cast<int>(a0.a0[14]) << ", " << static_cast<int>(a0.a0[15])
      << ", " << static_cast<int>(a0.a0[16]) << ", "
      << static_cast<int>(a0.a0[17]) << ", " << static_cast<int>(a0.a0[18])
      << ", " << static_cast<int>(a0.a0[19]) << ", "
      << static_cast<int>(a0.a0[20]) << ", " << static_cast<int>(a0.a0[21])
      << ", " << static_cast<int>(a0.a0[22]) << ", "
      << static_cast<int>(a0.a0[23]) << ", " << static_cast<int>(a0.a0[24])
      << ", " << static_cast<int>(a0.a0[25]) << ", "
      << static_cast<int>(a0.a0[26]) << ", " << static_cast<int>(a0.a0[27])
      << ", " << static_cast<int>(a0.a0[28]) << ", "
      << static_cast<int>(a0.a0[29]) << ", " << static_cast<int>(a0.a0[30])
      << ", " << static_cast<int>(a0.a0[31]) << ", "
      << static_cast<int>(a0.a0[32]) << ", " << static_cast<int>(a0.a0[33])
      << ", " << static_cast<int>(a0.a0[34]) << ", "
      << static_cast<int>(a0.a0[35]) << ", " << static_cast<int>(a0.a0[36])
      << ", " << static_cast<int>(a0.a0[37]) << ", "
      << static_cast<int>(a0.a0[38]) << ", " << static_cast<int>(a0.a0[39])
      << ", " << static_cast<int>(a0.a0[40]) << ", "
      << static_cast<int>(a0.a0[41]) << ", " << static_cast<int>(a0.a0[42])
      << ", " << static_cast<int>(a0.a0[43]) << ", "
      << static_cast<int>(a0.a0[44]) << ", " << static_cast<int>(a0.a0[45])
      << ", " << static_cast<int>(a0.a0[46]) << ", "
      << static_cast<int>(a0.a0[47]) << ", " << static_cast<int>(a0.a0[48])
      << ", " << static_cast<int>(a0.a0[49]) << ", "
      << static_cast<int>(a0.a0[50]) << ", " << static_cast<int>(a0.a0[51])
      << ", " << static_cast<int>(a0.a0[52]) << ", "
      << static_cast<int>(a0.a0[53]) << ", " << static_cast<int>(a0.a0[54])
      << ", " << static_cast<int>(a0.a0[55]) << ", "
      << static_cast<int>(a0.a0[56]) << ", " << static_cast<int>(a0.a0[57])
      << ", " << static_cast<int>(a0.a0[58]) << ", "
      << static_cast<int>(a0.a0[59]) << ", " << static_cast<int>(a0.a0[60])
      << ", " << static_cast<int>(a0.a0[61]) << ", "
      << static_cast<int>(a0.a0[62]) << ", " << static_cast<int>(a0.a0[63])
      << ", " << static_cast<int>(a0.a0[64]) << ", "
      << static_cast<int>(a0.a0[65]) << ", " << static_cast<int>(a0.a0[66])
      << ", " << static_cast<int>(a0.a0[67]) << ", "
      << static_cast<int>(a0.a0[68]) << ", " << static_cast<int>(a0.a0[69])
      << ", " << static_cast<int>(a0.a0[70]) << ", "
      << static_cast<int>(a0.a0[71]) << ", " << static_cast<int>(a0.a0[72])
      << ", " << static_cast<int>(a0.a0[73]) << ", "
      << static_cast<int>(a0.a0[74]) << ", " << static_cast<int>(a0.a0[75])
      << ", " << static_cast<int>(a0.a0[76]) << ", "
      << static_cast<int>(a0.a0[77]) << ", " << static_cast<int>(a0.a0[78])
      << ", " << static_cast<int>(a0.a0[79]) << ", "
      << static_cast<int>(a0.a0[80]) << ", " << static_cast<int>(a0.a0[81])
      << ", " << static_cast<int>(a0.a0[82]) << ", "
      << static_cast<int>(a0.a0[83]) << ", " << static_cast<int>(a0.a0[84])
      << ", " << static_cast<int>(a0.a0[85]) << ", "
      << static_cast<int>(a0.a0[86]) << ", " << static_cast<int>(a0.a0[87])
      << ", " << static_cast<int>(a0.a0[88]) << ", "
      << static_cast<int>(a0.a0[89]) << ", " << static_cast<int>(a0.a0[90])
      << ", " << static_cast<int>(a0.a0[91]) << ", "
      << static_cast<int>(a0.a0[92]) << ", " << static_cast<int>(a0.a0[93])
      << ", " << static_cast<int>(a0.a0[94]) << ", "
      << static_cast<int>(a0.a0[95]) << ", " << static_cast<int>(a0.a0[96])
      << ", " << static_cast<int>(a0.a0[97]) << ", "
      << static_cast<int>(a0.a0[98]) << ", " << static_cast<int>(a0.a0[99])
      << "]))" << "\n";
 
  int32_t result = 0;
 
  result += a0.a0[0];
  result += a0.a0[1];
  result += a0.a0[2];
  result += a0.a0[3];
  result += a0.a0[4];
  result += a0.a0[5];
  result += a0.a0[6];
  result += a0.a0[7];
  result += a0.a0[8];
  result += a0.a0[9];
  result += a0.a0[10];
  result += a0.a0[11];
  result += a0.a0[12];
  result += a0.a0[13];
  result += a0.a0[14];
  result += a0.a0[15];
  result += a0.a0[16];
  result += a0.a0[17];
  result += a0.a0[18];
  result += a0.a0[19];
  result += a0.a0[20];
  result += a0.a0[21];
  result += a0.a0[22];
  result += a0.a0[23];
  result += a0.a0[24];
  result += a0.a0[25];
  result += a0.a0[26];
  result += a0.a0[27];
  result += a0.a0[28];
  result += a0.a0[29];
  result += a0.a0[30];
  result += a0.a0[31];
  result += a0.a0[32];
  result += a0.a0[33];
  result += a0.a0[34];
  result += a0.a0[35];
  result += a0.a0[36];
  result += a0.a0[37];
  result += a0.a0[38];
  result += a0.a0[39];
  result += a0.a0[40];
  result += a0.a0[41];
  result += a0.a0[42];
  result += a0.a0[43];
  result += a0.a0[44];
  result += a0.a0[45];
  result += a0.a0[46];
  result += a0.a0[47];
  result += a0.a0[48];
  result += a0.a0[49];
  result += a0.a0[50];
  result += a0.a0[51];
  result += a0.a0[52];
  result += a0.a0[53];
  result += a0.a0[54];
  result += a0.a0[55];
  result += a0.a0[56];
  result += a0.a0[57];
  result += a0.a0[58];
  result += a0.a0[59];
  result += a0.a0[60];
  result += a0.a0[61];
  result += a0.a0[62];
  result += a0.a0[63];
  result += a0.a0[64];
  result += a0.a0[65];
  result += a0.a0[66];
  result += a0.a0[67];
  result += a0.a0[68];
  result += a0.a0[69];
  result += a0.a0[70];
  result += a0.a0[71];
  result += a0.a0[72];
  result += a0.a0[73];
  result += a0.a0[74];
  result += a0.a0[75];
  result += a0.a0[76];
  result += a0.a0[77];
  result += a0.a0[78];
  result += a0.a0[79];
  result += a0.a0[80];
  result += a0.a0[81];
  result += a0.a0[82];
  result += a0.a0[83];
  result += a0.a0[84];
  result += a0.a0[85];
  result += a0.a0[86];
  result += a0.a0[87];
  result += a0.a0[88];
  result += a0.a0[89];
  result += a0.a0[90];
  result += a0.a0[91];
  result += a0.a0[92];
  result += a0.a0[93];
  result += a0.a0[94];
  result += a0.a0[95];
  result += a0.a0[96];
  result += a0.a0[97];
  result += a0.a0[98];
  result += a0.a0[99];
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructInlineArrayIrregularx4()

DART_EXPORT int32_t dart::PassStructInlineArrayIrregularx4	(	StructInlineArrayIrregular	a0,
		StructInlineArrayIrregular	a1,
		StructInlineArrayIrregular	a2,
		StructInlineArrayIrregular	a3
	)

Definition at line 3467 of file ffi_test_functions_generated.cc.

                                                                {
  std::cout << "PassStructInlineArrayIrregularx4" << "(([(" << a0.a0[0].a0
            << ", " << static_cast<int>(a0.a0[0].a1) << "), (" << a0.a0[1].a0
            << ", " << static_cast<int>(a0.a0[1].a1) << ")], "
            << static_cast<int>(a0.a1) << "), ([(" << a1.a0[0].a0 << ", "
            << static_cast<int>(a1.a0[0].a1) << "), (" << a1.a0[1].a0 << ", "
            << static_cast<int>(a1.a0[1].a1) << ")], "
            << static_cast<int>(a1.a1) << "), ([(" << a2.a0[0].a0 << ", "
            << static_cast<int>(a2.a0[0].a1) << "), (" << a2.a0[1].a0 << ", "
            << static_cast<int>(a2.a0[1].a1) << ")], "
            << static_cast<int>(a2.a1) << "), ([(" << a3.a0[0].a0 << ", "
            << static_cast<int>(a3.a0[0].a1) << "), (" << a3.a0[1].a0 << ", "
            << static_cast<int>(a3.a0[1].a1) << ")], "
            << static_cast<int>(a3.a1) << "))" << "\n";
 
  int32_t result = 0;
 
  result += a0.a0[0].a0;
  result += a0.a0[0].a1;
  result += a0.a0[1].a0;
  result += a0.a0[1].a1;
  result += a0.a1;
  result += a1.a0[0].a0;
  result += a1.a0[0].a1;
  result += a1.a0[1].a0;
  result += a1.a0[1].a1;
  result += a1.a1;
  result += a2.a0[0].a0;
  result += a2.a0[0].a1;
  result += a2.a0[1].a0;
  result += a2.a0[1].a1;
  result += a2.a1;
  result += a3.a0[0].a0;
  result += a3.a0[0].a1;
  result += a3.a0[1].a0;
  result += a3.a0[1].a1;
  result += a3.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructNestedAlignmentStruct5BytesPackedMixed()

DART_EXPORT double dart::PassStructNestedAlignmentStruct5BytesPackedMixed

(

StructNestedAlignmentStruct5BytesPackedMixed

a0

)

Definition at line 4281 of file ffi_test_functions_generated.cc.

                                                     {
  std::cout << "PassStructNestedAlignmentStruct5BytesPackedMixed" << "(("
            << static_cast<int>(a0.a0) << ", (" << a0.a1.a0 << ", "
            << static_cast<int>(a0.a1.a1) << ")))" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a0.a1.a0;
  result += a0.a1.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructNestedIntStructAlignmentInt16()

DART_EXPORT int64_t dart::PassStructNestedIntStructAlignmentInt16

(

StructNestedIntStructAlignmentInt16

a0

)

Definition at line 3115 of file ffi_test_functions_generated.cc.

                                            {
  std::cout << "PassStructNestedIntStructAlignmentInt16" << "((("
            << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0.a0;
  result += a0.a0.a1;
  result += a0.a0.a2;
  result += a0.a1.a0;
  result += a0.a1.a1;
  result += a0.a1.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructNestedIntStructAlignmentInt32()

DART_EXPORT int64_t dart::PassStructNestedIntStructAlignmentInt32

(

StructNestedIntStructAlignmentInt32

a0

)

Definition at line 3139 of file ffi_test_functions_generated.cc.

                                            {
  std::cout << "PassStructNestedIntStructAlignmentInt32" << "((("
            << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0.a0;
  result += a0.a0.a1;
  result += a0.a0.a2;
  result += a0.a1.a0;
  result += a0.a1.a1;
  result += a0.a1.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructNestedIntStructAlignmentInt64()

DART_EXPORT int64_t dart::PassStructNestedIntStructAlignmentInt64

(

StructNestedIntStructAlignmentInt64

a0

)

Definition at line 3163 of file ffi_test_functions_generated.cc.

                                            {
  std::cout << "PassStructNestedIntStructAlignmentInt64" << "((("
            << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << "\n";
 
  int64_t result = 0;
 
  result += a0.a0.a0;
  result += a0.a0.a1;
  result += a0.a0.a2;
  result += a0.a1.a0;
  result += a0.a1.a1;
  result += a0.a1.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructNestedIrregularEvenBiggerx4()

DART_EXPORT double dart::PassStructNestedIrregularEvenBiggerx4	(	StructNestedIrregularEvenBigger	a0,
		StructNestedIrregularEvenBigger	a1,
		StructNestedIrregularEvenBigger	a2,
		StructNestedIrregularEvenBigger	a3
	)

Definition at line 3187 of file ffi_test_functions_generated.cc.

                                        {
  std::cout
      << "PassStructNestedIrregularEvenBiggerx4" << "((" << a0.a0 << ", (("
      << a0.a1.a0.a0 << ", ((" << a0.a1.a0.a1.a0.a0 << ", " << a0.a1.a0.a1.a0.a1
      << "), (" << a0.a1.a0.a1.a1.a0 << ")), " << a0.a1.a0.a2 << ", (("
      << a0.a1.a0.a3.a0.a0 << "), " << a0.a1.a0.a3.a1 << "), " << a0.a1.a0.a4
      << ", ((" << a0.a1.a0.a5.a0.a0 << "), (" << a0.a1.a0.a5.a1.a0 << ")), "
      << a0.a1.a0.a6 << "), ((" << a0.a1.a1.a0.a0 << ", " << a0.a1.a1.a0.a1
      << "), (" << a0.a1.a1.a1.a0 << ")), " << a0.a1.a2 << ", " << a0.a1.a3
      << "), ((" << a0.a2.a0.a0 << ", ((" << a0.a2.a0.a1.a0.a0 << ", "
      << a0.a2.a0.a1.a0.a1 << "), (" << a0.a2.a0.a1.a1.a0 << ")), "
      << a0.a2.a0.a2 << ", ((" << a0.a2.a0.a3.a0.a0 << "), " << a0.a2.a0.a3.a1
      << "), " << a0.a2.a0.a4 << ", ((" << a0.a2.a0.a5.a0.a0 << "), ("
      << a0.a2.a0.a5.a1.a0 << ")), " << a0.a2.a0.a6 << "), ((" << a0.a2.a1.a0.a0
      << ", " << a0.a2.a1.a0.a1 << "), (" << a0.a2.a1.a1.a0 << ")), "
      << a0.a2.a2 << ", " << a0.a2.a3 << "), " << a0.a3 << "), (" << a1.a0
      << ", ((" << a1.a1.a0.a0 << ", ((" << a1.a1.a0.a1.a0.a0 << ", "
      << a1.a1.a0.a1.a0.a1 << "), (" << a1.a1.a0.a1.a1.a0 << ")), "
      << a1.a1.a0.a2 << ", ((" << a1.a1.a0.a3.a0.a0 << "), " << a1.a1.a0.a3.a1
      << "), " << a1.a1.a0.a4 << ", ((" << a1.a1.a0.a5.a0.a0 << "), ("
      << a1.a1.a0.a5.a1.a0 << ")), " << a1.a1.a0.a6 << "), ((" << a1.a1.a1.a0.a0
      << ", " << a1.a1.a1.a0.a1 << "), (" << a1.a1.a1.a1.a0 << ")), "
      << a1.a1.a2 << ", " << a1.a1.a3 << "), ((" << a1.a2.a0.a0 << ", (("
      << a1.a2.a0.a1.a0.a0 << ", " << a1.a2.a0.a1.a0.a1 << "), ("
      << a1.a2.a0.a1.a1.a0 << ")), " << a1.a2.a0.a2 << ", (("
      << a1.a2.a0.a3.a0.a0 << "), " << a1.a2.a0.a3.a1 << "), " << a1.a2.a0.a4
      << ", ((" << a1.a2.a0.a5.a0.a0 << "), (" << a1.a2.a0.a5.a1.a0 << ")), "
      << a1.a2.a0.a6 << "), ((" << a1.a2.a1.a0.a0 << ", " << a1.a2.a1.a0.a1
      << "), (" << a1.a2.a1.a1.a0 << ")), " << a1.a2.a2 << ", " << a1.a2.a3
      << "), " << a1.a3 << "), (" << a2.a0 << ", ((" << a2.a1.a0.a0 << ", (("
      << a2.a1.a0.a1.a0.a0 << ", " << a2.a1.a0.a1.a0.a1 << "), ("
      << a2.a1.a0.a1.a1.a0 << ")), " << a2.a1.a0.a2 << ", (("
      << a2.a1.a0.a3.a0.a0 << "), " << a2.a1.a0.a3.a1 << "), " << a2.a1.a0.a4
      << ", ((" << a2.a1.a0.a5.a0.a0 << "), (" << a2.a1.a0.a5.a1.a0 << ")), "
      << a2.a1.a0.a6 << "), ((" << a2.a1.a1.a0.a0 << ", " << a2.a1.a1.a0.a1
      << "), (" << a2.a1.a1.a1.a0 << ")), " << a2.a1.a2 << ", " << a2.a1.a3
      << "), ((" << a2.a2.a0.a0 << ", ((" << a2.a2.a0.a1.a0.a0 << ", "
      << a2.a2.a0.a1.a0.a1 << "), (" << a2.a2.a0.a1.a1.a0 << ")), "
      << a2.a2.a0.a2 << ", ((" << a2.a2.a0.a3.a0.a0 << "), " << a2.a2.a0.a3.a1
      << "), " << a2.a2.a0.a4 << ", ((" << a2.a2.a0.a5.a0.a0 << "), ("
      << a2.a2.a0.a5.a1.a0 << ")), " << a2.a2.a0.a6 << "), ((" << a2.a2.a1.a0.a0
      << ", " << a2.a2.a1.a0.a1 << "), (" << a2.a2.a1.a1.a0 << ")), "
      << a2.a2.a2 << ", " << a2.a2.a3 << "), " << a2.a3 << "), (" << a3.a0
      << ", ((" << a3.a1.a0.a0 << ", ((" << a3.a1.a0.a1.a0.a0 << ", "
      << a3.a1.a0.a1.a0.a1 << "), (" << a3.a1.a0.a1.a1.a0 << ")), "
      << a3.a1.a0.a2 << ", ((" << a3.a1.a0.a3.a0.a0 << "), " << a3.a1.a0.a3.a1
      << "), " << a3.a1.a0.a4 << ", ((" << a3.a1.a0.a5.a0.a0 << "), ("
      << a3.a1.a0.a5.a1.a0 << ")), " << a3.a1.a0.a6 << "), ((" << a3.a1.a1.a0.a0
      << ", " << a3.a1.a1.a0.a1 << "), (" << a3.a1.a1.a1.a0 << ")), "
      << a3.a1.a2 << ", " << a3.a1.a3 << "), ((" << a3.a2.a0.a0 << ", (("
      << a3.a2.a0.a1.a0.a0 << ", " << a3.a2.a0.a1.a0.a1 << "), ("
      << a3.a2.a0.a1.a1.a0 << ")), " << a3.a2.a0.a2 << ", (("
      << a3.a2.a0.a3.a0.a0 << "), " << a3.a2.a0.a3.a1 << "), " << a3.a2.a0.a4
      << ", ((" << a3.a2.a0.a5.a0.a0 << "), (" << a3.a2.a0.a5.a1.a0 << ")), "
      << a3.a2.a0.a6 << "), ((" << a3.a2.a1.a0.a0 << ", " << a3.a2.a1.a0.a1
      << "), (" << a3.a2.a1.a1.a0 << ")), " << a3.a2.a2 << ", " << a3.a2.a3
      << "), " << a3.a3 << "))" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a0.a1.a0.a0;
  result += a0.a1.a0.a1.a0.a0;
  result += a0.a1.a0.a1.a0.a1;
  result += a0.a1.a0.a1.a1.a0;
  result += a0.a1.a0.a2;
  result += a0.a1.a0.a3.a0.a0;
  result += a0.a1.a0.a3.a1;
  result += a0.a1.a0.a4;
  result += a0.a1.a0.a5.a0.a0;
  result += a0.a1.a0.a5.a1.a0;
  result += a0.a1.a0.a6;
  result += a0.a1.a1.a0.a0;
  result += a0.a1.a1.a0.a1;
  result += a0.a1.a1.a1.a0;
  result += a0.a1.a2;
  result += a0.a1.a3;
  result += a0.a2.a0.a0;
  result += a0.a2.a0.a1.a0.a0;
  result += a0.a2.a0.a1.a0.a1;
  result += a0.a2.a0.a1.a1.a0;
  result += a0.a2.a0.a2;
  result += a0.a2.a0.a3.a0.a0;
  result += a0.a2.a0.a3.a1;
  result += a0.a2.a0.a4;
  result += a0.a2.a0.a5.a0.a0;
  result += a0.a2.a0.a5.a1.a0;
  result += a0.a2.a0.a6;
  result += a0.a2.a1.a0.a0;
  result += a0.a2.a1.a0.a1;
  result += a0.a2.a1.a1.a0;
  result += a0.a2.a2;
  result += a0.a2.a3;
  result += a0.a3;
  result += a1.a0;
  result += a1.a1.a0.a0;
  result += a1.a1.a0.a1.a0.a0;
  result += a1.a1.a0.a1.a0.a1;
  result += a1.a1.a0.a1.a1.a0;
  result += a1.a1.a0.a2;
  result += a1.a1.a0.a3.a0.a0;
  result += a1.a1.a0.a3.a1;
  result += a1.a1.a0.a4;
  result += a1.a1.a0.a5.a0.a0;
  result += a1.a1.a0.a5.a1.a0;
  result += a1.a1.a0.a6;
  result += a1.a1.a1.a0.a0;
  result += a1.a1.a1.a0.a1;
  result += a1.a1.a1.a1.a0;
  result += a1.a1.a2;
  result += a1.a1.a3;
  result += a1.a2.a0.a0;
  result += a1.a2.a0.a1.a0.a0;
  result += a1.a2.a0.a1.a0.a1;
  result += a1.a2.a0.a1.a1.a0;
  result += a1.a2.a0.a2;
  result += a1.a2.a0.a3.a0.a0;
  result += a1.a2.a0.a3.a1;
  result += a1.a2.a0.a4;
  result += a1.a2.a0.a5.a0.a0;
  result += a1.a2.a0.a5.a1.a0;
  result += a1.a2.a0.a6;
  result += a1.a2.a1.a0.a0;
  result += a1.a2.a1.a0.a1;
  result += a1.a2.a1.a1.a0;
  result += a1.a2.a2;
  result += a1.a2.a3;
  result += a1.a3;
  result += a2.a0;
  result += a2.a1.a0.a0;
  result += a2.a1.a0.a1.a0.a0;
  result += a2.a1.a0.a1.a0.a1;
  result += a2.a1.a0.a1.a1.a0;
  result += a2.a1.a0.a2;
  result += a2.a1.a0.a3.a0.a0;
  result += a2.a1.a0.a3.a1;
  result += a2.a1.a0.a4;
  result += a2.a1.a0.a5.a0.a0;
  result += a2.a1.a0.a5.a1.a0;
  result += a2.a1.a0.a6;
  result += a2.a1.a1.a0.a0;
  result += a2.a1.a1.a0.a1;
  result += a2.a1.a1.a1.a0;
  result += a2.a1.a2;
  result += a2.a1.a3;
  result += a2.a2.a0.a0;
  result += a2.a2.a0.a1.a0.a0;
  result += a2.a2.a0.a1.a0.a1;
  result += a2.a2.a0.a1.a1.a0;
  result += a2.a2.a0.a2;
  result += a2.a2.a0.a3.a0.a0;
  result += a2.a2.a0.a3.a1;
  result += a2.a2.a0.a4;
  result += a2.a2.a0.a5.a0.a0;
  result += a2.a2.a0.a5.a1.a0;
  result += a2.a2.a0.a6;
  result += a2.a2.a1.a0.a0;
  result += a2.a2.a1.a0.a1;
  result += a2.a2.a1.a1.a0;
  result += a2.a2.a2;
  result += a2.a2.a3;
  result += a2.a3;
  result += a3.a0;
  result += a3.a1.a0.a0;
  result += a3.a1.a0.a1.a0.a0;
  result += a3.a1.a0.a1.a0.a1;
  result += a3.a1.a0.a1.a1.a0;
  result += a3.a1.a0.a2;
  result += a3.a1.a0.a3.a0.a0;
  result += a3.a1.a0.a3.a1;
  result += a3.a1.a0.a4;
  result += a3.a1.a0.a5.a0.a0;
  result += a3.a1.a0.a5.a1.a0;
  result += a3.a1.a0.a6;
  result += a3.a1.a1.a0.a0;
  result += a3.a1.a1.a0.a1;
  result += a3.a1.a1.a1.a0;
  result += a3.a1.a2;
  result += a3.a1.a3;
  result += a3.a2.a0.a0;
  result += a3.a2.a0.a1.a0.a0;
  result += a3.a2.a0.a1.a0.a1;
  result += a3.a2.a0.a1.a1.a0;
  result += a3.a2.a0.a2;
  result += a3.a2.a0.a3.a0.a0;
  result += a3.a2.a0.a3.a1;
  result += a3.a2.a0.a4;
  result += a3.a2.a0.a5.a0.a0;
  result += a3.a2.a0.a5.a1.a0;
  result += a3.a2.a0.a6;
  result += a3.a2.a1.a0.a0;
  result += a3.a2.a1.a0.a1;
  result += a3.a2.a1.a1.a0;
  result += a3.a2.a2;
  result += a3.a2.a3;
  result += a3.a3;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructRecursive()

DART_EXPORT Struct20BytesHomogeneousInt32Copy dart::PassStructRecursive	(	int64_t	recursionCounter,
		Struct20BytesHomogeneousInt32Copy	a0,
		Struct20BytesHomogeneousInt32Copy(*)(int64_t, Struct20BytesHomogeneousInt32Copy)	f
	)

Definition at line 846 of file ffi_test_functions.cc.

                                                                               {
  std::cout << "PassStruct20BytesHomogeneousInt32x10" << "(" << recursionCounter
            << ", (" << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
            << ", " << a0.a4 << "), " << reinterpret_cast<void*>(f) << ")\n";
  a0.a0++;
  const int32_t a0_a0_saved = a0.a0;
 
  if (recursionCounter <= 0) {
    return a0;
  }
 
  Struct20BytesHomogeneousInt32Copy result = f(recursionCounter - 1, a0);
  result.a0++;
  if (a0_a0_saved != a0.a0) {
    result.a4 = 0;
  }
 
  return result;
}

PassStructStruct16BytesHomogeneousFloat2x5()

DART_EXPORT float dart::PassStructStruct16BytesHomogeneousFloat2x5	(	StructStruct16BytesHomogeneousFloat2	a0,
		StructStruct16BytesHomogeneousFloat2	a1,
		StructStruct16BytesHomogeneousFloat2	a2,
		StructStruct16BytesHomogeneousFloat2	a3,
		StructStruct16BytesHomogeneousFloat2	a4
	)

Definition at line 3698 of file ffi_test_functions_generated.cc.

                                             {
  std::cout << "PassStructStruct16BytesHomogeneousFloat2x5" << "(((" << a0.a0.a0
            << "), [(" << a0.a1[0].a0 << "), (" << a0.a1[1].a0 << ")], "
            << a0.a2 << "), ((" << a1.a0.a0 << "), [(" << a1.a1[0].a0 << "), ("
            << a1.a1[1].a0 << ")], " << a1.a2 << "), ((" << a2.a0.a0 << "), [("
            << a2.a1[0].a0 << "), (" << a2.a1[1].a0 << ")], " << a2.a2
            << "), ((" << a3.a0.a0 << "), [(" << a3.a1[0].a0 << "), ("
            << a3.a1[1].a0 << ")], " << a3.a2 << "), ((" << a4.a0.a0 << "), [("
            << a4.a1[0].a0 << "), (" << a4.a1[1].a0 << ")], " << a4.a2 << "))"
            << "\n";
 
  float result = 0;
 
  result += a0.a0.a0;
  result += a0.a1[0].a0;
  result += a0.a1[1].a0;
  result += a0.a2;
  result += a1.a0.a0;
  result += a1.a1[0].a0;
  result += a1.a1[1].a0;
  result += a1.a2;
  result += a2.a0.a0;
  result += a2.a1[0].a0;
  result += a2.a1[1].a0;
  result += a2.a2;
  result += a3.a0.a0;
  result += a3.a1[0].a0;
  result += a3.a1[1].a0;
  result += a3.a2;
  result += a4.a0.a0;
  result += a4.a1[0].a0;
  result += a4.a1[1].a0;
  result += a4.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructStruct16BytesMixed3x10()

DART_EXPORT float dart::PassStructStruct16BytesMixed3x10	(	StructStruct16BytesMixed3	a0,
		StructStruct16BytesMixed3	a1,
		StructStruct16BytesMixed3	a2,
		StructStruct16BytesMixed3	a3,
		StructStruct16BytesMixed3	a4,
		StructStruct16BytesMixed3	a5,
		StructStruct16BytesMixed3	a6,
		StructStruct16BytesMixed3	a7,
		StructStruct16BytesMixed3	a8,
		StructStruct16BytesMixed3	a9
	)

Definition at line 3794 of file ffi_test_functions_generated.cc.

                                  {
  std::cout << "PassStructStruct16BytesMixed3x10" << "(((" << a0.a0.a0
            << "), [(" << a0.a1[0].a0 << ", " << a0.a1[0].a1 << ", "
            << a0.a1[0].a2 << ")], [" << a0.a2[0] << ", " << a0.a2[1]
            << "]), ((" << a1.a0.a0 << "), [(" << a1.a1[0].a0 << ", "
            << a1.a1[0].a1 << ", " << a1.a1[0].a2 << ")], [" << a1.a2[0] << ", "
            << a1.a2[1] << "]), ((" << a2.a0.a0 << "), [(" << a2.a1[0].a0
            << ", " << a2.a1[0].a1 << ", " << a2.a1[0].a2 << ")], [" << a2.a2[0]
            << ", " << a2.a2[1] << "]), ((" << a3.a0.a0 << "), [("
            << a3.a1[0].a0 << ", " << a3.a1[0].a1 << ", " << a3.a1[0].a2
            << ")], [" << a3.a2[0] << ", " << a3.a2[1] << "]), ((" << a4.a0.a0
            << "), [(" << a4.a1[0].a0 << ", " << a4.a1[0].a1 << ", "
            << a4.a1[0].a2 << ")], [" << a4.a2[0] << ", " << a4.a2[1]
            << "]), ((" << a5.a0.a0 << "), [(" << a5.a1[0].a0 << ", "
            << a5.a1[0].a1 << ", " << a5.a1[0].a2 << ")], [" << a5.a2[0] << ", "
            << a5.a2[1] << "]), ((" << a6.a0.a0 << "), [(" << a6.a1[0].a0
            << ", " << a6.a1[0].a1 << ", " << a6.a1[0].a2 << ")], [" << a6.a2[0]
            << ", " << a6.a2[1] << "]), ((" << a7.a0.a0 << "), [("
            << a7.a1[0].a0 << ", " << a7.a1[0].a1 << ", " << a7.a1[0].a2
            << ")], [" << a7.a2[0] << ", " << a7.a2[1] << "]), ((" << a8.a0.a0
            << "), [(" << a8.a1[0].a0 << ", " << a8.a1[0].a1 << ", "
            << a8.a1[0].a2 << ")], [" << a8.a2[0] << ", " << a8.a2[1]
            << "]), ((" << a9.a0.a0 << "), [(" << a9.a1[0].a0 << ", "
            << a9.a1[0].a1 << ", " << a9.a1[0].a2 << ")], [" << a9.a2[0] << ", "
            << a9.a2[1] << "]))" << "\n";
 
  float result = 0;
 
  result += a0.a0.a0;
  result += a0.a1[0].a0;
  result += a0.a1[0].a1;
  result += a0.a1[0].a2;
  result += a0.a2[0];
  result += a0.a2[1];
  result += a1.a0.a0;
  result += a1.a1[0].a0;
  result += a1.a1[0].a1;
  result += a1.a1[0].a2;
  result += a1.a2[0];
  result += a1.a2[1];
  result += a2.a0.a0;
  result += a2.a1[0].a0;
  result += a2.a1[0].a1;
  result += a2.a1[0].a2;
  result += a2.a2[0];
  result += a2.a2[1];
  result += a3.a0.a0;
  result += a3.a1[0].a0;
  result += a3.a1[0].a1;
  result += a3.a1[0].a2;
  result += a3.a2[0];
  result += a3.a2[1];
  result += a4.a0.a0;
  result += a4.a1[0].a0;
  result += a4.a1[0].a1;
  result += a4.a1[0].a2;
  result += a4.a2[0];
  result += a4.a2[1];
  result += a5.a0.a0;
  result += a5.a1[0].a0;
  result += a5.a1[0].a1;
  result += a5.a1[0].a2;
  result += a5.a2[0];
  result += a5.a2[1];
  result += a6.a0.a0;
  result += a6.a1[0].a0;
  result += a6.a1[0].a1;
  result += a6.a1[0].a2;
  result += a6.a2[0];
  result += a6.a2[1];
  result += a7.a0.a0;
  result += a7.a1[0].a0;
  result += a7.a1[0].a1;
  result += a7.a1[0].a2;
  result += a7.a2[0];
  result += a7.a2[1];
  result += a8.a0.a0;
  result += a8.a1[0].a0;
  result += a8.a1[0].a1;
  result += a8.a1[0].a2;
  result += a8.a2[0];
  result += a8.a2[1];
  result += a9.a0.a0;
  result += a9.a1[0].a0;
  result += a9.a1[0].a1;
  result += a9.a1[0].a2;
  result += a9.a2[0];
  result += a9.a2[1];
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassStructStruct32BytesHomogeneousDouble2x5()

DART_EXPORT double dart::PassStructStruct32BytesHomogeneousDouble2x5	(	StructStruct32BytesHomogeneousDouble2	a0,
		StructStruct32BytesHomogeneousDouble2	a1,
		StructStruct32BytesHomogeneousDouble2	a2,
		StructStruct32BytesHomogeneousDouble2	a3,
		StructStruct32BytesHomogeneousDouble2	a4
	)

Definition at line 3745 of file ffi_test_functions_generated.cc.

                                              {
  std::cout << "PassStructStruct32BytesHomogeneousDouble2x5" << "((("
            << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), (" << a0.a1[1].a0
            << ")], " << a0.a2 << "), ((" << a1.a0.a0 << "), [(" << a1.a1[0].a0
            << "), (" << a1.a1[1].a0 << ")], " << a1.a2 << "), ((" << a2.a0.a0
            << "), [(" << a2.a1[0].a0 << "), (" << a2.a1[1].a0 << ")], "
            << a2.a2 << "), ((" << a3.a0.a0 << "), [(" << a3.a1[0].a0 << "), ("
            << a3.a1[1].a0 << ")], " << a3.a2 << "), ((" << a4.a0.a0 << "), [("
            << a4.a1[0].a0 << "), (" << a4.a1[1].a0 << ")], " << a4.a2 << "))"
            << "\n";
 
  double result = 0;
 
  result += a0.a0.a0;
  result += a0.a1[0].a0;
  result += a0.a1[1].a0;
  result += a0.a2;
  result += a1.a0.a0;
  result += a1.a1[0].a0;
  result += a1.a1[1].a0;
  result += a1.a2;
  result += a2.a0.a0;
  result += a2.a1[0].a0;
  result += a2.a1[1].a0;
  result += a2.a2;
  result += a3.a0.a0;
  result += a3.a1[0].a0;
  result += a3.a1[1].a0;
  result += a3.a2;
  result += a4.a0.a0;
  result += a4.a1[0].a0;
  result += a4.a1[1].a0;
  result += a4.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassThroughFinalizer()

static void dart::PassThroughFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 366 of file kernel_isolate.cc.

{}

PassUint8Boolx9Struct10BytesHomogeneousBoolBool()

DART_EXPORT int32_t dart::PassUint8Boolx9Struct10BytesHomogeneousBoolBool	(	uint8_t	a0,
		bool	a1,
		bool	a2,
		bool	a3,
		bool	a4,
		bool	a5,
		bool	a6,
		bool	a7,
		bool	a8,
		bool	a9,
		Struct10BytesHomogeneousBool	a10,
		bool	a11
	)

Definition at line 4604 of file ffi_test_functions_generated.cc.

              {
  std::cout << "PassUint8Boolx9Struct10BytesHomogeneousBoolBool" << "("
            << static_cast<int>(a0) << ", " << a1 << ", " << a2 << ", " << a3
            << ", " << a4 << ", " << a5 << ", " << a6 << ", " << a7 << ", "
            << a8 << ", " << a9 << ", (" << a10.a0 << ", " << a10.a1 << ", "
            << a10.a2 << ", " << a10.a3 << ", " << a10.a4 << ", " << a10.a5
            << ", " << a10.a6 << ", " << a10.a7 << ", " << a10.a8 << ", "
            << a10.a9 << "), " << a11 << ")" << "\n";
 
  int32_t result = 0;
 
  result += a0;
  result += a1 ? 1 : 0;
  result += a2 ? 1 : 0;
  result += a3 ? 1 : 0;
  result += a4 ? 1 : 0;
  result += a5 ? 1 : 0;
  result += a6 ? 1 : 0;
  result += a7 ? 1 : 0;
  result += a8 ? 1 : 0;
  result += a9 ? 1 : 0;
  result += a10.a0 ? 1 : 0;
  result += a10.a1 ? 1 : 0;
  result += a10.a2 ? 1 : 0;
  result += a10.a3 ? 1 : 0;
  result += a10.a4 ? 1 : 0;
  result += a10.a5 ? 1 : 0;
  result += a10.a6 ? 1 : 0;
  result += a10.a7 ? 1 : 0;
  result += a10.a8 ? 1 : 0;
  result += a10.a9 ? 1 : 0;
  result += a11 ? 1 : 0;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassUint8Boolx9Struct10BytesInlineArrayBoolBool()

DART_EXPORT int32_t dart::PassUint8Boolx9Struct10BytesInlineArrayBoolBool	(	uint8_t	a0,
		bool	a1,
		bool	a2,
		bool	a3,
		bool	a4,
		bool	a5,
		bool	a6,
		bool	a7,
		bool	a8,
		bool	a9,
		Struct10BytesInlineArrayBool	a10,
		bool	a11
	)

Definition at line 4658 of file ffi_test_functions_generated.cc.

              {
  std::cout << "PassUint8Boolx9Struct10BytesInlineArrayBoolBool" << "("
            << static_cast<int>(a0) << ", " << a1 << ", " << a2 << ", " << a3
            << ", " << a4 << ", " << a5 << ", " << a6 << ", " << a7 << ", "
            << a8 << ", " << a9 << ", ([" << a10.a0[0] << ", " << a10.a0[1]
            << ", " << a10.a0[2] << ", " << a10.a0[3] << ", " << a10.a0[4]
            << ", " << a10.a0[5] << ", " << a10.a0[6] << ", " << a10.a0[7]
            << ", " << a10.a0[8] << ", " << a10.a0[9] << "]), " << a11 << ")"
            << "\n";
 
  int32_t result = 0;
 
  result += a0;
  result += a1 ? 1 : 0;
  result += a2 ? 1 : 0;
  result += a3 ? 1 : 0;
  result += a4 ? 1 : 0;
  result += a5 ? 1 : 0;
  result += a6 ? 1 : 0;
  result += a7 ? 1 : 0;
  result += a8 ? 1 : 0;
  result += a9 ? 1 : 0;
  result += a10.a0[0] ? 1 : 0;
  result += a10.a0[1] ? 1 : 0;
  result += a10.a0[2] ? 1 : 0;
  result += a10.a0[3] ? 1 : 0;
  result += a10.a0[4] ? 1 : 0;
  result += a10.a0[5] ? 1 : 0;
  result += a10.a0[6] ? 1 : 0;
  result += a10.a0[7] ? 1 : 0;
  result += a10.a0[8] ? 1 : 0;
  result += a10.a0[9] ? 1 : 0;
  result += a11 ? 1 : 0;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassUint8Struct1ByteBool()

DART_EXPORT bool dart::PassUint8Struct1ByteBool	(	uint8_t	a0,
		Struct1ByteBool	a1
	)

Definition at line 4711 of file ffi_test_functions_generated.cc.

                                                                          {
  std::cout << "PassUint8Struct1ByteBool" << "(" << static_cast<int>(a0)
            << ", (" << a1.a0 << "))" << "\n";
 
  uint64_t result = 0;
 
  result += a0;
  result += a1.a0 ? 1 : 0;
 
  std::cout << "result = " << result << "\n";
 
  return result % 2 != 0;
}

PassUint8Struct32BytesInlineArrayMultiDimensionalI()

DART_EXPORT uint32_t dart::PassUint8Struct32BytesInlineArrayMultiDimensionalI	(	uint8_t	a0,
		Struct32BytesInlineArrayMultiDimensionalInt	a1,
		uint8_t	a2,
		Struct8BytesInlineArrayMultiDimensionalInt	a3,
		uint8_t	a4,
		Struct8BytesInlineArrayMultiDimensionalInt	a5,
		uint8_t	a6
	)

Definition at line 3900 of file ffi_test_functions_generated.cc.

                {
  std::cout << "PassUint8Struct32BytesInlineArrayMultiDimensionalI" << "("
            << static_cast<int>(a0) << ", ([[[[["
            << static_cast<int>(a1.a0[0][0][0][0][0]) << ", "
            << static_cast<int>(a1.a0[0][0][0][0][1]) << "], ["
            << static_cast<int>(a1.a0[0][0][0][1][0]) << ", "
            << static_cast<int>(a1.a0[0][0][0][1][1]) << "]], [["
            << static_cast<int>(a1.a0[0][0][1][0][0]) << ", "
            << static_cast<int>(a1.a0[0][0][1][0][1]) << "], ["
            << static_cast<int>(a1.a0[0][0][1][1][0]) << ", "
            << static_cast<int>(a1.a0[0][0][1][1][1]) << "]]], [[["
            << static_cast<int>(a1.a0[0][1][0][0][0]) << ", "
            << static_cast<int>(a1.a0[0][1][0][0][1]) << "], ["
            << static_cast<int>(a1.a0[0][1][0][1][0]) << ", "
            << static_cast<int>(a1.a0[0][1][0][1][1]) << "]], [["
            << static_cast<int>(a1.a0[0][1][1][0][0]) << ", "
            << static_cast<int>(a1.a0[0][1][1][0][1]) << "], ["
            << static_cast<int>(a1.a0[0][1][1][1][0]) << ", "
            << static_cast<int>(a1.a0[0][1][1][1][1]) << "]]]], [[[["
            << static_cast<int>(a1.a0[1][0][0][0][0]) << ", "
            << static_cast<int>(a1.a0[1][0][0][0][1]) << "], ["
            << static_cast<int>(a1.a0[1][0][0][1][0]) << ", "
            << static_cast<int>(a1.a0[1][0][0][1][1]) << "]], [["
            << static_cast<int>(a1.a0[1][0][1][0][0]) << ", "
            << static_cast<int>(a1.a0[1][0][1][0][1]) << "], ["
            << static_cast<int>(a1.a0[1][0][1][1][0]) << ", "
            << static_cast<int>(a1.a0[1][0][1][1][1]) << "]]], [[["
            << static_cast<int>(a1.a0[1][1][0][0][0]) << ", "
            << static_cast<int>(a1.a0[1][1][0][0][1]) << "], ["
            << static_cast<int>(a1.a0[1][1][0][1][0]) << ", "
            << static_cast<int>(a1.a0[1][1][0][1][1]) << "]], [["
            << static_cast<int>(a1.a0[1][1][1][0][0]) << ", "
            << static_cast<int>(a1.a0[1][1][1][0][1]) << "], ["
            << static_cast<int>(a1.a0[1][1][1][1][0]) << ", "
            << static_cast<int>(a1.a0[1][1][1][1][1]) << "]]]]]), "
            << static_cast<int>(a2) << ", ([[["
            << static_cast<int>(a3.a0[0][0][0]) << ", "
            << static_cast<int>(a3.a0[0][0][1]) << "], ["
            << static_cast<int>(a3.a0[0][1][0]) << ", "
            << static_cast<int>(a3.a0[0][1][1]) << "]], [["
            << static_cast<int>(a3.a0[1][0][0]) << ", "
            << static_cast<int>(a3.a0[1][0][1]) << "], ["
            << static_cast<int>(a3.a0[1][1][0]) << ", "
            << static_cast<int>(a3.a0[1][1][1]) << "]]]), "
            << static_cast<int>(a4) << ", ([[["
            << static_cast<int>(a5.a0[0][0][0]) << ", "
            << static_cast<int>(a5.a0[0][0][1]) << "], ["
            << static_cast<int>(a5.a0[0][1][0]) << ", "
            << static_cast<int>(a5.a0[0][1][1]) << "]], [["
            << static_cast<int>(a5.a0[1][0][0]) << ", "
            << static_cast<int>(a5.a0[1][0][1]) << "], ["
            << static_cast<int>(a5.a0[1][1][0]) << ", "
            << static_cast<int>(a5.a0[1][1][1]) << "]]]), "
            << static_cast<int>(a6) << ")" << "\n";
 
  uint32_t result = 0;
 
  result += a0;
  result += a1.a0[0][0][0][0][0];
  result += a1.a0[0][0][0][0][1];
  result += a1.a0[0][0][0][1][0];
  result += a1.a0[0][0][0][1][1];
  result += a1.a0[0][0][1][0][0];
  result += a1.a0[0][0][1][0][1];
  result += a1.a0[0][0][1][1][0];
  result += a1.a0[0][0][1][1][1];
  result += a1.a0[0][1][0][0][0];
  result += a1.a0[0][1][0][0][1];
  result += a1.a0[0][1][0][1][0];
  result += a1.a0[0][1][0][1][1];
  result += a1.a0[0][1][1][0][0];
  result += a1.a0[0][1][1][0][1];
  result += a1.a0[0][1][1][1][0];
  result += a1.a0[0][1][1][1][1];
  result += a1.a0[1][0][0][0][0];
  result += a1.a0[1][0][0][0][1];
  result += a1.a0[1][0][0][1][0];
  result += a1.a0[1][0][0][1][1];
  result += a1.a0[1][0][1][0][0];
  result += a1.a0[1][0][1][0][1];
  result += a1.a0[1][0][1][1][0];
  result += a1.a0[1][0][1][1][1];
  result += a1.a0[1][1][0][0][0];
  result += a1.a0[1][1][0][0][1];
  result += a1.a0[1][1][0][1][0];
  result += a1.a0[1][1][0][1][1];
  result += a1.a0[1][1][1][0][0];
  result += a1.a0[1][1][1][0][1];
  result += a1.a0[1][1][1][1][0];
  result += a1.a0[1][1][1][1][1];
  result += a2;
  result += a3.a0[0][0][0];
  result += a3.a0[0][0][1];
  result += a3.a0[0][1][0];
  result += a3.a0[0][1][1];
  result += a3.a0[1][0][0];
  result += a3.a0[1][0][1];
  result += a3.a0[1][1][0];
  result += a3.a0[1][1][1];
  result += a4;
  result += a5.a0[0][0][0];
  result += a5.a0[0][0][1];
  result += a5.a0[0][1][0];
  result += a5.a0[0][1][1];
  result += a5.a0[1][0][0];
  result += a5.a0[1][0][1];
  result += a5.a0[1][1][0];
  result += a5.a0[1][1][1];
  result += a6;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassUint8Struct4BytesInlineArrayMultiDimensionalIn()

DART_EXPORT uint32_t dart::PassUint8Struct4BytesInlineArrayMultiDimensionalIn	(	uint8_t	a0,
		Struct4BytesInlineArrayMultiDimensionalInt	a1,
		uint8_t	a2
	)

Definition at line 4024 of file ffi_test_functions_generated.cc.

                {
  std::cout << "PassUint8Struct4BytesInlineArrayMultiDimensionalIn" << "("
            << static_cast<int>(a0) << ", ([[("
            << static_cast<int>(a1.a0[0][0].a0) << "), ("
            << static_cast<int>(a1.a0[0][1].a0) << ")], [("
            << static_cast<int>(a1.a0[1][0].a0) << "), ("
            << static_cast<int>(a1.a0[1][1].a0) << ")]]), "
            << static_cast<int>(a2) << ")" << "\n";
 
  uint32_t result = 0;
 
  result += a0;
  result += a1.a0[0][0].a0;
  result += a1.a0[0][1].a0;
  result += a1.a0[1][0].a0;
  result += a1.a0[1][1].a0;
  result += a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassUnion16BytesNestedFloatx10()

DART_EXPORT double dart::PassUnion16BytesNestedFloatx10	(	Union16BytesNestedFloat	a0,
		Union16BytesNestedFloat	a1,
		Union16BytesNestedFloat	a2,
		Union16BytesNestedFloat	a3,
		Union16BytesNestedFloat	a4,
		Union16BytesNestedFloat	a5,
		Union16BytesNestedFloat	a6,
		Union16BytesNestedFloat	a7,
		Union16BytesNestedFloat	a8,
		Union16BytesNestedFloat	a9
	)

Definition at line 4553 of file ffi_test_functions_generated.cc.

                                                                              {
  std::cout << "PassUnion16BytesNestedFloatx10" << "(((" << a0.a0.a0 << ", "
            << a0.a0.a1 << ")), ((" << a1.a0.a0 << ", " << a1.a0.a1 << ")), (("
            << a2.a0.a0 << ", " << a2.a0.a1 << ")), ((" << a3.a0.a0 << ", "
            << a3.a0.a1 << ")), ((" << a4.a0.a0 << ", " << a4.a0.a1 << ")), (("
            << a5.a0.a0 << ", " << a5.a0.a1 << ")), ((" << a6.a0.a0 << ", "
            << a6.a0.a1 << ")), ((" << a7.a0.a0 << ", " << a7.a0.a1 << ")), (("
            << a8.a0.a0 << ", " << a8.a0.a1 << ")), ((" << a9.a0.a0 << ", "
            << a9.a0.a1 << ")))" << "\n";
 
  double result = 0;
 
  result += a0.a0.a0;
  result += a0.a0.a1;
  result += a1.a0.a0;
  result += a1.a0.a1;
  result += a2.a0.a0;
  result += a2.a0.a1;
  result += a3.a0.a0;
  result += a3.a0.a1;
  result += a4.a0.a0;
  result += a4.a0.a1;
  result += a5.a0.a0;
  result += a5.a0.a1;
  result += a6.a0.a0;
  result += a6.a0.a1;
  result += a7.a0.a0;
  result += a7.a0.a1;
  result += a8.a0.a0;
  result += a8.a0.a1;
  result += a9.a0.a0;
  result += a9.a0.a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassUnion16BytesNestedInlineArrayFloatx10()

DART_EXPORT double dart::PassUnion16BytesNestedInlineArrayFloatx10	(	Union16BytesNestedInlineArrayFloat	a0,
		Union16BytesNestedInlineArrayFloat	a1,
		Union16BytesNestedInlineArrayFloat	a2,
		Union16BytesNestedInlineArrayFloat	a3,
		Union16BytesNestedInlineArrayFloat	a4,
		Union16BytesNestedInlineArrayFloat	a5,
		Union16BytesNestedInlineArrayFloat	a6,
		Union16BytesNestedInlineArrayFloat	a7,
		Union16BytesNestedInlineArrayFloat	a8,
		Union16BytesNestedInlineArrayFloat	a9
	)

Definition at line 4476 of file ffi_test_functions_generated.cc.

                                           {
  std::cout << "PassUnion16BytesNestedInlineArrayFloatx10" << "(([" << a0.a0[0]
            << ", " << a0.a0[1] << ", " << a0.a0[2] << ", " << a0.a0[3]
            << "]), ([" << a1.a0[0] << ", " << a1.a0[1] << ", " << a1.a0[2]
            << ", " << a1.a0[3] << "]), ([" << a2.a0[0] << ", " << a2.a0[1]
            << ", " << a2.a0[2] << ", " << a2.a0[3] << "]), ([" << a3.a0[0]
            << ", " << a3.a0[1] << ", " << a3.a0[2] << ", " << a3.a0[3]
            << "]), ([" << a4.a0[0] << ", " << a4.a0[1] << ", " << a4.a0[2]
            << ", " << a4.a0[3] << "]), ([" << a5.a0[0] << ", " << a5.a0[1]
            << ", " << a5.a0[2] << ", " << a5.a0[3] << "]), ([" << a6.a0[0]
            << ", " << a6.a0[1] << ", " << a6.a0[2] << ", " << a6.a0[3]
            << "]), ([" << a7.a0[0] << ", " << a7.a0[1] << ", " << a7.a0[2]
            << ", " << a7.a0[3] << "]), ([" << a8.a0[0] << ", " << a8.a0[1]
            << ", " << a8.a0[2] << ", " << a8.a0[3] << "]), ([" << a9.a0[0]
            << ", " << a9.a0[1] << ", " << a9.a0[2] << ", " << a9.a0[3] << "]))"
            << "\n";
 
  double result = 0;
 
  result += a0.a0[0];
  result += a0.a0[1];
  result += a0.a0[2];
  result += a0.a0[3];
  result += a1.a0[0];
  result += a1.a0[1];
  result += a1.a0[2];
  result += a1.a0[3];
  result += a2.a0[0];
  result += a2.a0[1];
  result += a2.a0[2];
  result += a2.a0[3];
  result += a3.a0[0];
  result += a3.a0[1];
  result += a3.a0[2];
  result += a3.a0[3];
  result += a4.a0[0];
  result += a4.a0[1];
  result += a4.a0[2];
  result += a4.a0[3];
  result += a5.a0[0];
  result += a5.a0[1];
  result += a5.a0[2];
  result += a5.a0[3];
  result += a6.a0[0];
  result += a6.a0[1];
  result += a6.a0[2];
  result += a6.a0[3];
  result += a7.a0[0];
  result += a7.a0[1];
  result += a7.a0[2];
  result += a7.a0[3];
  result += a8.a0[0];
  result += a8.a0[1];
  result += a8.a0[2];
  result += a8.a0[3];
  result += a9.a0[0];
  result += a9.a0[1];
  result += a9.a0[2];
  result += a9.a0[3];
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassUnion4BytesMixedx10()

DART_EXPORT double dart::PassUnion4BytesMixedx10	(	Union4BytesMixed	a0,
		Union4BytesMixed	a1,
		Union4BytesMixed	a2,
		Union4BytesMixed	a3,
		Union4BytesMixed	a4,
		Union4BytesMixed	a5,
		Union4BytesMixed	a6,
		Union4BytesMixed	a7,
		Union4BytesMixed	a8,
		Union4BytesMixed	a9
	)

Definition at line 4344 of file ffi_test_functions_generated.cc.

                                                                {
  std::cout << "PassUnion4BytesMixedx10" << "((" << a0.a0 << "), (" << a1.a0
            << "), (" << a2.a0 << "), (" << a3.a0 << "), (" << a4.a0 << "), ("
            << a5.a0 << "), (" << a6.a0 << "), (" << a7.a0 << "), (" << a8.a0
            << "), (" << a9.a0 << "))" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a1.a0;
  result += a2.a0;
  result += a3.a0;
  result += a4.a0;
  result += a5.a0;
  result += a6.a0;
  result += a7.a0;
  result += a8.a0;
  result += a9.a0;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassUnion8BytesNestedFloatx10()

DART_EXPORT double dart::PassUnion8BytesNestedFloatx10	(	Union8BytesNestedFloat	a0,
		Union8BytesNestedFloat	a1,
		Union8BytesNestedFloat	a2,
		Union8BytesNestedFloat	a3,
		Union8BytesNestedFloat	a4,
		Union8BytesNestedFloat	a5,
		Union8BytesNestedFloat	a6,
		Union8BytesNestedFloat	a7,
		Union8BytesNestedFloat	a8,
		Union8BytesNestedFloat	a9
	)

Definition at line 4379 of file ffi_test_functions_generated.cc.

                                                                            {
  std::cout << "PassUnion8BytesNestedFloatx10" << "((" << a0.a0 << "), ("
            << a1.a0 << "), (" << a2.a0 << "), (" << a3.a0 << "), (" << a4.a0
            << "), (" << a5.a0 << "), (" << a6.a0 << "), (" << a7.a0 << "), ("
            << a8.a0 << "), (" << a9.a0 << "))" << "\n";
 
  double result = 0;
 
  result += a0.a0;
  result += a1.a0;
  result += a2.a0;
  result += a3.a0;
  result += a4.a0;
  result += a5.a0;
  result += a6.a0;
  result += a7.a0;
  result += a8.a0;
  result += a9.a0;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassUnion9BytesNestedIntx10()

DART_EXPORT double dart::PassUnion9BytesNestedIntx10	(	Union9BytesNestedInt	a0,
		Union9BytesNestedInt	a1,
		Union9BytesNestedInt	a2,
		Union9BytesNestedInt	a3,
		Union9BytesNestedInt	a4,
		Union9BytesNestedInt	a5,
		Union9BytesNestedInt	a6,
		Union9BytesNestedInt	a7,
		Union9BytesNestedInt	a8,
		Union9BytesNestedInt	a9
	)

Definition at line 4414 of file ffi_test_functions_generated.cc.

                                                                        {
  std::cout << "PassUnion9BytesNestedIntx10" << "(((" << a0.a0.a0 << ", "
            << a0.a0.a1 << ", " << a0.a0.a2 << ")), ((" << a1.a0.a0 << ", "
            << a1.a0.a1 << ", " << a1.a0.a2 << ")), ((" << a2.a0.a0 << ", "
            << a2.a0.a1 << ", " << a2.a0.a2 << ")), ((" << a3.a0.a0 << ", "
            << a3.a0.a1 << ", " << a3.a0.a2 << ")), ((" << a4.a0.a0 << ", "
            << a4.a0.a1 << ", " << a4.a0.a2 << ")), ((" << a5.a0.a0 << ", "
            << a5.a0.a1 << ", " << a5.a0.a2 << ")), ((" << a6.a0.a0 << ", "
            << a6.a0.a1 << ", " << a6.a0.a2 << ")), ((" << a7.a0.a0 << ", "
            << a7.a0.a1 << ", " << a7.a0.a2 << ")), ((" << a8.a0.a0 << ", "
            << a8.a0.a1 << ", " << a8.a0.a2 << ")), ((" << a9.a0.a0 << ", "
            << a9.a0.a1 << ", " << a9.a0.a2 << ")))" << "\n";
 
  double result = 0;
 
  result += a0.a0.a0;
  result += a0.a0.a1;
  result += a0.a0.a2;
  result += a1.a0.a0;
  result += a1.a0.a1;
  result += a1.a0.a2;
  result += a2.a0.a0;
  result += a2.a0.a1;
  result += a2.a0.a2;
  result += a3.a0.a0;
  result += a3.a0.a1;
  result += a3.a0.a2;
  result += a4.a0.a0;
  result += a4.a0.a1;
  result += a4.a0.a2;
  result += a5.a0.a0;
  result += a5.a0.a1;
  result += a5.a0.a2;
  result += a6.a0.a0;
  result += a6.a0.a1;
  result += a6.a0.a2;
  result += a7.a0.a0;
  result += a7.a0.a1;
  result += a7.a0.a2;
  result += a8.a0.a0;
  result += a8.a0.a1;
  result += a8.a0.a2;
  result += a9.a0.a0;
  result += a9.a0.a1;
  result += a9.a0.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

PassWCharStructInlineArrayIntUintPtrx2LongUnsigned()

DART_EXPORT wchar_t dart::PassWCharStructInlineArrayIntUintPtrx2LongUnsigned	(	wchar_t	a0,
		StructInlineArrayInt	a1,
		uintptr_t	a2,
		uintptr_t	a3,
		long	a4,
		unsigned long	a5
	)

Definition at line 4727 of file ffi_test_functions_generated.cc.

                        {
  std::cout << "PassWCharStructInlineArrayIntUintPtrx2LongUnsigned" << "(" << a0
            << ", ([" << a1.a0[0] << ", " << a1.a0[1] << ", " << a1.a0[2]
            << ", " << a1.a0[3] << ", " << a1.a0[4] << ", " << a1.a0[5] << ", "
            << a1.a0[6] << ", " << a1.a0[7] << ", " << a1.a0[8] << ", "
            << a1.a0[9] << "]), " << a2 << ", " << a3 << ", " << a4 << ", "
            << a5 << ")" << "\n";
 
  wchar_t result = 0;
 
  result += a0;
  result += a1.a0[0];
  result += a1.a0[1];
  result += a1.a0[2];
  result += a1.a0[3];
  result += a1.a0[4];
  result += a1.a0[5];
  result += a1.a0[6];
  result += a1.a0[7];
  result += a1.a0[8];
  result += a1.a0[9];
  result += a2;
  result += a3;
  result += a4;
  result += a5;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

Pause()

static void dart::Pause ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4414 of file service.cc.

                                                  {
  // TODO(turnidge): This interrupt message could have been sent from
  // the service isolate directly, but would require some special case
  // code.  That would prevent this isolate getting double-interrupted
  // with OOB messages.
  Isolate* isolate = thread->isolate();
  isolate->SendInternalLibMessage(Isolate::kInterruptMsg,
                                  isolate->pause_capability());
  PrintSuccess(js);
}

PhiHasSingleUse()

static bool dart::PhiHasSingleUse ( PhiInstr *  phi, Value *  use  )

static

Definition at line 15 of file branch_optimizer.cc.

                                                       {
  if ((use->next_use() != nullptr) || (phi->input_use_list() != use)) {
    return false;
  }
 
  BlockEntryInstr* block = phi->block();
  for (Value* env_use = phi->env_use_list(); env_use != nullptr;
       env_use = env_use->next_use()) {
    if ((env_use->instruction() != block) &&
        (env_use->instruction() != use->instruction())) {
      return false;
    }
  }
 
  return true;
}

PopulateUriMappings()

static void dart::PopulateUriMappings ( Thread *  thread )

static

Definition at line 5361 of file service.cc.

                                                {
  Zone* zone = thread->zone();
  auto object_store = thread->isolate_group()->object_store();
  UriMapping uri_to_resolved_uri(HashTables::New<UriMapping>(16, Heap::kOld));
  UriMapping resolved_uri_to_uri(HashTables::New<UriMapping>(16, Heap::kOld));
 
  const auto& libs =
      GrowableObjectArray::Handle(zone, object_store->libraries());
  intptr_t num_libs = libs.Length();
 
  Library& lib = Library::Handle(zone);
  Script& script = Script::Handle(zone);
  Array& scripts = Array::Handle(zone);
  String& uri = String::Handle(zone);
  String& resolved_uri = String::Handle(zone);
#if defined(DART_HOST_OS_WINDOWS) || defined(DART_HOST_OS_MACOS)
  String& tmp = thread->StringHandle();
#endif
  for (intptr_t i = 0; i < num_libs; ++i) {
    lib ^= libs.At(i);
    scripts ^= lib.LoadedScripts();
    intptr_t num_scripts = scripts.Length();
    for (intptr_t j = 0; j < num_scripts; ++j) {
      script ^= scripts.At(j);
      uri ^= script.url();
      resolved_uri ^= script.resolved_url();
      uri_to_resolved_uri.UpdateOrInsert(uri, resolved_uri);
      resolved_uri_to_uri.UpdateOrInsert(resolved_uri, uri);
 
#if defined(DART_HOST_OS_WINDOWS) || defined(DART_HOST_OS_MACOS)
      // Allow for case insensitive matching on platforms that might allow for
      // case insensitive paths.
      tmp = String::ToLowerCase(uri);
      uri_to_resolved_uri.UpdateOrInsert(tmp, resolved_uri);
      tmp = String::ToLowerCase(resolved_uri);
      resolved_uri_to_uri.UpdateOrInsert(tmp, uri);
#endif
    }
  }
 
  object_store->set_uri_to_resolved_uri_map(uri_to_resolved_uri.Release());
  object_store->set_resolved_uri_to_uri_map(resolved_uri_to_uri.Release());
  Smi& count = Smi::Handle(zone, Smi::New(num_libs));
  object_store->set_last_libraries_count(count);
}

PostCObjectHelper()

static bool dart::PostCObjectHelper ( Dart_Port  port_id, Dart_CObject *  message  )

static

Definition at line 46 of file native_api_impl.cc.

                                                                        {
  AllocOnlyStackZone zone;
  std::unique_ptr<Message> msg = WriteApiMessage(
      zone.GetZone(), message, port_id, Message::kNormalPriority);
 
  if (msg == nullptr) {
    return false;
  }
 
  // Post the message at the given port.
  return PortMap::PostMessage(std::move(msg));
}

PrecompilationModeHandler()

static void dart::PrecompilationModeHandler ( bool  value )

static

Definition at line 91 of file compiler.cc.

                                                  {
  if (value) {
#if defined(TARGET_ARCH_IA32)
    FATAL("Precompilation not supported on IA32");
#endif
 
    FLAG_background_compilation = false;
    FLAG_enable_mirrors = false;
    FLAG_interpret_irregexp = true;
    FLAG_lazy_dispatchers = false;
    FLAG_link_natives_lazily = true;
    FLAG_optimization_counter_threshold = -1;
    FLAG_polymorphic_with_deopt = false;
    FLAG_precompiled_mode = true;
    FLAG_reorder_basic_blocks = true;
    FLAG_use_field_guards = false;
    FLAG_use_cha_deopt = false;
 
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
    // Set flags affecting runtime accordingly for gen_snapshot.
    // These flags are constants with PRODUCT and DART_PRECOMPILED_RUNTIME.
    FLAG_deoptimize_alot = false;  // Used in some tests.
    FLAG_deoptimize_every = 0;     // Used in some tests.
    FLAG_use_osr = false;
#endif
  }
}

Prepare()

static intptr_t dart::Prepare ( const RegExp &  regexp, const String &  subject, bool  sticky, Zone *  zone  )

static

Definition at line 422 of file regexp_assembler_bytecode.cc.

                                    {
  bool is_one_byte = subject.IsOneByteString();
 
  if (regexp.bytecode(is_one_byte, sticky) == TypedData::null()) {
    const String& pattern = String::Handle(zone, regexp.pattern());
#if defined(SUPPORT_TIMELINE)
    TimelineBeginEndScope tbes(Thread::Current(), Timeline::GetCompilerStream(),
                               "CompileIrregexpBytecode");
    if (tbes.enabled()) {
      tbes.SetNumArguments(1);
      tbes.CopyArgument(0, "pattern", pattern.ToCString());
    }
#endif  // !defined(PRODUCT)
 
    RegExpCompileData* compile_data = new (zone) RegExpCompileData();
 
    // Parsing failures are handled in the RegExp factory constructor.
    RegExpParser::ParseRegExp(pattern, regexp.flags(), compile_data);
 
    regexp.set_num_bracket_expressions(compile_data->capture_count);
    regexp.set_capture_name_map(compile_data->capture_name_map);
    if (compile_data->simple) {
      regexp.set_is_simple();
    } else {
      regexp.set_is_complex();
    }
 
    RegExpEngine::CompilationResult result = RegExpEngine::CompileBytecode(
        compile_data, regexp, is_one_byte, sticky, zone);
    if (result.error_message != nullptr) {
      Exceptions::ThrowUnsupportedError(result.error_message);
    }
    ASSERT(result.bytecode != nullptr);
    ASSERT(regexp.num_registers(is_one_byte) == -1 ||
           regexp.num_registers(is_one_byte) == result.num_registers);
    regexp.set_num_registers(is_one_byte, result.num_registers);
    regexp.set_bytecode(is_one_byte, sticky, *(result.bytecode));
  }
 
  ASSERT(regexp.num_registers(is_one_byte) != -1);
 
  return regexp.num_registers(is_one_byte) +
         (regexp.num_bracket_expressions() + 1) * 2;
}

PrepareInlineIndexedOp()

static intptr_t dart::PrepareInlineIndexedOp ( FlowGraph *  flow_graph, Instruction *  call, intptr_t  array_cid, Definition **  array, Definition **  index, Instruction **  cursor  )

static

Definition at line 1753 of file call_specializer.cc.

                                                             {
  // Insert array length load and bounds check.
  LoadFieldInstr* length = new (Z) LoadFieldInstr(
      new (Z) Value(*array), Slot::GetLengthFieldForArrayCid(array_cid),
      call->source());
  *cursor = flow_graph->AppendTo(*cursor, length, nullptr, FlowGraph::kValue);
  *index = flow_graph->CreateCheckBound(length, *index, call->deopt_id());
  *cursor =
      flow_graph->AppendTo(*cursor, *index, call->env(), FlowGraph::kValue);
 
  if (array_cid == kGrowableObjectArrayCid) {
    // Insert data elements load.
    LoadFieldInstr* elements = new (Z)
        LoadFieldInstr(new (Z) Value(*array), Slot::GrowableObjectArray_data(),
                       call->source());
    *cursor =
        flow_graph->AppendTo(*cursor, elements, nullptr, FlowGraph::kValue);
    // Load from the data from backing store which is a fixed-length array.
    *array = elements;
    array_cid = kArrayCid;
  } else if (IsExternalTypedDataClassId(array_cid)) {
    auto* const elements = new (Z) LoadFieldInstr(
        new (Z) Value(*array), Slot::PointerBase_data(),
        InnerPointerAccess::kCannotBeInnerPointer, call->source());
    *cursor =
        flow_graph->AppendTo(*cursor, elements, nullptr, FlowGraph::kValue);
    *array = elements;
  }
  return array_cid;
}

PrepareInlineStringIndexOp()

static Definition * dart::PrepareInlineStringIndexOp ( FlowGraph *  flow_graph, Instruction *  call, intptr_t  cid, Definition *  str, Definition *  index, Instruction *  cursor  )

static

Definition at line 2068 of file call_specializer.cc.

                                                                   {
  LoadFieldInstr* length = new (Z) LoadFieldInstr(
      new (Z) Value(str), Slot::GetLengthFieldForArrayCid(cid), str->source());
  cursor = flow_graph->AppendTo(cursor, length, nullptr, FlowGraph::kValue);
 
  // Bounds check.
  if (CompilerState::Current().is_aot()) {
    // Add a null-check in case the index argument is known to be compatible
    // but possibly nullable. By inserting the null-check, we can allow the
    // unbox instruction later inserted to be non-speculative.
    auto* const null_check = new (Z)
        CheckNullInstr(new (Z) Value(index), Symbols::Index(), call->deopt_id(),
                       call->source(), CheckNullInstr::kArgumentError);
    cursor = flow_graph->AppendTo(cursor, null_check, call->env(),
                                  FlowGraph::kEffect);
  }
  index = flow_graph->CreateCheckBound(length, index, call->deopt_id());
  cursor = flow_graph->AppendTo(cursor, index, call->env(), FlowGraph::kValue);
 
  LoadIndexedInstr* load_indexed = new (Z) LoadIndexedInstr(
      new (Z) Value(str), new (Z) Value(index), /*index_unboxed=*/false,
      compiler::target::Instance::ElementSizeFor(cid), cid, kAlignedAccess,
      call->deopt_id(), call->source());
  cursor =
      flow_graph->AppendTo(cursor, load_indexed, nullptr, FlowGraph::kValue);
 
  auto box = BoxInstr::Create(kUnboxedIntPtr, new Value(load_indexed));
  cursor = flow_graph->AppendTo(cursor, box, nullptr, FlowGraph::kValue);
 
  ASSERT(box == cursor);
  return box;
}

PrintAndInspectResolver()

static Dart_NativeFunction dart::PrintAndInspectResolver ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 533 of file inliner_test.cc.

                                                                           {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  const char* cstr = nullptr;
  Dart_Handle result = Dart_StringToCString(name, &cstr);
  EXPECT_VALID(result);
  if (strcmp(cstr, "testPrint") == 0) {
    return &TestPrint;
  } else {
    return &InspectStack;
  }
}

PrintBitVector()

static void dart::PrintBitVector ( const char *  tag, BitVector *  v  )

static

Definition at line 746 of file flow_graph.cc.

                                                          {
  THR_Print("%s:", tag);
  for (BitVector::Iterator it(v); !it.Done(); it.Advance()) {
    THR_Print(" %" Pd "", it.Current());
  }
  THR_Print("\n");
}

PrintInboundReferences()

static void dart::PrintInboundReferences ( Thread *  thread, Object *  target, intptr_t  limit, JSONStream *  js  )

static

Definition at line 2285 of file service.cc.

                                                   {
  ObjectGraph graph(thread);
  Array& path = Array::Handle(Array::New(limit * 2));
  intptr_t length = graph.InboundReferences(target, path);
  OffsetsTable offsets_table(thread->zone());
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "InboundReferences");
  {
    JSONArray elements(&jsobj, "references");
    Object& source = Object::Handle();
    Smi& slot_offset = Smi::Handle();
    Array& field_names = Array::Handle();
    String& name = String::Handle();
    Class& source_class = Class::Handle();
    Field& field = Field::Handle();
    Array& parent_field_map = Array::Handle();
    limit = Utils::Minimum(limit, length);
    for (intptr_t i = 0; i < limit; ++i) {
      JSONObject jselement(&elements);
      source = path.At(i * 2);
      slot_offset ^= path.At((i * 2) + 1);
 
      jselement.AddProperty("source", source);
      if (source.IsArray()) {
        intptr_t element_index =
            (slot_offset.Value() - Array::element_offset(0)) /
            Array::kBytesPerElement;
        jselement.AddProperty("parentListIndex", element_index);
        jselement.AddProperty("parentField", element_index);
      } else if (source.IsRecord()) {
        AddParentFieldToResponseBasedOnRecord(thread, &field_names, &name,
                                              jselement, Record::Cast(source),
                                              slot_offset.Value());
      } else {
        if (source.IsInstance()) {
          source_class = source.clazz();
          parent_field_map = source_class.OffsetToFieldMap();
          intptr_t index = slot_offset.Value() >> kCompressedWordSizeLog2;
          if (index > 0 && index < parent_field_map.Length()) {
            field ^= parent_field_map.At(index);
            if (!field.IsNull()) {
              jselement.AddProperty("parentField", field);
              continue;
            }
          }
        }
        const char* field_name = offsets_table.FieldNameForOffset(
            source.GetClassId(), slot_offset.Value());
        if (field_name != nullptr) {
          jselement.AddProperty("_parentWordOffset", slot_offset.Value());
          // TODO(vm-service): Adjust RPC type to allow returning a field name
          // without a field object, or reify the fields described by
          // raw_object_fields.cc
          // jselement.AddProperty("_parentFieldName", field_name);
        } else if (source.IsContext()) {
          intptr_t element_index =
              (slot_offset.Value() - Context::variable_offset(0)) /
              Context::kBytesPerElement;
          jselement.AddProperty("parentListIndex", element_index);
          jselement.AddProperty("parentField", element_index);
        } else {
          jselement.AddProperty("_parentWordOffset", slot_offset.Value());
        }
      }
    }
  }
 
  // We nil out the array after generating the response to prevent
  // reporting spurious references when repeatedly looking for the
  // references to an object.
  for (intptr_t i = 0; i < path.Length(); i++) {
    path.SetAt(i, Object::null_object());
  }
}

PrintInvalidParamError()

static void dart::PrintInvalidParamError ( JSONStream *  js, const char *  param  )

static

Definition at line 128 of file service.cc.

                                                                      {
#if !defined(PRODUCT)
  js->PrintError(kInvalidParams, "%s: invalid '%s' parameter: %s", js->method(),
                 param, js->LookupParam(param));
#endif
}

PrintMetadata()

static void dart::PrintMetadata ( const char *  name, const Object &  data  )

static

Definition at line 5411 of file object_test.cc.

                                                                {
  if (data.IsError()) {
    OS::PrintErr("Error in metadata evaluation for %s: '%s'\n", name,
                 Error::Cast(data).ToErrorCString());
  }
  EXPECT(data.IsArray());
  const Array& metadata = Array::Cast(data);
  OS::PrintErr("Metadata for %s has %" Pd " values:\n", name,
               metadata.Length());
  Object& elem = Object::Handle();
  for (int i = 0; i < metadata.Length(); i++) {
    elem = metadata.At(i);
    OS::PrintErr("  %d: %s\n", i, elem.ToCString());
  }
}

PrintMissingParamError()

static void dart::PrintMissingParamError ( JSONStream *  js, const char *  param  )

static

Definition at line 885 of file service.cc.

                                                                      {
  js->PrintError(kInvalidParams, "%s expects the '%s' parameter", js->method(),
                 param);
}

PrintRequest()

static void dart::PrintRequest ( JSONObject *  obj, JSONStream *  js  )

static

Definition at line 152 of file json_stream.cc.

                                                          {
  JSONObject jsobj(obj, "request");
  jsobj.AddProperty("method", js->method());
  {
    JSONObject params(&jsobj, "params");
    for (intptr_t i = 0; i < js->num_params(); i++) {
      params.AddProperty(js->GetParamKey(i), js->GetParamValue(i));
    }
  }
}

PrintRetainingPath()

static void dart::PrintRetainingPath ( Thread *  thread, Object *  obj, intptr_t  limit, JSONStream *  js  )

static

Definition at line 2404 of file service.cc.

                                               {
  ObjectGraph graph(thread);
  Array& path = Array::Handle(Array::New(limit * 2));
  auto result = graph.RetainingPath(obj, path);
  intptr_t length = result.length;
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "RetainingPath");
  jsobj.AddProperty("length", length);
  jsobj.AddProperty("gcRootType", result.gc_root_type);
  JSONArray elements(&jsobj, "elements");
  Object& element = Object::Handle();
  Smi& slot_offset = Smi::Handle();
  Array& field_names = Array::Handle();
  String& name = String::Handle();
  Class& element_class = Class::Handle();
  Array& element_field_map = Array::Handle();
  Map& map = Map::Handle();
  Array& map_data = Array::Handle();
  Field& field = Field::Handle();
  WeakProperty& wp = WeakProperty::Handle();
  limit = Utils::Minimum(limit, length);
  OffsetsTable offsets_table(thread->zone());
  for (intptr_t i = 0; i < limit; ++i) {
    JSONObject jselement(&elements);
    element = path.At(i * 2);
    jselement.AddProperty("value", element);
    // Interpret the word offset from parent as list index, map key,
    // weak property, or instance field.
    if (i > 0) {
      slot_offset ^= path.At((i * 2) - 1);
      if (element.IsArray() || element.IsGrowableObjectArray()) {
        intptr_t element_index =
            (slot_offset.Value() - Array::element_offset(0)) /
            Array::kBytesPerElement;
        jselement.AddProperty("parentListIndex", element_index);
        jselement.AddProperty("parentField", element_index);
      } else if (element.IsRecord()) {
        AddParentFieldToResponseBasedOnRecord(thread, &field_names, &name,
                                              jselement, Record::Cast(element),
                                              slot_offset.Value());
      } else if (element.IsMap()) {
        map = static_cast<MapPtr>(path.At(i * 2));
        map_data = map.data();
        intptr_t element_index =
            (slot_offset.Value() - Array::element_offset(0)) /
            Array::kBytesPerElement;
        Map::Iterator iterator(map);
        while (iterator.MoveNext()) {
          if (iterator.CurrentKey() == map_data.At(element_index) ||
              iterator.CurrentValue() == map_data.At(element_index)) {
            element = iterator.CurrentKey();
            jselement.AddProperty("parentMapKey", element);
            break;
          }
        }
      } else if (element.IsWeakProperty()) {
        wp ^= static_cast<WeakPropertyPtr>(element.ptr());
        element = wp.key();
        jselement.AddProperty("parentMapKey", element);
      } else {
        if (element.IsInstance()) {
          element_class = element.clazz();
          element_field_map = element_class.OffsetToFieldMap();
          intptr_t index = slot_offset.Value() >> kCompressedWordSizeLog2;
          if ((index > 0) && (index < element_field_map.Length())) {
            field ^= element_field_map.At(index);
            if (!field.IsNull()) {
              name ^= field.name();
              jselement.AddProperty("parentField", name.ToCString());
              continue;
            }
          }
        }
        const char* field_name = offsets_table.FieldNameForOffset(
            element.GetClassId(), slot_offset.Value());
        if (field_name != nullptr) {
          jselement.AddProperty("parentField", field_name);
        } else if (element.IsContext()) {
          intptr_t element_index =
              (slot_offset.Value() - Context::variable_offset(0)) /
              Context::kBytesPerElement;
          jselement.AddProperty("parentListIndex", element_index);
          jselement.AddProperty("parentField", element_index);
        } else {
          jselement.AddProperty("_parentWordOffset", slot_offset.Value());
        }
      }
    }
  }
 
  // We nil out the array after generating the response to prevent
  // reporting spurious references when looking for inbound references
  // after looking for a retaining path.
  for (intptr_t i = 0; i < path.Length(); i++) {
    path.SetAt(i, Object::null_object());
  }
}

PrintSentinel()

static void dart::PrintSentinel ( JSONStream *  js, SentinelType  sentinel_type  )

static

Definition at line 1535 of file service.cc.

                                                                      {
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "Sentinel");
  switch (sentinel_type) {
    case kCollectedSentinel:
      jsobj.AddProperty("kind", "Collected");
      jsobj.AddProperty("valueAsString", "<collected>");
      break;
    case kExpiredSentinel:
      jsobj.AddProperty("kind", "Expired");
      jsobj.AddProperty("valueAsString", "<expired>");
      break;
    case kFreeSentinel:
      jsobj.AddProperty("kind", "Free");
      jsobj.AddProperty("valueAsString", "<free>");
      break;
    default:
      UNIMPLEMENTED();
      break;
  }
}

PrintShowHideNamesToJSON()

static void dart::PrintShowHideNamesToJSON ( JSONObject *  jsobj, const Namespace &  ns  )

static

Definition at line 568 of file object_service.cc.

                                                                             {
  Array& arr = Array::Handle();
  String& name = String::Handle();
  arr ^= ns.show_names();
  if (!arr.IsNull()) {
    JSONArray jsarr(jsobj, "shows");
    for (intptr_t i = 0; i < arr.Length(); ++i) {
      name ^= arr.At(i);
      jsarr.AddValue(name.ToCString());
    }
  }
  arr ^= ns.hide_names();
  if (!arr.IsNull()) {
    JSONArray jsarr(jsobj, "hides");
    for (intptr_t i = 0; i < arr.Length(); ++i) {
      name ^= arr.At(i);
      jsarr.AddValue(name.ToCString());
    }
  }
}

PrintSubtypeCheck()

static void dart::PrintSubtypeCheck ( const AbstractType &  subtype, const AbstractType &  supertype, const bool  result  )

static

Definition at line 652 of file runtime_entry.cc.

                                                 {
  DartFrameIterator iterator(Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame != nullptr);
 
  LogBlock lb;
  THR_Print("SubtypeCheck: '%s' %d %s '%s' %d (pc: %#" Px ").\n",
            subtype.NameCString(), subtype.type_class_id(),
            result ? "is" : "is !", supertype.NameCString(),
            supertype.type_class_id(), caller_frame->pc());
 
  const Function& function =
      Function::Handle(caller_frame->LookupDartFunction());
  if (function.HasSavedArgumentsDescriptor()) {
    const auto& args_desc_array = Array::Handle(function.saved_args_desc());
    const ArgumentsDescriptor args_desc(args_desc_array);
    THR_Print(" -> Function %s [%s]\n", function.ToFullyQualifiedCString(),
              args_desc.ToCString());
  } else {
    THR_Print(" -> Function %s\n", function.ToFullyQualifiedCString());
  }
}

PrintSuccess()

static void dart::PrintSuccess ( JSONStream *  js )

static

Definition at line 507 of file service.cc.

                                         {
  JSONObject jsobj(js);
  jsobj.AddProperty("type", "Success");
}

PrintSymbolicStackFrame()

static void dart::PrintSymbolicStackFrame ( Zone *  zone, BaseTextBuffer *  buffer, const Function &  function, TokenPosition  token_pos_or_line, intptr_t  frame_index, bool  is_line = false  )

static

Definition at line 26265 of file object.cc.

                                                          {
  ASSERT(!function.IsNull());
  const auto& script = Script::Handle(zone, function.script());
  const char* function_name = function.QualifiedUserVisibleNameCString();
  const char* url = script.IsNull()
                        ? "Kernel"
                        : String::Handle(zone, script.url()).ToCString();
 
  // If the URI starts with "data:application/dart;" this is a URI encoded
  // script so we shouldn't print the entire URI because it could be very long.
  if (strstr(url, "data:application/dart;") == url) {
    url = "<data:application/dart>";
  }
 
  intptr_t line = -1;
  intptr_t column = -1;
  if (is_line) {
    ASSERT(token_pos_or_line.IsNoSource() || token_pos_or_line.IsReal());
    if (token_pos_or_line.IsReal()) {
      line = token_pos_or_line.Pos();
    }
  } else {
    ASSERT(!script.IsNull());
    script.GetTokenLocation(token_pos_or_line, &line, &column);
  }
  PrintSymbolicStackFrameIndex(buffer, frame_index);
  PrintSymbolicStackFrameBody(buffer, function_name, url, line, column);
}

PrintSymbolicStackFrameBody()

static void dart::PrintSymbolicStackFrameBody ( BaseTextBuffer *  buffer, const char *  function_name, const char *  url, intptr_t  line = -1, intptr_t  column = -1  )

static

Definition at line 26250 of file object.cc.

                                                              {
  buffer->Printf(" %s (%s", function_name, url);
  if (line >= 0) {
    buffer->Printf(":%" Pd "", line);
    if (column >= 0) {
      buffer->Printf(":%" Pd "", column);
    }
  }
  buffer->Printf(")\n");
}

PrintSymbolicStackFrameIndex()

static void dart::PrintSymbolicStackFrameIndex ( BaseTextBuffer *  buffer, intptr_t  frame_index  )

static

Definition at line 26245 of file object.cc.

                                                               {
  buffer->Printf("#%-6" Pd "", frame_index);
}

PrintTypeCheck()

static void dart::PrintTypeCheck ( const char *  message, const Instance &  instance, const AbstractType &  type, const TypeArguments &  instantiator_type_arguments, const TypeArguments &  function_type_arguments, const Bool &  result  )

static

Definition at line 862 of file runtime_entry.cc.

                                               {
  DartFrameIterator iterator(Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* caller_frame = iterator.NextFrame();
  ASSERT(caller_frame != nullptr);
 
  const AbstractType& instance_type =
      AbstractType::Handle(instance.GetType(Heap::kNew));
  ASSERT(instance_type.IsInstantiated() ||
         (instance.IsClosure() && instance_type.IsInstantiated(kCurrentClass)));
  LogBlock lb;
  if (type.IsInstantiated()) {
    THR_Print("%s: '%s' %d %s '%s' %d (pc: %#" Px ").\n", message,
              instance_type.NameCString(), instance_type.type_class_id(),
              (result.ptr() == Bool::True().ptr()) ? "is" : "is !",
              type.NameCString(), type.type_class_id(), caller_frame->pc());
  } else {
    // Instantiate type before printing.
    const AbstractType& instantiated_type = AbstractType::Handle(
        type.InstantiateFrom(instantiator_type_arguments,
                             function_type_arguments, kAllFree, Heap::kOld));
    THR_Print("%s: '%s' %s '%s' instantiated from '%s' (pc: %#" Px ").\n",
              message, instance_type.NameCString(),
              (result.ptr() == Bool::True().ptr()) ? "is" : "is !",
              instantiated_type.NameCString(), type.NameCString(),
              caller_frame->pc());
  }
  const Function& function =
      Function::Handle(caller_frame->LookupDartFunction());
  if (function.HasSavedArgumentsDescriptor()) {
    const auto& args_desc_array = Array::Handle(function.saved_args_desc());
    const ArgumentsDescriptor args_desc(args_desc_array);
    THR_Print(" -> Function %s [%s]\n", function.ToFullyQualifiedCString(),
              args_desc.ToCString());
  } else {
    THR_Print(" -> Function %s\n", function.ToFullyQualifiedCString());
  }
}

PrintUnrecognizedMethodError()

static void dart::PrintUnrecognizedMethodError ( JSONStream *  js )

static

Definition at line 890 of file service.cc.

                                                         {
  js->PrintError(kMethodNotFound, nullptr);
}

PrintUsage()

static void dart::PrintUsage ( )

static

Definition at line 86 of file run_vm_tests.cc.

                         {
  Syslog::PrintErr(
      "Usage: one of the following\n"
      "  run_vm_tests --list\n"
      "  run_vm_tests [--dfe=<snapshot file name>] --benchmarks\n"
      "  run_vm_tests [--dfe=<snapshot file name>] [vm-flags ...] <test name>\n"
      "  run_vm_tests [--dfe=<snapshot file name>] [vm-flags ...] <benchmark "
      "name>\n");
}

PrintUtf16()

void dart::PrintUtf16

(

uint16_t

c

)

Definition at line 18 of file regexp_assembler.cc.

                            {
  const char* format = (0x20 <= c && c <= 0x7F) ? "%c"
                       : (c <= 0xff)            ? "\\x%02x"
                                                : "\\u%04x";
  OS::PrintErr(format, c);
}

PrintVarInfo()

static int dart::PrintVarInfo ( char *  buffer, int  len, intptr_t  i, const String &  var_name, const UntaggedLocalVarDescriptors::VarInfo &  info  )

static

Definition at line 16100 of file object.cc.

                                                                        {
  const UntaggedLocalVarDescriptors::VarInfoKind kind = info.kind();
  const int32_t index = info.index();
  if (kind == UntaggedLocalVarDescriptors::kContextLevel) {
    return Utils::SNPrint(buffer, len,
                          "%2" Pd
                          " %-13s level=%-3d"
                          " begin=%-3d end=%d\n",
                          i, LocalVarDescriptors::KindToCString(kind), index,
                          static_cast<int>(info.begin_pos.Pos()),
                          static_cast<int>(info.end_pos.Pos()));
  } else if (kind == UntaggedLocalVarDescriptors::kContextVar) {
    return Utils::SNPrint(
        buffer, len,
        "%2" Pd
        " %-13s level=%-3d index=%-3d"
        " begin=%-3d end=%-3d name=%s\n",
        i, LocalVarDescriptors::KindToCString(kind), info.scope_id, index,
        static_cast<int>(info.begin_pos.Pos()),
        static_cast<int>(info.end_pos.Pos()), var_name.ToCString());
  } else {
    return Utils::SNPrint(
        buffer, len,
        "%2" Pd
        " %-13s scope=%-3d index=%-3d"
        " begin=%-3d end=%-3d name=%s\n",
        i, LocalVarDescriptors::KindToCString(kind), info.scope_id, index,
        static_cast<int>(info.begin_pos.Pos()),
        static_cast<int>(info.end_pos.Pos()), var_name.ToCString());
  }
}

PrivateLibName()

static Dart_Handle dart::PrivateLibName ( Dart_Handle  lib, const char *  str  )

static

Definition at line 6583 of file dart_api_impl_test.cc.

                                                                    {
  EXPECT(Dart_IsLibrary(lib));
  Thread* thread = Thread::Current();
  TransitionNativeToVM transition(thread);
  const Library& library_obj = Api::UnwrapLibraryHandle(thread->zone(), lib);
  const String& name = String::Handle(String::New(str));
  return Api::NewHandle(thread, library_obj.PrivateName(name));
}

PropagateError_native_lookup()

static Dart_NativeFunction dart::PropagateError_native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 809 of file dart_api_impl_test.cc.

                            {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  return PropagateErrorNative;
}

PropagateErrorNative()

void dart::PropagateErrorNative

(

Dart_NativeArguments

args

)

Definition at line 792 of file dart_api_impl_test.cc.

                                                     {
  Dart_Handle closure = Dart_GetNativeArgument(args, 0);
  EXPECT(Dart_IsClosure(closure));
  Dart_Handle result = Dart_InvokeClosure(closure, 0, nullptr);
  EXPECT(Dart_IsError(result));
  if (use_set_return) {
    Dart_SetReturnValue(args, result);
  } else if (use_throw_exception) {
    result = Dart_ThrowException(result);
    EXPECT_VALID(result);  // We do not expect to reach here.
    UNREACHABLE();
  } else {
    Dart_PropagateError(result);
    UNREACHABLE();
  }
}

PropagateErrorWithoutHandle()

DART_EXPORT int64_t dart::PropagateErrorWithoutHandle

(

Dart_Handle(*)()

callback

)

Definition at line 1061 of file ffi_test_functions_vmspecific.cc.

                                                                           {
  Dart_EnterScope();
  Dart_Handle result = callback();
  if (Dart_IsError(result)) {
    Dart_PropagateError(result);
  }
  Dart_ExitScope();
  return 0;
}

PropagateLibraryModified()

static void dart::PropagateLibraryModified ( const ZoneGrowableArray< ZoneGrowableArray< intptr_t > * > *  imported_by, intptr_t  lib_index, BitVector *  modified_libs  )

static

Copied in from https://dart-review.googlesource.com/c/sdk/+/77722.

Definition at line 1021 of file isolate_reload.cc.

                              {
  ZoneGrowableArray<intptr_t>* dep_libs = (*imported_by)[lib_index];
  for (intptr_t i = 0; i < dep_libs->length(); i++) {
    intptr_t dep_lib_index = (*dep_libs)[i];
    if (!modified_libs->Contains(dep_lib_index)) {
      modified_libs->Add(dep_lib_index);
      PropagateLibraryModified(imported_by, dep_lib_index, modified_libs);
    }
  }
}

ProtectedHandleCallback()

void dart::ProtectedHandleCallback

(

void *

peer

)

Ptr() [1/2]

static ObjectPtr dart::Ptr ( const Object &  obj )

static

Definition at line 404 of file object_graph_copy.cc.

                                        {
  return obj.ptr();
}

Ptr() [2/2]

static ObjectPtr dart::Ptr ( ObjectPtr  obj )

static

Definition at line 401 of file object_graph_copy.cc.

                                    {
  return obj;
}

PurgeNegativeTestCidsEntries()

static void dart::PurgeNegativeTestCidsEntries ( ZoneGrowableArray< intptr_t > *  results )

static

Definition at line 1381 of file call_specializer.cc.

                                                                               {
  // We can't purge the Smi entry at the beginning since it is used in the
  // Smi check before the Cid is loaded.
  int dest = 2;
  for (intptr_t i = 2; i < results->length(); i += 2) {
    if (results->At(i + 1) != 0) {
      (*results)[dest++] = results->At(i);
      (*results)[dest++] = results->At(i + 1);
    }
  }
  results->SetLength(dest);
}

PushCodeUnit()

static void dart::PushCodeUnit ( RegExpCaptureName *  v, uint32_t  code_unit  )

static

Definition at line 1106 of file regexp_parser.cc.

                                                                   {
  if (code_unit <= Utf16::kMaxCodeUnit) {
    v->Add(code_unit);
  } else {
    uint16_t units[2];
    Utf16::Encode(code_unit, units);
    v->Add(units[0]);
    v->Add(units[1]);
  }
}

PutIfAbsent()

template<typename T >

T * dart::PutIfAbsent	(	Thread *	thread,
		ZoneGrowableArray< T * > **	array_slot,
		intptr_t	index,
		std::function< T *()>	create
	)

Definition at line 19 of file compiler_state.cc.

                                         {
  auto array = *array_slot;
 
  if (array == nullptr) {
    Zone* const Z = thread->zone();
    *array_slot = array = new (Z) ZoneGrowableArray<T*>(Z, index + 1);
  }
 
  while (array->length() <= index) {
    array->Add(nullptr);
  }
 
  if (array->At(index) == nullptr) {
    (*array)[index] = create();
  }
  return array->At(index);
}

QRegisterOf() [1/2]

static QRegister dart::QRegisterOf ( DRegister  d )

inlinestatic

Definition at line 279 of file constants_arm.h.

                                                 {
  return static_cast<QRegister>(d / 2);
}

QRegisterOf() [2/2]

static QRegister dart::QRegisterOf ( SRegister  s )

inlinestatic

Definition at line 282 of file constants_arm.h.

                                                 {
  return static_cast<QRegister>(s / 4);
}

QualifiedFunctionName()

static const char * dart::QualifiedFunctionName ( const Function &  func )

static

Definition at line 366 of file debugger.cc.

                                                               {
  const String& func_name = String::Handle(func.name());
  Class& func_class = Class::Handle(func.Owner());
  String& class_name = String::Handle(func_class.Name());
 
  return OS::SCreate(Thread::Current()->zone(), "%s%s%s",
                     func_class.IsTopLevel() ? "" : class_name.ToCString(),
                     func_class.IsTopLevel() ? "" : ".", func_name.ToCString());
}

RangeContainsLatin1Equivalents()

static bool dart::RangeContainsLatin1Equivalents ( CharacterRange  range )

inlinestatic

Definition at line 1947 of file regexp.cc.

                                                                        {
  // TODO(dcarney): this could be a lot more efficient.
  return range.Contains(0x39c) || range.Contains(0x3bc) ||
         range.Contains(0x178);
}

RangesContainExpectedCids()

static void dart::RangesContainExpectedCids ( const Expect &  expect, const CidRangeVector &  ranges, const GrowableArray< intptr_t > &  expected  )

static

Definition at line 470 of file il_test.cc.

                                                                               {
  ASSERT(!ranges.is_empty());
  ASSERT(!expected.is_empty());
  {
    TextBuffer buffer(128);
    buffer.AddString("Checking that ");
    WriteCidRangeVectorTo(ranges, &buffer);
    buffer.AddString("includes cids:\n");
    for (const intptr_t cid : expected) {
      buffer.AddString("  * ");
      WriteCidTo(cid, &buffer);
      buffer.AddString("\n");
    }
    THR_Print("%s", buffer.buffer());
  }
  bool all_found = true;
  for (const intptr_t cid : expected) {
    if (!ExpectRangesContainCid(expect, ranges, cid)) {
      all_found = false;
    }
  }
  if (all_found) {
    THR_Print("All expected cids included.\n\n");
  }
}

RangesContainLatin1Equivalents()

static bool dart::RangesContainLatin1Equivalents ( ZoneGrowableArray< CharacterRange > *  ranges )

static

Definition at line 1953 of file regexp.cc.

                                               {
  for (intptr_t i = 0; i < ranges->length(); i++) {
    // TODO(dcarney): this could be a lot more efficient.
    if (RangeContainsLatin1Equivalents(ranges->At(i))) return true;
  }
  return false;
}

RangeSizeForPhi()

static RangeBoundary::RangeSize dart::RangeSizeForPhi ( Definition *  phi )

static

Definition at line 436 of file range_analysis.cc.

                                                               {
  ASSERT(phi->IsPhi());
  if (phi->Type()->ToCid() == kSmiCid) {
    return RangeBoundary::kRangeBoundarySmi;
  } else if (phi->representation() == kUnboxedInt32) {
    return RangeBoundary::kRangeBoundaryInt32;
  } else if (phi->Type()->IsInt()) {
    return RangeBoundary::kRangeBoundaryInt64;
  } else {
    UNREACHABLE();
    return RangeBoundary::kRangeBoundaryInt64;
  }
}

RawMatch()

template<typename Char >

static ObjectPtr dart::RawMatch ( const TypedData &  bytecode, const String &  subject, int32_t *  registers, int32_t  current, uint32_t  current_char  )

static

Definition at line 182 of file regexp_interpreter.cc.

                                                 {
  // BacktrackStack ensures that the memory allocated for the backtracking stack
  // is returned to the system or cached if there is no stack being cached at
  // the moment.
  BacktrackStack backtrack_stack;
  if (backtrack_stack.out_of_memory()) {
    Exceptions::ThrowOOM();
    UNREACHABLE();
  }
  int32_t* backtrack_stack_base = backtrack_stack.data();
  int32_t* backtrack_sp = backtrack_stack_base;
  intptr_t backtrack_stack_space = backtrack_stack.max_size();
 
  // TODO(zerny): Optimize as single instance. V8 has this as an
  // isolate member.
  unibrow::Mapping<unibrow::Ecma262Canonicalize> canonicalize;
 
  intptr_t subject_length = subject.Length();
 
#ifdef DEBUG
  if (FLAG_trace_regexp_bytecodes) {
    OS::PrintErr("Start irregexp bytecode interpreter\n");
  }
#endif
  const auto thread = Thread::Current();
  const uint8_t* code_base;
  const uint8_t* pc;
  {
    NoSafepointScope no_safepoint;
    code_base = reinterpret_cast<uint8_t*>(bytecode.DataAddr(0));
    pc = code_base;
  }
  while (true) {
    if (UNLIKELY(thread->HasScheduledInterrupts())) {
      intptr_t pc_offset = pc - code_base;
      ErrorPtr error = thread->HandleInterrupts();
      if (error != Object::null()) {
        // Needs to be propagated to the Dart native invoking the
        // regex matcher.
        return error;
      }
      NoSafepointScope no_safepoint;
      code_base = reinterpret_cast<uint8_t*>(bytecode.DataAddr(0));
      pc = code_base + pc_offset;
    }
    NoSafepointScope no_safepoint;
    bool check_for_safepoint_now = false;
    while (!check_for_safepoint_now) {
      int32_t insn = Load32Aligned(pc);
      switch (insn & BYTECODE_MASK) {
        BYTECODE(BREAK)
        UNREACHABLE();
        return Bool::False().ptr();
        BYTECODE(PUSH_CP)
        if (--backtrack_stack_space < 0) {
          return Object::null();
        }
        *backtrack_sp++ = current;
        pc += BC_PUSH_CP_LENGTH;
        break;
        BYTECODE(PUSH_BT)
        if (--backtrack_stack_space < 0) {
          return Object::null();
        }
        *backtrack_sp++ = Load32Aligned(pc + 4);
        pc += BC_PUSH_BT_LENGTH;
        break;
        BYTECODE(PUSH_REGISTER)
        if (--backtrack_stack_space < 0) {
          return Object::null();
        }
        *backtrack_sp++ = registers[insn >> BYTECODE_SHIFT];
        pc += BC_PUSH_REGISTER_LENGTH;
        break;
        BYTECODE(SET_REGISTER)
        registers[insn >> BYTECODE_SHIFT] = Load32Aligned(pc + 4);
        pc += BC_SET_REGISTER_LENGTH;
        break;
        BYTECODE(ADVANCE_REGISTER)
        registers[insn >> BYTECODE_SHIFT] += Load32Aligned(pc + 4);
        pc += BC_ADVANCE_REGISTER_LENGTH;
        break;
        BYTECODE(SET_REGISTER_TO_CP)
        registers[insn >> BYTECODE_SHIFT] = current + Load32Aligned(pc + 4);
        pc += BC_SET_REGISTER_TO_CP_LENGTH;
        break;
        BYTECODE(SET_CP_TO_REGISTER)
        current = registers[insn >> BYTECODE_SHIFT];
        pc += BC_SET_CP_TO_REGISTER_LENGTH;
        break;
        BYTECODE(SET_REGISTER_TO_SP)
        registers[insn >> BYTECODE_SHIFT] =
            static_cast<int>(backtrack_sp - backtrack_stack_base);
        pc += BC_SET_REGISTER_TO_SP_LENGTH;
        break;
        BYTECODE(SET_SP_TO_REGISTER)
        backtrack_sp = backtrack_stack_base + registers[insn >> BYTECODE_SHIFT];
        backtrack_stack_space =
            backtrack_stack.max_size() -
            static_cast<int>(backtrack_sp - backtrack_stack_base);
        pc += BC_SET_SP_TO_REGISTER_LENGTH;
        break;
        BYTECODE(POP_CP)
        backtrack_stack_space++;
        --backtrack_sp;
        current = *backtrack_sp;
        pc += BC_POP_CP_LENGTH;
        break;
        BYTECODE(POP_BT)
        backtrack_stack_space++;
        --backtrack_sp;
        pc = code_base + *backtrack_sp;
        // This should match check cadence in JIT irregexp implementation.
        check_for_safepoint_now = true;
        break;
        BYTECODE(POP_REGISTER)
        backtrack_stack_space++;
        --backtrack_sp;
        registers[insn >> BYTECODE_SHIFT] = *backtrack_sp;
        pc += BC_POP_REGISTER_LENGTH;
        break;
        BYTECODE(FAIL)
        return Bool::False().ptr();
        BYTECODE(SUCCEED)
        return Bool::True().ptr();
        BYTECODE(ADVANCE_CP)
        current += insn >> BYTECODE_SHIFT;
        pc += BC_ADVANCE_CP_LENGTH;
        break;
        BYTECODE(GOTO)
        pc = code_base + Load32Aligned(pc + 4);
        break;
        BYTECODE(ADVANCE_CP_AND_GOTO)
        current += insn >> BYTECODE_SHIFT;
        pc = code_base + Load32Aligned(pc + 4);
        break;
        BYTECODE(CHECK_GREEDY)
        if (current == backtrack_sp[-1]) {
          backtrack_sp--;
          backtrack_stack_space++;
          pc = code_base + Load32Aligned(pc + 4);
        } else {
          pc += BC_CHECK_GREEDY_LENGTH;
        }
        break;
        BYTECODE(LOAD_CURRENT_CHAR) {
          int pos = current + (insn >> BYTECODE_SHIFT);
          if (pos < 0 || pos >= subject_length) {
            pc = code_base + Load32Aligned(pc + 4);
          } else {
            current_char = subject.CharAt(pos);
            pc += BC_LOAD_CURRENT_CHAR_LENGTH;
          }
          break;
        }
        BYTECODE(LOAD_CURRENT_CHAR_UNCHECKED) {
          int pos = current + (insn >> BYTECODE_SHIFT);
          current_char = subject.CharAt(pos);
          pc += BC_LOAD_CURRENT_CHAR_UNCHECKED_LENGTH;
          break;
        }
        BYTECODE(LOAD_2_CURRENT_CHARS) {
          int pos = current + (insn >> BYTECODE_SHIFT);
          if (pos + 2 > subject_length) {
            pc = code_base + Load32Aligned(pc + 4);
          } else {
            Char next = subject.CharAt(pos + 1);
            current_char =
                subject.CharAt(pos) | (next << (kBitsPerByte * sizeof(Char)));
            pc += BC_LOAD_2_CURRENT_CHARS_LENGTH;
          }
          break;
        }
        BYTECODE(LOAD_2_CURRENT_CHARS_UNCHECKED) {
          int pos = current + (insn >> BYTECODE_SHIFT);
          Char next = subject.CharAt(pos + 1);
          current_char =
              subject.CharAt(pos) | (next << (kBitsPerByte * sizeof(Char)));
          pc += BC_LOAD_2_CURRENT_CHARS_UNCHECKED_LENGTH;
          break;
        }
        BYTECODE(LOAD_4_CURRENT_CHARS) {
          ASSERT(sizeof(Char) == 1);
          int pos = current + (insn >> BYTECODE_SHIFT);
          if (pos + 4 > subject_length) {
            pc = code_base + Load32Aligned(pc + 4);
          } else {
            Char next1 = subject.CharAt(pos + 1);
            Char next2 = subject.CharAt(pos + 2);
            Char next3 = subject.CharAt(pos + 3);
            current_char = (subject.CharAt(pos) | (next1 << 8) | (next2 << 16) |
                            (next3 << 24));
            pc += BC_LOAD_4_CURRENT_CHARS_LENGTH;
          }
          break;
        }
        BYTECODE(LOAD_4_CURRENT_CHARS_UNCHECKED) {
          ASSERT(sizeof(Char) == 1);
          int pos = current + (insn >> BYTECODE_SHIFT);
          Char next1 = subject.CharAt(pos + 1);
          Char next2 = subject.CharAt(pos + 2);
          Char next3 = subject.CharAt(pos + 3);
          current_char = (subject.CharAt(pos) | (next1 << 8) | (next2 << 16) |
                          (next3 << 24));
          pc += BC_LOAD_4_CURRENT_CHARS_UNCHECKED_LENGTH;
          break;
        }
        BYTECODE(CHECK_4_CHARS) {
          uint32_t c = Load32Aligned(pc + 4);
          if (c == current_char) {
            pc = code_base + Load32Aligned(pc + 8);
          } else {
            pc += BC_CHECK_4_CHARS_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_CHAR) {
          uint32_t c = (insn >> BYTECODE_SHIFT);
          if (c == current_char) {
            pc = code_base + Load32Aligned(pc + 4);
          } else {
            pc += BC_CHECK_CHAR_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_NOT_4_CHARS) {
          uint32_t c = Load32Aligned(pc + 4);
          if (c != current_char) {
            pc = code_base + Load32Aligned(pc + 8);
          } else {
            pc += BC_CHECK_NOT_4_CHARS_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_NOT_CHAR) {
          uint32_t c = (insn >> BYTECODE_SHIFT);
          if (c != current_char) {
            pc = code_base + Load32Aligned(pc + 4);
          } else {
            pc += BC_CHECK_NOT_CHAR_LENGTH;
          }
          break;
        }
        BYTECODE(AND_CHECK_4_CHARS) {
          uint32_t c = Load32Aligned(pc + 4);
          if (c == (current_char & Load32Aligned(pc + 8))) {
            pc = code_base + Load32Aligned(pc + 12);
          } else {
            pc += BC_AND_CHECK_4_CHARS_LENGTH;
          }
          break;
        }
        BYTECODE(AND_CHECK_CHAR) {
          uint32_t c = (insn >> BYTECODE_SHIFT);
          if (c == (current_char & Load32Aligned(pc + 4))) {
            pc = code_base + Load32Aligned(pc + 8);
          } else {
            pc += BC_AND_CHECK_CHAR_LENGTH;
          }
          break;
        }
        BYTECODE(AND_CHECK_NOT_4_CHARS) {
          uint32_t c = Load32Aligned(pc + 4);
          if (c != (current_char & Load32Aligned(pc + 8))) {
            pc = code_base + Load32Aligned(pc + 12);
          } else {
            pc += BC_AND_CHECK_NOT_4_CHARS_LENGTH;
          }
          break;
        }
        BYTECODE(AND_CHECK_NOT_CHAR) {
          uint32_t c = (insn >> BYTECODE_SHIFT);
          if (c != (current_char & Load32Aligned(pc + 4))) {
            pc = code_base + Load32Aligned(pc + 8);
          } else {
            pc += BC_AND_CHECK_NOT_CHAR_LENGTH;
          }
          break;
        }
        BYTECODE(MINUS_AND_CHECK_NOT_CHAR) {
          uint32_t c = (insn >> BYTECODE_SHIFT);
          uint32_t minus = Load16Aligned(pc + 4);
          uint32_t mask = Load16Aligned(pc + 6);
          if (c != ((current_char - minus) & mask)) {
            pc = code_base + Load32Aligned(pc + 8);
          } else {
            pc += BC_MINUS_AND_CHECK_NOT_CHAR_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_CHAR_IN_RANGE) {
          uint32_t from = Load16Aligned(pc + 4);
          uint32_t to = Load16Aligned(pc + 6);
          if (from <= current_char && current_char <= to) {
            pc = code_base + Load32Aligned(pc + 8);
          } else {
            pc += BC_CHECK_CHAR_IN_RANGE_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_CHAR_NOT_IN_RANGE) {
          uint32_t from = Load16Aligned(pc + 4);
          uint32_t to = Load16Aligned(pc + 6);
          if (from > current_char || current_char > to) {
            pc = code_base + Load32Aligned(pc + 8);
          } else {
            pc += BC_CHECK_CHAR_NOT_IN_RANGE_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_BIT_IN_TABLE) {
          int mask = RegExpMacroAssembler::kTableMask;
          uint8_t b = pc[8 + ((current_char & mask) >> kBitsPerByteLog2)];
          int bit = (current_char & (kBitsPerByte - 1));
          if ((b & (1 << bit)) != 0) {
            pc = code_base + Load32Aligned(pc + 4);
          } else {
            pc += BC_CHECK_BIT_IN_TABLE_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_LT) {
          uint32_t limit = (insn >> BYTECODE_SHIFT);
          if (current_char < limit) {
            pc = code_base + Load32Aligned(pc + 4);
          } else {
            pc += BC_CHECK_LT_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_GT) {
          uint32_t limit = (insn >> BYTECODE_SHIFT);
          if (current_char > limit) {
            pc = code_base + Load32Aligned(pc + 4);
          } else {
            pc += BC_CHECK_GT_LENGTH;
          }
          break;
        }
        BYTECODE(CHECK_REGISTER_LT)
        if (registers[insn >> BYTECODE_SHIFT] < Load32Aligned(pc + 4)) {
          pc = code_base + Load32Aligned(pc + 8);
        } else {
          pc += BC_CHECK_REGISTER_LT_LENGTH;
        }
        break;
        BYTECODE(CHECK_REGISTER_GE)
        if (registers[insn >> BYTECODE_SHIFT] >= Load32Aligned(pc + 4)) {
          pc = code_base + Load32Aligned(pc + 8);
        } else {
          pc += BC_CHECK_REGISTER_GE_LENGTH;
        }
        break;
        BYTECODE(CHECK_REGISTER_EQ_POS)
        if (registers[insn >> BYTECODE_SHIFT] == current) {
          pc = code_base + Load32Aligned(pc + 4);
        } else {
          pc += BC_CHECK_REGISTER_EQ_POS_LENGTH;
        }
        break;
        BYTECODE(CHECK_NOT_REGS_EQUAL)
        if (registers[insn >> BYTECODE_SHIFT] ==
            registers[Load32Aligned(pc + 4)]) {
          pc += BC_CHECK_NOT_REGS_EQUAL_LENGTH;
        } else {
          pc = code_base + Load32Aligned(pc + 8);
        }
        break;
        BYTECODE(CHECK_NOT_BACK_REF) {
          int from = registers[insn >> BYTECODE_SHIFT];
          int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
          if (from < 0 || len <= 0) {
            pc += BC_CHECK_NOT_BACK_REF_LENGTH;
            break;
          }
          if (current + len > subject_length) {
            pc = code_base + Load32Aligned(pc + 4);
            break;
          } else {
            int i;
            for (i = 0; i < len; i++) {
              if (subject.CharAt(from + i) != subject.CharAt(current + i)) {
                pc = code_base + Load32Aligned(pc + 4);
                break;
              }
            }
            if (i < len) break;
            current += len;
          }
          pc += BC_CHECK_NOT_BACK_REF_LENGTH;
          break;
        }
        BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_UNICODE)
        FALL_THROUGH;
        BYTECODE(CHECK_NOT_BACK_REF_NO_CASE) {
          const bool unicode =
              (insn & BYTECODE_MASK) == BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE;
          int from = registers[insn >> BYTECODE_SHIFT];
          int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
          if (from < 0 || len <= 0) {
            pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
            break;
          }
          if (current + len > subject_length) {
            pc = code_base + Load32Aligned(pc + 4);
            break;
          } else {
            if (BackRefMatchesNoCase<Char>(&canonicalize, from, current, len,
                                           subject, unicode)) {
              current += len;
              pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
            } else {
              pc = code_base + Load32Aligned(pc + 4);
            }
          }
          break;
        }
        BYTECODE(CHECK_NOT_BACK_REF_BACKWARD) {
          const int from = registers[insn >> BYTECODE_SHIFT];
          const int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
          if (from < 0 || len <= 0) {
            pc += BC_CHECK_NOT_BACK_REF_BACKWARD_LENGTH;
            break;
          }
          if ((current - len) < 0) {
            pc = code_base + Load32Aligned(pc + 4);
            break;
          } else {
            // When looking behind, the string to match (if it is there) lies
            // before the current position, so we will check the [len]
            // characters before the current position, excluding the current
            // position itself.
            const int start = current - len;
            int i;
            for (i = 0; i < len; i++) {
              if (subject.CharAt(from + i) != subject.CharAt(start + i)) {
                pc = code_base + Load32Aligned(pc + 4);
                break;
              }
            }
            if (i < len) break;
            current -= len;
          }
          pc += BC_CHECK_NOT_BACK_REF_BACKWARD_LENGTH;
          break;
        }
        BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD)
        FALL_THROUGH;
        BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_BACKWARD) {
          bool unicode = (insn & BYTECODE_MASK) ==
                         BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD;
          int from = registers[insn >> BYTECODE_SHIFT];
          int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
          if (from < 0 || len <= 0) {
            pc += BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD_LENGTH;
            break;
          }
          if (current < len) {
            pc = code_base + Load32Aligned(pc + 4);
            break;
          } else {
            if (BackRefMatchesNoCase<Char>(&canonicalize, from, current - len,
                                           len, subject, unicode)) {
              current -= len;
              pc += BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD_LENGTH;
            } else {
              pc = code_base + Load32Aligned(pc + 4);
            }
          }
          break;
        }
        BYTECODE(CHECK_AT_START)
        if (current == 0) {
          pc = code_base + Load32Aligned(pc + 4);
        } else {
          pc += BC_CHECK_AT_START_LENGTH;
        }
        break;
        BYTECODE(CHECK_NOT_AT_START) {
          const int32_t cp_offset = insn >> BYTECODE_SHIFT;
          if (current + cp_offset == 0) {
            pc += BC_CHECK_NOT_AT_START_LENGTH;
          } else {
            pc = code_base + Load32Aligned(pc + 4);
          }
          break;
        }
        BYTECODE(SET_CURRENT_POSITION_FROM_END) {
          int by = static_cast<uint32_t>(insn) >> BYTECODE_SHIFT;
          if (subject_length - current > by) {
            current = subject_length - by;
            current_char = subject.CharAt(current - 1);
          }
          pc += BC_SET_CURRENT_POSITION_FROM_END_LENGTH;
          break;
        }
        default:
          UNREACHABLE();
          break;
      }
    }
  }
}

RawSmiValue()

intptr_t dart::RawSmiValue ( const SmiPtr  raw_value )

inline

Definition at line 459 of file tagged_pointer.h.

                                                    {
#if !defined(DART_COMPRESSED_POINTERS)
  const intptr_t value = static_cast<intptr_t>(raw_value);
#else
  const intptr_t value = static_cast<intptr_t>(static_cast<int32_t>(
      static_cast<uint32_t>(static_cast<uintptr_t>(raw_value))));
#endif
  ASSERT((value & kSmiTagMask) == kSmiTag);
  return (value >> kSmiTagShift);
}

ReadApiMessage()

Dart_CObject * dart::ReadApiMessage	(	Zone *	zone,
		Message *	message
	)

Definition at line 3501 of file message_snapshot.cc.

                                                           {
  if (message->IsRaw()) {
    Dart_CObject* result = zone->Alloc<Dart_CObject>(1);
    ApiObjectConverter::Convert(message->raw_obj(), result);
    return result;
  } else {
    RELEASE_ASSERT(message->IsSnapshot());
    ApiMessageDeserializer deserializer(zone, message);
    return deserializer.Deserialize();
  }
}

ReadHeaderRelaxed()

static DART_FORCE_INLINE uword dart::ReadHeaderRelaxed ( ObjectPtr  obj )

static

Definition at line 118 of file scavenger.cc.

                                              {
  return reinterpret_cast<std::atomic<uword>*>(UntaggedObject::ToAddr(obj))
      ->load(std::memory_order_relaxed);
}

ReadMessage()

ObjectPtr dart::ReadMessage	(	Thread *	thread,
		Message *	message
	)

Definition at line 3479 of file message_snapshot.cc.

                                                        {
  if (message->IsRaw()) {
    return message->raw_obj();
  } else if (message->IsFinalizerInvocationRequest()) {
    PersistentHandle* handle = message->persistent_handle();
    Object& msg_obj = Object::Handle(thread->zone(), handle->ptr());
    ASSERT(msg_obj.IsFinalizer() || msg_obj.IsNativeFinalizer());
    return msg_obj.ptr();
  } else if (message->IsPersistentHandle()) {
    return ReadObjectGraphCopyMessage(thread, message->persistent_handle());
  } else {
    RELEASE_ASSERT(message->IsSnapshot());
    LongJumpScope jump(thread);
    if (setjmp(*jump.Set()) == 0) {
      MessageDeserializer deserializer(thread, message);
      return deserializer.Deserialize();
    } else {
      return thread->StealStickyError();
    }
  }
}

ReadObjectGraphCopyMessage()

ObjectPtr dart::ReadObjectGraphCopyMessage	(	Thread *	thread,
		PersistentHandle *	handle
	)

Definition at line 3447 of file message_snapshot.cc.

                                                                               {
  // msg_array = [
  //     <message>,
  //     <collection-lib-objects-to-rehash>,
  //     <core-lib-objects-to-rehash>,
  // ]
  Zone* zone = thread->zone();
  Object& msg_obj = Object::Handle(zone);
  const auto& msg_array = Array::Handle(zone, Array::RawCast(handle->ptr()));
  ASSERT(msg_array.Length() == 3);
  msg_obj = msg_array.At(0);
  if (msg_array.At(1) != Object::null()) {
    const auto& objects_to_rehash = Object::Handle(zone, msg_array.At(1));
    auto& result = Object::Handle(zone);
    result = DartLibraryCalls::RehashObjectsInDartCollection(thread,
                                                             objects_to_rehash);
    if (result.ptr() != Object::null()) {
      msg_obj = result.ptr();
    }
  }
  if (msg_array.At(2) != Object::null()) {
    const auto& objects_to_rehash = Object::Handle(zone, msg_array.At(2));
    auto& result = Object::Handle(zone);
    result =
        DartLibraryCalls::RehashObjectsInDartCore(thread, objects_to_rehash);
    if (result.ptr() != Object::null()) {
      msg_obj = result.ptr();
    }
  }
  return msg_obj.ptr();
}

realloc()

void * dart::realloc	(	void *	ptr,
		size_t	size
	)

Definition at line 27 of file allocation.cc.

                                      {
  void* result = ::realloc(ptr, size);
  if (result == nullptr) {
    OUT_OF_MEMORY();
  }
  return result;
}

ReciprocalEstimate()

float dart::ReciprocalEstimate

(

float

op

)

ReciprocalSqrtEstimate()

float dart::ReciprocalSqrtEstimate

(

float

op

)

ReciprocalSqrtStep()

float dart::ReciprocalSqrtStep	(	float	op1,
		float	op2
	)

ReciprocalStep()

float dart::ReciprocalStep	(	float	op1,
		float	op2
	)

RecognizeTestPattern()

static bool dart::RecognizeTestPattern ( Value *  left, Value *  right, bool *  negate  )

static

Definition at line 3611 of file il.cc.

                                                                          {
  if (!right->BindsToConstant() || !right->BoundConstant().IsSmi()) {
    return false;
  }
 
  const intptr_t value = Smi::Cast(right->BoundConstant()).Value();
  if ((value != 0) && !Utils::IsPowerOfTwo(value)) {
    return false;
  }
 
  BinarySmiOpInstr* mask_op = left->definition()->AsBinarySmiOp();
  if ((mask_op == nullptr) || (mask_op->op_kind() != Token::kBIT_AND) ||
      !mask_op->HasOnlyUse(left)) {
    return false;
  }
 
  if (value == 0) {
    // Recognized (a & b) == 0 pattern.
    *negate = false;
    return true;
  }
 
  // Recognize
  if (BindsToGivenConstant(mask_op->left(), value) ||
      BindsToGivenConstant(mask_op->right(), value)) {
    // Recognized (a & 2^n) == 2^n pattern. It's equivalent to (a & 2^n) != 0
    // so we need to negate original comparison.
    *negate = true;
    return true;
  }
 
  return false;
}

RecognizeTokenKindHelper()

static Token::Kind dart::RecognizeTokenKindHelper ( const String &  name )

static

Definition at line 256 of file method_recognizer.cc.

                                                              {
  if (name.ptr() == Symbols::Plus().ptr()) {
    return Token::kADD;
  } else if (name.ptr() == Symbols::Minus().ptr()) {
    return Token::kSUB;
  } else if (name.ptr() == Symbols::Star().ptr()) {
    return Token::kMUL;
  } else if (name.ptr() == Symbols::Slash().ptr()) {
    return Token::kDIV;
  } else if (name.ptr() == Symbols::TruncDivOperator().ptr()) {
    return Token::kTRUNCDIV;
  } else if (name.ptr() == Symbols::Percent().ptr()) {
    return Token::kMOD;
  } else if (name.ptr() == Symbols::BitOr().ptr()) {
    return Token::kBIT_OR;
  } else if (name.ptr() == Symbols::Ampersand().ptr()) {
    return Token::kBIT_AND;
  } else if (name.ptr() == Symbols::Caret().ptr()) {
    return Token::kBIT_XOR;
  } else if (name.ptr() == Symbols::LeftShiftOperator().ptr()) {
    return Token::kSHL;
  } else if (name.ptr() == Symbols::RightShiftOperator().ptr()) {
    return Token::kSHR;
  } else if (name.ptr() == Symbols::UnsignedRightShiftOperator().ptr()) {
    return Token::kUSHR;
  } else if (name.ptr() == Symbols::Tilde().ptr()) {
    return Token::kBIT_NOT;
  } else if (name.ptr() == Symbols::UnaryMinus().ptr()) {
    return Token::kNEGATE;
  } else if (name.ptr() == Symbols::EqualOperator().ptr()) {
    return Token::kEQ;
  } else if (name.ptr() == Symbols::Token(Token::kNE).ptr()) {
    return Token::kNE;
  } else if (name.ptr() == Symbols::LAngleBracket().ptr()) {
    return Token::kLT;
  } else if (name.ptr() == Symbols::RAngleBracket().ptr()) {
    return Token::kGT;
  } else if (name.ptr() == Symbols::LessEqualOperator().ptr()) {
    return Token::kLTE;
  } else if (name.ptr() == Symbols::GreaterEqualOperator().ptr()) {
    return Token::kGTE;
  } else if (Field::IsGetterName(name)) {
    return Token::kGET;
  } else if (Field::IsSetterName(name)) {
    return Token::kSET;
  }
  return Token::kILLEGAL;
}

RefineBreakpointPos()

static void dart::RefineBreakpointPos ( const Script &  script, TokenPosition  pos, TokenPosition  next_closest_token_position, TokenPosition  requested_token_pos, TokenPosition  last_token_pos, intptr_t  requested_column, TokenPosition  exact_token_pos, TokenPosition *  best_fit_pos, intptr_t *  best_column, intptr_t *  best_line  )

static

Definition at line 1955 of file debugger.cc.

                                                     {
  ASSERT(
      (requested_column == -1 && exact_token_pos == TokenPosition::kNoSource) ||
      (requested_column > -1 && exact_token_pos != TokenPosition::kNoSource));
 
  intptr_t token_start_column = -1;
  intptr_t token_line = -1;
  if (requested_column >= 0) {
    TokenPosition ignored = TokenPosition::kNoSource;
    TokenPosition end_of_line_pos = TokenPosition::kNoSource;
    script.GetTokenLocation(pos, &token_line, &token_start_column);
    script.TokenRangeAtLine(token_line, &ignored, &end_of_line_pos);
 
    TokenPosition token_end_pos = TokenPosition::Min(
        TokenPosition::Deserialize(next_closest_token_position.Pos() - 1),
        end_of_line_pos);
 
    if ((token_end_pos.IsReal() && exact_token_pos.IsReal() &&
         (token_end_pos < exact_token_pos)) ||
        (token_start_column > *best_column)) {
      // We prefer the token with the lowest column number compatible with the
      // requested column. The current token under consideration either ends
      // before the requested column, and is thus incompatible with it, or
      // has a higher column number than the best token we've found so far, so
      // we reject the current token under consideration.
      return;
    }
  }
 
  // Prefer the lowest (first) token pos.
  if (pos < *best_fit_pos) {
    *best_fit_pos = pos;
    *best_line = token_line;
    *best_column = token_start_column;
  }
}

RefineUseTypes()

static void dart::RefineUseTypes ( Definition *  instr )

static

Definition at line 22 of file call_specializer.cc.

                                              {
  CompileType* new_type = instr->Type();
  for (Value::Iterator it(instr->input_use_list()); !it.Done(); it.Advance()) {
    it.Current()->RefineReachingType(new_type);
  }
}

RegisterClosureCallback()

DART_EXPORT void dart::RegisterClosureCallback

(

Dart_Handle

h

)

Definition at line 1110 of file ffi_test_functions_vmspecific.cc.

                                                        {
  closure_to_callback_ = Dart_NewPersistentHandle_DL(h);
}

RegisterClosureCallbackFP()

DART_EXPORT void dart::RegisterClosureCallbackFP

(

void(*)(Dart_Handle)

callback

)

Definition at line 1106 of file ffi_test_functions_vmspecific.cc.

                                                                          {
  callback_ = callback;
}

RegisterFakeFunction()

const Function & dart::RegisterFakeFunction	(	const char *	name,
		const Code &	code
	)

Definition at line 13 of file stub_code_test.cc.

                                                                         {
  Thread* thread = Thread::Current();
  const String& class_name = String::Handle(Symbols::New(thread, "ownerClass"));
  const Script& script = Script::Handle();
  const Library& lib = Library::Handle(Library::CoreLibrary());
  const Class& owner_class = Class::Handle(
      Class::New(lib, class_name, script, TokenPosition::kNoSource));
  const String& function_name = String::ZoneHandle(Symbols::New(thread, name));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  Function& function = Function::ZoneHandle(Function::New(
      signature, function_name, UntaggedFunction::kRegularFunction, true, false,
      false, false, false, owner_class, TokenPosition::kNoSource));
  const Array& functions = Array::Handle(Array::New(1));
  functions.SetAt(0, function);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    owner_class.SetFunctions(functions);
  }
  lib.AddClass(owner_class);
  function.AttachCode(code);
  return function;
}

RegisterKindFromPolicy()

static Location::Kind dart::RegisterKindFromPolicy ( Location  loc )

static

Definition at line 876 of file linearscan.cc.

                                                         {
  if (loc.policy() == Location::kRequiresFpuRegister) {
    return Location::kFpuRegister;
  } else {
    return Location::kRegister;
  }
}

RegisterMyCallbackBlocking()

DART_EXPORT void dart::RegisterMyCallbackBlocking	(	Dart_Port	send_port,
		intptr_t(*)(intptr_t)	callback1
	)

Definition at line 584 of file ffi_test_functions_vmspecific.cc.

                                                                             {
  my_callback_blocking_fp_ = callback1;
  my_callback_blocking_send_port_ = send_port;
}

RegisterMyCallbackNonBlocking()

DART_EXPORT void dart::RegisterMyCallbackNonBlocking	(	Dart_Port	send_port,
		void(*)(intptr_t)	callback
	)

Definition at line 590 of file ffi_test_functions_vmspecific.cc.

                                                                           {
  my_callback_non_blocking_fp_ = callback;
  my_callback_non_blocking_send_port_ = send_port;
}

RegisterRange()

static Utils::BitsRange< Register > dart::RegisterRange ( uint32_t  regs )

inlinestatic

Definition at line 110 of file constants.h.

                                                                    {
  return Utils::BitsRange<Register>(regs);
}

RegisterSendPort()

DART_EXPORT void dart::RegisterSendPort

(

Dart_Port

send_port

)

Definition at line 874 of file ffi_test_functions_vmspecific.cc.

                                                       {
  send_port_ = send_port;
}

RegisterTypeArgumentsUse()

void dart::RegisterTypeArgumentsUse	(	const Function &	function,
		TypeUsageInfo *	type_usage_info,
		const Class &	klass,
		Definition *	type_arguments
	)

Definition at line 1260 of file type_testing_stubs.cc.

                                                          {
  // The [type_arguments] can, in the general case, be any kind of [Definition]
  // but generally (in order of expected frequency)
  //
  //   Case a)
  //      type_arguments <- Constant(#null)
  //      type_arguments <- Constant(#TypeArguments: [ ... ])
  //
  //   Case b)
  //      type_arguments <- InstantiateTypeArguments(ita, fta, uta)
  //      (where uta may not be a constant non-null TypeArguments object)
  //
  //   Case c)
  //      type_arguments <- LoadField(vx)
  //      type_arguments <- LoadField(vx T{_ABC})
  //      type_arguments <- LoadField(vx T{Type: class: '_ABC'})
  //
  //   Case d, e)
  //      type_arguments <- LoadIndexedUnsafe(rbp[vx + 16]))
  //      type_arguments <- Parameter(0)
 
  if (ConstantInstr* constant = type_arguments->AsConstant()) {
    const Object& object = constant->value();
    ASSERT(object.IsNull() || object.IsTypeArguments());
    const TypeArguments& type_arguments =
        TypeArguments::Handle(TypeArguments::RawCast(object.ptr()));
    type_usage_info->UseTypeArgumentsInInstanceCreation(klass, type_arguments);
  } else if (InstantiateTypeArgumentsInstr* instantiate =
                 type_arguments->AsInstantiateTypeArguments()) {
    if (instantiate->type_arguments()->BindsToConstant() &&
        !instantiate->type_arguments()->BoundConstant().IsNull()) {
      const auto& ta =
          TypeArguments::Cast(instantiate->type_arguments()->BoundConstant());
      type_usage_info->UseTypeArgumentsInInstanceCreation(klass, ta);
    }
  } else if (LoadFieldInstr* load_field = type_arguments->AsLoadField()) {
    Definition* instance = load_field->instance()->definition();
    intptr_t cid = instance->Type()->ToNullableCid();
    if (cid == kDynamicCid) {
      // This is an approximation: If we only know the type, but not the cid, we
      // might have a this-dispatch where we know it's either this class or any
      // subclass.
      // We try to strengthen this assumption further down by checking the
      // offset of the type argument vector, but generally speaking this could
      // be a false-positive, which is still ok!
      const AbstractType& type = *instance->Type()->ToAbstractType();
      if (type.IsType()) {
        const Class& type_class = Class::Handle(type.type_class());
        if (type_class.NumTypeArguments() >= klass.NumTypeArguments()) {
          cid = type_class.id();
        }
      }
    }
    if (cid != kDynamicCid) {
      const Class& instance_klass =
          Class::Handle(IsolateGroup::Current()->class_table()->At(cid));
      if (load_field->slot().IsTypeArguments() && instance_klass.IsGeneric() &&
          compiler::target::Class::TypeArgumentsFieldOffset(instance_klass) ==
              load_field->slot().offset_in_bytes()) {
        // This is a subset of Case c) above, namely forwarding the type
        // argument vector.
        //
        // We use the declaration type arguments for the instance creation,
        // which is a non-instantiated, expanded, type arguments vector.
        TypeArguments& declaration_type_args = TypeArguments::Handle(
            instance_klass.GetDeclarationInstanceTypeArguments());
        type_usage_info->UseTypeArgumentsInInstanceCreation(
            klass, declaration_type_args);
      }
    }
  } else if (type_arguments->IsParameter() ||
             type_arguments->IsLoadIndexedUnsafe()) {
    // This happens in constructors with non-optional/optional parameters
    // where we forward the type argument vector to object allocation.
    //
    // Theoretically this could be a false-positive, which is still ok, but
    // practically it's guaranteed that this is a forward of a type argument
    // vector passed in by the caller.
    if (function.IsFactory()) {
      const Class& enclosing_class = Class::Handle(function.Owner());
      TypeArguments& declaration_type_args = TypeArguments::Handle(
          enclosing_class.GetDeclarationInstanceTypeArguments());
      type_usage_info->UseTypeArgumentsInInstanceCreation(
          klass, declaration_type_args);
    }
  } else {
    // It can also be a phi node where the inputs are any of the above,
    // or it could be the result of _prependTypeArguments call.
    ASSERT(type_arguments->IsPhi() || type_arguments->IsStaticCall());
  }
}

RegMaskBit()

static uword dart::RegMaskBit ( Register  reg )

static

Definition at line 80 of file parallel_move_resolver.cc.

                                      {
  return ((reg) != kNoRegister) ? (1 << (reg)) : 0;
}

Regress37069()

DART_EXPORT void dart::Regress37069	(	uint64_t	a,
		uint64_t	b,
		uint64_t	c,
		uint64_t	d,
		uint64_t	e,
		uint64_t	f,
		uint64_t	g,
		uint64_t	h,
		uint64_t	i,
		uint64_t	j,
		uint64_t	k
	)

Definition at line 101 of file ffi_test_functions_vmspecific.cc.

                                          {
  Dart_ExecuteInternalCommand("gc-now", nullptr);
}

Regress39044()

DART_EXPORT int64_t dart::Regress39044	(	int64_t	a,
		int8_t	b
	)

Definition at line 207 of file ffi_test_functions.cc.

                                                      {
  std::cout << "Regress39044(" << a << ", " << static_cast<int>(b) << ")\n";
  const int64_t retval = a - b;
  std::cout << "returning " << retval << "\n";
  return retval;
}

Regress40537()

DART_EXPORT intptr_t dart::Regress40537

(

uint8_t

x

)

Definition at line 214 of file ffi_test_functions.cc.

                                             {
  std::cout << "Regress40537(" << static_cast<int>(x) << ")\n";
  return x == 249 ? 1 : 0;
}

Regress40537Variant2()

DART_EXPORT intptr_t dart::Regress40537Variant2

(

uint8_t

x

)

Definition at line 219 of file ffi_test_functions.cc.

                                                     {
  std::cout << "Regress40537Variant2(" << static_cast<int>(x) << ")\n";
  return x;
}

Regress40537Variant3()

DART_EXPORT uint8_t dart::Regress40537Variant3

(

intptr_t

x

)

Definition at line 224 of file ffi_test_functions.cc.

                                                     {
  std::cout << "Regress40537Variant3(" << static_cast<int>(x) << ")\n";
  return x;
}

Regress43693()

DART_EXPORT uint64_t dart::Regress43693

(

Struct43693 *

my_struct

)

Definition at line 1195 of file ffi_test_functions.cc.

                                                          {
  return my_struct->someValue;
}

Regress46127()

DART_EXPORT Struct46127 dart::Regress46127

(

)

Definition at line 1203 of file ffi_test_functions.cc.

                                       {
  struct Struct46127 myStruct;
  myStruct.val = 123;
  return myStruct;
}

RehashObjects()

static ObjectPtr dart::RehashObjects ( Zone *  zone, const Library &  library, const Object &  array_or_growable_array  )

static

Definition at line 777 of file dart_entry.cc.

                                                                      {
  ASSERT(array_or_growable_array.IsArray() ||
         array_or_growable_array.IsGrowableObjectArray());
  const auto& rehashing_function = Function::Handle(
      zone, library.LookupFunctionAllowPrivate(Symbols::_rehashObjects()));
  ASSERT(!rehashing_function.IsNull());
 
  const auto& arguments = Array::Handle(zone, Array::New(1));
  arguments.SetAt(0, array_or_growable_array);
 
  return DartEntry::InvokeFunction(rehashing_function, arguments);
}

RejectCompilation()

static ObjectPtr dart::RejectCompilation ( Thread *  thread )

static

Definition at line 663 of file isolate_reload.cc.

                                                   {
  TransitionVMToNative transition(thread);
  Dart_KernelCompilationResult result = KernelIsolate::RejectCompilation();
  if (result.status != Dart_KernelCompilationStatus_Ok) {
    if (result.status != Dart_KernelCompilationStatus_MsgFailed) {
      FATAL(
          "An error occurred while rejecting the most recent"
          " compilation results: %s",
          result.error);
    }
    TIR_Print(
        "An error occurred while rejecting the most recent"
        " compilation results: %s",
        result.error);
    Zone* zone = thread->zone();
    const auto& error_str = String::Handle(zone, String::New(result.error));
    free(result.error);
    return ApiError::New(error_str);
  }
  return Object::null();
}

ReleaseClosureCallback()

DART_EXPORT void dart::ReleaseClosureCallback

(

)

Definition at line 1120 of file ffi_test_functions_vmspecific.cc.

                                          {
  Dart_DeletePersistentHandle_DL(closure_to_callback_);
}

ReleaseFilesPairs()

static void dart::ReleaseFilesPairs ( const Dart_CObject &  files )

static

Definition at line 359 of file kernel_isolate.cc.

                                                         {
  for (intptr_t i = 0; i < files.value.as_array.length; i++) {
    delete files.value.as_array.values[i];
  }
  delete[] files.value.as_array.values;
}

RELOAD_NATIVE_LIST()

dart::RELOAD_NATIVE_LIST

(

DECLARE_FUNCTION

)

ReloadSources()

static void dart::ReloadSources ( Thread *  thread, JSONStream *  js  )

static

Definition at line 3840 of file service.cc.

                                                          {
#if defined(DART_PRECOMPILED_RUNTIME)
  js->PrintError(kFeatureDisabled, "Compiler is disabled in AOT mode.");
#else
  IsolateGroup* isolate_group = thread->isolate_group();
  if (isolate_group->library_tag_handler() == nullptr) {
    js->PrintError(kFeatureDisabled,
                   "A library tag handler must be installed.");
    return;
  }
  // TODO(dartbug.com/36097): We need to change the "reloadSources" service-api
  // call to accept an isolate group instead of an isolate.
  Isolate* isolate = thread->isolate();
  if ((isolate->sticky_error() != Error::null()) ||
      (Thread::Current()->sticky_error() != Error::null())) {
    js->PrintError(kIsolateReloadBarred,
                   "This isolate cannot reload sources anymore because there "
                   "was an unhandled exception error. Restart the isolate.");
    return;
  }
  if (isolate_group->IsReloading()) {
    js->PrintError(kIsolateIsReloading, "This isolate is being reloaded.");
    return;
  }
  if (!isolate_group->CanReload()) {
    js->PrintError(kFeatureDisabled,
                   "This isolate cannot reload sources right now.");
    return;
  }
  const bool force_reload =
      BoolParameter::Parse(js->LookupParam("force"), false);
 
  isolate_group->ReloadSources(js, force_reload, js->LookupParam("rootLibUri"),
                               js->LookupParam("packagesUri"));
 
  Service::CheckForPause(isolate, js);
 
#endif
}

ReloadTestScript()

LibraryPtr dart::ReloadTestScript

(

const char *

script

)

Definition at line 42 of file il_test_helper.cc.

                                                {
  Dart_Handle api_lib;
  {
    TransitionVMToNative transition(Thread::Current());
    api_lib = TestCase::ReloadTestScript(script);
    EXPECT_VALID(api_lib);
  }
  auto& lib = Library::Handle();
  lib ^= Api::UnwrapHandle(api_lib);
  EXPECT(!lib.IsNull());
  return lib.ptr();
}

RemoveBreakpoint()

static void dart::RemoveBreakpoint ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4040 of file service.cc.

                                                             {
  if (CheckDebuggerDisabled(thread, js)) {
    return;
  }
 
  if (!js->HasParam("breakpointId")) {
    PrintMissingParamError(js, "breakpointId");
    return;
  }
  const char* bpt_id = js->LookupParam("breakpointId");
  ObjectIdRing::LookupResult lookup_result;
  Isolate* isolate = thread->isolate();
  Breakpoint* bpt = LookupBreakpoint(isolate, bpt_id, &lookup_result);
  // TODO(turnidge): Should we return a different error for bpts which
  // have been already removed?
  if (bpt == nullptr) {
    PrintInvalidParamError(js, "breakpointId");
    return;
  }
  isolate->debugger()->RemoveBreakpoint(bpt->id());
  PrintSuccess(js);
}

RemoveCHAOptimizedCode()

static void dart::RemoveCHAOptimizedCode ( const Class &  subclass, const GrowableArray< intptr_t > &  added_subclass_to_cids  )

static

Definition at line 53 of file class_finalizer.cc.

                                                           {
  ASSERT(FLAG_use_cha_deopt);
  if (added_subclass_to_cids.is_empty()) {
    return;
  }
  // Switch all functions' code to unoptimized.
  const ClassTable& class_table = *IsolateGroup::Current()->class_table();
  Class& cls = Class::Handle();
  for (intptr_t i = 0; i < added_subclass_to_cids.length(); i++) {
    intptr_t cid = added_subclass_to_cids[i];
    cls = class_table.At(cid);
    ASSERT(!cls.IsNull());
    cls.DisableCHAOptimizedCode(subclass);
  }
}

RemoveDotSegments()

static const char * dart::RemoveDotSegments ( const char *  path )

static

Definition at line 282 of file uri.cc.

                                                       {
  const char* input = path;
 
  // The output path will always be less than or equal to the size of
  // the input path.
  Zone* zone = ThreadState::Current()->zone();
  char* buffer = zone->Alloc<char>(strlen(path) + 1);  // +1 for '\0'
  char* output = buffer;
 
  while (*input != '\0') {
    if (strncmp("../", input, 3) == 0) {
      // Discard initial "../" from the input.  It's junk.
      input += 3;
 
    } else if (strncmp("./", input, 3) == 0) {
      // Discard initial "./" from the input.  It's junk.
      input += 2;
 
    } else if (strncmp("/./", input, 3) == 0) {
      // Advance past the "/." part of the input.
      input += 2;
 
    } else if (strcmp("/.", input) == 0) {
      // Pretend the input just contains a "/".
      input = "/";
 
    } else if (strncmp("/../", input, 4) == 0) {
      // Advance past the "/.." part of the input and remove one
      // segment from the output.
      input += 3;
      output = RemoveLastSegment(output, buffer);
 
    } else if (strcmp("/..", input) == 0) {
      // Pretend the input contains a "/" and remove one segment from
      // the output.
      input = "/";
      output = RemoveLastSegment(output, buffer);
 
    } else if (strcmp("..", input) == 0) {
      // The input has been reduced to nothing useful.
      input += 2;
 
    } else if (strcmp(".", input) == 0) {
      // The input has been reduced to nothing useful.
      input += 1;
 
    } else {
      intptr_t segment_len = SegmentLength(input);
      if (input[0] != '/' && output != buffer) {
        *output = '/';
        output++;
      }
      strncpy(output, input, segment_len);
      output += segment_len;
      input += segment_len;
    }
  }
  *output = '\0';
  return buffer;
}

RemoveLastSegment()

static char * dart::RemoveLastSegment ( char *  current, char *  base  )

static

Definition at line 253 of file uri.cc.

                                                          {
  if (current == base) {
    return current;
  }
  ASSERT(current > base);
  for (current--; current > base; current--) {
    if (*current == '/') {
      // We have found the beginning of the last segment.
      return current;
    }
  }
  ASSERT(current == base);
  return current;
}

RepeatBitsAcrossReg()

static uint64_t dart::RepeatBitsAcrossReg ( uint8_t  reg_size, uint64_t  value, uint8_t  width  )

inlinestatic

Definition at line 1280 of file constants_arm64.h.

                                                          {
  ASSERT((width == 2) || (width == 4) || (width == 8) || (width == 16) ||
         (width == 32));
  ASSERT((reg_size == kWRegSizeInBits) || (reg_size == kXRegSizeInBits));
  uint64_t result = value & ((1ULL << width) - 1ULL);
  for (unsigned i = width; i < reg_size; i *= 2) {
    result |= (result << i);
  }
  return result;
}

ReplaceParameterStubs()

static void dart::ReplaceParameterStubs ( Zone *  zone, FlowGraph *  caller_graph, InlinedCallData *  call_data, const TargetInfo *  target_info  )

static

Definition at line 842 of file inliner.cc.

                                                                 {
  const bool is_polymorphic = call_data->call->IsPolymorphicInstanceCall();
  const bool no_checks =
      IsAThisCallThroughAnUncheckedEntryPoint(call_data->call);
  ASSERT(is_polymorphic == (target_info != nullptr));
  FlowGraph* callee_graph = call_data->callee_graph;
  auto callee_entry = callee_graph->graph_entry()->normal_entry();
  const Function& callee = callee_graph->function();
 
  FunctionType& interface_target_signature = FunctionType::Handle();
  FunctionType& callee_signature = FunctionType::Handle(callee.signature());
 
  // If we are inlining a call on this and we are going to skip parameter checks
  // then a situation can arise when parameter type in the callee has a narrower
  // type than what interface target specifies, e.g.
  //
  //    class A<T> {
  //      void f(T v);
  //      void g(T v) { f(v); }
  //    }
  //    class B extends A<X> { void f(X v) { ... } }
  //
  // Consider when B.f is inlined into a callsite in A.g (e.g. due to
  // polymorphic inlining). v is known to be X within the body of B.f, but not
  // guaranteed to be X outside of it. Thus we must ensure that all operations
  // with v that depend on its type being X are pinned to stay within the
  // inlined body.
  //
  // We achieve that by inserting redefinitions for parameters which potentially
  // have narrower types in callee compared to those in the interface target of
  // the call.
  BitVector* is_generic_covariant_impl = nullptr;
  if (no_checks && callee.IsRegularFunction()) {
    const Function& interface_target =
        call_data->call->AsInstanceCallBase()->interface_target();
 
    callee_signature = callee.signature();
    interface_target_signature = interface_target.signature();
 
    // If signatures match then there is nothing to do.
    if (interface_target.signature() != callee.signature()) {
      const intptr_t num_params = callee.NumParameters();
      BitVector is_covariant(zone, num_params);
      is_generic_covariant_impl = new (zone) BitVector(zone, num_params);
 
      kernel::ReadParameterCovariance(callee_graph->function(), &is_covariant,
                                      is_generic_covariant_impl);
    }
  }
 
  // Replace each stub with the actual argument or the caller's constant.
  // Nulls denote optional parameters for which no actual was given.
  const intptr_t first_arg_index = call_data->first_arg_index;
 
  // When first_arg_index > 0, the stub and actual argument processed in the
  // first loop iteration represent a passed-in type argument vector.
  GrowableArray<Value*>* arguments = call_data->arguments;
  intptr_t first_arg_stub_index = 0;
  if (arguments->length() != call_data->parameter_stubs->length()) {
    ASSERT(arguments->length() == call_data->parameter_stubs->length() - 1);
    ASSERT(first_arg_index == 0);
    // The first parameter stub accepts an optional type argument vector, but
    // none was provided in arguments.
    first_arg_stub_index = 1;
  }
  for (intptr_t i = 0; i < arguments->length(); ++i) {
    Value* actual = (*arguments)[i];
    Definition* defn = nullptr;
 
    // Replace the receiver argument with a redefinition to prevent code from
    // the inlined body from being hoisted above the inlined entry.
    const bool is_polymorphic_receiver =
        (is_polymorphic && (i == first_arg_index));
 
    if (actual == nullptr) {
      ASSERT(!is_polymorphic_receiver);
      continue;
    }
 
    if (is_polymorphic_receiver ||
        CalleeParameterTypeMightBeMoreSpecific(
            is_generic_covariant_impl, interface_target_signature,
            callee_signature, first_arg_index, i)) {
      RedefinitionInstr* redefinition =
          new (zone) RedefinitionInstr(actual->Copy(zone));
      caller_graph->AllocateSSAIndex(redefinition);
      if (is_polymorphic_receiver && target_info->IsSingleCid()) {
        redefinition->UpdateType(CompileType::FromCid(target_info->cid_start));
      }
      redefinition->InsertAfter(callee_entry);
      defn = redefinition;
      // Since the redefinition does not dominate the callee entry, replace
      // uses of the receiver argument in this entry with the redefined value.
      callee_entry->ReplaceInEnvironment(
          call_data->parameter_stubs->At(first_arg_stub_index + i),
          actual->definition());
    } else {
      defn = actual->definition();
    }
 
    call_data->parameter_stubs->At(first_arg_stub_index + i)
        ->ReplaceUsesWith(defn);
  }
 
  // Replace remaining constants with uses by constants in the caller's
  // initial definitions.
  auto defns = callee_graph->graph_entry()->initial_definitions();
  for (intptr_t i = 0; i < defns->length(); ++i) {
    ConstantInstr* constant = (*defns)[i]->AsConstant();
    if (constant != nullptr && constant->HasUses()) {
      constant->ReplaceUsesWith(caller_graph->GetConstant(
          constant->value(), constant->representation()));
    }
  }
 
  defns = callee_graph->graph_entry()->normal_entry()->initial_definitions();
  for (intptr_t i = 0; i < defns->length(); ++i) {
    auto defn = (*defns)[i];
    if (!defn->HasUses()) continue;
 
    if (auto constant = defn->AsConstant()) {
      constant->ReplaceUsesWith(caller_graph->GetConstant(
          constant->value(), constant->representation()));
    }
 
    if (auto param = defn->AsParameter()) {
      if (param->location().Equals(Location::RegisterLocation(ARGS_DESC_REG))) {
        param->ReplaceUsesWith(
            caller_graph->GetConstant(call_data->arguments_descriptor));
      }
    }
  }
}

ReportImpossibleNullError()

void dart::ReportImpossibleNullError	(	intptr_t	cid,
		StackFrame *	caller_frame,
		Thread *	thread
	)

Definition at line 273 of file runtime_entry.cc.

                                               {
  TextBuffer buffer(512);
  buffer.Printf("hit null error with cid %" Pd ", caller context: ", cid);
 
  const intptr_t kMaxSlotsCollected = 5;
  const auto slots = reinterpret_cast<ObjectPtr*>(caller_frame->sp());
  const intptr_t num_slots_in_frame =
      reinterpret_cast<ObjectPtr*>(caller_frame->fp()) - slots;
  const auto num_slots_to_collect =
      Utils::Maximum(kMaxSlotsCollected, num_slots_in_frame);
  bool comma = false;
  for (intptr_t i = 0; i < num_slots_to_collect; i++) {
    const ObjectPtr ptr = slots[i];
    buffer.Printf("%s[sp+%" Pd "] %" Pp "", comma ? ", " : "", i,
                  static_cast<uword>(ptr));
    if (ptr->IsHeapObject() &&
        (Dart::vm_isolate_group()->heap()->Contains(
             UntaggedObject::ToAddr(ptr)) ||
         thread->heap()->Contains(UntaggedObject::ToAddr(ptr)))) {
      buffer.Printf("(%" Pp ")", static_cast<uword>(ptr->untag()->tags_));
    }
    comma = true;
  }
 
  const char* message = buffer.buffer();
  FATAL("%s", message);
}

ReportPauseOnConsole()

static void dart::ReportPauseOnConsole ( ServiceEvent *  event )

static

Definition at line 1152 of file service.cc.

                                                      {
  const char* name = event->isolate()->name();
  const int64_t main_port = static_cast<int64_t>(event->isolate()->main_port());
  switch (event->kind()) {
    case ServiceEvent::kPauseStart:
      OS::PrintErr("vm-service: isolate(%" Pd64
                   ") '%s' has no debugger attached and is paused at start.",
                   main_port, name);
      break;
    case ServiceEvent::kPauseExit:
      OS::PrintErr("vm-service: isolate(%" Pd64
                   ")  '%s' has no debugger attached and is paused at exit.",
                   main_port, name);
      break;
    case ServiceEvent::kPauseException:
      OS::PrintErr(
          "vm-service: isolate (%" Pd64
          ") '%s' has no debugger attached and is paused due to exception.",
          main_port, name);
      break;
    case ServiceEvent::kPauseInterrupted:
      OS::PrintErr(
          "vm-service: isolate (%" Pd64
          ") '%s' has no debugger attached and is paused due to interrupt.",
          main_port, name);
      break;
    case ServiceEvent::kPauseBreakpoint:
      OS::PrintErr("vm-service: isolate (%" Pd64
                   ") '%s' has no debugger attached and is paused.",
                   main_port, name);
      break;
    case ServiceEvent::kPausePostRequest:
      OS::PrintErr("vm-service: isolate (%" Pd64
                   ") '%s' has no debugger attached and is paused post reload.",
                   main_port, name);
      break;
    default:
      UNREACHABLE();
      break;
  }
  if (!ServiceIsolate::IsRunning()) {
    OS::PrintErr("  Start the vm-service to debug.\n");
  } else if (ServiceIsolate::server_address() == nullptr) {
    OS::PrintErr("  Connect to the Dart VM service to debug.\n");
  } else {
    OS::PrintErr("  Connect to the Dart VM service at %s to debug.\n",
                 ServiceIsolate::server_address());
  }
  const Error& err = Error::Handle(Thread::Current()->sticky_error());
  if (!err.IsNull()) {
    OS::PrintErr("%s\n", err.ToErrorCString());
  }
}

ReportTimelineEvents()

static void dart::ReportTimelineEvents ( )

static

Definition at line 9975 of file dart_api_impl_test.cc.

                   :math';\n"
      "import 'dart:developer';\n"
      "main() {}";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  Dart_Handle max = Dart_NewStringFromCString("max");
 
  Dart_Handle args[2] = {Dart_NewInteger(123), Dart_NewInteger(321)};
  Dart_Handle result = Dart_Invoke(lib, max, 2, args);
  EXPECT_ERROR(result,
               "NoSuchMethodError: No top-level method 'max' declared.");
 
  Dart_Handle getCurrentTag = Dart_NewStringFromCString("getCurrentTag");
  result = Dart_Invoke(lib, getCurrentTag, 0, nullptr);
  EXPECT_ERROR(
      result,
      "NoSuchMethodError: No top-level method 'getCurrentTag' declared.");
}
 
TEST_CASE(DartAPI_InvokeVMServiceMethod) {
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 R"({
                  "jsonrpc": 2.0,
                  "id": "foo",
                  "method": "getVM",
                  "params": { }
                 })");
  uint8_t* response_json = nullptr;
  intptr_t response_json_length = 0;
  char* error = nullptr;
  const bool success = Dart_InvokeVMServiceMethod(
      reinterpret_cast<uint8_t*>(buffer), strlen(buffer), &response_json,
      &response_json_length, &error);
  EXPECT(success);
  EXPECT(error == nullptr);
 
  Dart_Handle bytes = Dart_NewExternalTypedDataWithFinalizer(
      Dart_TypedData_kUint8, response_json, response_json_length, response_json,
      response_json_length, [](void* ignored, void* peer) { free(peer); });
  EXPECT_VALID(bytes);
 
  // We don't have a C++ JSON decoder so we'll invoke dart to validate the
  // result.
  const char* kScript =
      R"(
        import 'dart:convert';
        import 'dart:typed_data';
        bool validate(bool condition) {
          if (!condition) {
            throw 'Failed to validate InvokeVMServiceMethod() response.';
          }
          return false;
        }
        bool validateResult(Uint8List bytes) {
          final map = json.decode(utf8.decode(bytes));
          validate(map['jsonrpc'] == '2.0');
          validate(map['id'] == 'foo');
          validate(map['result']['name'] == 'vm');
          validate(map['result']['type'] == 'VM');

ReportTooManyImports()

static void dart::ReportTooManyImports ( const Library &  lib )

static

Definition at line 13608 of file object.cc.

                                                     {
  const String& url = String::Handle(lib.url());
  Report::MessageF(Report::kError, Script::Handle(lib.LookupScript(url)),
                   TokenPosition::kNoSource, Report::AtLocation,
                   "too many imports in library '%s'", url.ToCString());
  UNREACHABLE();
}

ReportTooManyTypeArguments()

static void dart::ReportTooManyTypeArguments ( const Class &  cls )

static

Definition at line 3160 of file object.cc.

                                                         {
  Report::MessageF(Report::kError, Script::Handle(cls.script()),
                   cls.token_pos(), Report::AtLocation,
                   "too many type parameters declared in class '%s' or in its "
                   "super classes",
                   String::Handle(cls.Name()).ToCString());
  UNREACHABLE();
}

ReportTooManyTypeParameters()

static void dart::ReportTooManyTypeParameters ( const FunctionType &  sig )

static

Definition at line 8875 of file object.cc.

                                                                 {
  Report::MessageF(Report::kError, Script::Handle(), TokenPosition::kNoSource,
                   Report::AtLocation,
                   "too many type parameters declared in signature '%s' or in "
                   "its enclosing signatures",
                   sig.ToUserVisibleCString());
  UNREACHABLE();
}

RepresentationBits()

static intptr_t dart::RepresentationBits ( Representation  r )

static

Definition at line 2125 of file il.cc.

                                                     {
  switch (r) {
    case kTagged:
      return compiler::target::kSmiBits + 1;
    case kUnboxedInt32:
    case kUnboxedUint32:
      return 32;
    case kUnboxedInt64:
      return 64;
    default:
      UNREACHABLE();
      return 0;
  }
}

RepresentationForRange()

static Representation dart::RepresentationForRange ( Representation  definition_rep )

static

Definition at line 3191 of file linearscan.cc.

                                                                            {
  if (definition_rep == kUnboxedInt64) {
    // kUnboxedInt64 is split into two ranges, each of which are kUntagged.
    return kUntagged;
  } else if (definition_rep == kUnboxedUint32) {
    // kUnboxedUint32 is untagged.
    return kUntagged;
  }
  return definition_rep;
}

RepresentationMask()

static int64_t dart::RepresentationMask ( Representation  r )

static

Definition at line 2140 of file il.cc.

                                                    {
  return static_cast<int64_t>(static_cast<uint64_t>(-1) >>
                              (64 - RepresentationBits(r)));
}

RepresentationToRangeSize()

static RangeBoundary::RangeSize dart::RepresentationToRangeSize ( Representation  r )

static

Definition at line 2099 of file range_analysis.cc.

                                                                          {
  switch (r) {
    case kTagged:
      return RangeBoundary::kRangeBoundarySmi;
    case kUnboxedInt8:
      return RangeBoundary::kRangeBoundaryInt8;
    case kUnboxedInt16:
    case kUnboxedUint8:  // Overapproximate Uint8 as Int16.
      return RangeBoundary::kRangeBoundaryInt16;
    case kUnboxedInt32:
    case kUnboxedUint16:  // Overapproximate Uint16 as Int32.
      return RangeBoundary::kRangeBoundaryInt32;
    case kUnboxedInt64:
    case kUnboxedUint32:  // Overapproximate Uint32 as Int64.
      return RangeBoundary::kRangeBoundaryInt64;
    default:
      UNREACHABLE();
      return RangeBoundary::kRangeBoundarySmi;
  }
}

RequestHeapSnapshot()

static void dart::RequestHeapSnapshot ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4595 of file service.cc.

                                                                {
  if (Service::heapsnapshot_stream.enabled()) {
    VmServiceHeapSnapshotChunkedWriter vmservice_writer(thread);
    HeapSnapshotWriter writer(thread, &vmservice_writer);
    writer.Write();
  }
  // TODO(koda): Provide some id that ties this request to async response(s).
  PrintSuccess(js);
}

ResetHeapSamplingState()

void dart::ResetHeapSamplingState

(

const char *

expected_cls = nullptr

)

Definition at line 10262 of file dart_api_impl_test.cc.

Resolve()

static FunctionPtr dart::Resolve ( Thread *  thread, Zone *  zone, const GrowableArray< const Instance * > &  caller_arguments, const Class &  receiver_class, const String &  name, const Array &  descriptor  )

static

Definition at line 1733 of file runtime_entry.cc.

                             {
  ASSERT(name.IsSymbol());
  auto& target_function = Function::Handle(zone);
  ArgumentsDescriptor args_desc(descriptor);
 
  if (receiver_class.EnsureIsFinalized(thread) == Error::null()) {
    target_function = Resolver::ResolveDynamicForReceiverClass(receiver_class,
                                                               name, args_desc);
  }
  if (caller_arguments.length() == 2 &&
      target_function.ptr() == thread->isolate_group()
                                   ->object_store()
                                   ->simple_instance_of_function()) {
    // Replace the target function with constant function.
    const AbstractType& type = AbstractType::Cast(*caller_arguments[1]);
    target_function =
        ComputeTypeCheckTarget(*caller_arguments[0], type, args_desc);
  }
 
  if (target_function.IsNull()) {
    target_function = InlineCacheMissHelper(receiver_class, descriptor, name);
  }
  if (target_function.IsNull()) {
    ASSERT(!FLAG_lazy_dispatchers);
  }
 
  return target_function.ptr();
}

ResolveBreakpointPos()

static TokenPosition dart::ResolveBreakpointPos ( const Function &  func, TokenPosition  requested_token_pos, TokenPosition  last_token_pos, intptr_t  requested_column, TokenPosition  exact_token_pos  )

static

Definition at line 2062 of file debugger.cc.

                                                                         {
  ASSERT(!func.HasOptimizedCode());
  ASSERT(
      (requested_column == -1 && exact_token_pos == TokenPosition::kNoSource) ||
      (requested_column > -1 && exact_token_pos != TokenPosition::kNoSource));
 
  requested_token_pos =
      TokenPosition::Max(requested_token_pos, func.token_pos());
  last_token_pos = TokenPosition::Min(last_token_pos, func.end_token_pos());
 
  Zone* zone = Thread::Current()->zone();
  Script& script = Script::Handle(zone, func.script());
  Code& code = Code::Handle(zone);
  PcDescriptors& desc = PcDescriptors::Handle(zone);
  ASSERT(func.HasCode());
  code = func.unoptimized_code();
  ASSERT(!code.IsNull());
  desc = code.pc_descriptors();
 
  // First pass: find the safe point which is closest to the beginning
  // of the given token range.
  TokenPosition best_fit_pos = TokenPosition::kMaxSource;
  intptr_t best_column = INT_MAX;
  intptr_t best_line = INT_MAX;
 
  PcDescriptors::Iterator iter(desc, kSafepointKind);
  while (iter.MoveNext()) {
    const TokenPosition& pos = iter.TokenPos();
    if (pos.IsSynthetic() && pos == requested_token_pos) {
      // if there's a safepoint for a synthetic function start and the start
      // was requested, we're done.
      return pos;
    }
    if (!pos.IsWithin(requested_token_pos, last_token_pos)) {
      // Token is not in the target range.
      continue;
    }
    TokenPosition next_closest_token_position = TokenPosition::kMaxSource;
    if (requested_column >= 0) {
      // Find next closest safepoint
      PcDescriptors::Iterator iter2(desc, kSafepointKind);
      while (iter2.MoveNext()) {
        const TokenPosition& next = iter2.TokenPos();
        if (!next.IsReal()) continue;
        if ((pos < next) && (next < next_closest_token_position)) {
          next_closest_token_position = next;
        }
      }
    }
    RefineBreakpointPos(script, pos, next_closest_token_position,
                        requested_token_pos, last_token_pos, requested_column,
                        exact_token_pos, &best_fit_pos, &best_column,
                        &best_line);
  }
 
  // Second pass (if we found a safe point in the first pass).  Find
  // the token on the line which is at the best fit column (if column
  // was specified) and has the lowest code address.
  if (best_fit_pos != TokenPosition::kMaxSource) {
    ASSERT(best_fit_pos.IsReal());
    const Script& script = Script::Handle(zone, func.script());
    const TokenPosition begin_pos = best_fit_pos;
 
    TokenPosition end_of_line_pos = TokenPosition::kNoSource;
    if (best_line < 0) {
      script.GetTokenLocation(begin_pos, &best_line);
    }
    ASSERT(best_line > 0);
    TokenPosition ignored = TokenPosition::kNoSource;
    script.TokenRangeAtLine(best_line, &ignored, &end_of_line_pos);
    end_of_line_pos = TokenPosition::Max(end_of_line_pos, begin_pos);
 
    uword lowest_pc_offset = kUwordMax;
    PcDescriptors::Iterator iter(desc, kSafepointKind);
    while (iter.MoveNext()) {
      const TokenPosition& pos = iter.TokenPos();
      if (requested_column >= 0) {
        if (pos != best_fit_pos) {
          // Not an match for the requested column.
          continue;
        }
      } else if (!pos.IsWithin(begin_pos, end_of_line_pos)) {
        // Token is not on same line as best fit.
        continue;
      }
 
      // Prefer the lowest pc offset.
      if (iter.PcOffset() < lowest_pc_offset) {
        lowest_pc_offset = iter.PcOffset();
        best_fit_pos = pos;
      }
    }
    return best_fit_pos;
  }
 
  // We didn't find a safe point in the given token range. Try and
  // find a safe point in the remaining source code of the function.
  // Since we have moved to the next line of the function, we no
  // longer are requesting a specific column number.
  if (last_token_pos < func.end_token_pos()) {
    return ResolveBreakpointPos(func, last_token_pos, func.end_token_pos(),
                                -1 /* no column */, TokenPosition::kNoSource);
  }
  return TokenPosition::kNoSource;
}

ResolveCallThroughGetter()

static bool dart::ResolveCallThroughGetter ( const Class &  receiver_class, const String &  target_name, const String &  demangled, const Array &  arguments_descriptor, Function *  result  )

static

Definition at line 1563 of file runtime_entry.cc.

                                                       {
  const String& getter_name = String::Handle(Field::GetterName(demangled));
  const int kTypeArgsLen = 0;
  const int kNumArguments = 1;
  ArgumentsDescriptor args_desc(Array::Handle(
      ArgumentsDescriptor::NewBoxed(kTypeArgsLen, kNumArguments)));
  const Function& getter =
      Function::Handle(Resolver::ResolveDynamicForReceiverClass(
          receiver_class, getter_name, args_desc));
  if (getter.IsNull() || getter.IsMethodExtractor()) {
    return false;
  }
  // We do this on the target_name, _not_ on the demangled name, so that
  // FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher can detect dynamic
  // calls from the dyn: tag on the name of the dispatcher.
  const Function& target_function =
      Function::Handle(receiver_class.GetInvocationDispatcher(
          target_name, arguments_descriptor,
          UntaggedFunction::kInvokeFieldDispatcher, FLAG_lazy_dispatchers));
  ASSERT(!target_function.IsNull() || !FLAG_lazy_dispatchers);
  if (FLAG_trace_ic) {
    OS::PrintErr(
        "InvokeField IC miss: adding <%s> id:%" Pd " -> <%s>\n",
        receiver_class.ToCString(), receiver_class.id(),
        target_function.IsNull() ? "null" : target_function.ToCString());
  }
  *result = target_function.ptr();
  return true;
}

ResolveConstructor()

static ObjectPtr dart::ResolveConstructor ( const char *  current_func, const Class &  cls, const String &  class_name, const String &  dotted_name, int  num_args  )

static

Definition at line 4173 of file dart_api_impl.cc.

                                                  {
  // The constructor must be present in the interface.
  Function& constructor = Function::Handle();
  if (cls.EnsureIsFinalized(Thread::Current()) == Error::null()) {
    constructor = cls.LookupFunctionAllowPrivate(constr_name);
  }
  if (constructor.IsNull() ||
      (!constructor.IsGenerativeConstructor() && !constructor.IsFactory())) {
    const String& lookup_class_name = String::Handle(cls.Name());
    if (!class_name.Equals(lookup_class_name)) {
      // When the class name used to build the constructor name is
      // different than the name of the class in which we are doing
      // the lookup, it can be confusing to the user to figure out
      // what's going on.  Be a little more explicit for these error
      // messages.
      const String& message = String::Handle(String::NewFormatted(
          "%s: could not find factory '%s' in class '%s'.", current_func,
          constr_name.ToCString(), lookup_class_name.ToCString()));
      return ApiError::New(message);
    } else {
      const String& message = String::Handle(
          String::NewFormatted("%s: could not find constructor '%s'.",
                               current_func, constr_name.ToCString()));
      return ApiError::New(message);
    }
  }
  const int kTypeArgsLen = 0;
  const int extra_args = 1;
  String& error_message = String::Handle();
  if (!constructor.AreValidArgumentCounts(kTypeArgsLen, num_args + extra_args,
                                          0, &error_message)) {
    const String& message = String::Handle(String::NewFormatted(
        "%s: wrong argument count for "
        "constructor '%s': %s.",
        current_func, constr_name.ToCString(), error_message.ToCString()));
    return ApiError::New(message);
  }
  ErrorPtr error = constructor.VerifyCallEntryPoint();
  if (error != Error::null()) return error;
  return constructor.ptr();
}

ResolveDynamicAnyArgsWithCustomLookup()

static FunctionPtr dart::ResolveDynamicAnyArgsWithCustomLookup ( Zone *  zone, const Class &  receiver_class, const String &  function_name, bool  allow_add, std::function< FunctionPtr(Class &, const String &)>  lookup  )

static

Definition at line 33 of file resolver.cc.

                                                            {
  Class& cls = Class::Handle(zone, receiver_class.ptr());
  if (FLAG_trace_resolving) {
    THR_Print("ResolveDynamic '%s' for class %s\n", function_name.ToCString(),
              String::Handle(zone, cls.Name()).ToCString());
  }
  Function& function = Function::Handle(zone);
 
  const String& demangled = String::Handle(
      zone,
      Function::IsDynamicInvocationForwarderName(function_name)
          ? Function::DemangleDynamicInvocationForwarderName(function_name)
          : function_name.ptr());
 
  const bool is_getter = Field::IsGetterName(demangled);
  String& demangled_getter_name = String::Handle();
  if (is_getter) {
    demangled_getter_name = Field::NameFromGetter(demangled);
  }
 
  const bool is_dyn_call = demangled.ptr() != function_name.ptr();
 
  Thread* thread = Thread::Current();
  bool need_to_create_method_extractor = false;
  while (!cls.IsNull()) {
    if (is_dyn_call) {
      // Try to find a dyn:* forwarder & return it.
      function = cls.GetInvocationDispatcher(
          function_name, Array::null_array(),
          UntaggedFunction::kDynamicInvocationForwarder,
          /*create_if_absent=*/false);
    }
    if (!function.IsNull()) return function.ptr();
 
    ASSERT(cls.is_finalized());
    {
      SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
      function = lookup(cls, demangled);
    }
#if !defined(DART_PRECOMPILED_RUNTIME)
    // In JIT we might need to lazily create a dyn:* forwarder.
    if (is_dyn_call && !function.IsNull()) {
      function =
          function.GetDynamicInvocationForwarder(function_name, allow_add);
    }
#endif
    if (!function.IsNull()) return function.ptr();
 
    // Getter invocation might actually be a method extraction.
    if (is_getter) {
      SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
      function = lookup(cls, demangled_getter_name);
      if (!function.IsNull()) {
        if (allow_add && FLAG_lazy_dispatchers) {
          need_to_create_method_extractor = true;
          break;
        } else {
          return Function::null();
        }
      }
    }
    cls = cls.SuperClass();
  }
  if (need_to_create_method_extractor) {
    // We were looking for the getter but found a method with the same
    // name. Create a method extractor and return it.
    // Use GetMethodExtractor instead of CreateMethodExtractor to ensure
    // nobody created method extractor since we last checked under ReadRwLocker.
    function = function.GetMethodExtractor(demangled);
  } else if (is_getter && receiver_class.IsRecordClass() && allow_add &&
             FLAG_lazy_dispatchers) {
    function = receiver_class.GetRecordFieldGetter(demangled);
  }
  return function.ptr();
}

ResolveDynamicForReceiverClassWithCustomLookup()

static FunctionPtr dart::ResolveDynamicForReceiverClassWithCustomLookup ( const Class &  receiver_class, const String &  function_name, const ArgumentsDescriptor &  args_desc, bool  allow_add, std::function< FunctionPtr(Class &, const String &)>  lookup  )

static

Definition at line 114 of file resolver.cc.

                                                            {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  Function& function = Function::Handle(
      zone, ResolveDynamicAnyArgsWithCustomLookup(
                zone, receiver_class, function_name, allow_add, lookup));
 
#if defined(DART_PRECOMPILED_RUNTIME)
  if (!function.IsNull() && function.signature() == FunctionType::null()) {
    // FfiTrampolines are the only functions that can still be called
    // dynamically without going through a dynamic invocation forwarder.
    RELEASE_ASSERT(!Function::IsDynamicInvocationForwarderName(function_name) &&
                   !function.IsFfiCallbackTrampoline());
    // The signature for this function was dropped in the precompiler, which
    // means it is not a possible target for a dynamic call in the program.
    // That means we're resolving an UnlinkedCall for an InstanceCall to
    // a known interface. Since there's no overloading in Dart, the type checker
    // has already checked the validity of the arguments at compile time.
    return function.ptr();
  }
#endif
 
  if (function.IsNull() || !function.AreValidArguments(args_desc, nullptr)) {
    // Return a null function to signal to the upper levels to dispatch to
    // "noSuchMethod" function.
    if (FLAG_trace_resolving) {
      String& error_message =
          String::Handle(zone, Symbols::New(thread, "function not found"));
      if (!function.IsNull()) {
        // Obtain more detailed error message.
        function.AreValidArguments(args_desc, &error_message);
      }
      THR_Print("ResolveDynamic error '%s': %s.\n", function_name.ToCString(),
                error_message.ToCString());
    }
    return Function::null();
  }
  return function.ptr();
}

ResolveNativeFunction()

static NativeFunction dart::ResolveNativeFunction ( Zone *  zone, const Function &  func, bool *  is_bootstrap_native, bool *  is_auto_scope  )

static

Definition at line 228 of file native_entry.cc.

                                                                 {
  const Class& cls = Class::Handle(zone, func.Owner());
  const Library& library = Library::Handle(zone, cls.library());
 
  *is_bootstrap_native =
      Bootstrap::IsBootstrapResolver(library.native_entry_resolver());
 
  const String& native_name = String::Handle(zone, func.native_name());
  ASSERT(!native_name.IsNull());
 
  const int num_params = NativeArguments::ParameterCountForResolution(func);
  NativeFunction native_function = NativeEntry::ResolveNative(
      library, native_name, num_params, is_auto_scope);
  if (native_function == nullptr) {
    FATAL("Failed to resolve native function '%s' in '%s'\n",
          native_name.ToCString(), func.ToQualifiedCString());
  }
  return native_function;
}

ResolveSymbol()

static void * dart::ResolveSymbol ( void *  handle, const char *  symbol, char **  error  )

static

Definition at line 136 of file ffi_dynamic_library.cc.

                                                                           {
#if defined(DART_HOST_OS_WINDOWS)
  if (handle == kWindowsDynamicLibraryProcessPtr) {
    return LookupSymbolInProcess(symbol, error);
  }
#endif
  return Utils::ResolveSymbolInDynamicLibrary(handle, symbol, error);
}

ResolveUri()

bool dart::ResolveUri	(	const char *	ref_uri,
		const char *	base_uri,
		const char **	target_uri
	)

Definition at line 424 of file uri.cc.

                                         {
  // Parse the reference uri.
  ParsedUri ref;
  if (!ParseUri(ref_uri, &ref)) {
    *target_uri = nullptr;
    return false;
  }
 
  ParsedUri target;
  if (ref.scheme != nullptr) {
    if (strcmp(ref.scheme, "dart") == 0) {
      Zone* zone = ThreadState::Current()->zone();
      *target_uri = zone->MakeCopyOfString(ref_uri);
      return true;
    }
 
    // When the ref_uri specifies a scheme, the base_uri is ignored.
    target.scheme = ref.scheme;
    target.userinfo = ref.userinfo;
    target.host = ref.host;
    target.port = ref.port;
    target.path = RemoveDotSegments(ref.path);
    target.query = ref.query;
    target.fragment = ref.fragment;
    *target_uri = BuildUri(target);
    return true;
  }
 
  // Parse the base uri.
  ParsedUri base;
  if (!ParseUri(base_uri, &base)) {
    *target_uri = nullptr;
    return false;
  }
 
  if ((base.scheme != nullptr) && strcmp(base.scheme, "dart") == 0) {
    Zone* zone = ThreadState::Current()->zone();
    *target_uri = zone->MakeCopyOfString(ref_uri);
    return true;
  }
 
  if (ref.host != nullptr) {
    // When the ref_uri specifies an authority, we only use the base scheme.
    target.scheme = base.scheme;
    target.userinfo = ref.userinfo;
    target.host = ref.host;
    target.port = ref.port;
    target.path = RemoveDotSegments(ref.path);
    target.query = ref.query;
    target.fragment = ref.fragment;
    *target_uri = BuildUri(target);
    return true;
  }
 
  if (ref.path[0] == '\0') {
    // Empty path.  Use most parts of base_uri.
    target.scheme = base.scheme;
    target.userinfo = base.userinfo;
    target.host = base.host;
    target.port = base.port;
    target.path = base.path;
    target.query = ((ref.query == nullptr) ? base.query : ref.query);
    target.fragment = ref.fragment;
    *target_uri = BuildUri(target);
    return true;
 
  } else if (ref.path[0] == '/') {
    // Absolute path.  ref_path wins.
    target.scheme = base.scheme;
    target.userinfo = base.userinfo;
    target.host = base.host;
    target.port = base.port;
    target.path = RemoveDotSegments(ref.path);
    target.query = ref.query;
    target.fragment = ref.fragment;
    *target_uri = BuildUri(target);
    return true;
 
  } else {
    // Relative path.  We need to merge the base path and the ref path.
 
    if (base.scheme == nullptr && base.host == nullptr && base.path[0] != '/') {
      // The dart:core Uri class handles resolving a relative uri
      // against a second relative uri specially, in a way not
      // described in the RFC.  We do not need to support this for
      // library resolution.  If we need to implement this later, we
      // can.
      *target_uri = nullptr;
      return false;
    }
 
    target.scheme = base.scheme;
    target.userinfo = base.userinfo;
    target.host = base.host;
    target.port = base.port;
    target.path = RemoveDotSegments(MergePaths(base.path, ref.path));
    target.query = ref.query;
    target.fragment = ref.fragment;
    *target_uri = BuildUri(target);
    return true;
  }
}

Respecialization()

static TTSTestCase dart::Respecialization ( const TTSTestCase &  original )

static

Definition at line 391 of file type_testing_stubs_test.cc.

                                                                 {
  return TTSTestCase(original.instance, original.instantiator_tav,
                     original.function_tav, kRespecialize);
}

RespondWithMalformedJson()

static void dart::RespondWithMalformedJson ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4988 of file service.cc.

                                                                     {
  JSONObject jsobj(js);
  jsobj.AddProperty("a", "a");
  JSONObject jsobj1(js);
  jsobj1.AddProperty("a", "a");
  JSONObject jsobj2(js);
  jsobj2.AddProperty("a", "a");
  JSONObject jsobj3(js);
  jsobj3.AddProperty("a", "a");
}

RespondWithMalformedObject()

static void dart::RespondWithMalformedObject ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4999 of file service.cc.

                                                                       {
  JSONObject jsobj(js);
  jsobj.AddProperty("bart", "simpson");
}

RestoreSIGPIPEHandler()

DART_EXPORT void dart::RestoreSIGPIPEHandler

(

)

Definition at line 327 of file ffi_test_functions_vmspecific.cc.

                                         {
#if defined(DART_HOST_OS_MACOS)
  signal(SIGPIPE, SIG_DFL);
#endif
}

ResultType()

static CompileType * dart::ResultType ( Definition *  call )

static

Definition at line 1704 of file call_specializer.cc.

                                                 {
  if (auto static_call = call->AsStaticCall()) {
    return static_call->result_type();
  } else if (auto instance_call = call->AsInstanceCall()) {
    return instance_call->result_type();
  }
  return nullptr;
}

Resume()

static void dart::Resume ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4329 of file service.cc.

                                                   {
  const char* step_param = js->LookupParam("step");
  Debugger::ResumeAction step = Debugger::kContinue;
  if (step_param != nullptr) {
    step = EnumMapper(step_param, step_enum_names, step_enum_values);
  }
  intptr_t frame_index = 1;
  const char* frame_index_param = js->LookupParam("frameIndex");
  if (frame_index_param != nullptr) {
    if (step != Debugger::kStepRewind) {
      // Only rewind supports the frameIndex parameter.
      js->PrintError(
          kInvalidParams,
          "%s: the 'frameIndex' parameter can only be used when rewinding",
          js->method());
      return;
    }
    frame_index = UIntParameter::Parse(js->LookupParam("frameIndex"));
  }
  Isolate* isolate = thread->isolate();
  if (isolate->message_handler()->is_paused_on_start()) {
    // If the user is issuing a 'Over' or an 'Out' step, that is the
    // same as a regular resume request.
    if (step == Debugger::kStepInto) {
      isolate->debugger()->EnterSingleStepMode();
    }
    isolate->message_handler()->set_should_pause_on_start(false);
    isolate->SetResumeRequest();
    if (Service::debug_stream.enabled()) {
      ServiceEvent event(isolate, ServiceEvent::kResume);
      Service::HandleEvent(&event);
    }
    PrintSuccess(js);
    return;
  }
  if (isolate->message_handler()->should_pause_on_start()) {
    isolate->message_handler()->set_should_pause_on_start(false);
    isolate->SetResumeRequest();
    if (Service::debug_stream.enabled()) {
      ServiceEvent event(isolate, ServiceEvent::kResume);
      Service::HandleEvent(&event);
    }
    PrintSuccess(js);
    return;
  }
  if (isolate->message_handler()->is_paused_on_exit()) {
    isolate->message_handler()->set_should_pause_on_exit(false);
    isolate->SetResumeRequest();
    // We don't send a resume event because we will be exiting.
    PrintSuccess(js);
    return;
  }
  if (isolate->debugger()->PauseEvent() == nullptr) {
    js->PrintError(kIsolateMustBePaused, nullptr);
    return;
  }
 
  const char* error = nullptr;
  if (!isolate->debugger()->SetResumeAction(step, frame_index, &error)) {
    js->PrintError(kCannotResume, "%s", error);
    return;
  }
  isolate->SetResumeRequest();
  PrintSuccess(js);
}

RetrieveFunctionTypeArguments()

static TypeArgumentsPtr dart::RetrieveFunctionTypeArguments ( Thread *  thread, Zone *  zone, const Function &  function, const Instance &  receiver, const TypeArguments &  instantiator_type_args, const Array &  args, const ArgumentsDescriptor &  args_desc  )

static

Definition at line 9467 of file object.cc.

                                          {
  ASSERT(!function.IsNull());
 
  const intptr_t kNumCurrentTypeArgs = function.NumTypeParameters();
  const intptr_t kNumParentTypeArgs = function.NumParentTypeArguments();
  const intptr_t kNumTypeArgs = kNumCurrentTypeArgs + kNumParentTypeArgs;
  // Non-generic functions don't receive type arguments.
  if (kNumTypeArgs == 0) return Object::empty_type_arguments().ptr();
  // Closure functions require that the receiver be provided (and is a closure).
  ASSERT(!function.IsClosureFunction() || receiver.IsClosure());
 
  // Only closure functions should have possibly generic parents.
  ASSERT(function.IsClosureFunction() || kNumParentTypeArgs == 0);
  const auto& parent_type_args =
      function.IsClosureFunction()
          ? TypeArguments::Handle(
                zone, Closure::Cast(receiver).function_type_arguments())
          : Object::empty_type_arguments();
  // We don't try to instantiate the parent type parameters to their bounds
  // if not provided or check any closed-over type arguments against the parent
  // type parameter bounds (since they have been type checked already).
  if (kNumCurrentTypeArgs == 0) return parent_type_args.ptr();
 
  auto& function_type_args = TypeArguments::Handle(zone);
  // First check for delayed type arguments before using either provided or
  // default type arguments.
  bool has_delayed_type_args = false;
  if (function.IsClosureFunction()) {
    const auto& closure = Closure::Cast(receiver);
    function_type_args = closure.delayed_type_arguments();
    has_delayed_type_args =
        function_type_args.ptr() != Object::empty_type_arguments().ptr();
  }
 
  if (args_desc.TypeArgsLen() > 0) {
    // We should never end up here when the receiver is a closure with delayed
    // type arguments unless this dynamically called closure function was
    // retrieved directly from the closure instead of going through
    // DartEntry::ResolveCallable, which appropriately checks for this case.
    ASSERT(!has_delayed_type_args);
    function_type_args ^= args.At(0);
  } else if (!has_delayed_type_args) {
    // We have no explicitly provided function type arguments, so instantiate
    // the type parameters to bounds or replace as appropriate.
    function_type_args = function.DefaultTypeArguments(zone);
    auto const mode =
        function.IsClosureFunction()
            ? function.default_type_arguments_instantiation_mode()
            : function_type_args.GetInstantiationMode(zone, &function);
    switch (mode) {
      case InstantiationMode::kIsInstantiated:
        // Nothing left to do.
        break;
      case InstantiationMode::kNeedsInstantiation:
        function_type_args = function_type_args.InstantiateAndCanonicalizeFrom(
            instantiator_type_args, parent_type_args);
        break;
      case InstantiationMode::kSharesInstantiatorTypeArguments:
        function_type_args = instantiator_type_args.ptr();
        break;
      case InstantiationMode::kSharesFunctionTypeArguments:
        function_type_args = parent_type_args.ptr();
        break;
    }
  }
 
  return function_type_args.Prepend(zone, parent_type_args, kNumParentTypeArgs,
                                    kNumTypeArgs);
}

RetrieveInstantiatorTypeArguments()

static TypeArgumentsPtr dart::RetrieveInstantiatorTypeArguments ( Zone *  zone, const Function &  function, const Instance &  receiver  )

static

Definition at line 9545 of file object.cc.

                              {
  if (function.IsClosureFunction()) {
    ASSERT(receiver.IsClosure());
    const auto& closure = Closure::Cast(receiver);
    return closure.instantiator_type_arguments();
  }
  if (!receiver.IsNull()) {
    const auto& cls = Class::Handle(zone, receiver.clazz());
    if (cls.NumTypeArguments() > 0) {
      return receiver.GetTypeArguments();
    }
  }
  return Object::empty_type_arguments().ptr();
}

RetryCompilationWithFarBranches()

static CodePtr dart::RetryCompilationWithFarBranches ( Thread *  thread, std::function< CodePtr(compiler::Assembler &)>  fun  )

static

Definition at line 220 of file type_testing_stubs.cc.

                                                  {
  volatile intptr_t far_branch_level = 0;
  while (true) {
    LongJumpScope jump;
    if (setjmp(*jump.Set()) == 0) {
      // To use the already-defined __ Macro !
      compiler::Assembler assembler(nullptr, far_branch_level);
      return fun(assembler);
    } else {
      // We bailed out or we encountered an error.
      const Error& error = Error::Handle(thread->StealStickyError());
      if (error.ptr() == Object::branch_offset_error().ptr()) {
        ASSERT(far_branch_level < 2);
        far_branch_level++;
      } else if (error.ptr() == Object::out_of_memory_error().ptr()) {
        thread->set_sticky_error(error);
        return Code::null();
      } else {
        UNREACHABLE();
      }
    }
  }
}

ReturnHandleInCallback()

DART_EXPORT Dart_Handle dart::ReturnHandleInCallback

(

Dart_Handle(*)()

callback

)

Definition at line 990 of file ffi_test_functions_vmspecific.cc.

                                                                          {
  printf("ReturnHandleInCallback %p\n", callback);
  Dart_Handle handle = callback();
  if (Dart_IsError(handle)) {
    printf("callback() returned an error, propagating error\n");
    // Do C/C++ resource cleanup if needed, before propagating error.
    Dart_PropagateError(handle);
  }
  return handle;
}

ReturnIntPtr()

intptr_t dart::ReturnIntPtr

(

intptr_t

x

)

Definition at line 1141 of file ffi_test_functions_vmspecific.cc.

                                  {
  return x;
}

ReturnIntPtrMethod()

intptr_t dart::ReturnIntPtrMethod	(	Dart_Handle	self,
		intptr_t	value
	)

Definition at line 1218 of file ffi_test_functions_vmspecific.cc.

                                                              {
  return value;
}

ReturnMaxUint16()

DART_EXPORT uint16_t dart::ReturnMaxUint16

(

)

Definition at line 83 of file ffi_test_functions.cc.

                                       {
  return 0xffff;
}

ReturnMaxUint16v2()

DART_EXPORT uint16_t dart::ReturnMaxUint16v2

(

)

Definition at line 111 of file ffi_test_functions.cc.

                                         {
  uint64_t v = 0xabcffff;
  return v;
}

ReturnMaxUint32()

DART_EXPORT uint32_t dart::ReturnMaxUint32

(

)

Definition at line 87 of file ffi_test_functions.cc.

                                       {
  return 0xffffffff;
}

ReturnMaxUint32v2()

DART_EXPORT uint32_t dart::ReturnMaxUint32v2

(

)

Definition at line 116 of file ffi_test_functions.cc.

                                         {
  uint64_t v = 0xabcffffffff;
  return v;
}

ReturnMaxUint8()

DART_EXPORT uint8_t dart::ReturnMaxUint8

(

)

Definition at line 79 of file ffi_test_functions.cc.

                                     {
  return 0xff;
}

ReturnMaxUint8v2()

DART_EXPORT uint8_t dart::ReturnMaxUint8v2

(

)

Definition at line 104 of file ffi_test_functions.cc.

                                       {
  uint64_t v = 0xabcff;
  // Truncated to 8 bits and zero extended, or truncated to 32 bits, depending
  // on ABI.
  return v;
}

ReturnMinInt16()

DART_EXPORT int16_t dart::ReturnMinInt16

(

)

Definition at line 95 of file ffi_test_functions.cc.

                                     {
  return 0x8000;
}

ReturnMinInt16v2()

DART_EXPORT int16_t dart::ReturnMinInt16v2

(

)

Definition at line 126 of file ffi_test_functions.cc.

                                       {
  int64_t v = 0x8abc8000;
  return v;
}

ReturnMinInt32()

DART_EXPORT int32_t dart::ReturnMinInt32

(

)

Definition at line 99 of file ffi_test_functions.cc.

                                     {
  return 0x80000000;
}

ReturnMinInt32v2()

DART_EXPORT int32_t dart::ReturnMinInt32v2

(

)

Definition at line 131 of file ffi_test_functions.cc.

                                       {
  int64_t v = 0x8abc80000000;
  return v;
}

ReturnMinInt8()

DART_EXPORT int8_t dart::ReturnMinInt8

(

)

Definition at line 91 of file ffi_test_functions.cc.

                                   {
  return 0x80;
}

ReturnMinInt8v2()

DART_EXPORT int8_t dart::ReturnMinInt8v2

(

)

Definition at line 121 of file ffi_test_functions.cc.

                                     {
  int64_t v = 0x8abc80;
  return v;
}

ReturnPtrAsInt()

static intptr_t dart::ReturnPtrAsInt ( void *  ptr )

static

Definition at line 4442 of file dart_api_impl_test.cc.

                                          {
  return reinterpret_cast<intptr_t>(ptr);
}

ReturnStruct1024BytesHomogeneousUint64()

DART_EXPORT Struct1024BytesHomogeneousUint64 dart::ReturnStruct1024BytesHomogeneousUint64	(	uint64_t	a0,
		uint64_t	a1,
		uint64_t	a2,
		uint64_t	a3,
		uint64_t	a4,
		uint64_t	a5,
		uint64_t	a6,
		uint64_t	a7,
		uint64_t	a8,
		uint64_t	a9,
		uint64_t	a10,
		uint64_t	a11,
		uint64_t	a12,
		uint64_t	a13,
		uint64_t	a14,
		uint64_t	a15,
		uint64_t	a16,
		uint64_t	a17,
		uint64_t	a18,
		uint64_t	a19,
		uint64_t	a20,
		uint64_t	a21,
		uint64_t	a22,
		uint64_t	a23,
		uint64_t	a24,
		uint64_t	a25,
		uint64_t	a26,
		uint64_t	a27,
		uint64_t	a28,
		uint64_t	a29,
		uint64_t	a30,
		uint64_t	a31,
		uint64_t	a32,
		uint64_t	a33,
		uint64_t	a34,
		uint64_t	a35,
		uint64_t	a36,
		uint64_t	a37,
		uint64_t	a38,
		uint64_t	a39,
		uint64_t	a40,
		uint64_t	a41,
		uint64_t	a42,
		uint64_t	a43,
		uint64_t	a44,
		uint64_t	a45,
		uint64_t	a46,
		uint64_t	a47,
		uint64_t	a48,
		uint64_t	a49,
		uint64_t	a50,
		uint64_t	a51,
		uint64_t	a52,
		uint64_t	a53,
		uint64_t	a54,
		uint64_t	a55,
		uint64_t	a56,
		uint64_t	a57,
		uint64_t	a58,
		uint64_t	a59,
		uint64_t	a60,
		uint64_t	a61,
		uint64_t	a62,
		uint64_t	a63,
		uint64_t	a64,
		uint64_t	a65,
		uint64_t	a66,
		uint64_t	a67,
		uint64_t	a68,
		uint64_t	a69,
		uint64_t	a70,
		uint64_t	a71,
		uint64_t	a72,
		uint64_t	a73,
		uint64_t	a74,
		uint64_t	a75,
		uint64_t	a76,
		uint64_t	a77,
		uint64_t	a78,
		uint64_t	a79,
		uint64_t	a80,
		uint64_t	a81,
		uint64_t	a82,
		uint64_t	a83,
		uint64_t	a84,
		uint64_t	a85,
		uint64_t	a86,
		uint64_t	a87,
		uint64_t	a88,
		uint64_t	a89,
		uint64_t	a90,
		uint64_t	a91,
		uint64_t	a92,
		uint64_t	a93,
		uint64_t	a94,
		uint64_t	a95,
		uint64_t	a96,
		uint64_t	a97,
		uint64_t	a98,
		uint64_t	a99,
		uint64_t	a100,
		uint64_t	a101,
		uint64_t	a102,
		uint64_t	a103,
		uint64_t	a104,
		uint64_t	a105,
		uint64_t	a106,
		uint64_t	a107,
		uint64_t	a108,
		uint64_t	a109,
		uint64_t	a110,
		uint64_t	a111,
		uint64_t	a112,
		uint64_t	a113,
		uint64_t	a114,
		uint64_t	a115,
		uint64_t	a116,
		uint64_t	a117,
		uint64_t	a118,
		uint64_t	a119,
		uint64_t	a120,
		uint64_t	a121,
		uint64_t	a122,
		uint64_t	a123,
		uint64_t	a124,
		uint64_t	a125,
		uint64_t	a126,
		uint64_t	a127
	)

Definition at line 5338 of file ffi_test_functions_generated.cc.

                                                      {
  std::cout << "ReturnStruct1024BytesHomogeneousUint64" << "(" << a0 << ", "
            << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", " << a5
            << ", " << a6 << ", " << a7 << ", " << a8 << ", " << a9 << ", "
            << a10 << ", " << a11 << ", " << a12 << ", " << a13 << ", " << a14
            << ", " << a15 << ", " << a16 << ", " << a17 << ", " << a18 << ", "
            << a19 << ", " << a20 << ", " << a21 << ", " << a22 << ", " << a23
            << ", " << a24 << ", " << a25 << ", " << a26 << ", " << a27 << ", "
            << a28 << ", " << a29 << ", " << a30 << ", " << a31 << ", " << a32
            << ", " << a33 << ", " << a34 << ", " << a35 << ", " << a36 << ", "
            << a37 << ", " << a38 << ", " << a39 << ", " << a40 << ", " << a41
            << ", " << a42 << ", " << a43 << ", " << a44 << ", " << a45 << ", "
            << a46 << ", " << a47 << ", " << a48 << ", " << a49 << ", " << a50
            << ", " << a51 << ", " << a52 << ", " << a53 << ", " << a54 << ", "
            << a55 << ", " << a56 << ", " << a57 << ", " << a58 << ", " << a59
            << ", " << a60 << ", " << a61 << ", " << a62 << ", " << a63 << ", "
            << a64 << ", " << a65 << ", " << a66 << ", " << a67 << ", " << a68
            << ", " << a69 << ", " << a70 << ", " << a71 << ", " << a72 << ", "
            << a73 << ", " << a74 << ", " << a75 << ", " << a76 << ", " << a77
            << ", " << a78 << ", " << a79 << ", " << a80 << ", " << a81 << ", "
            << a82 << ", " << a83 << ", " << a84 << ", " << a85 << ", " << a86
            << ", " << a87 << ", " << a88 << ", " << a89 << ", " << a90 << ", "
            << a91 << ", " << a92 << ", " << a93 << ", " << a94 << ", " << a95
            << ", " << a96 << ", " << a97 << ", " << a98 << ", " << a99 << ", "
            << a100 << ", " << a101 << ", " << a102 << ", " << a103 << ", "
            << a104 << ", " << a105 << ", " << a106 << ", " << a107 << ", "
            << a108 << ", " << a109 << ", " << a110 << ", " << a111 << ", "
            << a112 << ", " << a113 << ", " << a114 << ", " << a115 << ", "
            << a116 << ", " << a117 << ", " << a118 << ", " << a119 << ", "
            << a120 << ", " << a121 << ", " << a122 << ", " << a123 << ", "
            << a124 << ", " << a125 << ", " << a126 << ", " << a127 << ")"
            << "\n";
 
  Struct1024BytesHomogeneousUint64 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
  result.a4 = a4;
  result.a5 = a5;
  result.a6 = a6;
  result.a7 = a7;
  result.a8 = a8;
  result.a9 = a9;
  result.a10 = a10;
  result.a11 = a11;
  result.a12 = a12;
  result.a13 = a13;
  result.a14 = a14;
  result.a15 = a15;
  result.a16 = a16;
  result.a17 = a17;
  result.a18 = a18;
  result.a19 = a19;
  result.a20 = a20;
  result.a21 = a21;
  result.a22 = a22;
  result.a23 = a23;
  result.a24 = a24;
  result.a25 = a25;
  result.a26 = a26;
  result.a27 = a27;
  result.a28 = a28;
  result.a29 = a29;
  result.a30 = a30;
  result.a31 = a31;
  result.a32 = a32;
  result.a33 = a33;
  result.a34 = a34;
  result.a35 = a35;
  result.a36 = a36;
  result.a37 = a37;
  result.a38 = a38;
  result.a39 = a39;
  result.a40 = a40;
  result.a41 = a41;
  result.a42 = a42;
  result.a43 = a43;
  result.a44 = a44;
  result.a45 = a45;
  result.a46 = a46;
  result.a47 = a47;
  result.a48 = a48;
  result.a49 = a49;
  result.a50 = a50;
  result.a51 = a51;
  result.a52 = a52;
  result.a53 = a53;
  result.a54 = a54;
  result.a55 = a55;
  result.a56 = a56;
  result.a57 = a57;
  result.a58 = a58;
  result.a59 = a59;
  result.a60 = a60;
  result.a61 = a61;
  result.a62 = a62;
  result.a63 = a63;
  result.a64 = a64;
  result.a65 = a65;
  result.a66 = a66;
  result.a67 = a67;
  result.a68 = a68;
  result.a69 = a69;
  result.a70 = a70;
  result.a71 = a71;
  result.a72 = a72;
  result.a73 = a73;
  result.a74 = a74;
  result.a75 = a75;
  result.a76 = a76;
  result.a77 = a77;
  result.a78 = a78;
  result.a79 = a79;
  result.a80 = a80;
  result.a81 = a81;
  result.a82 = a82;
  result.a83 = a83;
  result.a84 = a84;
  result.a85 = a85;
  result.a86 = a86;
  result.a87 = a87;
  result.a88 = a88;
  result.a89 = a89;
  result.a90 = a90;
  result.a91 = a91;
  result.a92 = a92;
  result.a93 = a93;
  result.a94 = a94;
  result.a95 = a95;
  result.a96 = a96;
  result.a97 = a97;
  result.a98 = a98;
  result.a99 = a99;
  result.a100 = a100;
  result.a101 = a101;
  result.a102 = a102;
  result.a103 = a103;
  result.a104 = a104;
  result.a105 = a105;
  result.a106 = a106;
  result.a107 = a107;
  result.a108 = a108;
  result.a109 = a109;
  result.a110 = a110;
  result.a111 = a111;
  result.a112 = a112;
  result.a113 = a113;
  result.a114 = a114;
  result.a115 = a115;
  result.a116 = a116;
  result.a117 = a117;
  result.a118 = a118;
  result.a119 = a119;
  result.a120 = a120;
  result.a121 = a121;
  result.a122 = a122;
  result.a123 = a123;
  result.a124 = a124;
  result.a125 = a125;
  result.a126 = a126;
  result.a127 = a127;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ", "
            << result.a5 << ", " << result.a6 << ", " << result.a7 << ", "
            << result.a8 << ", " << result.a9 << ", " << result.a10 << ", "
            << result.a11 << ", " << result.a12 << ", " << result.a13 << ", "
            << result.a14 << ", " << result.a15 << ", " << result.a16 << ", "
            << result.a17 << ", " << result.a18 << ", " << result.a19 << ", "
            << result.a20 << ", " << result.a21 << ", " << result.a22 << ", "
            << result.a23 << ", " << result.a24 << ", " << result.a25 << ", "
            << result.a26 << ", " << result.a27 << ", " << result.a28 << ", "
            << result.a29 << ", " << result.a30 << ", " << result.a31 << ", "
            << result.a32 << ", " << result.a33 << ", " << result.a34 << ", "
            << result.a35 << ", " << result.a36 << ", " << result.a37 << ", "
            << result.a38 << ", " << result.a39 << ", " << result.a40 << ", "
            << result.a41 << ", " << result.a42 << ", " << result.a43 << ", "
            << result.a44 << ", " << result.a45 << ", " << result.a46 << ", "
            << result.a47 << ", " << result.a48 << ", " << result.a49 << ", "
            << result.a50 << ", " << result.a51 << ", " << result.a52 << ", "
            << result.a53 << ", " << result.a54 << ", " << result.a55 << ", "
            << result.a56 << ", " << result.a57 << ", " << result.a58 << ", "
            << result.a59 << ", " << result.a60 << ", " << result.a61 << ", "
            << result.a62 << ", " << result.a63 << ", " << result.a64 << ", "
            << result.a65 << ", " << result.a66 << ", " << result.a67 << ", "
            << result.a68 << ", " << result.a69 << ", " << result.a70 << ", "
            << result.a71 << ", " << result.a72 << ", " << result.a73 << ", "
            << result.a74 << ", " << result.a75 << ", " << result.a76 << ", "
            << result.a77 << ", " << result.a78 << ", " << result.a79 << ", "
            << result.a80 << ", " << result.a81 << ", " << result.a82 << ", "
            << result.a83 << ", " << result.a84 << ", " << result.a85 << ", "
            << result.a86 << ", " << result.a87 << ", " << result.a88 << ", "
            << result.a89 << ", " << result.a90 << ", " << result.a91 << ", "
            << result.a92 << ", " << result.a93 << ", " << result.a94 << ", "
            << result.a95 << ", " << result.a96 << ", " << result.a97 << ", "
            << result.a98 << ", " << result.a99 << ", " << result.a100 << ", "
            << result.a101 << ", " << result.a102 << ", " << result.a103 << ", "
            << result.a104 << ", " << result.a105 << ", " << result.a106 << ", "
            << result.a107 << ", " << result.a108 << ", " << result.a109 << ", "
            << result.a110 << ", " << result.a111 << ", " << result.a112 << ", "
            << result.a113 << ", " << result.a114 << ", " << result.a115 << ", "
            << result.a116 << ", " << result.a117 << ", " << result.a118 << ", "
            << result.a119 << ", " << result.a120 << ", " << result.a121 << ", "
            << result.a122 << ", " << result.a123 << ", " << result.a124 << ", "
            << result.a125 << ", " << result.a126 << ", " << result.a127 << ")"
            << "\n";
 
  return result;
}

ReturnStruct12BytesHomogeneousFloat()

DART_EXPORT Struct12BytesHomogeneousFloat dart::ReturnStruct12BytesHomogeneousFloat	(	float	a0,
		float	a1,
		float	a2
	)

Definition at line 5055 of file ffi_test_functions_generated.cc.

                                                                  {
  std::cout << "ReturnStruct12BytesHomogeneousFloat" << "(" << a0 << ", " << a1
            << ", " << a2 << ")" << "\n";
 
  Struct12BytesHomogeneousFloat result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ")" << "\n";
 
  return result;
}

ReturnStruct16BytesHomogeneousFloat()

DART_EXPORT Struct16BytesHomogeneousFloat dart::ReturnStruct16BytesHomogeneousFloat	(	float	a0,
		float	a1,
		float	a2,
		float	a3
	)

Definition at line 5074 of file ffi_test_functions_generated.cc.

                                                                            {
  std::cout << "ReturnStruct16BytesHomogeneousFloat" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ")" << "\n";
 
  Struct16BytesHomogeneousFloat result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ")" << "\n";
 
  return result;
}

ReturnStruct16BytesMixed()

DART_EXPORT Struct16BytesMixed dart::ReturnStruct16BytesMixed	(	double	a0,
		int64_t	a1
	)

Definition at line 5093 of file ffi_test_functions_generated.cc.

                                                                               {
  std::cout << "ReturnStruct16BytesMixed" << "(" << a0 << ", " << a1 << ")"
            << "\n";
 
  Struct16BytesMixed result = {};
 
  result.a0 = a0;
  result.a1 = a1;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ")"
            << "\n";
 
  return result;
}

ReturnStruct16BytesMixed2()

DART_EXPORT Struct16BytesMixed2 dart::ReturnStruct16BytesMixed2	(	float	a0,
		float	a1,
		float	a2,
		int32_t	a3
	)

Definition at line 5111 of file ffi_test_functions_generated.cc.

                                                                      {
  std::cout << "ReturnStruct16BytesMixed2" << "(" << a0 << ", " << a1 << ", "
            << a2 << ", " << a3 << ")" << "\n";
 
  Struct16BytesMixed2 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ")" << "\n";
 
  return result;
}

ReturnStruct16BytesNestedInt()

DART_EXPORT Struct16BytesNestedInt dart::ReturnStruct16BytesNestedInt	(	Struct8BytesNestedInt	a0,
		Struct8BytesNestedInt	a1
	)

Definition at line 6132 of file ffi_test_functions_generated.cc.

                                                       {
  std::cout << "ReturnStruct16BytesNestedInt" << "(((" << a0.a0.a0 << ", "
            << a0.a0.a1 << "), (" << a0.a1.a0 << ", " << a0.a1.a1 << ")), (("
            << a1.a0.a0 << ", " << a1.a0.a1 << "), (" << a1.a1.a0 << ", "
            << a1.a1.a1 << ")))" << "\n";
 
  Struct16BytesNestedInt result = {};
 
  result.a0.a0.a0 = a0.a0.a0;
  result.a0.a0.a1 = a0.a0.a1;
  result.a0.a1.a0 = a0.a1.a0;
  result.a0.a1.a1 = a0.a1.a1;
  result.a1.a0.a0 = a1.a0.a0;
  result.a1.a0.a1 = a1.a0.a1;
  result.a1.a1.a0 = a1.a1.a0;
  result.a1.a1.a1 = a1.a1.a1;
 
  std::cout << "result = " << "(((" << result.a0.a0.a0 << ", "
            << result.a0.a0.a1 << "), (" << result.a0.a1.a0 << ", "
            << result.a0.a1.a1 << ")), ((" << result.a1.a0.a0 << ", "
            << result.a1.a0.a1 << "), (" << result.a1.a1.a0 << ", "
            << result.a1.a1.a1 << ")))" << "\n";
 
  return result;
}

ReturnStruct17BytesInt()

DART_EXPORT Struct17BytesInt dart::ReturnStruct17BytesInt	(	int64_t	a0,
		int64_t	a1,
		int8_t	a2
	)

Definition at line 5135 of file ffi_test_functions_generated.cc.

                                                               {
  std::cout << "ReturnStruct17BytesInt" << "(" << a0 << ", " << a1 << ", "
            << static_cast<int>(a2) << ")" << "\n";
 
  Struct17BytesInt result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << static_cast<int>(result.a2) << ")" << "\n";
 
  return result;
}

ReturnStruct19BytesHomogeneousUint8()

DART_EXPORT Struct19BytesHomogeneousUint8 dart::ReturnStruct19BytesHomogeneousUint8	(	uint8_t	a0,
		uint8_t	a1,
		uint8_t	a2,
		uint8_t	a3,
		uint8_t	a4,
		uint8_t	a5,
		uint8_t	a6,
		uint8_t	a7,
		uint8_t	a8,
		uint8_t	a9,
		uint8_t	a10,
		uint8_t	a11,
		uint8_t	a12,
		uint8_t	a13,
		uint8_t	a14,
		uint8_t	a15,
		uint8_t	a16,
		uint8_t	a17,
		uint8_t	a18
	)

Definition at line 5158 of file ffi_test_functions_generated.cc.

                                                 {
  std::cout << "ReturnStruct19BytesHomogeneousUint8" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ", " << static_cast<int>(a7) << ", "
            << static_cast<int>(a8) << ", " << static_cast<int>(a9) << ", "
            << static_cast<int>(a10) << ", " << static_cast<int>(a11) << ", "
            << static_cast<int>(a12) << ", " << static_cast<int>(a13) << ", "
            << static_cast<int>(a14) << ", " << static_cast<int>(a15) << ", "
            << static_cast<int>(a16) << ", " << static_cast<int>(a17) << ", "
            << static_cast<int>(a18) << ")" << "\n";
 
  Struct19BytesHomogeneousUint8 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
  result.a4 = a4;
  result.a5 = a5;
  result.a6 = a6;
  result.a7 = a7;
  result.a8 = a8;
  result.a9 = a9;
  result.a10 = a10;
  result.a11 = a11;
  result.a12 = a12;
  result.a13 = a13;
  result.a14 = a14;
  result.a15 = a15;
  result.a16 = a16;
  result.a17 = a17;
  result.a18 = a18;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << static_cast<int>(result.a1) << ", "
            << static_cast<int>(result.a2) << ", "
            << static_cast<int>(result.a3) << ", "
            << static_cast<int>(result.a4) << ", "
            << static_cast<int>(result.a5) << ", "
            << static_cast<int>(result.a6) << ", "
            << static_cast<int>(result.a7) << ", "
            << static_cast<int>(result.a8) << ", "
            << static_cast<int>(result.a9) << ", "
            << static_cast<int>(result.a10) << ", "
            << static_cast<int>(result.a11) << ", "
            << static_cast<int>(result.a12) << ", "
            << static_cast<int>(result.a13) << ", "
            << static_cast<int>(result.a14) << ", "
            << static_cast<int>(result.a15) << ", "
            << static_cast<int>(result.a16) << ", "
            << static_cast<int>(result.a17) << ", "
            << static_cast<int>(result.a18) << ")" << "\n";
 
  return result;
}

ReturnStruct1ByteInt()

DART_EXPORT Struct1ByteInt dart::ReturnStruct1ByteInt

(

int8_t

a0

)

Definition at line 4800 of file ffi_test_functions_generated.cc.

                                                           {
  std::cout << "ReturnStruct1ByteInt" << "(" << static_cast<int>(a0) << ")"
            << "\n";
 
  Struct1ByteInt result = {};
 
  result.a0 = a0;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ")" << "\n";
 
  return result;
}

ReturnStruct20BytesHomogeneousFloat()

DART_EXPORT Struct20BytesHomogeneousFloat dart::ReturnStruct20BytesHomogeneousFloat	(	float	a0,
		float	a1,
		float	a2,
		float	a3,
		float	a4
	)

Definition at line 5263 of file ffi_test_functions_generated.cc.

                                              {
  std::cout << "ReturnStruct20BytesHomogeneousFloat" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ")" << "\n";
 
  Struct20BytesHomogeneousFloat result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
  result.a4 = a4;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  return result;
}

ReturnStruct20BytesHomogeneousInt32()

DART_EXPORT Struct20BytesHomogeneousInt32 dart::ReturnStruct20BytesHomogeneousInt32	(	int32_t	a0,
		int32_t	a1,
		int32_t	a2,
		int32_t	a3,
		int32_t	a4
	)

Definition at line 5237 of file ffi_test_functions_generated.cc.

                                                {
  std::cout << "ReturnStruct20BytesHomogeneousInt32" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ")" << "\n";
 
  Struct20BytesHomogeneousInt32 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
  result.a4 = a4;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  return result;
}

ReturnStruct32BytesHomogeneousDouble()

DART_EXPORT Struct32BytesHomogeneousDouble dart::ReturnStruct32BytesHomogeneousDouble	(	double	a0,
		double	a1,
		double	a2,
		double	a3
	)

Definition at line 5289 of file ffi_test_functions_generated.cc.

                                                {
  std::cout << "ReturnStruct32BytesHomogeneousDouble" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ")" << "\n";
 
  Struct32BytesHomogeneousDouble result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ")" << "\n";
 
  return result;
}

ReturnStruct32BytesNestedInt()

DART_EXPORT Struct32BytesNestedInt dart::ReturnStruct32BytesNestedInt	(	Struct16BytesNestedInt	a0,
		Struct16BytesNestedInt	a1
	)

Definition at line 6162 of file ffi_test_functions_generated.cc.

                                                        {
  std::cout << "ReturnStruct32BytesNestedInt" << "((((" << a0.a0.a0.a0 << ", "
            << a0.a0.a0.a1 << "), (" << a0.a0.a1.a0 << ", " << a0.a0.a1.a1
            << ")), ((" << a0.a1.a0.a0 << ", " << a0.a1.a0.a1 << "), ("
            << a0.a1.a1.a0 << ", " << a0.a1.a1.a1 << "))), (((" << a1.a0.a0.a0
            << ", " << a1.a0.a0.a1 << "), (" << a1.a0.a1.a0 << ", "
            << a1.a0.a1.a1 << ")), ((" << a1.a1.a0.a0 << ", " << a1.a1.a0.a1
            << "), (" << a1.a1.a1.a0 << ", " << a1.a1.a1.a1 << "))))" << "\n";
 
  Struct32BytesNestedInt result = {};
 
  result.a0.a0.a0.a0 = a0.a0.a0.a0;
  result.a0.a0.a0.a1 = a0.a0.a0.a1;
  result.a0.a0.a1.a0 = a0.a0.a1.a0;
  result.a0.a0.a1.a1 = a0.a0.a1.a1;
  result.a0.a1.a0.a0 = a0.a1.a0.a0;
  result.a0.a1.a0.a1 = a0.a1.a0.a1;
  result.a0.a1.a1.a0 = a0.a1.a1.a0;
  result.a0.a1.a1.a1 = a0.a1.a1.a1;
  result.a1.a0.a0.a0 = a1.a0.a0.a0;
  result.a1.a0.a0.a1 = a1.a0.a0.a1;
  result.a1.a0.a1.a0 = a1.a0.a1.a0;
  result.a1.a0.a1.a1 = a1.a0.a1.a1;
  result.a1.a1.a0.a0 = a1.a1.a0.a0;
  result.a1.a1.a0.a1 = a1.a1.a0.a1;
  result.a1.a1.a1.a0 = a1.a1.a1.a0;
  result.a1.a1.a1.a1 = a1.a1.a1.a1;
 
  std::cout << "result = " << "((((" << result.a0.a0.a0.a0 << ", "
            << result.a0.a0.a0.a1 << "), (" << result.a0.a0.a1.a0 << ", "
            << result.a0.a0.a1.a1 << ")), ((" << result.a0.a1.a0.a0 << ", "
            << result.a0.a1.a0.a1 << "), (" << result.a0.a1.a1.a0 << ", "
            << result.a0.a1.a1.a1 << "))), (((" << result.a1.a0.a0.a0 << ", "
            << result.a1.a0.a0.a1 << "), (" << result.a1.a0.a1.a0 << ", "
            << result.a1.a0.a1.a1 << ")), ((" << result.a1.a1.a0.a0 << ", "
            << result.a1.a1.a0.a1 << "), (" << result.a1.a1.a1.a0 << ", "
            << result.a1.a1.a1.a1 << "))))" << "\n";
 
  return result;
}

ReturnStruct3BytesHomogeneousUint8()

DART_EXPORT Struct3BytesHomogeneousUint8 dart::ReturnStruct3BytesHomogeneousUint8	(	uint8_t	a0,
		uint8_t	a1,
		uint8_t	a2
	)

Definition at line 4816 of file ffi_test_functions_generated.cc.

                                                                       {
  std::cout << "ReturnStruct3BytesHomogeneousUint8" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ")" << "\n";
 
  Struct3BytesHomogeneousUint8 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << static_cast<int>(result.a1) << ", "
            << static_cast<int>(result.a2) << ")" << "\n";
 
  return result;
}

ReturnStruct3BytesInt2ByteAligned()

DART_EXPORT Struct3BytesInt2ByteAligned dart::ReturnStruct3BytesInt2ByteAligned	(	int16_t	a0,
		int8_t	a1
	)

Definition at line 4838 of file ffi_test_functions_generated.cc.

                                                         {
  std::cout << "ReturnStruct3BytesInt2ByteAligned" << "(" << a0 << ", "
            << static_cast<int>(a1) << ")" << "\n";
 
  Struct3BytesInt2ByteAligned result = {};
 
  result.a0 = a0;
  result.a1 = a1;
 
  std::cout << "result = " << "(" << result.a0 << ", "
            << static_cast<int>(result.a1) << ")" << "\n";
 
  return result;
}

ReturnStruct3BytesPackedInt()

DART_EXPORT Struct3BytesPackedInt dart::ReturnStruct3BytesPackedInt	(	int8_t	a0,
		int16_t	a1
	)

Definition at line 5679 of file ffi_test_functions_generated.cc.

                                                                          {
  std::cout << "ReturnStruct3BytesPackedInt" << "(" << static_cast<int>(a0)
            << ", " << a1 << ")" << "\n";
 
  Struct3BytesPackedInt result = {};
 
  result.a0 = a0;
  result.a1 = a1;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ")" << "\n";
 
  return result;
}

ReturnStruct40BytesHomogeneousDouble()

DART_EXPORT Struct40BytesHomogeneousDouble dart::ReturnStruct40BytesHomogeneousDouble	(	double	a0,
		double	a1,
		double	a2,
		double	a3,
		double	a4
	)

Definition at line 5312 of file ffi_test_functions_generated.cc.

                                                {
  std::cout << "ReturnStruct40BytesHomogeneousDouble" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ")" << "\n";
 
  Struct40BytesHomogeneousDouble result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
  result.a4 = a4;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  return result;
}

ReturnStruct4BytesHomogeneousInt16()

DART_EXPORT Struct4BytesHomogeneousInt16 dart::ReturnStruct4BytesHomogeneousInt16	(	int16_t	a0,
		int16_t	a1
	)

Definition at line 4856 of file ffi_test_functions_generated.cc.

                                                           {
  std::cout << "ReturnStruct4BytesHomogeneousInt16" << "(" << a0 << ", " << a1
            << ")" << "\n";
 
  Struct4BytesHomogeneousInt16 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ")"
            << "\n";
 
  return result;
}

ReturnStruct7BytesHomogeneousUint8()

DART_EXPORT Struct7BytesHomogeneousUint8 dart::ReturnStruct7BytesHomogeneousUint8	(	uint8_t	a0,
		uint8_t	a1,
		uint8_t	a2,
		uint8_t	a3,
		uint8_t	a4,
		uint8_t	a5,
		uint8_t	a6
	)

Definition at line 4874 of file ffi_test_functions_generated.cc.

                                               {
  std::cout << "ReturnStruct7BytesHomogeneousUint8" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ")" << "\n";
 
  Struct7BytesHomogeneousUint8 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
  result.a4 = a4;
  result.a5 = a5;
  result.a6 = a6;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << static_cast<int>(result.a1) << ", "
            << static_cast<int>(result.a2) << ", "
            << static_cast<int>(result.a3) << ", "
            << static_cast<int>(result.a4) << ", "
            << static_cast<int>(result.a5) << ", "
            << static_cast<int>(result.a6) << ")" << "\n";
 
  return result;
}

ReturnStruct7BytesInt4ByteAligned()

DART_EXPORT Struct7BytesInt4ByteAligned dart::ReturnStruct7BytesInt4ByteAligned	(	int32_t	a0,
		int16_t	a1,
		int8_t	a2
	)

Definition at line 4912 of file ffi_test_functions_generated.cc.

                                                                     {
  std::cout << "ReturnStruct7BytesInt4ByteAligned" << "(" << a0 << ", " << a1
            << ", " << static_cast<int>(a2) << ")" << "\n";
 
  Struct7BytesInt4ByteAligned result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << static_cast<int>(result.a2) << ")" << "\n";
 
  return result;
}

ReturnStruct8BytesHomogeneousFloat()

DART_EXPORT Struct8BytesHomogeneousFloat dart::ReturnStruct8BytesHomogeneousFloat	(	float	a0,
		float	a1
	)

Definition at line 4951 of file ffi_test_functions_generated.cc.

                                                       {
  std::cout << "ReturnStruct8BytesHomogeneousFloat" << "(" << a0 << ", " << a1
            << ")" << "\n";
 
  Struct8BytesHomogeneousFloat result = {};
 
  result.a0 = a0;
  result.a1 = a1;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ")"
            << "\n";
 
  return result;
}

ReturnStruct8BytesInt()

DART_EXPORT Struct8BytesInt dart::ReturnStruct8BytesInt	(	int16_t	a0,
		int16_t	a1,
		int32_t	a2
	)

Definition at line 4930 of file ffi_test_functions_generated.cc.

                                                              {
  std::cout << "ReturnStruct8BytesInt" << "(" << a0 << ", " << a1 << ", " << a2
            << ")" << "\n";
 
  Struct8BytesInt result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ")" << "\n";
 
  return result;
}

ReturnStruct8BytesMixed()

DART_EXPORT Struct8BytesMixed dart::ReturnStruct8BytesMixed	(	float	a0,
		int16_t	a1,
		int16_t	a2
	)

Definition at line 4968 of file ffi_test_functions_generated.cc.

                                                                  {
  std::cout << "ReturnStruct8BytesMixed" << "(" << a0 << ", " << a1 << ", "
            << a2 << ")" << "\n";
 
  Struct8BytesMixed result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ")" << "\n";
 
  return result;
}

ReturnStruct8BytesNestedFloat()

DART_EXPORT Struct8BytesNestedFloat dart::ReturnStruct8BytesNestedFloat	(	Struct4BytesFloat	a0,
		Struct4BytesFloat	a1
	)

Definition at line 6075 of file ffi_test_functions_generated.cc.

                                                                          {
  std::cout << "ReturnStruct8BytesNestedFloat" << "((" << a0.a0 << "), ("
            << a1.a0 << "))" << "\n";
 
  Struct8BytesNestedFloat result = {};
 
  result.a0.a0 = a0.a0;
  result.a1.a0 = a1.a0;
 
  std::cout << "result = " << "((" << result.a0.a0 << "), (" << result.a1.a0
            << "))" << "\n";
 
  return result;
}

ReturnStruct8BytesNestedFloat2()

DART_EXPORT Struct8BytesNestedFloat2 dart::ReturnStruct8BytesNestedFloat2	(	Struct4BytesFloat	a0,
		float	a1
	)

Definition at line 6094 of file ffi_test_functions_generated.cc.

                                                               {
  std::cout << "ReturnStruct8BytesNestedFloat2" << "((" << a0.a0 << "), " << a1
            << ")" << "\n";
 
  Struct8BytesNestedFloat2 result = {};
 
  result.a0.a0 = a0.a0;
  result.a1 = a1;
 
  std::cout << "result = " << "((" << result.a0.a0 << "), " << result.a1 << ")"
            << "\n";
 
  return result;
}

ReturnStruct8BytesNestedInt()

DART_EXPORT Struct8BytesNestedInt dart::ReturnStruct8BytesNestedInt	(	Struct4BytesHomogeneousInt16	a0,
		Struct4BytesHomogeneousInt16	a1
	)

Definition at line 6054 of file ffi_test_functions_generated.cc.

                                                             {
  std::cout << "ReturnStruct8BytesNestedInt" << "((" << a0.a0 << ", " << a0.a1
            << "), (" << a1.a0 << ", " << a1.a1 << "))" << "\n";
 
  Struct8BytesNestedInt result = {};
 
  result.a0.a0 = a0.a0;
  result.a0.a1 = a0.a1;
  result.a1.a0 = a1.a0;
  result.a1.a1 = a1.a1;
 
  std::cout << "result = " << "((" << result.a0.a0 << ", " << result.a0.a1
            << "), (" << result.a1.a0 << ", " << result.a1.a1 << "))" << "\n";
 
  return result;
}

ReturnStruct8BytesNestedMixed()

DART_EXPORT Struct8BytesNestedMixed dart::ReturnStruct8BytesNestedMixed	(	Struct4BytesHomogeneousInt16	a0,
		Struct4BytesFloat	a1
	)

Definition at line 6112 of file ffi_test_functions_generated.cc.

                                                    {
  std::cout << "ReturnStruct8BytesNestedMixed" << "((" << a0.a0 << ", " << a0.a1
            << "), (" << a1.a0 << "))" << "\n";
 
  Struct8BytesNestedMixed result = {};
 
  result.a0.a0 = a0.a0;
  result.a0.a1 = a0.a1;
  result.a1.a0 = a1.a0;
 
  std::cout << "result = " << "((" << result.a0.a0 << ", " << result.a0.a1
            << "), (" << result.a1.a0 << "))" << "\n";
 
  return result;
}

ReturnStruct8BytesPackedInt()

DART_EXPORT Struct8BytesPackedInt dart::ReturnStruct8BytesPackedInt	(	uint8_t	a0,
		uint32_t	a1,
		uint8_t	a2,
		uint8_t	a3,
		uint8_t	a4
	)

Definition at line 5697 of file ffi_test_functions_generated.cc.

                                                                          {
  std::cout << "ReturnStruct8BytesPackedInt" << "(" << static_cast<int>(a0)
            << ", " << a1 << ", " << static_cast<int>(a2) << ", "
            << static_cast<int>(a3) << ", " << static_cast<int>(a4) << ")"
            << "\n";
 
  Struct8BytesPackedInt result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
  result.a4 = a4;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ", " << static_cast<int>(result.a2) << ", "
            << static_cast<int>(result.a3) << ", "
            << static_cast<int>(result.a4) << ")" << "\n";
 
  return result;
}

ReturnStruct9BytesHomogeneousUint8()

DART_EXPORT Struct9BytesHomogeneousUint8 dart::ReturnStruct9BytesHomogeneousUint8	(	uint8_t	a0,
		uint8_t	a1,
		uint8_t	a2,
		uint8_t	a3,
		uint8_t	a4,
		uint8_t	a5,
		uint8_t	a6,
		uint8_t	a7,
		uint8_t	a8
	)

Definition at line 4991 of file ffi_test_functions_generated.cc.

                                               {
  std::cout << "ReturnStruct9BytesHomogeneousUint8" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ", " << static_cast<int>(a7) << ", "
            << static_cast<int>(a8) << ")" << "\n";
 
  Struct9BytesHomogeneousUint8 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
  result.a3 = a3;
  result.a4 = a4;
  result.a5 = a5;
  result.a6 = a6;
  result.a7 = a7;
  result.a8 = a8;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << static_cast<int>(result.a1) << ", "
            << static_cast<int>(result.a2) << ", "
            << static_cast<int>(result.a3) << ", "
            << static_cast<int>(result.a4) << ", "
            << static_cast<int>(result.a5) << ", "
            << static_cast<int>(result.a6) << ", "
            << static_cast<int>(result.a7) << ", "
            << static_cast<int>(result.a8) << ")" << "\n";
 
  return result;
}

ReturnStruct9BytesInt4Or8ByteAligned()

DART_EXPORT Struct9BytesInt4Or8ByteAligned dart::ReturnStruct9BytesInt4Or8ByteAligned	(	int64_t	a0,
		int8_t	a1
	)

Definition at line 5036 of file ffi_test_functions_generated.cc.

                                                            {
  std::cout << "ReturnStruct9BytesInt4Or8ByteAligned" << "(" << a0 << ", "
            << static_cast<int>(a1) << ")" << "\n";
 
  Struct9BytesInt4Or8ByteAligned result = {};
 
  result.a0 = a0;
  result.a1 = a1;
 
  std::cout << "result = " << "(" << result.a0 << ", "
            << static_cast<int>(result.a1) << ")" << "\n";
 
  return result;
}

ReturnStruct9BytesPackedMixed()

DART_EXPORT Struct9BytesPackedMixed dart::ReturnStruct9BytesPackedMixed	(	uint8_t	a0,
		double	a1
	)

Definition at line 5726 of file ffi_test_functions_generated.cc.

                                                                             {
  std::cout << "ReturnStruct9BytesPackedMixed" << "(" << static_cast<int>(a0)
            << ", " << a1 << ")" << "\n";
 
  Struct9BytesPackedMixed result = {};
 
  result.a0 = a0;
  result.a1 = a1;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ")" << "\n";
 
  return result;
}

ReturnStructAlignmentInt16()

DART_EXPORT StructAlignmentInt16 dart::ReturnStructAlignmentInt16	(	int8_t	a0,
		int16_t	a1,
		int8_t	a2
	)

Definition at line 5993 of file ffi_test_functions_generated.cc.

                                                                       {
  std::cout << "ReturnStructAlignmentInt16" << "(" << static_cast<int>(a0)
            << ", " << a1 << ", " << static_cast<int>(a2) << ")" << "\n";
 
  StructAlignmentInt16 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ", " << static_cast<int>(result.a2) << ")" << "\n";
 
  return result;
}

ReturnStructAlignmentInt32()

DART_EXPORT StructAlignmentInt32 dart::ReturnStructAlignmentInt32	(	int8_t	a0,
		int32_t	a1,
		int8_t	a2
	)

Definition at line 6013 of file ffi_test_functions_generated.cc.

                                                                       {
  std::cout << "ReturnStructAlignmentInt32" << "(" << static_cast<int>(a0)
            << ", " << a1 << ", " << static_cast<int>(a2) << ")" << "\n";
 
  StructAlignmentInt32 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ", " << static_cast<int>(result.a2) << ")" << "\n";
 
  return result;
}

ReturnStructAlignmentInt64()

DART_EXPORT StructAlignmentInt64 dart::ReturnStructAlignmentInt64	(	int8_t	a0,
		int64_t	a1,
		int8_t	a2
	)

Definition at line 6033 of file ffi_test_functions_generated.cc.

                                                                       {
  std::cout << "ReturnStructAlignmentInt64" << "(" << static_cast<int>(a0)
            << ", " << a1 << ", " << static_cast<int>(a2) << ")" << "\n";
 
  StructAlignmentInt64 result = {};
 
  result.a0 = a0;
  result.a1 = a1;
  result.a2 = a2;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ", " << static_cast<int>(result.a2) << ")" << "\n";
 
  return result;
}

ReturnStructArgumentInt32x8Struct1ByteInt()

DART_EXPORT Struct1ByteInt dart::ReturnStructArgumentInt32x8Struct1ByteInt	(	int32_t	a0,
		int32_t	a1,
		int32_t	a2,
		int32_t	a3,
		int32_t	a4,
		int32_t	a5,
		int32_t	a6,
		int32_t	a7,
		Struct1ByteInt	a8
	)

Definition at line 5828 of file ffi_test_functions_generated.cc.

                                                             {
  std::cout << "ReturnStructArgumentInt32x8Struct1ByteInt" << "(" << a0 << ", "
            << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", " << a5
            << ", " << a6 << ", " << a7 << ", (" << static_cast<int>(a8.a0)
            << "))" << "\n";
 
  Struct1ByteInt result = a8;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ")" << "\n";
 
  return result;
}

ReturnStructArgumentInt32x8Struct20BytesHomogeneou()

DART_EXPORT Struct20BytesHomogeneousInt32 dart::ReturnStructArgumentInt32x8Struct20BytesHomogeneou	(	int32_t	a0,
		int32_t	a1,
		int32_t	a2,
		int32_t	a3,
		int32_t	a4,
		int32_t	a5,
		int32_t	a6,
		int32_t	a7,
		Struct20BytesHomogeneousInt32	a8
	)

Definition at line 5889 of file ffi_test_functions_generated.cc.

                                      {
  std::cout << "ReturnStructArgumentInt32x8Struct20BytesHomogeneou" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", "
            << a5 << ", " << a6 << ", " << a7 << ", (" << a8.a0 << ", " << a8.a1
            << ", " << a8.a2 << ", " << a8.a3 << ", " << a8.a4 << "))" << "\n";
 
  Struct20BytesHomogeneousInt32 result = a8;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  return result;
}

ReturnStructArgumentStruct1ByteInt()

DART_EXPORT Struct1ByteInt dart::ReturnStructArgumentStruct1ByteInt

(

Struct1ByteInt

a0

)

Definition at line 5812 of file ffi_test_functions_generated.cc.

                                                      {
  std::cout << "ReturnStructArgumentStruct1ByteInt" << "(("
            << static_cast<int>(a0.a0) << "))" << "\n";
 
  Struct1ByteInt result = a0;
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ")" << "\n";
 
  return result;
}

ReturnStructArgumentStruct20BytesHomogeneousInt32()

DART_EXPORT Struct20BytesHomogeneousInt32 dart::ReturnStructArgumentStruct20BytesHomogeneousInt32

(

Struct20BytesHomogeneousInt32

a0

)

Definition at line 5870 of file ffi_test_functions_generated.cc.

                                      {
  std::cout << "ReturnStructArgumentStruct20BytesHomogeneousInt32" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << "))" << "\n";
 
  Struct20BytesHomogeneousInt32 result = a0;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  return result;
}

ReturnStructArgumentStruct8BytesHomogeneousFloat()

DART_EXPORT Struct8BytesHomogeneousFloat dart::ReturnStructArgumentStruct8BytesHomogeneousFloat

(

Struct8BytesHomogeneousFloat

a0

)

Definition at line 5854 of file ffi_test_functions_generated.cc.

                                     {
  std::cout << "ReturnStructArgumentStruct8BytesHomogeneousFloat" << "(("
            << a0.a0 << ", " << a0.a1 << "))" << "\n";
 
  Struct8BytesHomogeneousFloat result = a0;
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ")"
            << "\n";
 
  return result;
}

ReturnStructArgumentStruct8BytesInlineArrayInt()

DART_EXPORT Struct8BytesInlineArrayInt dart::ReturnStructArgumentStruct8BytesInlineArrayInt

(

Struct8BytesInlineArrayInt

a0

)

Definition at line 5916 of file ffi_test_functions_generated.cc.

                                                                              {
  std::cout << "ReturnStructArgumentStruct8BytesInlineArrayInt" << "((["
            << static_cast<int>(a0.a0[0]) << ", " << static_cast<int>(a0.a0[1])
            << ", " << static_cast<int>(a0.a0[2]) << ", "
            << static_cast<int>(a0.a0[3]) << ", " << static_cast<int>(a0.a0[4])
            << ", " << static_cast<int>(a0.a0[5]) << ", "
            << static_cast<int>(a0.a0[6]) << ", " << static_cast<int>(a0.a0[7])
            << "]))" << "\n";
 
  Struct8BytesInlineArrayInt result = a0;
 
  std::cout << "result = " << "([" << static_cast<int>(result.a0[0]) << ", "
            << static_cast<int>(result.a0[1]) << ", "
            << static_cast<int>(result.a0[2]) << ", "
            << static_cast<int>(result.a0[3]) << ", "
            << static_cast<int>(result.a0[4]) << ", "
            << static_cast<int>(result.a0[5]) << ", "
            << static_cast<int>(result.a0[6]) << ", "
            << static_cast<int>(result.a0[7]) << "])" << "\n";
 
  return result;
}

ReturnStructArgumentStructStruct16BytesHomogeneous()

DART_EXPORT StructStruct16BytesHomogeneousFloat2 dart::ReturnStructArgumentStructStruct16BytesHomogeneous

(

StructStruct16BytesHomogeneousFloat2

a0

)

Definition at line 5942 of file ffi_test_functions_generated.cc.

                                             {
  std::cout << "ReturnStructArgumentStructStruct16BytesHomogeneous" << "((("
            << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), (" << a0.a1[1].a0
            << ")], " << a0.a2 << "))" << "\n";
 
  StructStruct16BytesHomogeneousFloat2 result = a0;
 
  std::cout << "result = " << "((" << result.a0.a0 << "), [(" << result.a1[0].a0
            << "), (" << result.a1[1].a0 << ")], " << result.a2 << ")" << "\n";
 
  return result;
}

ReturnStructArgumentStructStruct16BytesMixed3()

DART_EXPORT StructStruct16BytesMixed3 dart::ReturnStructArgumentStructStruct16BytesMixed3

(

StructStruct16BytesMixed3

a0

)

Definition at line 5976 of file ffi_test_functions_generated.cc.

                                                                            {
  std::cout << "ReturnStructArgumentStructStruct16BytesMixed3" << "((("
            << a0.a0.a0 << "), [(" << a0.a1[0].a0 << ", " << a0.a1[0].a1 << ", "
            << a0.a1[0].a2 << ")], [" << a0.a2[0] << ", " << a0.a2[1] << "]))"
            << "\n";
 
  StructStruct16BytesMixed3 result = a0;
 
  std::cout << "result = " << "((" << result.a0.a0 << "), [(" << result.a1[0].a0
            << ", " << result.a1[0].a1 << ", " << result.a1[0].a2 << ")], ["
            << result.a2[0] << ", " << result.a2[1] << "])" << "\n";
 
  return result;
}

ReturnStructArgumentStructStruct32BytesHomogeneous()

DART_EXPORT StructStruct32BytesHomogeneousDouble2 dart::ReturnStructArgumentStructStruct32BytesHomogeneous

(

StructStruct32BytesHomogeneousDouble2

a0

)

Definition at line 5959 of file ffi_test_functions_generated.cc.

                                              {
  std::cout << "ReturnStructArgumentStructStruct32BytesHomogeneous" << "((("
            << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), (" << a0.a1[1].a0
            << ")], " << a0.a2 << "))" << "\n";
 
  StructStruct32BytesHomogeneousDouble2 result = a0;
 
  std::cout << "result = " << "((" << result.a0.a0 << "), [(" << result.a1[0].a0
            << "), (" << result.a1[1].a0 << ")], " << result.a2 << ")" << "\n";
 
  return result;
}

ReturnStructNestedIntStructAlignmentInt16()

DART_EXPORT StructNestedIntStructAlignmentInt16 dart::ReturnStructNestedIntStructAlignmentInt16	(	StructAlignmentInt16	a0,
		StructAlignmentInt16	a1
	)

Definition at line 6207 of file ffi_test_functions_generated.cc.

                                                                   {
  std::cout << "ReturnStructNestedIntStructAlignmentInt16" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))" << "\n";
 
  StructNestedIntStructAlignmentInt16 result = {};
 
  result.a0.a0 = a0.a0;
  result.a0.a1 = a0.a1;
  result.a0.a2 = a0.a2;
  result.a1.a0 = a1.a0;
  result.a1.a1 = a1.a1;
  result.a1.a2 = a1.a2;
 
  std::cout << "result = " << "((" << static_cast<int>(result.a0.a0) << ", "
            << result.a0.a1 << ", " << static_cast<int>(result.a0.a2) << "), ("
            << static_cast<int>(result.a1.a0) << ", " << result.a1.a1 << ", "
            << static_cast<int>(result.a1.a2) << "))" << "\n";
 
  return result;
}

ReturnStructNestedIntStructAlignmentInt32()

DART_EXPORT StructNestedIntStructAlignmentInt32 dart::ReturnStructNestedIntStructAlignmentInt32	(	StructAlignmentInt32	a0,
		StructAlignmentInt32	a1
	)

Definition at line 6234 of file ffi_test_functions_generated.cc.

                                                                   {
  std::cout << "ReturnStructNestedIntStructAlignmentInt32" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))" << "\n";
 
  StructNestedIntStructAlignmentInt32 result = {};
 
  result.a0.a0 = a0.a0;
  result.a0.a1 = a0.a1;
  result.a0.a2 = a0.a2;
  result.a1.a0 = a1.a0;
  result.a1.a1 = a1.a1;
  result.a1.a2 = a1.a2;
 
  std::cout << "result = " << "((" << static_cast<int>(result.a0.a0) << ", "
            << result.a0.a1 << ", " << static_cast<int>(result.a0.a2) << "), ("
            << static_cast<int>(result.a1.a0) << ", " << result.a1.a1 << ", "
            << static_cast<int>(result.a1.a2) << "))" << "\n";
 
  return result;
}

ReturnStructNestedIntStructAlignmentInt64()

DART_EXPORT StructNestedIntStructAlignmentInt64 dart::ReturnStructNestedIntStructAlignmentInt64	(	StructAlignmentInt64	a0,
		StructAlignmentInt64	a1
	)

Definition at line 6261 of file ffi_test_functions_generated.cc.

                                                                   {
  std::cout << "ReturnStructNestedIntStructAlignmentInt64" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))" << "\n";
 
  StructNestedIntStructAlignmentInt64 result = {};
 
  result.a0.a0 = a0.a0;
  result.a0.a1 = a0.a1;
  result.a0.a2 = a0.a2;
  result.a1.a0 = a1.a0;
  result.a1.a1 = a1.a1;
  result.a1.a2 = a1.a2;
 
  std::cout << "result = " << "((" << static_cast<int>(result.a0.a0) << ", "
            << result.a0.a1 << ", " << static_cast<int>(result.a0.a2) << "), ("
            << static_cast<int>(result.a1.a0) << ", " << result.a1.a1 << ", "
            << static_cast<int>(result.a1.a2) << "))" << "\n";
 
  return result;
}

ReturnStructNestedIrregularEvenBigger()

DART_EXPORT StructNestedIrregularEvenBigger dart::ReturnStructNestedIrregularEvenBigger	(	uint64_t	a0,
		StructNestedIrregularBigger	a1,
		StructNestedIrregularBigger	a2,
		double	a3
	)

Definition at line 6288 of file ffi_test_functions_generated.cc.

                                                 {
  std::cout << "ReturnStructNestedIrregularEvenBigger" << "(" << a0 << ", (("
            << a1.a0.a0 << ", ((" << a1.a0.a1.a0.a0 << ", " << a1.a0.a1.a0.a1
            << "), (" << a1.a0.a1.a1.a0 << ")), " << a1.a0.a2 << ", (("
            << a1.a0.a3.a0.a0 << "), " << a1.a0.a3.a1 << "), " << a1.a0.a4
            << ", ((" << a1.a0.a5.a0.a0 << "), (" << a1.a0.a5.a1.a0 << ")), "
            << a1.a0.a6 << "), ((" << a1.a1.a0.a0 << ", " << a1.a1.a0.a1
            << "), (" << a1.a1.a1.a0 << ")), " << a1.a2 << ", " << a1.a3
            << "), ((" << a2.a0.a0 << ", ((" << a2.a0.a1.a0.a0 << ", "
            << a2.a0.a1.a0.a1 << "), (" << a2.a0.a1.a1.a0 << ")), " << a2.a0.a2
            << ", ((" << a2.a0.a3.a0.a0 << "), " << a2.a0.a3.a1 << "), "
            << a2.a0.a4 << ", ((" << a2.a0.a5.a0.a0 << "), (" << a2.a0.a5.a1.a0
            << ")), " << a2.a0.a6 << "), ((" << a2.a1.a0.a0 << ", "
            << a2.a1.a0.a1 << "), (" << a2.a1.a1.a0 << ")), " << a2.a2 << ", "
            << a2.a3 << "), " << a3 << ")" << "\n";
 
  StructNestedIrregularEvenBigger result = {};
 
  result.a0 = a0;
  result.a1.a0.a0 = a1.a0.a0;
  result.a1.a0.a1.a0.a0 = a1.a0.a1.a0.a0;
  result.a1.a0.a1.a0.a1 = a1.a0.a1.a0.a1;
  result.a1.a0.a1.a1.a0 = a1.a0.a1.a1.a0;
  result.a1.a0.a2 = a1.a0.a2;
  result.a1.a0.a3.a0.a0 = a1.a0.a3.a0.a0;
  result.a1.a0.a3.a1 = a1.a0.a3.a1;
  result.a1.a0.a4 = a1.a0.a4;
  result.a1.a0.a5.a0.a0 = a1.a0.a5.a0.a0;
  result.a1.a0.a5.a1.a0 = a1.a0.a5.a1.a0;
  result.a1.a0.a6 = a1.a0.a6;
  result.a1.a1.a0.a0 = a1.a1.a0.a0;
  result.a1.a1.a0.a1 = a1.a1.a0.a1;
  result.a1.a1.a1.a0 = a1.a1.a1.a0;
  result.a1.a2 = a1.a2;
  result.a1.a3 = a1.a3;
  result.a2.a0.a0 = a2.a0.a0;
  result.a2.a0.a1.a0.a0 = a2.a0.a1.a0.a0;
  result.a2.a0.a1.a0.a1 = a2.a0.a1.a0.a1;
  result.a2.a0.a1.a1.a0 = a2.a0.a1.a1.a0;
  result.a2.a0.a2 = a2.a0.a2;
  result.a2.a0.a3.a0.a0 = a2.a0.a3.a0.a0;
  result.a2.a0.a3.a1 = a2.a0.a3.a1;
  result.a2.a0.a4 = a2.a0.a4;
  result.a2.a0.a5.a0.a0 = a2.a0.a5.a0.a0;
  result.a2.a0.a5.a1.a0 = a2.a0.a5.a1.a0;
  result.a2.a0.a6 = a2.a0.a6;
  result.a2.a1.a0.a0 = a2.a1.a0.a0;
  result.a2.a1.a0.a1 = a2.a1.a0.a1;
  result.a2.a1.a1.a0 = a2.a1.a1.a0;
  result.a2.a2 = a2.a2;
  result.a2.a3 = a2.a3;
  result.a3 = a3;
 
  std::cout << "result = " << "(" << result.a0 << ", ((" << result.a1.a0.a0
            << ", ((" << result.a1.a0.a1.a0.a0 << ", " << result.a1.a0.a1.a0.a1
            << "), (" << result.a1.a0.a1.a1.a0 << ")), " << result.a1.a0.a2
            << ", ((" << result.a1.a0.a3.a0.a0 << "), " << result.a1.a0.a3.a1
            << "), " << result.a1.a0.a4 << ", ((" << result.a1.a0.a5.a0.a0
            << "), (" << result.a1.a0.a5.a1.a0 << ")), " << result.a1.a0.a6
            << "), ((" << result.a1.a1.a0.a0 << ", " << result.a1.a1.a0.a1
            << "), (" << result.a1.a1.a1.a0 << ")), " << result.a1.a2 << ", "
            << result.a1.a3 << "), ((" << result.a2.a0.a0 << ", (("
            << result.a2.a0.a1.a0.a0 << ", " << result.a2.a0.a1.a0.a1 << "), ("
            << result.a2.a0.a1.a1.a0 << ")), " << result.a2.a0.a2 << ", (("
            << result.a2.a0.a3.a0.a0 << "), " << result.a2.a0.a3.a1 << "), "
            << result.a2.a0.a4 << ", ((" << result.a2.a0.a5.a0.a0 << "), ("
            << result.a2.a0.a5.a1.a0 << ")), " << result.a2.a0.a6 << "), (("
            << result.a2.a1.a0.a0 << ", " << result.a2.a1.a0.a1 << "), ("
            << result.a2.a1.a1.a0 << ")), " << result.a2.a2 << ", "
            << result.a2.a3 << "), " << result.a3 << ")" << "\n";
 
  return result;
}

ReturnUnion16BytesNestedFloat()

DART_EXPORT Union16BytesNestedFloat dart::ReturnUnion16BytesNestedFloat

(

Struct8BytesHomogeneousFloat

a0

)

Definition at line 5792 of file ffi_test_functions_generated.cc.

                                                               {
  std::cout << "ReturnUnion16BytesNestedFloat" << "((" << a0.a0 << ", " << a0.a1
            << "))" << "\n";
 
  Union16BytesNestedFloat result = {};
 
  result.a0.a0 = a0.a0;
  result.a0.a1 = a0.a1;
 
  std::cout << "result = " << "((" << result.a0.a0 << ", " << result.a0.a1
            << "))" << "\n";
 
  return result;
}

ReturnUnion4BytesMixed()

DART_EXPORT Union4BytesMixed dart::ReturnUnion4BytesMixed

(

uint32_t

a0

)

Definition at line 5744 of file ffi_test_functions_generated.cc.

                                                                 {
  std::cout << "ReturnUnion4BytesMixed" << "(" << a0 << ")" << "\n";
 
  Union4BytesMixed result = {};
 
  result.a0 = a0;
 
  std::cout << "result = " << "(" << result.a0 << ")" << "\n";
 
  return result;
}

ReturnUnion8BytesNestedFloat()

DART_EXPORT Union8BytesNestedFloat dart::ReturnUnion8BytesNestedFloat

(

double

a0

)

Definition at line 5758 of file ffi_test_functions_generated.cc.

                                                                           {
  std::cout << "ReturnUnion8BytesNestedFloat" << "(" << a0 << ")" << "\n";
 
  Union8BytesNestedFloat result = {};
 
  result.a0 = a0;
 
  std::cout << "result = " << "(" << result.a0 << ")" << "\n";
 
  return result;
}

ReturnUnion9BytesNestedInt()

DART_EXPORT Union9BytesNestedInt dart::ReturnUnion9BytesNestedInt

(

Struct8BytesInt

a0

)

Definition at line 5773 of file ffi_test_functions_generated.cc.

                                               {
  std::cout << "ReturnUnion9BytesNestedInt" << "((" << a0.a0 << ", " << a0.a1
            << ", " << a0.a2 << "))" << "\n";
 
  Union9BytesNestedInt result = {};
 
  result.a0.a0 = a0.a0;
  result.a0.a1 = a0.a1;
  result.a0.a2 = a0.a2;
 
  std::cout << "result = " << "((" << result.a0.a0 << ", " << result.a0.a1
            << ", " << result.a0.a2 << "))" << "\n";
 
  return result;
}

RotateRight()

static uint64_t dart::RotateRight ( uint64_t  value, uint8_t  rotate, uint8_t  width  )

inlinestatic

Definition at line 1271 of file constants_arm64.h.

                                                  {
  ASSERT(width <= 64);
  uint8_t right = rotate & 63;
  uint8_t left = (width - rotate) & 63;
  return ((value & ((1ULL << right) - 1ULL)) << left) | (value >> right);
}

RoundWordsToGB()

constexpr intptr_t dart::RoundWordsToGB ( intptr_t  size_in_words )

constexpr

Definition at line 548 of file globals.h.

                                                          {
  return (size_in_words + (GBInWords >> 1)) >> GBInWordsLog2;
}

RoundWordsToKB()

constexpr intptr_t dart::RoundWordsToKB ( intptr_t  size_in_words )

constexpr

Definition at line 542 of file globals.h.

                                                          {
  return (size_in_words + (KBInWords >> 1)) >> KBInWordsLog2;
}

RoundWordsToMB()

constexpr intptr_t dart::RoundWordsToMB ( intptr_t  size_in_words )

constexpr

Definition at line 545 of file globals.h.

                                                          {
  return (size_in_words + (MBInWords >> 1)) >> MBInWordsLog2;
}

RunBigRandomMultithreadedTest()

static void dart::RunBigRandomMultithreadedTest ( uint64_t  seed )

static

Definition at line 498 of file ffi_callback_metadata_test.cc.

                                                         {
  static constexpr int kIterations = 1000;
 
  TestIsolateScope isolate_scope;
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  ASSERT(isolate == isolate_scope.isolate());
  TransitionNativeToVM transition(thread);
  StackZone stack_zone(thread);
  HandleScope handle_scope(thread);
 
  struct TrampolineWithPort {
    FfiCallbackMetadata::Trampoline tramp;
    Dart_Port port;
  };
 
  auto* fcm = FfiCallbackMetadata::Instance();
  Random random(seed);
  std::vector<TrampolineWithPort> tramps;
  std::unordered_set<FfiCallbackMetadata::Trampoline> tramp_set;
  FfiCallbackMetadata::Metadata* list_head = nullptr;
 
  const Function& async_func =
      Function::Handle(CreateTestFunction(FfiCallbackKind::kAsyncCallback));
  const Code& async_code = Code::Handle(async_func.EnsureHasCode());
  EXPECT(!async_code.IsNull());
  const Function& sync_func = Function::Handle(
      CreateTestFunction(FfiCallbackKind::kIsolateLocalStaticCallback));
  const auto& sync_code = Code::Handle(sync_func.EnsureHasCode());
  EXPECT(!sync_code.IsNull());
 
  for (int itr = 0; itr < kIterations; ++itr) {
    // Do a random action:
    //  - Allocate a sync callback
    //  - Allocate an async callback
    //  - Delete a callback
    //  - Delete all the sync callbacks for an isolate
 
    if ((random.NextUInt32() % 100) == 0) {
      // 1% chance of deleting all the callbacks on the thread.
      fcm->DeleteAllCallbacks(&list_head);
 
      // It would be nice to verify that all the trampolines have been deleted,
      // but this is flaky because other threads can recycle these trampolines
      // before we finish checking all of them.
      tramps.clear();
      tramp_set.clear();
      EXPECT_EQ(list_head, nullptr);
    } else if (tramps.size() > 0 && (random.NextUInt32() % 4) == 0) {
      // 25% chance of deleting a callback.
      uint32_t r = random.NextUInt32() % tramps.size();
      auto tramp = tramps[r].tramp;
      fcm->DeleteCallback(tramp, &list_head);
      tramps[r] = tramps[tramps.size() - 1];
      tramps.pop_back();
      tramp_set.erase(tramp);
    } else {
      TrampolineWithPort tramp;
      if ((random.NextUInt32() % 2) == 0) {
        // 50% chance of creating a sync callback.
        tramp.port = ILLEGAL_PORT;
        tramp.tramp = fcm->CreateIsolateLocalFfiCallback(
            isolate, thread->zone(), sync_func,
            Closure::Handle(Closure::null()), &list_head);
      } else {
        // 50% chance of creating an async callback.
        tramp.port = PortMap::CreatePort(new FakeMessageHandler());
        tramp.tramp = fcm->CreateAsyncFfiCallback(
            isolate, thread->zone(), async_func, tramp.port, &list_head);
      }
      tramps.push_back(tramp);
      tramp_set.insert(tramp.tramp);
    }
 
    // Verify all the callbacks.
    for (const auto& tramp : tramps) {
      auto metadata = fcm->LookupMetadataForTrampoline(tramp.tramp);
      EXPECT(metadata.IsLive());
      EXPECT_EQ(metadata.target_isolate(), isolate);
      if (metadata.trampoline_type() ==
          FfiCallbackMetadata::TrampolineType::kSync) {
        EXPECT_EQ(metadata.closure_handle(), nullptr);
        EXPECT_EQ(metadata.target_entry_point(), sync_code.EntryPoint());
      } else {
        EXPECT_EQ(metadata.send_port(), tramp.port);
        EXPECT_EQ(metadata.target_entry_point(), async_code.EntryPoint());
      }
    }
 
    // Verify the isolate's list of callbacks.
    uword list_length = 0;
    for (FfiCallbackMetadata::Metadata* m = list_head; m != nullptr;) {
      ++list_length;
      auto tramp = fcm->TrampolineOfMetadata(m);
      EXPECT(m->IsLive());
      EXPECT_EQ(m->target_isolate(), isolate);
      EXPECT_EQ(tramp_set.count(tramp), 1u);
      m = m->list_next();
    }
    EXPECT_EQ(list_length, tramps.size());
    EXPECT_EQ(list_length, tramp_set.size());
  }
 
  // Delete all remaining callbacks.

RunFinalizer()

static void dart::RunFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 948 of file ffi_test_functions_vmspecific.cc.

                                                                  {
  printf("Running finalizer for weak handle.\n");
}

RunInitializingStoresTest()

static void dart::RunInitializingStoresTest ( const Library &  root_library, const char *  function_name, CompilerPass::PipelineMode  mode, const std::vector< const char * > &  expected_stores  )

static

Definition at line 112 of file il_test.cc.

                                                   {
  const auto& function =
      Function::Handle(GetFunction(root_library, function_name));
  TestPipeline pipeline(function, mode);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
      CompilerPass::kTypePropagation,
      CompilerPass::kApplyICData,
      CompilerPass::kInlining,
      CompilerPass::kTypePropagation,
      CompilerPass::kSelectRepresentations,
      CompilerPass::kCanonicalize,
      CompilerPass::kConstantPropagation,
  });
  ASSERT(flow_graph != nullptr);
  ExpectStores(flow_graph, expected_stores);
}

RunLockerWithLongJumpTest()

template<typename LockType , typename LockerType >

static void dart::RunLockerWithLongJumpTest ( )

static

Definition at line 1030 of file thread_test.cc.

                                        {
  const intptr_t kNumIterations = 5;
  volatile intptr_t execution_count = 0;
  volatile intptr_t thrown_count = 0;
  LockType lock;
  for (intptr_t i = 0; i < kNumIterations; ++i) {
    LongJumpScope jump;
    if (setjmp(*jump.Set()) == 0) {
      LockerType locker(Thread::Current(), &lock);
      execution_count++;
      Thread::Current()->long_jump_base()->Jump(
          1, Object::background_compilation_error());
    } else {
      ASSERT(Thread::Current()->StealStickyError() ==
             Object::background_compilation_error().ptr());
      thrown_count++;
    }
  }
  EXPECT_EQ(kNumIterations, execution_count);
  EXPECT_EQ(kNumIterations, thrown_count);
}

RunLoopDone()

static void dart::RunLoopDone ( uword  param )

static

Definition at line 1988 of file dart_api_impl.cc.

                                     {
  RunLoopData* data = reinterpret_cast<RunLoopData*>(param);
  ASSERT(data->monitor != nullptr);
  MonitorLocker ml(data->monitor);
  data->done = true;
  ml.Notify();
}

RunLoopTest()

static void dart::RunLoopTest ( bool  throw_exception )

static

Definition at line 8469 of file dart_api_impl_test.cc.

                                              {
  Dart_IsolateGroupCreateCallback saved = Isolate::CreateGroupCallback();
  Isolate::SetCreateGroupCallback(RunLoopTestCallback);
  Dart_Isolate isolate = RunLoopTestCallback(nullptr, nullptr, nullptr, nullptr,
                                             nullptr, nullptr, nullptr);
 
  Dart_EnterIsolate(isolate);
  Dart_EnterScope();
  Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
  EXPECT_VALID(lib);
 
  Dart_Handle result;
  Dart_Handle args[1];
  args[0] = (throw_exception ? Dart_True() : Dart_False());

RunLoopTestCallback()

static Dart_Isolate dart::RunLoopTestCallback ( const char *  script_name, const char *  main, const char *  package_root, const char *  package_config, Dart_IsolateFlags *  flags, void *  data, char **  error  )

static

Definition at line 8428 of file dart_api_impl_test.cc.

                             : 123\n", Dart_GetError(result));
 
  Dart_ExitScope();
 
  // Delete the native ports.
  EXPECT(Dart_CloseNativePort(port_id1));
}
 
static Dart_Isolate RunLoopTestCallback(const char* script_name,
                                        const char* main,
                                        const char* package_root,
                                        const char* package_config,
                                        Dart_IsolateFlags* flags,
                                        void* data,
                                        char** error) {
  const char* kScriptChars =
      "import 'dart:isolate';\n"
      "void main(shouldThrowException) {\n"
      "  var rp = new RawReceivePort();\n"
      "  rp.handler = (msg) {\n"
      "    rp.close();\n"
      "    if (shouldThrowException) {\n"
      "      throw new Exception('ExceptionFromTimer');\n"
      "    }\n"
      "  };\n"
      "  rp.sendPort.send(1);\n"
      "}\n";
 
  if (Dart_CurrentIsolate() != nullptr) {
    Dart_ExitIsolate();
  }
  Dart_Isolate isolate = TestCase::CreateTestIsolate(script_name);
  ASSERT(isolate != nullptr);

RunMemoryCopyInstrTest()

static void dart::RunMemoryCopyInstrTest ( intptr_t  src_start, intptr_t  dest_start, intptr_t  length, intptr_t  elem_size, bool  unboxed_inputs, bool  use_same_buffer  )

static

Definition at line 133 of file memory_copy_test.cc.

                                                         {
  OS::Print("==================================================\n");
  OS::Print("RunMemoryCopyInstrTest src_start %" Pd " dest_start %" Pd
            " length "
            "%" Pd "%s elem_size %" Pd "\n",
            src_start, dest_start, length, unboxed_inputs ? " (unboxed)" : "",
            elem_size);
  OS::Print("==================================================\n");
  classid_t cid = TypedDataCidForElementSize(elem_size);
 
  uint8_t* ptr = reinterpret_cast<uint8_t*>(malloc(kMemoryTestLength));
  uint8_t* ptr2 = use_same_buffer
                      ? ptr
                      : reinterpret_cast<uint8_t*>(malloc(kMemoryTestLength));
  InitializeMemory(ptr, ptr2);
 
  OS::Print("&ptr %p &ptr2 %p\n", ptr, ptr2);
 
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
    import 'dart:ffi';
 
    void copyConst() {
      final pointer = Pointer<Uint8>.fromAddress(%s%p);
      final pointer2 = Pointer<Uint8>.fromAddress(%s%p);
      noop();
    }
 
    void callNonConstCopy() {
      final pointer = Pointer<Uint8>.fromAddress(%s%p);
      final pointer2 = Pointer<Uint8>.fromAddress(%s%p);
      final src_start = %)" Pd R"(;
      final dest_start = %)" Pd R"(;
      final length = %)" Pd R"(;
      copyNonConst(
          pointer, pointer2, src_start, dest_start, length);
    }
 
    void noop() {}
 
    void copyNonConst(Pointer<Uint8> ptr1,
                      Pointer<Uint8> ptr2,
                      int src_start,
                      int dest_start,
                      int length) {}
  )", pointer_prefix, ptr, pointer_prefix, ptr2,
      pointer_prefix, ptr, pointer_prefix, ptr2,
      src_start, dest_start, length), std::free);
  // clang-format on
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript.get()));
 
  // Test the MemoryCopy instruction when the inputs are constants.
  {
    Invoke(root_library, "copyConst");
    // Running this should be a no-op on the memory.
    CHECK_DEFAULT_MEMORY(ptr, ptr2);
 
    const auto& const_copy =
        Function::Handle(GetFunction(root_library, "copyConst"));
 
    TestPipeline pipeline(const_copy, CompilerPass::kJIT);
    FlowGraph* flow_graph = pipeline.RunPasses({
        CompilerPass::kComputeSSA,
    });
 
    StaticCallInstr* pointer = nullptr;
    StaticCallInstr* pointer2 = nullptr;
    StaticCallInstr* another_function_call = nullptr;
    {
      ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
 
      EXPECT(cursor.TryMatch({
          kMoveGlob,
          {kMatchAndMoveStaticCall, &pointer},
          {kMatchAndMoveStaticCall, &pointer2},
          {kMatchAndMoveStaticCall, &another_function_call},
      }));
    }
 
    Zone* const zone = Thread::Current()->zone();
    auto const rep = unboxed_inputs ? kUnboxedIntPtr : kTagged;
 
    auto* const src_start_constant_instr = flow_graph->GetConstant(
        Integer::ZoneHandle(zone, Integer::New(src_start, Heap::kOld)), rep);
 
    auto* const dest_start_constant_instr = flow_graph->GetConstant(
        Integer::ZoneHandle(zone, Integer::New(dest_start, Heap::kOld)), rep);
 
    auto* const length_constant_instr = flow_graph->GetConstant(
        Integer::ZoneHandle(zone, Integer::New(length, Heap::kOld)), rep);
 
    auto* const memory_copy_instr = new (zone) MemoryCopyInstr(
        new (zone) Value(pointer), /*src_cid=*/cid, new (zone) Value(pointer2),
        /*dest_cid=*/cid, new (zone) Value(src_start_constant_instr),
        new (zone) Value(dest_start_constant_instr),
        new (zone) Value(length_constant_instr), unboxed_inputs,
        /*can_overlap=*/use_same_buffer);
    flow_graph->InsertBefore(another_function_call, memory_copy_instr, nullptr,
                             FlowGraph::kEffect);
 
    another_function_call->RemoveFromGraph();
 
    {
      // Check we constructed the right graph.
      ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
      EXPECT(cursor.TryMatch({
          kMoveGlob,
          kMatchAndMoveStaticCall,
          kMatchAndMoveStaticCall,
          kMatchAndMoveMemoryCopy,
      }));
    }
 
    {
#if !defined(PRODUCT) && !defined(USING_THREAD_SANITIZER)
      SetFlagScope<bool> sfs(&FLAG_disassemble_optimized, true);
#endif
 
      pipeline.RunForcedOptimizedAfterSSAPasses();
      pipeline.CompileGraphAndAttachFunction();
    }
 
    {
      // Check that the memory copy has constant inputs after optimization.
      ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
      MemoryCopyInstr* memory_copy;
      EXPECT(cursor.TryMatch({
          kMoveGlob,
          {kMatchAndMoveMemoryCopy, &memory_copy},
      }));
      EXPECT_EQ(kUntagged, memory_copy->src()->definition()->representation());
      EXPECT_EQ(kUntagged, memory_copy->dest()->definition()->representation());
      EXPECT(memory_copy->src_start()->BindsToConstant());
      EXPECT(memory_copy->dest_start()->BindsToConstant());
      EXPECT(memory_copy->length()->BindsToConstant());
    }
 
    // Run the mem copy.
    Invoke(root_library, "copyConst");
  }
 
  CHECK_MEMORY(ptr, ptr2, dest_start, src_start, length, elem_size);
  // Reinitialize the memory for the non-constant MemoryCopy version.
  InitializeMemory(ptr, ptr2);
 
  // Test the MemoryCopy instruction when the inputs are not constants.
  {
    Invoke(root_library, "callNonConstCopy");
    // Running this should be a no-op on the memory.
    CHECK_DEFAULT_MEMORY(ptr, ptr2);
 
    const auto& copy_non_const =
        Function::Handle(GetFunction(root_library, "copyNonConst"));
 
    TestPipeline pipeline(copy_non_const, CompilerPass::kJIT);
    FlowGraph* flow_graph = pipeline.RunPasses({
        CompilerPass::kComputeSSA,
    });
 
    auto* const entry_instr = flow_graph->graph_entry()->normal_entry();
    auto* const initial_defs = entry_instr->initial_definitions();
    EXPECT(initial_defs != nullptr);
    EXPECT_EQ(5, initial_defs->length());
 
    auto* const param_ptr = initial_defs->At(0)->AsParameter();
    EXPECT(param_ptr != nullptr);
    auto* const param_ptr2 = initial_defs->At(1)->AsParameter();
    EXPECT(param_ptr2 != nullptr);
    auto* const param_src_start = initial_defs->At(2)->AsParameter();
    EXPECT(param_src_start != nullptr);
    auto* const param_dest_start = initial_defs->At(3)->AsParameter();
    EXPECT(param_dest_start != nullptr);
    auto* const param_length = initial_defs->At(4)->AsParameter();
    EXPECT(param_length != nullptr);
 
    DartReturnInstr* return_instr;
    {
      ILMatcher cursor(flow_graph, entry_instr);
 
      EXPECT(cursor.TryMatch({
          kMoveGlob,
          {kMatchDartReturn, &return_instr},
      }));
    }
 
    Zone* const zone = Thread::Current()->zone();
 
    Definition* src_start_def = param_src_start;
    Definition* dest_start_def = param_dest_start;
    Definition* length_def = param_length;
    if (unboxed_inputs) {
      // Manually add the unbox instruction ourselves instead of leaving it
      // up to the SelectDefinitions pass.
      length_def =
          UnboxInstr::Create(kUnboxedWord, new (zone) Value(param_length),
                             DeoptId::kNone, Instruction::kNotSpeculative);
      flow_graph->InsertBefore(return_instr, length_def, nullptr,
                               FlowGraph::kValue);
      dest_start_def =
          UnboxInstr::Create(kUnboxedWord, new (zone) Value(param_dest_start),
                             DeoptId::kNone, Instruction::kNotSpeculative);
      flow_graph->InsertBefore(length_def, dest_start_def, nullptr,
                               FlowGraph::kValue);
      src_start_def =
          UnboxInstr::Create(kUnboxedWord, new (zone) Value(param_src_start),
                             DeoptId::kNone, Instruction::kNotSpeculative);
      flow_graph->InsertBefore(dest_start_def, src_start_def, nullptr,
                               FlowGraph::kValue);
    }
 
    auto* const memory_copy_instr = new (zone) MemoryCopyInstr(
        new (zone) Value(param_ptr), /*src_cid=*/cid,
        new (zone) Value(param_ptr2), /*dest_cid=*/cid,
        new (zone) Value(src_start_def), new (zone) Value(dest_start_def),
        new (zone) Value(length_def),
 
        unboxed_inputs, /*can_overlap=*/use_same_buffer);
    flow_graph->InsertBefore(return_instr, memory_copy_instr, nullptr,
                             FlowGraph::kEffect);
 
    {
      // Check we constructed the right graph.
      ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
      if (unboxed_inputs) {
        EXPECT(cursor.TryMatch({
            kMoveGlob,
            kMatchAndMoveUnbox,
            kMatchAndMoveUnbox,
            kMatchAndMoveUnbox,
            kMatchAndMoveMemoryCopy,
            kMatchDartReturn,
        }));
      } else {
        EXPECT(cursor.TryMatch({
            kMoveGlob,
            kMatchAndMoveMemoryCopy,
            kMatchDartReturn,
        }));
      }
    }
 
    {
#if !defined(PRODUCT) && !defined(USING_THREAD_SANITIZER)
      SetFlagScope<bool> sfs(&FLAG_disassemble_optimized, true);
#endif
 
      pipeline.RunForcedOptimizedAfterSSAPasses();
      pipeline.CompileGraphAndAttachFunction();
    }
 
    {
      // Check that the memory copy has non-constant inputs after optimization.
      ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry());
      MemoryCopyInstr* memory_copy;
      EXPECT(cursor.TryMatch({
          kMoveGlob,
          {kMatchAndMoveMemoryCopy, &memory_copy},
      }));
      EXPECT_EQ(kUntagged, memory_copy->src()->definition()->representation());
      EXPECT_EQ(kUntagged, memory_copy->dest()->definition()->representation());
      EXPECT(!memory_copy->src_start()->BindsToConstant());
      EXPECT(!memory_copy->dest_start()->BindsToConstant());
      EXPECT(!memory_copy->length()->BindsToConstant());
    }
 
    // Run the mem copy.
    Invoke(root_library, "callNonConstCopy");
  }
 
  CHECK_MEMORY(ptr, ptr2, dest_start, src_start, length, elem_size);
  free(ptr);
  if (!use_same_buffer) {
    free(ptr2);
  }
}

RunNativeFinalizerCallback()

template<typename GCVisitorType >

void dart::RunNativeFinalizerCallback	(	NativeFinalizerPtr	raw_finalizer,
		FinalizerEntryPtr	raw_entry,
		Heap::Space	before_gc_space,
		GCVisitorType *	visitor
	)

Definition at line 107 of file gc_shared.h.

                                                        {
  PointerPtr callback_pointer = raw_finalizer->untag()->callback();
  const auto callback = reinterpret_cast<NativeFinalizer::Callback>(
      callback_pointer->untag()->data());
  ObjectPtr token_object = raw_entry->untag()->token();
  const bool is_detached = token_object == raw_entry;
  const intptr_t external_size = raw_entry->untag()->external_size();
  if (is_detached) {
    // Detached from Dart code.
    ASSERT(token_object == raw_entry);
    ASSERT(external_size == 0);
    if (FLAG_trace_finalizers) {
      TRACE_FINALIZER("Not running native finalizer %p callback %p, detached",
                      raw_finalizer->untag(), callback);
    }
  } else {
    // TODO(http://dartbug.com/48615): Unbox pointer address in entry.
    ASSERT(token_object.IsPointer());
    PointerPtr token = static_cast<PointerPtr>(token_object);
    void* peer = reinterpret_cast<void*>(token->untag()->data());
    if (FLAG_trace_finalizers) {
      TRACE_FINALIZER("Running native finalizer %p callback %p with token %p",
                      raw_finalizer->untag(), callback, peer);
    }
    raw_entry.untag()->set_token(raw_entry);
    (*callback)(peer);
    if (external_size > 0) {
      if (FLAG_trace_finalizers) {
        TRACE_FINALIZER("Clearing external size %" Pd " bytes in %s space",
                        external_size, before_gc_space == 0 ? "new" : "old");
      }
      visitor->isolate_group()->heap()->FreedExternal(external_size,
                                                      before_gc_space);
      raw_entry->untag()->set_external_size(0);
    }
  }
}

RunTestCase()

void dart::RunTestCase	(	const TestCaseMoves *	mapping,
		intptr_t	count
	)

Definition at line 67 of file catch_entry_moves_test.cc.

                                                               {
  std::unique_ptr<intptr_t[]> permutation(new intptr_t[count]);
  for (intptr_t i = 0; i < count; ++i) {
    permutation[i] = i;
  }
 
  std::function<void(intptr_t)> run_all_permutations = [&](intptr_t offset) {
    if (offset == count) {
      RunTestCaseWithPermutations(mapping, &permutation[0], count);
    } else {
      for (intptr_t i = offset; i < count; ++i) {
        const intptr_t start = permutation[offset];
        const intptr_t replacement = permutation[i];
 
        permutation[offset] = replacement;
        permutation[i] = start;
 
        run_all_permutations(offset + 1);
 
        permutation[offset] = start;
        permutation[i] = replacement;
      }
    }
  };
 
  run_all_permutations(0);
}

RunTestCaseWithPermutations()

void dart::RunTestCaseWithPermutations	(	const TestCaseMoves *	mapping,
		intptr_t *	insert_permutation,
		intptr_t	count
	)

Definition at line 39 of file catch_entry_moves_test.cc.

                                                 {
  CatchEntryMovesMapBuilder b;
 
  for (intptr_t i = 0; i < count; ++i) {
    auto expected_moves = mapping[insert_permutation[i]];
    b.NewMapping(/*pc_offset=*/insert_permutation[i]);
    for (intptr_t j = 0; j < expected_moves.count; ++j) {
      b.Append(expected_moves.moves[j]);
    }
    b.EndMapping();
  }
 
  const auto& bytes = TypedData::Handle(b.FinalizeCatchEntryMovesMap());
  CatchEntryMovesMapReader reader(bytes);
 
  for (intptr_t i = 0; i < count; ++i) {
    auto expected_moves = mapping[i];
    auto read_moves = reader.ReadMovesForPcOffset(i);
    EXPECT_EQ(expected_moves.count, read_moves->count());
    for (intptr_t j = 0; j < expected_moves.count; ++j) {
      EXPECT(expected_moves.moves[j] == read_moves->At(j));
    }
    free(read_moves);
  }
}

RunTestInMode()

void dart::RunTestInMode

(

CompilerPass::PipelineMode

mode

)

Definition at line 50 of file yield_position_test.cc.

                                                  {
  const char* kScript =
      R"(
      import 'dart:async';
 
      Future foo() async {
        print('pos-0');
        await 0;
        print('pos-1');
        await 1;
        print('pos-2');
        await 2;
      }
      )";
 
  SetupCoreLibrariesForUnitTest();
 
  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  // Ensure the outer function was compiled once, ensuring we have a closure
  // function for the inner closure.
  Invoke(root_library, "foo");
 
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
 
  // Ensure we have 3 different return instructions with yield indices attached
  // to them.
  TestPipeline pipeline(function, mode);
  FlowGraph* flow_graph = pipeline.RunPasses({
      CompilerPass::kComputeSSA,
  });
 
  auto validate_indices = [](const YieldPoints& yield_points) {
    EXPECT_EQ(3, yield_points.length());
 
    EXPECT_EQ(88, yield_points[0].Pos());
    EXPECT_EQ(129, yield_points[1].Pos());
    EXPECT_EQ(170, yield_points[2].Pos());
  };

RuntimeAllocationEpilogue()

static void dart::RuntimeAllocationEpilogue ( Thread *  thread )

static

Definition at line 371 of file runtime_entry.cc.

                                                      {
  if (UNLIKELY(FLAG_runtime_allocate_spill_tlab)) {
    static RelaxedAtomic<uword> count = 0;
    if ((count++ % 10) == 0) {
      thread->heap()->new_space()->AbandonRemainingTLAB(thread);
    }
  }
}

RuntimeCheck()

static TTSTestCase dart::RuntimeCheck ( const TTSTestCase &  original )

static

Definition at line 384 of file type_testing_stubs_test.cc.

                                                             {
  return TTSTestCase(original.instance, original.instantiator_tav,
                     original.function_tav, kRuntimeCheck);
}

RunTTSTest()

static void dart::RunTTSTest ( const AbstractType &  dst_type, const TTSTestCase &  test_case, bool  should_specialize = true  )

static

Definition at line 780 of file type_testing_stubs_test.cc.

                                                      {
  // We're testing null here, there's no need to call this with null.
  EXPECT(!test_case.instance.IsNull());
  // should_specialize is what governs whether specialization is expected here.
  EXPECT_NE(kSpecialize, test_case.expected_result);
  EXPECT_NE(kRespecialize, test_case.expected_result);
  // We're creating a new STC so it _can't_ use an existing entry.
  EXPECT_NE(kExistingSTCEntry, test_case.expected_result);
 
  bool null_should_fail = !Instance::NullIsAssignableTo(
      dst_type, test_case.instantiator_tav, test_case.function_tav);
  const TTSTestCase null_test{Instance::Handle(), test_case.instantiator_tav,
                              test_case.function_tav,
                              null_should_fail ? kFail : kTTS};
 
  // First test the lazy case.
  {
    TTSTestState state(Thread::Current(), dst_type);
 
    // We only get specialization when testing null if the type being tested
    // isn't nullable and it is either a Type or a RecordType.
    const auto& type_to_test =
        AbstractType::Handle(state.TypeToTest(test_case));
    const bool null_should_specialize =
        null_should_fail &&
        (type_to_test.IsType() || type_to_test.IsRecordType());
 
    // First check the null case. This should _never_ create an STC.
    state.InvokeLazilySpecializedStub(null_test, null_should_specialize);
    state.InvokeExistingStub(null_test);
    EXPECT(state.last_stc().IsNull());
 
    // Now run the actual test case, starting with a fresh stub.
    state.InvokeLazilySpecializedStub(test_case, should_specialize);
    if (test_case.expected_result == kNewSTCEntry) {
      if (state.last_stc().IsNull()) {
        // The stub specialized to a non-default stub, so we need to run the
        // test again to see it added to the cache.
        state.InvokeExistingStub(test_case);
      } else {
        // The stub doesn't specialize or it specialized to a default stub,
        // in which case the entry did get added to the STC already.
      }
      state.InvokeExistingStub(STCCheck(test_case));
    } else {
      state.InvokeExistingStub(test_case);
    }
  }
 
  // Now test the eager case with a fresh stub/null STC.
  {
    TTSTestState state(Thread::Current(), dst_type);
 
    // First check the null case. This should _never_ create an STC.
    state.InvokeEagerlySpecializedStub(null_test);
    state.InvokeExistingStub(null_test);
    EXPECT(state.last_stc().IsNull());
 
    state.InvokeEagerlySpecializedStub(test_case);
    if (test_case.expected_result == kNewSTCEntry) {
      // When eagerly specializing, the first invocation always adds to the STC.
      state.InvokeExistingStub(STCCheck(test_case));
    } else {
      // Other cases should be idempotent.
      state.InvokeExistingStub(test_case);
    }
  }
}

RV_A()

static constexpr Extension dart::RV_A ( 2  )

staticconstexpr

RV_C()

static constexpr Extension dart::RV_C ( 5  )

staticconstexpr

RV_D()

static constexpr Extension dart::RV_D ( 4  )

staticconstexpr

RV_F()

static constexpr Extension dart::RV_F ( 3  )

staticconstexpr

RV_I()

static constexpr Extension dart::RV_I ( 0  )

staticconstexpr

RV_M()

static constexpr Extension dart::RV_M ( 1  )

staticconstexpr

RV_Zba()

static constexpr Extension dart::RV_Zba ( 6  )

staticconstexpr

RV_Zbb()

static constexpr Extension dart::RV_Zbb ( 7  )

staticconstexpr

RV_Zbc()

static constexpr Extension dart::RV_Zbc ( 8  )

staticconstexpr

RV_Zbs()

static constexpr Extension dart::RV_Zbs ( 9  )

staticconstexpr

SafelyAdjust()

static bool dart::SafelyAdjust ( Zone *  zone, InductionVar *  lower_bound, int64_t  lower_bound_offset, InductionVar *  upper_bound, int64_t  upper_bound_offset, InductionVar **  min, InductionVar **  max  )

static

Definition at line 167 of file loops.cc.

                                             {
  bool success = false;
  int64_t lval = 0;
  int64_t uval = 0;
  if (InductionVar::IsConstant(lower_bound, &lval)) {
    const int64_t l = lval + lower_bound_offset;
    if (InductionVar::IsConstant(upper_bound, &uval)) {
      // Make sure a proper new range [l,u] results. Even if bounds
      // were subject to arithmetic wrap-around, we preserve the
      // property that the minimum is in l and the maximum in u.
      const int64_t u = uval + upper_bound_offset;
      success = (l <= u);
    } else if (InductionVar::IsInvariant(upper_bound) &&
               upper_bound->mult() == 1 &&
               Definition::IsArrayLength(upper_bound->def())) {
      // No arithmetic wrap-around on the lower bound, and a properly
      // non-positive offset on an array length, which is always >= 0.
      const int64_t c = upper_bound->offset() + upper_bound_offset;
      success = ((lower_bound_offset >= 0 && lval <= l) ||
                 (lower_bound_offset < 0 && lval > l)) &&
                (c <= 0);
    }
  }
  if (success) {
    *min = (lower_bound_offset == 0)
               ? lower_bound
               : new (zone) InductionVar(lval + lower_bound_offset);
    *max = (upper_bound_offset == 0)
               ? upper_bound
               : new (zone)
                     InductionVar(upper_bound->offset() + upper_bound_offset,
                                  upper_bound->mult(), upper_bound->def());
  }
  return success;
}

SafeTypeArgumentsToCString()

static const char * dart::SafeTypeArgumentsToCString ( const TypeArguments &  args )

static

Definition at line 12843 of file object.cc.

                                                                         {
  return (args.ptr() == TypeArguments::null()) ? "<null>" : args.ToCString();
}

SamplesPerSecond()

static intptr_t dart::SamplesPerSecond ( )

static

Definition at line 631 of file profiler.cc.

                                   {
  const intptr_t kMicrosPerSec = 1000000;
  return kMicrosPerSec / FLAG_profile_period;
}

ScanUntilDash()

static const char * dart::ScanUntilDash ( const char *  s )

static

Definition at line 603 of file service.cc.

                                                {
  if ((s == nullptr) || (*s == '\0')) {
    // Empty string.
    return nullptr;
  }
  while (*s != '\0') {
    if (*s == '-') {
      return s;
    }
    s++;
  }
  return nullptr;
}

SecretKeeper_KeepSecret()

void FUNCTION_NAME() dart::SecretKeeper_KeepSecret

(

Dart_NativeArguments

native_args

)

Definition at line 4429 of file dart_api_impl_test.cc.

                                                                              {
  Dart_Handle receiver = Dart_GetNativeArgument(native_args, 0);
  int64_t secret = 0;
  Dart_GetNativeIntegerArgument(native_args, 1, &secret);
  EXPECT_VALID(Dart_SetNativeInstanceField(receiver, 0, secret));
}

SecretKeeperFfiNativeResolver()

static void * dart::SecretKeeperFfiNativeResolver ( const char *  name, uintptr_t  argn  )

static

Definition at line 4446 of file dart_api_impl_test.cc.

                                                                             {
  if (strcmp(name, "returnPtrAsInt") == 0 && argn == 1) {
    return reinterpret_cast<void*>(&ReturnPtrAsInt);
  }
  return nullptr;
}

SecretKeeperNativeResolver()

static Dart_NativeFunction dart::SecretKeeperNativeResolver ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 4436 of file dart_api_impl_test.cc.

                                                                              {
  return reinterpret_cast<Dart_NativeFunction>(Builtin_SecretKeeper_KeepSecret);
}

SegmentLength()

static intptr_t dart::SegmentLength ( const char *  input )

static

Definition at line 268 of file uri.cc.

                                                 {
  const char* cp = input;
 
  // Include initial slash in the segment, if any.
  if (*cp == '/') {
    cp++;
  }
 
  // Don't include trailing slash in the segment.
  cp += strcspn(cp, "/");
  return cp - input;
}

SemanticsUpdateBuilderUpdateNode()

DART_EXPORT void dart::SemanticsUpdateBuilderUpdateNode	(	void *	this_,
		int	id,
		int	flags,
		int	actions,
		int	maxValueLength,
		int	currentValueLength,
		int	textSelectionBase,
		int	textSelectionExtent,
		int	platformViewId,
		int	scrollChildren,
		int	scrollIndex,
		double	scrollPosition,
		double	scrollExtentMax,
		double	scrollExtentMin,
		double	left,
		double	top,
		double	right,
		double	bottom,
		double	elevation,
		double	thickness,
		Dart_Handle	label,
		Dart_Handle	labelAttributes,
		Dart_Handle	value,
		Dart_Handle	valueAttributes,
		Dart_Handle	increasedValue,
		Dart_Handle	increasedValueAttributes,
		Dart_Handle	decreasedValue,
		Dart_Handle	decreasedValueAttributes,
		Dart_Handle	hint,
		Dart_Handle	hintAttributes,
		Dart_Handle	tooltip,
		int	textDirection,
		Dart_Handle	transform,
		Dart_Handle	childrenInTraversalOrder,
		Dart_Handle	childrenInHitTestOrder,
		Dart_Handle	localContextActions
	)

Definition at line 1368 of file ffi_test_functions_vmspecific.cc.

                                     {
  if (!Dart_IsString(tooltip)) {
    FATAL("expected Dart_IsString(tooltip)");
  }
  const char* cstr;
  auto to_cstring_result = Dart_StringToCString(tooltip, &cstr);
  if (Dart_IsError(to_cstring_result)) {
    FATAL(Dart_GetError(to_cstring_result));
  }
  if (strcmp(cstr, "tooltip") != 0) {
    printf("cstr %s\n", cstr);
    FATAL("cstr not equal to \"tooltip\"");
  }
}

SendMessages()

static void dart::SendMessages ( uword  param )

static

Definition at line 336 of file message_handler_test.cc.

                                      {
  ThreadStartInfo* info = reinterpret_cast<ThreadStartInfo*>(param);
  info->join_id = OSThread::GetCurrentThreadJoinId(OSThread::Current());
  MessageHandler* handler = info->handler;
  MessageHandlerTestPeer handler_peer(handler);
  for (int i = 0; i < info->count; i++) {
    handler_peer.PostMessage(
        BlankMessage(info->ports[i], Message::kNormalPriority));
  }
}

SendNull()

static void dart::SendNull ( const SendPort &  port )

static

Definition at line 121 of file developer.cc.

                                           {
  const Dart_Port destination_port_id = port.Id();
  PortMap::PostMessage(Message::New(destination_port_id, Object::null(),
                                    Message::kNormalPriority));
}

SENTINEL_TOKEN_DESCRIPTORS()

dart::SENTINEL_TOKEN_DESCRIPTORS

(

DEFINE_VALUES

)

SerializeAndDeserializeMint()

Dart_CObject * dart::SerializeAndDeserializeMint	(	Zone *	zone,
		const Mint &	mint
	)

Definition at line 191 of file snapshot_test.cc.

                                                                        {
  // Write snapshot with object content.
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, mint, ILLEGAL_PORT, Message::kNormalPriority);
 
  {
    // Switch to a regular zone, where VM handle allocation is allowed.
    Thread* thread = Thread::Current();
    StackZone zone(thread);
    // Read object back from the snapshot.
    const Object& serialized_object =
        Object::Handle(ReadMessage(thread, message.get()));
    EXPECT(serialized_object.IsMint());
  }
 
  // Read object back from the snapshot into a C structure.
  Dart_CObject* root = ReadApiMessage(zone, message.get());
  EXPECT_NOTNULL(root);
  CheckEncodeDecodeMessage(zone, root);
  return root;
}

SerializeMessage() [1/2]

static std::unique_ptr< Message > dart::SerializeMessage ( Dart_Port  dest_port, const Instance &  obj  )

static

Definition at line 121 of file isolate.cc.

                                                                      {
  return WriteMessage(/* same_group */ false, obj, dest_port,
                      Message::kNormalPriority);
}

SerializeMessage() [2/2]

static std::unique_ptr< Message > dart::SerializeMessage ( Zone *  zone, Dart_Port  dest_port, Dart_CObject *  obj  )

static

Definition at line 127 of file isolate.cc.

                                                                    {
  return WriteApiMessage(zone, obj, dest_port, Message::kNormalPriority);
}

SetArgumentTo42()

DART_EXPORT void dart::SetArgumentTo42

(

void *

token

)

Definition at line 1127 of file ffi_test_functions_vmspecific.cc.

                                              {
  *reinterpret_cast<intptr_t*>(token) = 42;
}

SetBreakpoint()

void dart::SetBreakpoint

(

Dart_NativeArguments

args

)

Definition at line 5638 of file object_test.cc.

                                              {
  // Refers to the DeoptimizeFramesWhenSettingBreakpoint function below.
  const int kBreakpointLine = 8;
 
  // This will force deoptimization of functions on stack.
  // Function on stack has to be optimized, since we want to trigger debuggers
  // on-stack deoptimization flow when we set a breakpoint.
  Dart_Handle result =
      Dart_SetBreakpoint(NewString(TestCase::url()), kBreakpointLine);
  EXPECT_VALID(result);
}

SetBreakpointResolver()

static Dart_NativeFunction dart::SetBreakpointResolver ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 5650 of file object_test.cc.

                                                                         {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  const char* cstr = nullptr;
  Dart_Handle result = Dart_StringToCString(name, &cstr);
  EXPECT_VALID(result);
  EXPECT_STREQ(cstr, "setBreakpoint");
  return &SetBreakpoint;
}

SetBreakpointState()

static void dart::SetBreakpointState ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5571 of file service.cc.

                                                               {
  Isolate* isolate = thread->isolate();
  const char* bpt_id = js->LookupParam("breakpointId");
  bool enable = BoolParameter::Parse(js->LookupParam("enable"), true);
  ObjectIdRing::LookupResult lookup_result;
  Breakpoint* bpt = LookupBreakpoint(isolate, bpt_id, &lookup_result);
  // TODO(bkonyi): Should we return a different error for bpts which
  // have been already removed?
  if (bpt == nullptr) {
    PrintInvalidParamError(js, "breakpointId");
    return;
  }
  if (isolate->debugger()->SetBreakpointState(bpt, enable)) {
    if (Service::debug_stream.enabled()) {
      ServiceEvent event(isolate, ServiceEvent::kBreakpointUpdated);
      event.set_breakpoint(bpt);
      Service::HandleEvent(&event);
    }
  }
  bpt->PrintJSON(js);
}

SetDartVmNode()

void dart::SetDartVmNode

(

std::unique_ptr< inspect::Node >

node

)

SetEdgeWeight()

static void dart::SetEdgeWeight ( BlockEntryInstr *  block, BlockEntryInstr *  successor, const Array &  edge_counters, intptr_t  entry_count  )

static

Definition at line 24 of file block_scheduler.cc.

                                                {
  ASSERT(entry_count != 0);
  if (auto target = successor->AsTargetEntry()) {
    // If this block ends in a goto, the edge count of this edge is the same
    // as the count on the single outgoing edge. This is true as long as the
    // block does not throw an exception.
    intptr_t count = GetEdgeCount(edge_counters, target->preorder_number());
    if (count >= 0) {
      double weight =
          static_cast<double>(count) / static_cast<double>(entry_count);
      target->set_edge_weight(weight);
    }
  } else if (auto jump = block->last_instruction()->AsGoto()) {
    intptr_t count = GetEdgeCount(edge_counters, block->preorder_number());
    if (count >= 0) {
      double weight =
          static_cast<double>(count) / static_cast<double>(entry_count);
      jump->set_edge_weight(weight);
    }
  }
}

SetExceptionPauseMode()

static void dart::SetExceptionPauseMode ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5505 of file service.cc.

                                                                  {
  const char* mode = js->LookupParam("mode");
  if (mode == nullptr) {
    PrintMissingParamError(js, "mode");
    return;
  }
  Dart_ExceptionPauseInfo info =
      EnumMapper(mode, exception_pause_mode_names, exception_pause_mode_values);
  if (info == kInvalidExceptionPauseInfo) {
    PrintInvalidParamError(js, "mode");
    return;
  }
  Isolate* isolate = thread->isolate();
  isolate->debugger()->SetExceptionPauseInfo(info);
  if (Service::debug_stream.enabled()) {
    ServiceEvent event(isolate, ServiceEvent::kDebuggerSettingsUpdate);
    Service::HandleEvent(&event);
  }
  PrintSuccess(js);
}

SetFfiNativeResolverForTest()

DART_EXPORT void dart::SetFfiNativeResolverForTest

(

Dart_Handle

url

)

Definition at line 1281 of file ffi_test_functions_vmspecific.cc.

                                                              {
  Dart_Handle library = Dart_LookupLibrary(url);
  ENSURE(!Dart_IsError(library));
  Dart_Handle result = Dart_SetFfiNativeResolver(library, &FfiNativeResolver);
  ENSURE(!Dart_IsError(result));
}

SetFlag()

static void dart::SetFlag ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5607 of file service.cc.

                                                    {
  const char* flag_name = js->LookupParam("name");
  if (flag_name == nullptr) {
    PrintMissingParamError(js, "name");
    return;
  }
  const char* flag_value = js->LookupParam("value");
  if (flag_value == nullptr) {
    PrintMissingParamError(js, "value");
    return;
  }
 
  if (Flags::Lookup(flag_name) == nullptr) {
    JSONObject jsobj(js);
    jsobj.AddProperty("type", "Error");
    jsobj.AddProperty("message", "Cannot set flag: flag not found");
    return;
  }
 
  // Changing most flags at runtime is dangerous because e.g., it may leave the
  // behavior generated code and the runtime out of sync.
  const uintptr_t kProfilePeriodIndex = 3;
  const uintptr_t kProfilerIndex = 4;
  const char* kAllowedFlags[] = {
      "pause_isolates_on_start",
      "pause_isolates_on_exit",
      "pause_isolates_on_unhandled_exceptions",
      "profile_period",
      "profiler",
  };
 
  bool allowed = false;
  bool profile_period = false;
  bool profiler = false;
  for (size_t i = 0; i < ARRAY_SIZE(kAllowedFlags); i++) {
    if (strcmp(flag_name, kAllowedFlags[i]) == 0) {
      allowed = true;
      profile_period = (i == kProfilePeriodIndex);
      profiler = (i == kProfilerIndex);
      break;
    }
  }
 
  if (!allowed) {
    JSONObject jsobj(js);
    jsobj.AddProperty("type", "Error");
    jsobj.AddProperty("message", "Cannot set flag: cannot change at runtime");
    return;
  }
 
  const char* error = nullptr;
  if (Flags::SetFlag(flag_name, flag_value, &error)) {
    PrintSuccess(js);
    if (profile_period) {
      // FLAG_profile_period has already been set to the new value. Now we need
      // to notify the ThreadInterrupter to pick up the change.
      Profiler::UpdateSamplePeriod();
    } else if (profiler) {
      // FLAG_profiler has already been set to the new value.
      Profiler::UpdateRunningState();
    }
    if (Service::vm_stream.enabled()) {
      ServiceEvent event(ServiceEvent::kVMFlagUpdate);
      event.set_flag_name(flag_name);
      event.set_flag_new_value(flag_value);
      Service::HandleEvent(&event);
    }
  } else {
    JSONObject jsobj(js);
    jsobj.AddProperty("type", "Error");
    jsobj.AddProperty("message", error);
  }
}

SetGlobalVar()

DART_EXPORT void dart::SetGlobalVar

(

int32_t

v

)

Definition at line 55 of file ffi_test_functions.cc.

                                         {
  globalInt = v;
}

SetIsolatePauseMode()

static void dart::SetIsolatePauseMode ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5533 of file service.cc.

                                                                {
  bool state_changed = false;
  const char* exception_pause_mode = js->LookupParam("exceptionPauseMode");
  if (exception_pause_mode != nullptr) {
    Dart_ExceptionPauseInfo info =
        EnumMapper(exception_pause_mode, exception_pause_mode_names,
                   exception_pause_mode_values);
    if (info == kInvalidExceptionPauseInfo) {
      PrintInvalidParamError(js, "exceptionPauseMode");
      return;
    }
    Isolate* isolate = thread->isolate();
    isolate->debugger()->SetExceptionPauseInfo(info);
    state_changed = true;
  }
 
  const char* pause_isolate_on_exit = js->LookupParam("shouldPauseOnExit");
  if (pause_isolate_on_exit != nullptr) {
    bool enable = BoolParameter::Parse(pause_isolate_on_exit, false);
    thread->isolate()->message_handler()->set_should_pause_on_exit(enable);
    state_changed = true;
  }
 
  if (state_changed && Service::debug_stream.enabled()) {
    ServiceEvent event(thread->isolate(),
                       ServiceEvent::kDebuggerSettingsUpdate);
    Service::HandleEvent(&event);
  }
  PrintSuccess(js);
}

SetLibraryDebuggable()

static void dart::SetLibraryDebuggable ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5688 of file service.cc.

                                                                 {
  const char* lib_id = js->LookupParam("libraryId");
  ObjectIdRing::LookupResult lookup_result;
  Object& obj =
      Object::Handle(LookupHeapObject(thread, lib_id, &lookup_result));
  const bool is_debuggable =
      BoolParameter::Parse(js->LookupParam("isDebuggable"), false);
  if (obj.IsLibrary()) {
    const Library& lib = Library::Cast(obj);
    lib.set_debuggable(is_debuggable);
    PrintSuccess(js);
    return;
  }
  PrintInvalidParamError(js, "libraryId");
}

SetMode_native_lookup()

static Dart_NativeFunction dart::SetMode_native_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_setup_scope  )

static

Definition at line 9771 of file dart_api_impl_test.cc.

  {
    result = Dart_SetEnabledTimelineCategory("");
    EXPECT_EQ(true, result);
    JSONStream js;
    JSONObject obj(&js);
    JSONArray jstream(&obj, "available");
    Timeline::PrintFlagsToJSONArray(&jstream);
    const char* js_str = js.ToCString();

SetName()

static void dart::SetName ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5710 of file service.cc.

                                                    {
  Isolate* isolate = thread->isolate();
  isolate->set_name(js->LookupParam("name"));
  if (Service::isolate_stream.enabled()) {
    ServiceEvent event(isolate, ServiceEvent::kIsolateUpdate);
    Service::HandleEvent(&event);
  }
  PrintSuccess(js);
  return;
}

SetNewSpaceTaggingWord()

DART_FORCE_INLINE void dart::SetNewSpaceTaggingWord	(	ObjectPtr	to,
		classid_t	cid,
		uint32_t	size
	)

Definition at line 229 of file object_graph_copy.cc.

                                                                        {
  uword tags = 0;
 
  tags = UntaggedObject::SizeTag::update(size, tags);
  tags = UntaggedObject::ClassIdTag::update(cid, tags);
  tags = UntaggedObject::AlwaysSetBit::update(true, tags);
  tags = UntaggedObject::NotMarkedBit::update(true, tags);
  tags = UntaggedObject::OldAndNotRememberedBit::update(false, tags);
  tags = UntaggedObject::CanonicalBit::update(false, tags);
  tags = UntaggedObject::NewBit::update(true, tags);
  tags = UntaggedObject::ImmutableBit::update(
      IsUnmodifiableTypedDataViewClassId(cid), tags);
#if defined(HASH_IN_OBJECT_HEADER)
  tags = UntaggedObject::HashTag::update(0, tags);
#endif
  to.untag()->tags_ = tags;
}

SetPerformanceModeDefault()

static void dart::SetPerformanceModeDefault ( Dart_NativeArguments  args )

static

Definition at line 9764 of file dart_api_impl_test.cc.

SetPerformanceModeLatency()

static void dart::SetPerformanceModeLatency ( Dart_NativeArguments  args )

static

Definition at line 9767 of file dart_api_impl_test.cc.

SetPlaceId()

static DART_FORCE_INLINE void dart::SetPlaceId ( Instruction *  instr, intptr_t  id  )

static

Definition at line 1356 of file redundancy_elimination.cc.

                                                                          {
  instr->SetPassSpecificId(CompilerPass::kCSE, id);
}

SetResourceFinalizer()

void dart::SetResourceFinalizer	(	Dart_Handle	handle,
		intptr_t *	resource
	)

Definition at line 1179 of file ffi_test_functions_vmspecific.cc.

                                                                  {
  Dart_NewFinalizableHandle(handle, resource, sizeof(Dart_FinalizableHandle),
                            DummyResourceFinalizer);
}

SetStreamIncludePrivateMembers()

static void dart::SetStreamIncludePrivateMembers ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1564 of file service.cc.

                                                                           {
  const char* stream_id = js->LookupParam("streamId");
  if (stream_id == nullptr) {
    PrintMissingParamError(js, "streamId");
    return;
  }
  bool include_private_members =
      BoolParameter::Parse(js->LookupParam("includePrivateMembers"), false);
  intptr_t num_streams = sizeof(streams_) / sizeof(streams_[0]);
  for (intptr_t i = 0; i < num_streams; i++) {
    if (strcmp(stream_id, streams_[i]->id()) == 0) {
      streams_[i]->set_include_private_members(include_private_members);
      break;
    }
  }
  PrintSuccess(js);
}

SetTraceClassAllocation()

static void dart::SetTraceClassAllocation ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5746 of file service.cc.

                                                                    {
  const char* class_id = js->LookupParam("classId");
  const bool enable = BoolParameter::Parse(js->LookupParam("enable"));
  intptr_t cid = -1;
  GetPrefixedIntegerId(class_id, "classes/", &cid);
  Isolate* isolate = thread->isolate();
  if (!IsValidClassId(isolate, cid)) {
    PrintInvalidParamError(js, "classId");
    return;
  }
  const Class& cls = Class::Handle(GetClassForId(isolate, cid));
  ASSERT(!cls.IsNull());
  cls.SetTraceAllocation(enable);
  PrintSuccess(js);
}

SetupArguments()

static Dart_Handle dart::SetupArguments ( Thread *  thread, int  num_args, Dart_Handle *  arguments, int  extra_args, Array *  args  )

static

Definition at line 4444 of file dart_api_impl.cc.

                                               {
  Zone* zone = thread->zone();
  // Check for malformed arguments in the arguments list.
  *args = Array::New(num_args + extra_args);
  Object& arg = Object::Handle(zone);
  for (int i = 0; i < num_args; i++) {
    arg = Api::UnwrapHandle(arguments[i]);
    if (!arg.IsNull() && !arg.IsInstance()) {
      *args = Array::null();
      if (arg.IsError()) {
        return Api::NewHandle(thread, arg.ptr());
      } else {
        return Api::NewError(
            "%s expects arguments[%d] to be an Instance handle.", "Dart_Invoke",
            i);
      }
    }
    args->SetAt((i + extra_args), arg);
  }
  return Api::Success();
}

SetupCoreLibrariesForUnitTest()

void dart::SetupCoreLibrariesForUnitTest

(

)

Definition at line 148 of file unit_test.cc.

                                     {
  TransitionVMToNative transition(Thread::Current());
 
  Dart_EnterScope();
  bool ok = bin::DartUtils::SetOriginalWorkingDirectory();
  RELEASE_ASSERT(ok);
  Dart_Handle result = bin::DartUtils::PrepareForScriptLoading(
      /*is_service_isolate=*/false,
      /*trace_loading=*/false);
  Dart_ExitScope();
 
  RELEASE_ASSERT(!Dart_IsError(result));
}

SetupFfiFlowgraph()

FlowGraph * dart::SetupFfiFlowgraph	(	TestPipeline *	pipeline,
		const compiler::ffi::CallMarshaller &	marshaller,
		uword	native_entry,
		bool	is_leaf
	)

Definition at line 864 of file il_test.cc.

                                           {
  FlowGraph* flow_graph = pipeline->RunPasses({CompilerPass::kComputeSSA});
 
  {
    // Locate the placeholder call.
    StaticCallInstr* static_call = nullptr;
    {
      ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry(),
                       /*trace=*/false);
      cursor.TryMatch({kMoveGlob, {kMatchStaticCall, &static_call}});
    }
    RELEASE_ASSERT(static_call != nullptr);
 
    // Store the native entry as an unboxed constant and convert it to an
    // untagged pointer for the FfiCall.
    Zone* const Z = flow_graph->zone();
    auto* const load_entry_point = new (Z) IntConverterInstr(
        kUnboxedIntPtr, kUntagged,
        new (Z) Value(flow_graph->GetConstant(
            Integer::Handle(Z, Integer::NewCanonical(native_entry)),
            kUnboxedIntPtr)),
        DeoptId::kNone);
    flow_graph->InsertBefore(static_call, load_entry_point, /*env=*/nullptr,
                             FlowGraph::kValue);
 
    // Make an FfiCall based on ffi_trampoline that calls our native function.
    const intptr_t num_arguments =
        FfiCallInstr::InputCountForMarshaller(marshaller);
    RELEASE_ASSERT(num_arguments == 1);
    InputsArray arguments(num_arguments);
    arguments.Add(new (Z) Value(load_entry_point));
    auto* const ffi_call = new (Z)
        FfiCallInstr(DeoptId::kNone, marshaller, is_leaf, std::move(arguments));
    RELEASE_ASSERT(
        ffi_call->InputAt(ffi_call->TargetAddressIndex())->definition() ==
        load_entry_point);
    flow_graph->InsertBefore(static_call, ffi_call, /*env=*/nullptr,
                             FlowGraph::kEffect);
 
    // Remove the placeholder call.
    static_call->RemoveFromGraph(/*return_previous=*/false);
  }
 
  // Run remaining relevant compiler passes.
  pipeline->RunAdditionalPasses({
      CompilerPass::kApplyICData,
      CompilerPass::kTryOptimizePatterns,
      CompilerPass::kSetOuterInliningId,
      CompilerPass::kTypePropagation,
      // Skipping passes that don't seem to do anything for this test.
      CompilerPass::kWidenSmiToInt32,
      CompilerPass::kSelectRepresentations,
      // Skipping passes that don't seem to do anything for this test.
      CompilerPass::kTypePropagation,
      CompilerPass::kRangeAnalysis,
      // Skipping passes that don't seem to do anything for this test.
      CompilerPass::kFinalizeGraph,
      CompilerPass::kCanonicalize,
      CompilerPass::kAllocateRegisters,
      CompilerPass::kReorderBlocks,
  });
 
  return flow_graph;
}

SetupSample()

static Sample * dart::SetupSample ( Thread *  thread, bool  allocation_sample, ThreadId  tid  )

static

Definition at line 1229 of file profiler.cc.

                                         {
  ASSERT(thread != nullptr);
  Isolate* isolate = thread->isolate();
  SampleBlockBuffer* buffer = Profiler::sample_block_buffer();
  Sample* sample = allocation_sample ? buffer->ReserveAllocationSample(isolate)
                                     : buffer->ReserveCPUSample(isolate);
  if (sample == nullptr) {
    return nullptr;
  }
  sample->Init(isolate->main_port(), OS::GetCurrentMonotonicMicros(), tid);
  uword vm_tag = thread->vm_tag();
#if defined(USING_SIMULATOR)
  // When running in the simulator, the runtime entry function address
  // (stored as the vm tag) is the address of a redirect function.
  // Attempt to find the real runtime entry function address and use that.
  uword redirect_vm_tag = Simulator::FunctionForRedirect(vm_tag);
  if (redirect_vm_tag != 0) {
    vm_tag = redirect_vm_tag;
  }
#endif
  sample->set_vm_tag(vm_tag);
  sample->set_user_tag(isolate->user_tag());
  sample->set_thread_task(thread->task_kind());
  return sample;
}

SetVMName()

static void dart::SetVMName ( Thread *  thread, JSONStream *  js  )

static

Definition at line 5727 of file service.cc.

                                                      {
  const char* name_param = js->LookupParam("name");
  free(vm_name);
  vm_name = Utils::StrDup(name_param);
  if (Service::vm_stream.enabled()) {
    ServiceEvent event(ServiceEvent::kVMUpdate);
    Service::HandleEvent(&event);
  }
  PrintSuccess(js);
  return;
}

SetVMTimelineFlags()

static void dart::SetVMTimelineFlags ( Thread *  thread, JSONStream *  js  )

static

Definition at line 4241 of file service.cc.

                                                               {
#if !defined(SUPPORT_TIMELINE)
  PrintSuccess(js);
#else
  Isolate* isolate = thread->isolate();
  ASSERT(isolate != nullptr);
  StackZone zone(thread);
 
  char* recorded_streams = Utils::StrDup(js->LookupParam("recordedStreams"));
  Service::EnableTimelineStreams(recorded_streams);
  free(recorded_streams);
 
  PrintSuccess(js);
#endif
}

ShiftArgs()

void dart::ShiftArgs	(	int *	argc,
		const char **	argv
	)

Definition at line 290 of file run_vm_tests.cc.

                                             {
  // Remove the first flag from the list by shifting all arguments down.
  for (intptr_t i = 1; i < *argc - 1; i++) {
    argv[i] = argv[i + 1];
  }
  argv[*argc - 1] = nullptr;
  (*argc)--;
}

ShiftOperationHelper()

static IntegerPtr dart::ShiftOperationHelper ( Token::Kind  kind, const Integer &  value, const Integer &  amount  )

static

Definition at line 206 of file integers.cc.

                                                              {
  if (amount.AsInt64Value() < 0) {
    Exceptions::ThrowArgumentError(amount);
  }
  return value.ShiftOp(kind, amount, Heap::kNew);
}

ShortCutEmitCharacterPair()

static bool dart::ShortCutEmitCharacterPair ( RegExpMacroAssembler *  macro_assembler, bool  one_byte, uint16_t  c1, uint16_t  c2, BlockLabel *  on_failure  )

static

Definition at line 935 of file regexp.cc.

                                                              {
  uint16_t char_mask;
  if (one_byte) {
    char_mask = Symbols::kMaxOneCharCodeSymbol;
  } else {
    char_mask = Utf16::kMaxCodeUnit;
  }
  uint16_t exor = c1 ^ c2;
  // Check whether exor has only one bit set.
  if (((exor - 1) & exor) == 0) {
    // If c1 and c2 differ only by one bit.
    // Ecma262UnCanonicalize always gives the highest number last.
    ASSERT(c2 > c1);
    uint16_t mask = char_mask ^ exor;
    macro_assembler->CheckNotCharacterAfterAnd(c1, mask, on_failure);
    return true;
  }
  ASSERT(c2 > c1);
  uint16_t diff = c2 - c1;
  if (((diff - 1) & diff) == 0 && c1 >= diff) {
    // If the characters differ by 2^n but don't differ by one bit then
    // subtract the difference from the found character, then do the or
    // trick.  We avoid the theoretical case where negative numbers are
    // involved in order to simplify code generation.
    uint16_t mask = char_mask ^ diff;
    macro_assembler->CheckNotCharacterAfterMinusAnd(c1 - diff, diff, mask,
                                                    on_failure);
    return true;
  }
  return false;
}

ShouldBeAllocatedBefore()

static bool dart::ShouldBeAllocatedBefore ( LiveRange *  a, LiveRange *  b  )

inlinestatic

Definition at line 2837 of file linearscan.cc.

                                                                       {
  // TODO(vegorov): consider first hint position when ordering live ranges.
  return a->Start() <= b->Start();
}

ShouldBePrivate()

static bool dart::ShouldBePrivate ( const String &  name )

static

Definition at line 13818 of file object.cc.

                                                {
  return (name.Length() >= 1 && name.CharAt(0) == '_') ||
         (name.Length() >= 5 &&
          (name.CharAt(4) == '_' &&
           (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
           name.CharAt(1) == 'e' && name.CharAt(2) == 't' &&
           name.CharAt(3) == ':'));
}

ShouldHaveImmutabilityBitSetCid()

bool dart::ShouldHaveImmutabilityBitSetCid ( intptr_t  predefined_cid )

inline

Definition at line 507 of file class_id.h.

                                                                     {
  ASSERT(predefined_cid < kNumPredefinedCids);
  return IsDeeplyImmutableCid(predefined_cid) ||
         IsShallowlyImmutableCid(predefined_cid);
}

ShouldInlineSimd() [1/2]

static bool dart::ShouldInlineSimd ( )

static

Definition at line 1932 of file flow_graph.cc.

                               {
  return FlowGraphCompiler::SupportsUnboxedSimd128();
}

ShouldInlineSimd() [2/2]

static bool dart::ShouldInlineSimd ( )

static

Definition at line 29 of file call_specializer.cc.

                               {
  return FlowGraphCompiler::SupportsUnboxedSimd128();
}

ShouldReorderBlocks()

static bool dart::ShouldReorderBlocks ( const Function &  function, FlowGraph::CompilationMode  mode  )

static

Definition at line 37 of file flow_graph.cc.

                                                               {
  return (mode == FlowGraph::CompilationMode::kOptimized) &&
         FLAG_reorder_basic_blocks && !function.IsFfiCallbackTrampoline();
}

ShouldSpecializeForDouble()

static bool dart::ShouldSpecializeForDouble ( const BinaryFeedback &  binary_feedback )

static

Definition at line 45 of file call_specializer.cc.

                                                                             {
  // Don't specialize for double if we can't unbox them.
  if (!CanUnboxDouble()) {
    return false;
  }
 
  // Unboxed double operation can't handle case of two smis.
  if (binary_feedback.IncludesOperands(kSmiCid)) {
    return false;
  }
 
  // Check that the call site has seen only smis and doubles.
  return binary_feedback.OperandsAreSmiOrDouble();
}

ShouldSuspend()

static bool dart::ShouldSuspend ( bool  isolate_shutdown, Thread *  thread  )

static

Definition at line 407 of file thread.cc.

                                                                 {
  // Must destroy thread.
  if (isolate_shutdown) return false;
 
  // Must retain thread.
  if (thread->HasActiveState() || thread->OwnsSafepoint()) return true;
 
  // Could do either. When there are few isolates suspend to avoid work
  // entering and leaving. When there are many isolate, destroy the thread to
  // avoid the root set growing too big.
  const intptr_t kMaxSuspendedThreads = 20;
  auto group = thread->isolate_group();
  return group->thread_registry()->active_isolates_count() <
         kMaxSuspendedThreads;
}

ShutdownIsolate()

static void dart::ShutdownIsolate ( uword  parameter )

static

Definition at line 2363 of file isolate.cc.

                                             {
  Dart_EnterIsolate(reinterpret_cast<Dart_Isolate>(parameter));
  Dart_ShutdownIsolate();
}

sign_extend() [1/4]

intx_t dart::sign_extend ( int32_t  x )

inline

Definition at line 693 of file constants_riscv.h.

                                     {
  return static_cast<intx_t>(x);
}

sign_extend() [2/4]

intx_t dart::sign_extend ( int64_t  x )

inline

Definition at line 696 of file constants_riscv.h.

                                     {
  return static_cast<intx_t>(x);
}

sign_extend() [3/4]

intx_t dart::sign_extend ( uint32_t  x )

inline

Definition at line 699 of file constants_riscv.h.

                                      {
  return static_cast<intx_t>(static_cast<int32_t>(x));
}

sign_extend() [4/4]

intx_t dart::sign_extend ( uint64_t  x )

inline

Definition at line 702 of file constants_riscv.h.

                                      {
  return static_cast<intx_t>(static_cast<int64_t>(x));
}

SignExtend()

int32_t dart::SignExtend ( int  N, int32_t  value  )

inline

Definition at line 688 of file constants_riscv.h.

                                                {
  return static_cast<int32_t>(static_cast<uint32_t>(value) << (32 - N)) >>
         (32 - N);
}

SimdRepresentation()

static constexpr Representation dart::SimdRepresentation ( Representation  rep )

staticconstexpr

Definition at line 8259 of file il.cc.

                                                                       {
  // Keep the old semantics where kUnboxedInt8 was a locally created
  // alias for kUnboxedInt32, and pass everything else through unchanged.
  return rep == kUnboxedInt8 ? kUnboxedInt32 : rep;
}

SimpleInstanceOfType()

bool dart::SimpleInstanceOfType

(

const AbstractType &

type

)

Definition at line 372 of file flow_graph_builder.cc.

                                                    {
  // Bail if the type is still uninstantiated at compile time.
  if (!type.IsInstantiated()) return false;
 
  // Bail if the type is a function, record or a Dart Function type.
  if (type.IsFunctionType() || type.IsRecordType() ||
      type.IsDartFunctionType()) {
    return false;
  }
 
  ASSERT(type.HasTypeClass());
  auto* const zone = Thread::Current()->zone();
  const Class& type_class = Class::Handle(zone, type.type_class());
 
  // Bail if the type has any type parameters.
  if (type_class.IsGeneric()) {
    // If the interface type is a supertype of the rare type, as any instances
    // are guaranteed to be subtypes of the rare type, then we can still use
    // the _simpleInstanceOf implementation (see also
    // runtime/lib/object.cc:Object_SimpleInstanceOf).
    // See #52848 for why the type might be a supertype and not strictly equal.
    const auto& rare_type = Type::Handle(zone, type_class.RareType());
    return rare_type.IsSubtypeOf(type, Heap::kNew);
  }
 
  // Finally a simple class for instance of checking.
  return true;
}

SimpleInvoke()

int64_t dart::SimpleInvoke	(	Dart_Handle	lib,
		const char *	method
	)

Definition at line 23 of file isolate_reload_test.cc.

                                                          {
  Dart_Handle result = Dart_Invoke(lib, NewString(method), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsInteger(result));
  int64_t integer_result = 0;
  result = Dart_IntegerToInt64(result, &integer_result);
  EXPECT_VALID(result);
  return integer_result;
}

SimpleInvokeError()

Dart_Handle dart::SimpleInvokeError	(	Dart_Handle	lib,
		const char *	method
	)

Definition at line 41 of file isolate_reload_test.cc.

                                                                   {
  Dart_Handle result = Dart_Invoke(lib, NewString(method), 0, nullptr);
  EXPECT(Dart_IsError(result));
  return result;
}

SimpleInvokeStr()

const char * dart::SimpleInvokeStr	(	Dart_Handle	lib,
		const char *	method
	)

Definition at line 33 of file isolate_reload_test.cc.

                                                                 {
  Dart_Handle result = Dart_Invoke(lib, NewString(method), 0, nullptr);
  const char* result_str = nullptr;
  EXPECT(Dart_IsString(result));
  EXPECT_VALID(Dart_StringToCString(result, &result_str));
  return result_str;
}

SizeOfStruct3BytesPackedInt()

DART_EXPORT uint64_t dart::SizeOfStruct3BytesPackedInt

(

)

Definition at line 1216 of file ffi_test_functions.cc.

                                                   {
  return sizeof(Struct3BytesPackedIntCopy);
}

SleepOnAnyOS()

DART_EXPORT void dart::SleepOnAnyOS

(

intptr_t

seconds

)

Definition at line 437 of file ffi_test_functions_vmspecific.cc.

                                                {
#if defined(DART_HOST_OS_WINDOWS)
  Sleep(1000 * seconds);
#else
  sleep(seconds);
#endif
}

SlotIndexToFpRelativeOffset()

static intptr_t dart::SlotIndexToFpRelativeOffset ( intptr_t  slot )

static

Definition at line 385 of file exceptions.cc.

                                                           {
  return SlotIndexToFrameIndex(slot) * compiler::target::kWordSize;
}

SlotIndexToFrameIndex()

static intptr_t dart::SlotIndexToFrameIndex ( intptr_t  slot )

static

Definition at line 381 of file exceptions.cc.

                                                     {
  return runtime_frame_layout.FrameSlotForVariableIndex(-slot);
}

SlowFinalizer()

static void dart::SlowFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3174 of file dart_api_impl_test.cc.

                                                                   {
  OS::Sleep(10);
  intptr_t* count = reinterpret_cast<intptr_t*>(peer);
  (*count)++;
}

SlowWeakPersistentHandle()

static void dart::SlowWeakPersistentHandle ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3199 of file dart_api_impl_test.cc.

                                                                              {
  OS::Sleep(10);
  intptr_t* count = reinterpret_cast<intptr_t*>(peer);
  (*count)++;
}

SmallDouble()

DART_EXPORT double dart::SmallDouble

(

)

Definition at line 75 of file ffi_test_functions_vmspecific.cc.

                                 {
  Dart_ExecuteInternalCommand("gc-on-nth-allocation",
                              reinterpret_cast<void*>(1));
  return 0x80000000 * -1.0;
}

SmearBitsRight()

static uint32_t dart::SmearBitsRight ( uint32_t  v )

inlinestatic

Definition at line 1589 of file regexp.cc.

                                                  {
  v |= v >> 1;
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  return v;
}

SmiFitsInDouble()

static bool dart::SmiFitsInDouble ( )

static

Definition at line 369 of file call_specializer.cc.

                              {
  return compiler::target::kSmiBits < 53;
}

SpaceForExternal()

Heap::Space dart::SpaceForExternal

(

FinalizerEntryPtr

raw_entry

)

Definition at line 42 of file gc_shared.cc.

                                                        {
  // As with WeakTables, Smis are "old".
  return raw_entry->untag()->value()->IsImmediateOrOldObject() ? Heap::kOld
                                                               : Heap::kNew;
}

SpaceForRuntimeAllocation()

static Heap::Space dart::SpaceForRuntimeAllocation ( )

static

Definition at line 367 of file runtime_entry.cc.

                                             {
  return UNLIKELY(FLAG_runtime_allocate_old) ? Heap::kOld : Heap::kNew;
}

SpecialCharacter()

template<typename type >

static type dart::SpecialCharacter ( type  value )

static

Definition at line 530 of file object.cc.

                                         {
  if (value == '"') {
    return '"';
  } else if (value == '\n') {
    return 'n';
  } else if (value == '\f') {
    return 'f';
  } else if (value == '\b') {
    return 'b';
  } else if (value == '\t') {
    return 't';
  } else if (value == '\v') {
    return 'v';
  } else if (value == '\r') {
    return 'r';
  } else if (value == '\\') {
    return '\\';
  } else if (value == '$') {
    return '$';
  }
  UNREACHABLE();
  return '\0';
}

SplitByTypeArgumentsFieldOffset()

static void dart::SplitByTypeArgumentsFieldOffset ( Thread *  T, const Class &  type_class, const CidRangeVector &  ranges, GrowableArray< CidRangeVector * > *  output  )

static

Definition at line 774 of file type_testing_stubs.cc.

                                            {
  ASSERT(output != nullptr);
  ASSERT(!ranges.is_empty());
 
  Zone* const Z = T->zone();
  ClassTable* const class_table = T->isolate_group()->class_table();
  IntMap<CidRangeVector*> offset_map(Z);
  IntMap<intptr_t> predefined_offsets(Z);
  IntMap<intptr_t> user_defined_offsets(Z);
 
  auto add_to_vector = [&](intptr_t tav_offset, const CidRange& range) {
    if (range.cid_start == -1) return;
    ASSERT(tav_offset != compiler::target::Class::kNoTypeArguments);
    if (CidRangeVector* vector = offset_map.Lookup(tav_offset)) {
      vector->Add(range);
    } else {
      vector = new CidRangeVector(1);
      vector->Add(range);
      offset_map.Insert(tav_offset, vector);
    }
  };
 
  auto increment_count = [&](intptr_t cid, intptr_t tav_offset) {
    if (cid <= kNumPredefinedCids) {
      predefined_offsets.Update(
          {tav_offset, predefined_offsets.Lookup(tav_offset) + 1});
    } else if (auto* const kv = predefined_offsets.LookupPair(tav_offset)) {
      predefined_offsets.Update({kv->key, kv->value + 1});
    } else {
      user_defined_offsets.Update(
          {tav_offset, user_defined_offsets.Lookup(tav_offset) + 1});
    }
  };
 
  // First populate offset_map.
  auto& cls = Class::Handle(Z);
  for (const auto& range : ranges) {
    intptr_t last_offset = compiler::target::Class::kNoTypeArguments;
    intptr_t cid_start = -1;
    intptr_t cid_end = -1;
    for (intptr_t cid = range.cid_start; cid <= range.cid_end; cid++) {
      if (!class_table->HasValidClassAt(cid)) continue;
      cls = class_table->At(cid);
      if (cls.is_abstract()) continue;
      // Only finalized concrete classes are present due to the conditions on
      // returning kInstanceTypeArgumentsAreSubtypes in SubtypeChecksForClass.
      ASSERT(cls.is_finalized());
      const intptr_t tav_offset =
          compiler::target::Class::TypeArgumentsFieldOffset(cls);
      if (tav_offset == compiler::target::Class::kNoTypeArguments) continue;
      if (tav_offset == last_offset && cid_start >= 0) {
        cid_end = cid;
        increment_count(cid, tav_offset);
        continue;
      }
      add_to_vector(last_offset, {cid_start, cid_end});
      last_offset = tav_offset;
      cid_start = cid_end = cid;
      increment_count(cid, tav_offset);
    }
    add_to_vector(last_offset, {cid_start, cid_end});
  }
 
  ASSERT(!offset_map.IsEmpty());
 
  // Add the CidRangeVector for the type_class's offset, if it has one.
  if (!type_class.is_abstract() && type_class.is_finalized()) {
    const intptr_t type_class_offset =
        compiler::target::Class::TypeArgumentsFieldOffset(type_class);
    ASSERT(predefined_offsets.LookupPair(type_class_offset) != nullptr ||
           user_defined_offsets.LookupPair(type_class_offset) != nullptr);
    CidRangeVector* const vector = offset_map.Lookup(type_class_offset);
    ASSERT(vector != nullptr);
    output->Add(vector);
    // Remove this CidRangeVector from consideration in the following loops.
    predefined_offsets.Remove(type_class_offset);
    user_defined_offsets.Remove(type_class_offset);
  }
  // Now add CidRangeVectors that include predefined cids.
  // For now, we do this in an arbitrary order, but we could use the counts
  // to prioritize offsets that are more shared if desired.
  auto predefined_it = predefined_offsets.GetIterator();
  while (auto* const kv = predefined_it.Next()) {
    CidRangeVector* const vector = offset_map.Lookup(kv->key);
    ASSERT(vector != nullptr);
    output->Add(vector);
  }
  // Finally, add CidRangeVectors that only include user-defined cids.
  // For now, we do this in an arbitrary order, but we could use the counts
  // to prioritize offsets that are more shared if desired.
  auto user_defined_it = user_defined_offsets.GetIterator();
  while (auto* const kv = user_defined_it.Next()) {
    CidRangeVector* const vector = offset_map.Lookup(kv->key);
    ASSERT(vector != nullptr);
    output->Add(vector);
  }
  ASSERT(output->length() > 0);
}

SplitListOfPositions()

template<typename PositionType >

PositionType * dart::SplitListOfPositions	(	PositionType **	head,
		intptr_t	split_pos,
		bool	split_at_start
	)

Definition at line 1869 of file linearscan.cc.

                                                        {
  PositionType* last_before_split = nullptr;
  PositionType* pos = *head;
  if (split_at_start) {
    while ((pos != nullptr) && (pos->pos() < split_pos)) {
      last_before_split = pos;
      pos = pos->next();
    }
  } else {
    while ((pos != nullptr) && (pos->pos() <= split_pos)) {
      last_before_split = pos;
      pos = pos->next();
    }
  }
 
  if (last_before_split == nullptr) {
    *head = nullptr;
  } else {
    last_before_split->set_next(nullptr);
  }
 
  return pos;
}

SplitOnTypeArgumentTests()

static void dart::SplitOnTypeArgumentTests ( HierarchyInfo *  hi, const Type &  type, const Class &  type_class, const CidRangeVector &  ranges, CidRangeVector *  cid_check_only, CidRangeVector *  type_argument_checks, CidRangeVector *  not_checked  )

static

Definition at line 902 of file type_testing_stubs.cc.

                                                                  {
  ASSERT(type_class.is_implemented());  // No need to split if not implemented.
  ASSERT(cid_check_only->is_empty());
  ASSERT(type_argument_checks->is_empty());
  ASSERT(not_checked->is_empty());
  ClassTable* const class_table = hi->thread()->isolate_group()->class_table();
  Zone* const zone = hi->thread()->zone();
  auto& to_check = Class::Handle(zone);
  auto add_cid_range = [&](CheckType check, const CidRange& range) {
    if (range.cid_start == -1) return;
    switch (check) {
      case CheckType::kCidCheckOnly:
        cid_check_only->Add(range);
        break;
      case CheckType::kInstanceTypeArgumentsAreSubtypes:
        type_argument_checks->Add(range);
        break;
      default:
        not_checked->Add(range);
    }
  };
  for (const auto& range : ranges) {
    CheckType last_check = CheckType::kCannotBeChecked;
    classid_t cid_start = -1, cid_end = -1;
    for (classid_t cid = range.cid_start; cid <= range.cid_end; cid++) {
      // Invalid entries can be included to keep range count low.
      if (!class_table->HasValidClassAt(cid)) continue;
      to_check = class_table->At(cid);
      if (to_check.is_abstract()) continue;
      const CheckType current_check =
          SubtypeChecksForClass(zone, type, type_class, to_check);
      ASSERT(current_check != CheckType::kInstanceTypeArgumentsAreSubtypes ||
             to_check.is_finalized());
      if (last_check == current_check && cid_start >= 0) {
        cid_end = cid;
        continue;
      }
      add_cid_range(last_check, {cid_start, cid_end});
      last_check = current_check;
      cid_start = cid_end = cid;
    }
    add_cid_range(last_check, {cid_start, cid_end});
  }
}

SplitSearchSpace()

static void dart::SplitSearchSpace ( ZoneGrowableArray< uint16_t > *  ranges, intptr_t  start_index, intptr_t  end_index, intptr_t *  new_start_index, intptr_t *  new_end_index, uint16_t *  border  )

static

Definition at line 1148 of file regexp.cc.

                                               {
  const intptr_t kSize = RegExpMacroAssembler::kTableSize;
  const intptr_t kMask = RegExpMacroAssembler::kTableMask;
 
  uint16_t first = ranges->At(start_index);
  uint16_t last = ranges->At(end_index) - 1;
 
  *new_start_index = start_index;
  *border = (ranges->At(start_index) & ~kMask) + kSize;
  while (*new_start_index < end_index) {
    if (ranges->At(*new_start_index) > *border) break;
    (*new_start_index)++;
  }
  // new_start_index is the index of the first edge that is beyond the
  // current kSize space.
 
  // For very large search spaces we do a binary chop search of the non-Latin1
  // space instead of just going to the end of the current kSize space.  The
  // heuristics are complicated a little by the fact that any 128-character
  // encoding space can be quickly tested with a table lookup, so we don't
  // wish to do binary chop search at a smaller granularity than that.  A
  // 128-character space can take up a lot of space in the ranges array if,
  // for example, we only want to match every second character (eg. the lower
  // case characters on some Unicode pages).
  intptr_t binary_chop_index = (end_index + start_index) / 2;
  // The first test ensures that we get to the code that handles the Latin1
  // range with a single not-taken branch, speeding up this important
  // character range (even non-Latin1 charset-based text has spaces and
  // punctuation).
  if (*border - 1 > Symbols::kMaxOneCharCodeSymbol &&  // Latin1 case.
      end_index - start_index > (*new_start_index - start_index) * 2 &&
      last - first > kSize * 2 && binary_chop_index > *new_start_index &&
      ranges->At(binary_chop_index) >= first + 2 * kSize) {
    intptr_t scan_forward_for_section_border = binary_chop_index;
    intptr_t new_border = (ranges->At(binary_chop_index) | kMask) + 1;
 
    while (scan_forward_for_section_border < end_index) {
      if (ranges->At(scan_forward_for_section_border) > new_border) {
        *new_start_index = scan_forward_for_section_border;
        *border = new_border;
        break;
      }
      scan_forward_for_section_border++;
    }
  }
 
  ASSERT(*new_start_index > start_index);
  *new_end_index = *new_start_index - 1;
  if (ranges->At(*new_end_index) == *border) {
    (*new_end_index)--;
  }
  if (*border >= ranges->At(end_index)) {
    *border = ranges->At(end_index);
    *new_start_index = end_index;  // Won't be used.
    *new_end_index = end_index - 1;
  }
}

StackAllocatedDestructionHelper()

static void dart::StackAllocatedDestructionHelper ( int *  ptr )

static

Definition at line 70 of file allocation_test.cc.

                                                      {
  TestValueObject stacked(ptr);
  EXPECT_EQ(2, *ptr);
  *ptr = 3;
}

StackAllocatedLongJumpHelper()

static void dart::StackAllocatedLongJumpHelper ( int *  ptr, LongJumpScope *  jump  )

static

Definition at line 82 of file allocation_test.cc.

                                                                        {
  TestValueObject stacked(ptr);
  EXPECT_EQ(2, *ptr);
  *ptr = 3;
  const Error& error = Error::Handle(LanguageError::New(
      String::Handle(String::New("StackAllocatedLongJump"))));
  jump->Jump(1, error);
  UNREACHABLE();
}

StackedStackResourceDestructionHelper()

static void dart::StackedStackResourceDestructionHelper ( int *  ptr )

static

Definition at line 104 of file allocation_test.cc.

                                                            {
  TestStackedStackResource stacked(ptr);
  EXPECT_EQ(4, *ptr);
  *ptr = 5;
}

StackedStackResourceLongJumpHelper()

static void dart::StackedStackResourceLongJumpHelper ( int *  ptr, LongJumpScope *  jump  )

static

Definition at line 125 of file allocation_test.cc.

                                                                              {
  TestStackedStackResource stacked(ptr);
  EXPECT_EQ(4, *ptr);
  *ptr = 5;
  const Error& error = Error::Handle(LanguageError::New(
      String::Handle(String::New("StackedStackResourceLongJump"))));
  jump->Jump(1, error);
  UNREACHABLE();
}

StackFrame_accessFrame()

static void dart::StackFrame_accessFrame ( Dart_NativeArguments  args )

static

Definition at line 265 of file benchmark_test.cc.

                                                              {
  Timer timer;
  timer.Start();
  {
    Thread* thread = Thread::Current();
    TransitionNativeToVM transition(thread);
    const int kNumIterations = 100;
    Code& code = Code::Handle(thread->zone());
    for (int i = 0; i < kNumIterations; i++) {
      StackFrameIterator frames(ValidationPolicy::kDontValidateFrames, thread,
                                StackFrameIterator::kNoCrossThreadIteration);
      StackFrame* frame = frames.NextFrame();
      while (frame != nullptr) {
        if (frame->IsStubFrame()) {
          code = frame->LookupDartCode();
          EXPECT(code.function() == Function::null());
        } else if (frame->IsDartFrame()) {
          code = frame->LookupDartCode();
          EXPECT(code.function() != Function::null());
        }
        frame = frames.NextFrame();
      }
    }
  }
  timer.Stop();
  int64_t elapsed_time = timer.TotalElapsedTime();
  Dart_SetReturnValue(args, Dart_NewInteger(elapsed_time));
}

StackFrame_dartFrameCount()

void FUNCTION_NAME() dart::StackFrame_dartFrameCount

(

Dart_NativeArguments

args

)

Definition at line 69 of file stack_frame_test.cc.

                                                                         {
  TransitionNativeToVM transition(Thread::Current());
  int count = 0;
  DartFrameIterator frames(Thread::Current(),
                           StackFrameIterator::kNoCrossThreadIteration);
  while (frames.NextFrame() != nullptr) {
    count += 1;  // Count the dart frame.
  }
  VerifyPointersVisitor::VerifyPointers("StackFrame_dartFrameCount_Test");
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  arguments->SetReturn(Object::Handle(Smi::New(count)));
}

StackFrame_equals()

void FUNCTION_NAME() dart::StackFrame_equals

(

Dart_NativeArguments

args

)

Definition at line 40 of file stack_frame_test.cc.

                                                                 {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
  Zone* zone = arguments->thread()->zone();
  const Instance& expected =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Instance& actual =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(1));
  if (!expected.OperatorEquals(actual)) {
    OS::PrintErr("expected: '%s' actual: '%s'\n", expected.ToCString(),
                 actual.ToCString());
    EXPECT(false);
  }
}

StackFrame_frameCount()

void FUNCTION_NAME() dart::StackFrame_frameCount

(

Dart_NativeArguments

args

)

Definition at line 55 of file stack_frame_test.cc.

                                                                     {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
  int count = 0;
  StackFrameIterator frames(ValidationPolicy::kValidateFrames,
                            arguments->thread(),
                            StackFrameIterator::kNoCrossThreadIteration);
  while (frames.NextFrame() != nullptr) {
    count += 1;  // Count the frame.
  }
  VerifyPointersVisitor::VerifyPointers("StackFrame_frameCount_Test");
  arguments->SetReturn(Object::Handle(Smi::New(count)));
}

StackFrame_validateFrame()

void FUNCTION_NAME() dart::StackFrame_validateFrame

(

Dart_NativeArguments

args

)

Definition at line 82 of file stack_frame_test.cc.

                                                                        {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  Dart_Handle index = Dart_GetNativeArgument(args, 0);
  Dart_Handle name = Dart_GetNativeArgument(args, 1);
 
  TransitionNativeToVM transition(thread);
  const Smi& frame_index_smi =
      Smi::CheckedHandle(zone, Api::UnwrapHandle(index));
  const char* expected_name =
      String::CheckedHandle(zone, Api::UnwrapHandle(name)).ToCString();
  int frame_index = frame_index_smi.Value();
  int count = 0;
  DartFrameIterator frames(thread, StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = frames.NextFrame();
  while (frame != nullptr) {
    if (count == frame_index) {
      // Find the function corresponding to this frame and check if it
      // matches the function name passed in.
      const Function& function =
          Function::Handle(zone, frame->LookupDartFunction());
      if (function.IsNull()) {
        FATAL("StackFrame_validateFrame fails, invalid dart frame.\n");
      }
      const char* name = function.ToFullyQualifiedCString();
      // Currently all unit tests are loaded as being part of dart:core-lib.
      String& url = String::Handle(zone, String::New(TestCase::url()));
      const Library& lib =
          Library::Handle(zone, Library::LookupLibrary(thread, url));
      ASSERT(!lib.IsNull());
      const char* lib_name = String::Handle(zone, lib.url()).ToCString();
      char* full_name = OS::SCreate(zone, "%s_%s", lib_name, expected_name);
      EXPECT_STREQ(full_name, name);
      return;
    }
    count += 1;  // Count the dart frames.
    frame = frames.NextFrame();
  }
  FATAL("StackFrame_validateFrame fails, frame count < index passed in.\n");
}

StackFrameNativeResolver()

static Dart_NativeFunction dart::StackFrameNativeResolver ( Dart_Handle  name, int  arg_count, bool *  auto_setup_scope  )

static

Definition at line 294 of file benchmark_test.cc.

                                                                            {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = false;
  return &StackFrame_accessFrame;
}

StackResourceDestructionHelper()

static void dart::StackResourceDestructionHelper ( int *  ptr )

static

Definition at line 110 of file allocation_test.cc.

                                                     {
  TestStackResource stacked(ptr);
  EXPECT_EQ(2, *ptr);
  *ptr = 3;
  StackedStackResourceDestructionHelper(ptr);
  EXPECT_EQ(6, *ptr);
  // Do not set data because the LongJump version does not return control here.
}

StackResourceLongJumpHelper()

static void dart::StackResourceLongJumpHelper ( int *  ptr, LongJumpScope *  jump  )

static

Definition at line 135 of file allocation_test.cc.

                                                                       {
  TestStackResource stacked(ptr);
  EXPECT_EQ(2, *ptr);
  *ptr = 3;
  StackedStackResourceLongJumpHelper(ptr, jump);
  UNREACHABLE();
}

StartWorkSimulator()

DART_EXPORT void dart::StartWorkSimulator

(

)

Definition at line 596 of file ffi_test_functions_vmspecific.cc.

                                      {
  SimulateWork::StartWorkSimulator();
}

StartWorkSimulator2()

DART_EXPORT void dart::StartWorkSimulator2

(

)

Definition at line 878 of file ffi_test_functions_vmspecific.cc.

                                       {
  SimulateWork2::StartWorkSimulator();
}

StaticNativeFoo1()

static void dart::StaticNativeFoo1 ( Dart_NativeArguments  args )

static

Definition at line 8767 of file dart_api_impl_test.cc.

                   :external-name', 'NativeFoo3')
        external int foo3([int k = 10000, int l = 1]);
 
        @pragma('vm:external-name', 'NativeFoo4')
        external int foo4(int i, [int j = 10, int k = 1]);
 

StaticNativeFoo2()

static void dart::StaticNativeFoo2 ( Dart_NativeArguments  args )

static

Definition at line 8775 of file dart_api_impl_test.cc.

                        { var func = foo2; return func(i); }
        int bar30() { var func = foo3; return func(); }
        int bar31(int i) { var func = foo3; return func(i); }
        int bar32(int i, int j) { var func = foo3; return func(i, j); }
        int bar41(int i) {
          var func = foo4; return func(i); }
        int bar42(int i, int j) {
          var func = foo4; return func(i, j); }

StaticNativeFoo3()

static void dart::StaticNativeFoo3 ( Dart_NativeArguments  args )

static

Definition at line 8784 of file dart_api_impl_test.cc.

                   {
        static equals(a, b) {
          if (a != b) {
            throw 'not equal. expected: $a, got: $b';
          }
        }
      }

StaticNativeFoo4()

static void dart::StaticNativeFoo4 ( Dart_NativeArguments  args )

static

Definition at line 8794 of file dart_api_impl_test.cc.

STCCheck()

static TTSTestCase dart::STCCheck ( const TTSTestCase &  original )

static

Definition at line 370 of file type_testing_stubs_test.cc.

                                                         {
  return TTSTestCase(original.instance, original.instantiator_tav,
                     original.function_tav, kExistingSTCEntry);
}

StopWorkSimulator()

DART_EXPORT void dart::StopWorkSimulator

(

)

Definition at line 600 of file ffi_test_functions_vmspecific.cc.

                                     {
  SimulateWork::StopWorkSimulator();
}

StopWorkSimulator2()

DART_EXPORT void dart::StopWorkSimulator2

(

)

Definition at line 882 of file ffi_test_functions_vmspecific.cc.

                                      {
  SimulateWork2::StopWorkSimulator();
}

StoreDestination()

static Definition * dart::StoreDestination ( Value *  use )

static

Definition at line 3398 of file redundancy_elimination.cc.

                                                {
  if (auto* const alloc = use->instruction()->AsAllocation()) {
    return alloc;
  }
  if (auto* const store = use->instruction()->AsStoreField()) {
    return store->instance()->definition();
  }
  if (auto* const store = use->instruction()->AsStoreIndexed()) {
    return store->array()->definition();
  }
  return nullptr;
}

StoreError()

static MessageHandler::MessageStatus dart::StoreError ( Thread *  thread, const Error &  error  )

static

Definition at line 1482 of file isolate.cc.

                                                                    {
  thread->set_sticky_error(error);
  if (error.IsUnwindError()) {
    const UnwindError& unwind = UnwindError::Cast(error);
    if (!unwind.is_user_initiated()) {
      return MessageHandler::kShutdown;
    }
  }
  return MessageHandler::kError;
}

StoreUnaligned()

template<typename T >

static void dart::StoreUnaligned ( T *  ptr, T  value  )

inlinestatic

Definition at line 22 of file unaligned.h.

                                                   {
  memcpy(reinterpret_cast<void*>(ptr),  // NOLINT
         reinterpret_cast<const void*>(&value), sizeof(value));
}

StrengthenAlignment()

static AlignmentType dart::StrengthenAlignment ( intptr_t  cid, AlignmentType  alignment  )

static

Definition at line 6813 of file il.cc.

                                                                  {
  switch (RepresentationUtils::RepresentationOfArrayElement(cid)) {
    case kUnboxedInt8:
    case kUnboxedUint8:
      // Don't need to worry about alignment for accessing bytes.
      return kAlignedAccess;
    case kUnboxedFloat32x4:
    case kUnboxedInt32x4:
    case kUnboxedFloat64x2:
      // TODO(rmacnak): Investigate alignment requirements of floating point
      // loads.
      return kAlignedAccess;
    default:
      return alignment;
  }
}

StrictCompareSentinel()

void dart::StrictCompareSentinel	(	Thread *	thread,
		bool	negate,
		bool	non_sentinel_on_left
	)

Definition at line 289 of file constant_propagator_test.cc.

                                                      {
  const char* kScript = R"(
    late final int x = 4;
  )";
  Zone* const Z = Thread::Current()->zone();
  const auto& root_library = Library::CheckedHandle(Z, LoadTestScript(kScript));
  const auto& toplevel = Class::Handle(Z, root_library.toplevel_class());
  const auto& field_x = Field::Handle(
      Z, toplevel.LookupStaticField(String::Handle(Z, String::New("x"))));
 
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    auto v_load = builder.AddDefinition(new LoadStaticFieldInstr(
        field_x, {},
        /*calls_initializer=*/true, S.GetNextDeoptId()));
    auto v_sentinel = H.flow_graph()->GetConstant(Object::sentinel());
    Value* const left_value =
        non_sentinel_on_left ? new Value(v_load) : new Value(v_sentinel);
    Value* const right_value =
        non_sentinel_on_left ? new Value(v_sentinel) : new Value(v_load);
    auto v_compare = builder.AddDefinition(new StrictCompareInstr(
        {}, negate ? Token::kNE_STRICT : Token::kEQ_STRICT, left_value,
        right_value,
        /*needs_number_check=*/false, S.GetNextDeoptId()));
    builder.AddReturn(new Value(v_compare));
  }
 
  H.FinishGraph();
 
  FlowGraphPrinter::PrintGraph("Before TypePropagator", H.flow_graph());
  FlowGraphTypePropagator::Propagate(H.flow_graph());
  FlowGraphPrinter::PrintGraph("After TypePropagator", H.flow_graph());
  GrowableArray<BlockEntryInstr*> ignored;
  ConstantPropagator::Optimize(H.flow_graph());
  FlowGraphPrinter::PrintGraph("After ConstantPropagator", H.flow_graph());
 
  DartReturnInstr* ret = nullptr;
 
  ILMatcher cursor(H.flow_graph(),
                   H.flow_graph()->graph_entry()->normal_entry(), true);
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveFunctionEntry,
      kMatchAndMoveLoadStaticField,
      // The StrictCompare instruction should be removed.
      {kMatchDartReturn, &ret},
  }));
 
  EXPECT_PROPERTY(ret, it.value()->BindsToConstant());
  EXPECT_PROPERTY(&ret->value()->BoundConstant(), it.IsBool());
  EXPECT_PROPERTY(&ret->value()->BoundConstant(),
                  Bool::Cast(it).value() == negate);
}

String2UTF8()

static const char * dart::String2UTF8 ( const String &  str )

static

Definition at line 857 of file isolate.cc.

                                                  {
  intptr_t len = Utf8::Length(str);
  char* result = new char[len + 1];
  str.ToUTF8(reinterpret_cast<uint8_t*>(result), len);
  result[len] = 0;
 
  return result;
}

StringFrom() [1/2]

StringPtr dart::StringFrom	(	const uint16_t *	data,
		intptr_t	len,
		Heap::Space	space
	)

Definition at line 42 of file symbols.cc.

                                                                          {
  return String::FromUTF16(data, len, space);
}

StringFrom() [2/2]

StringPtr dart::StringFrom	(	const uint8_t *	data,
		intptr_t	len,
		Heap::Space	space
	)

Definition at line 38 of file symbols.cc.

                                                                         {
  return String::FromLatin1(data, len, space);
}

StringLower()

static void dart::StringLower ( char *  str )

static

Definition at line 128 of file uri.cc.

                                   {
  const intptr_t len = strlen(str);
  intptr_t i = 0;
  while (i < len) {
    int escaped_value = GetEscapedValue(str, i, len);
    if (escaped_value >= 0) {
      // Don't lowercase escape sequences.
      i += 3;
    } else {
      // I don't use tolower() because I don't want the locale
      // transforming any non-ascii characters.
      char c = str[i];
      if (c >= 'A' && c <= 'Z') {
        str[i] = c + ('a' - 'A');
      }
      i++;
    }
  }
}

StringValueAt()

static uint16_t dart::StringValueAt ( const String &  str, const Integer &  index  )

static

Definition at line 430 of file string.cc.

                                                                       {
  if (index.IsSmi()) {
    const intptr_t index_value = Smi::Cast(index).Value();
    if ((0 <= index_value) && (index_value < str.Length())) {
      return str.CharAt(index_value);
    }
  }
 
  // An index larger than Smi is always illegal.
  Exceptions::ThrowRangeError("index", index, 0, str.Length() - 1);
  return 0;
}

StripTokenPositions()

void dart::StripTokenPositions

(

char *

buffer

)

Definition at line 799 of file unit_test.cc.

                                       {
  ElideJSONSubstring(",\"tokenPos\":", buffer, buffer, ",");
  ElideJSONSubstring(",\"endTokenPos\":", buffer, buffer, "}");
}

StubEntryFor()

static const Code & dart::StubEntryFor ( const ICData &  ic_data, bool  optimized  )

static

Definition at line 1486 of file flow_graph_compiler.cc.

                                                                       {
  switch (ic_data.NumArgsTested()) {
    case 1:
      if (ic_data.is_tracking_exactness()) {
        if (optimized) {
          return StubCode::OneArgOptimizedCheckInlineCacheWithExactnessCheck();
        } else {
          return StubCode::OneArgCheckInlineCacheWithExactnessCheck();
        }
      }
      return optimized ? StubCode::OneArgOptimizedCheckInlineCache()
                       : StubCode::OneArgCheckInlineCache();
    case 2:
      ASSERT(!ic_data.is_tracking_exactness());
      return optimized ? StubCode::TwoArgsOptimizedCheckInlineCache()
                       : StubCode::TwoArgsCheckInlineCache();
    default:
      ic_data.Print();
      UNIMPLEMENTED();
      return Code::Handle();
  }
}

SubtypeChecksForClass()

static CheckType dart::SubtypeChecksForClass ( Zone *  zone, const Type &  type, const Class &  type_class, const Class &  to_check  )

static

Definition at line 474 of file type_testing_stubs.cc.

                                                              {
  ASSERT_EQUAL(type.type_class_id(), type_class.id());
  ASSERT(type_class.is_type_finalized());
  ASSERT(!to_check.is_abstract());
  ASSERT(to_check.is_type_finalized());
  ASSERT(AbstractType::Handle(zone, to_check.RareType())
             .IsSubtypeOf(AbstractType::Handle(zone, type_class.RareType()),
                          Heap::kNew));
  if (!type_class.IsGeneric()) {
    // All instances of [to_check] are subtypes of [type].
    return CheckType::kCidCheckOnly;
  }
  if (to_check.FindInstantiationOf(zone, type_class,
                                   /*only_super_classes=*/true)) {
    // No need to check for type argument consistency, as [to_check] is the same
    // as or a subclass of [type_class].
    return to_check.is_finalized()
               ? CheckType::kInstanceTypeArgumentsAreSubtypes
               : CheckType::kCannotBeChecked;
  }
  auto& calculated_type =
      Type::Handle(zone, to_check.GetInstantiationOf(zone, type_class));
  if (calculated_type.IsInstantiated()) {
    if (type.IsInstantiated()) {
      return calculated_type.IsSubtypeOf(type, Heap::kNew)
                 ? CheckType::kCidCheckOnly
                 : CheckType::kNotSubtype;
    }
    // TODO(dartbug.com/46920): Requires walking both types, checking
    // corresponding instantiated parts at compile time (assuming uninstantiated
    // parts check successfully) and then creating appropriate runtime checks
    // for uninstantiated parts of [type].
    return CheckType::kCannotBeChecked;
  }
  if (!to_check.is_finalized()) {
    return CheckType::kNeedsFinalization;
  }
  ASSERT(to_check.NumTypeArguments() > 0);
  ASSERT(compiler::target::Class::TypeArgumentsFieldOffset(to_check) !=
         compiler::target::Class::kNoTypeArguments);
  // If the calculated type arguments are a prefix of the declaration type
  // arguments, then we can just treat the instance type arguments as if they
  // were used to instantiate the type class during checking.
  const auto& decl_type_args = TypeArguments::Handle(
      zone, to_check.GetDeclarationInstanceTypeArguments());
  const auto& calculated_type_args = TypeArguments::Handle(
      zone, calculated_type.GetInstanceTypeArguments(Thread::Current(),
                                                     /*canonicalize=*/false));
  const bool type_args_consistent = calculated_type_args.IsSubvectorEquivalent(
      decl_type_args, 0, type_class.NumTypeArguments(),
      TypeEquality::kCanonical);
  // TODO(dartbug.com/46920): Currently we require subtyping to be checkable
  // by comparing the instance type arguments against the type arguments of
  // [type] piecewise, but we could check other cases as well.
  return type_args_consistent ? CheckType::kInstanceTypeArgumentsAreSubtypes
                              : CheckType::kCannotBeChecked;
}

SubtypeTestCacheCheckContents()

static void dart::SubtypeTestCacheCheckContents ( Zone *  zone, const SubtypeTestCache &  cache  )

static

Definition at line 8200 of file object_test.cc.

                                                  {
  const intptr_t kNumClasses = 100000;
  static_assert(kNumClasses > TypeArguments::Cache::kMaxLinearCacheEntries,
                "too few classes to trigger change to a hash-based cache");
  TypeArgumentsHashCacheTest(thread, kNumClasses);
}
#endif
 
#undef EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT
 
static void SubtypeTestCacheCheckContents(Zone* zone,
                                          const SubtypeTestCache& cache) {
  const intptr_t used_inputs = cache.num_inputs();
  if (used_inputs < 1 || used_inputs > SubtypeTestCache::kMaxInputs) {
    FAIL("Invalid number of used inputs: %" Pd "", used_inputs);
    return;
  }
  const auto& array = Array::Handle(zone, cache.cache());
  for (intptr_t i = 0; i < cache.NumEntries(); i++) {
    if (!cache.IsOccupied(i)) continue;
    const intptr_t entry_start = i * SubtypeTestCache::kTestEntryLength;
    {
      const intptr_t cid =
          array.At(entry_start + SubtypeTestCache::kTestResult)
              ->GetClassIdMayBeSmi();
      EXPECT(cid == kNullCid || cid == kBoolCid);
    }
 
    // Used to make sure all the cases are in the correct order below.
    int check_ordering = used_inputs;
    // Input: the value of SubtypeTestCache::Entries for this input
    // ExpectedCids is an expression where [cid] is bound to the contents cid.
#define USED_INPUT_CASE(Input, ExpectedCids)                                   \
  case (Input) + 1: {                                                          \
    RELEASE_ASSERT((Input) + 1 == check_ordering);                             \
    const intptr_t cid =                                                       \
        array.At(entry_start + (Input))->GetClassIdMayBeSmi();                 \
    if (!(ExpectedCids)) {                                                     \
      FAIL("expected: " #ExpectedCids ", got: cid %" Pd "", cid);              \
    }                                                                          \
    --check_ordering;                                                          \
  }
 
    switch (used_inputs) {
      USED_INPUT_CASE(SubtypeTestCache::kDestinationType,
                      IsConcreteTypeClassId(cid));
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstanceDelayedFunctionTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstanceParentFunctionTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kFunctionTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstantiatorTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstanceTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstanceCidOrSignature,
                      cid == kSmiCid || cid == kFunctionTypeCid);
      break;
      default:
        UNREACHABLE();
    }
 
#undef USED_INPUT_CASE
    RELEASE_ASSERT(0 == check_ordering);
 

SubtypeTestCacheEntryMatches()

static bool dart::SubtypeTestCacheEntryMatches ( const SubtypeTestCacheTable::TupleView &  t, intptr_t  num_inputs, const Object &  instance_class_id_or_signature, const AbstractType &  destination_type, const TypeArguments &  instance_type_arguments, const TypeArguments &  instantiator_type_arguments, const TypeArguments &  function_type_arguments, const TypeArguments &  instance_parent_function_type_arguments, const TypeArguments &  instance_delayed_type_arguments  )

inlinestatic

Definition at line 19116 of file object.cc.

                                                          {
  switch (num_inputs) {
    case 7:
      if (t.Get<SubtypeTestCache::kDestinationType>() !=
          destination_type.ptr()) {
        return false;
      }
      FALL_THROUGH;
    case 6:
      if (t.Get<SubtypeTestCache::kInstanceDelayedFunctionTypeArguments>() !=
          instance_delayed_type_arguments.ptr()) {
        return false;
      }
      FALL_THROUGH;
    case 5:
      if (t.Get<SubtypeTestCache::kInstanceParentFunctionTypeArguments>() !=
          instance_parent_function_type_arguments.ptr()) {
        return false;
      }
      FALL_THROUGH;
    case 4:
      if (t.Get<SubtypeTestCache::kFunctionTypeArguments>() !=
          function_type_arguments.ptr()) {
        return false;
      }
      FALL_THROUGH;
    case 3:
      if (t.Get<SubtypeTestCache::kInstantiatorTypeArguments>() !=
          instantiator_type_arguments.ptr()) {
        return false;
      }
      FALL_THROUGH;
    case 2:
      if (t.Get<SubtypeTestCache::kInstanceTypeArguments>() !=
          instance_type_arguments.ptr()) {
        return false;
      }
      FALL_THROUGH;
    case 1:
      // We don't need to perform load-acquire semantics when re-retrieving
      // the kInstanceCidOrSignature field, as this is performed only if the
      // entry is occupied, and occupied entries never change.
      return t.Get<SubtypeTestCache::kInstanceCidOrSignature>() ==
             instance_class_id_or_signature.ptr();
    default:
      UNREACHABLE();
  }
}

SubtypeTestCacheEntryTest()

static void dart::SubtypeTestCacheEntryTest ( Thread *  thread, const SubtypeTestCache &  cache, const Object &  instance_class_id_or_signature, const AbstractType &  destination_type, const TypeArguments &  instance_type_arguments, const TypeArguments &  instantiator_type_arguments, const TypeArguments &  function_type_arguments, const TypeArguments &  parent_function_type_arguments, const TypeArguments &  delayed_type_arguments, const Bool &  expected_result, Bool *  got_result  )

static

Definition at line 8274 of file object_test.cc.

                                                                        {
      // Since we sometimes use Array::NewUninitialized() for allocations of
      // STCs and never set unused inputs, the only thing we know is that the
      // entry is GC-safe. Since we don't expect valid values for unused inputs,
      // we just check if it's either a Smi or null.
      const intptr_t cid = array.At(entry_start + i)->GetClassIdMayBeSmi();
      EXPECT(cid == kSmiCid || cid == kNullCid);
    }
  }
}
 
static void SubtypeTestCacheEntryTest(
    Thread* thread,
    const SubtypeTestCache& cache,
    const Object& instance_class_id_or_signature,
    const AbstractType& destination_type,
    const TypeArguments& instance_type_arguments,
    const TypeArguments& instantiator_type_arguments,
    const TypeArguments& function_type_arguments,
    const TypeArguments& parent_function_type_arguments,
    const TypeArguments& delayed_type_arguments,
    const Bool& expected_result,
    Bool* got_result) {
  const auto& tav_null = TypeArguments::null_type_arguments();
  const intptr_t num_inputs = cache.num_inputs();
  const bool was_hash = cache.IsHash();
  const intptr_t old_count = cache.NumberOfChecks();
  intptr_t expected_index, got_index;
 
  EXPECT(!cache.HasCheck(
      instance_class_id_or_signature, destination_type, instance_type_arguments,
      instantiator_type_arguments, function_type_arguments,
      parent_function_type_arguments, delayed_type_arguments, /*index=*/nullptr,
      /*result=*/nullptr));
  {
    SafepointMutexLocker ml(
        thread->isolate_group()->subtype_test_cache_mutex());
    expected_index =
        cache.AddCheck(instance_class_id_or_signature, destination_type,
                       instance_type_arguments, instantiator_type_arguments,
                       function_type_arguments, parent_function_type_arguments,
                       delayed_type_arguments, expected_result);
    EXPECT(expected_index >= 0);
  }
  EXPECT_EQ(old_count + 1, cache.NumberOfChecks());
  EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                        instance_type_arguments, instantiator_type_arguments,
                        function_type_arguments, parent_function_type_arguments,
                        delayed_type_arguments, &got_index, got_result));
  EXPECT_EQ(expected_index, got_index);
  EXPECT(got_result->ptr() == expected_result.ptr());
  if (num_inputs < (SubtypeTestCache::kInstanceTypeArguments + 1)) {
    // Match replacing unused instance type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          tav_null, instantiator_type_arguments,
                          function_type_arguments,
                          parent_function_type_arguments,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used instance type arguments with null.
    EXPECT(!cache.HasCheck(
        instance_class_id_or_signature, destination_type, tav_null,
        instantiator_type_arguments, function_type_arguments,
        parent_function_type_arguments, delayed_type_arguments,
        /*index=*/nullptr, /*result=*/nullptr));
  }
  if (num_inputs < (SubtypeTestCache::kInstantiatorTypeArguments + 1)) {
    // Match replacing unused instantiator type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          instance_type_arguments, tav_null,
                          function_type_arguments,
                          parent_function_type_arguments,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used instantiator type arguments with null.
    EXPECT(!cache.HasCheck(
        instance_class_id_or_signature, destination_type,
        instance_type_arguments, tav_null, function_type_arguments,
        parent_function_type_arguments, delayed_type_arguments,
        /*index=*/nullptr, /*result=*/nullptr));
  }
  if (num_inputs < (SubtypeTestCache::kFunctionTypeArguments + 1)) {
    // Match replacing unused function type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          instance_type_arguments, instantiator_type_arguments,
                          tav_null, parent_function_type_arguments,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used function type arguments with null.
    EXPECT(!cache.HasCheck(instance_class_id_or_signature, destination_type,
                           instance_type_arguments, instantiator_type_arguments,
                           tav_null, parent_function_type_arguments,
                           delayed_type_arguments,
                           /*index=*/nullptr, /*result=*/nullptr));
  }
  if (num_inputs <
      (SubtypeTestCache::kInstanceParentFunctionTypeArguments + 1)) {
    // Match replacing unused parent function type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          instance_type_arguments, instantiator_type_arguments,
                          function_type_arguments, tav_null,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used parent function type arguments with null.
    EXPECT(!cache.HasCheck(instance_class_id_or_signature, destination_type,
                           instance_type_arguments, instantiator_type_arguments,
                           function_type_arguments, tav_null,
                           delayed_type_arguments, /*index=*/nullptr,
                           /*result=*/nullptr));
  }
  if (num_inputs <
      (SubtypeTestCache::kInstanceDelayedFunctionTypeArguments + 1)) {
    // Match replacing unused delayed type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          instance_type_arguments, instantiator_type_arguments,
                          function_type_arguments,
                          parent_function_type_arguments, tav_null, &got_index,
                          got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used delayed type arguments with null.
    EXPECT(!cache.HasCheck(instance_class_id_or_signature, destination_type,
                           instance_type_arguments, instantiator_type_arguments,
                           function_type_arguments,
                           parent_function_type_arguments, tav_null,
                           /*index=*/nullptr, /*result=*/nullptr));
  }
  // Make sure we're not accidentally using the same type as the input below.
  RELEASE_ASSERT(destination_type.ptr() != Type::VoidType());
  if (num_inputs < (SubtypeTestCache::kDestinationType + 1)) {
    // Match replacing unused destination type argument with the null type.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, Object::void_type(),
                          instance_type_arguments, instantiator_type_arguments,
                          function_type_arguments,
                          parent_function_type_arguments,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {

SubtypeTestCacheTest()

static void dart::SubtypeTestCacheTest ( Thread *  thread, intptr_t  num_classes, bool  expect_hash  )

static

Definition at line 8423 of file object_test.cc.

                                                   {
  TextBuffer buffer(MB);
  buffer.AddString("class D {}\n");
  buffer.AddString("D createInstanceD() => D();");
  buffer.AddString("D Function() createClosureD() => () => D();\n");
  for (intptr_t i = 0; i < num_classes; i++) {
    buffer.Printf(R"(class C%)" Pd R"( extends D {}
)"
                  R"(C%)" Pd R"( createInstanceC%)" Pd R"(() => C%)" Pd
                  R"(();
)"
                  R"(C%)" Pd R"( Function() createClosureC%)" Pd
                  R"(() => () => C%)" Pd
                  R"(();
)",
                  i, i, i, i, i, i, i);
  }
 
  Dart_Handle api_lib = TestCase::LoadTestScript(buffer.buffer(), nullptr);
  EXPECT_VALID(api_lib);
 
  // D + C0...CN, where N = kNumClasses - 1
  EXPECT(IsolateGroup::Current()->class_table()->NumCids() > num_classes);
 
  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();
 
  const auto& root_lib =
      Library::CheckedHandle(zone, Api::UnwrapHandle(api_lib));
  EXPECT(!root_lib.IsNull());
 
  const auto& class_d = Class::Handle(zone, GetClass(root_lib, "D"));
  ASSERT(!class_d.IsNull());
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    ClassFinalizer::FinalizeClass(class_d);
  }
  const auto& instance_d =
      Instance::CheckedHandle(zone, Invoke(root_lib, "createInstanceD"));
  auto& type_instance_d_int =
      Type::CheckedHandle(zone, instance_d.GetType(Heap::kNew));
  const auto& closure_d =
      Instance::CheckedHandle(zone, Invoke(root_lib, "createClosureD"));
  ASSERT(!closure_d.IsNull());
  auto& type_closure_d_int =
      FunctionType::CheckedHandle(zone, closure_d.GetType(Heap::kNew));
 
  // Test all the possible input values.
  const SubtypeTestCache* stcs[SubtypeTestCache::kMaxInputs];
  for (intptr_t i = 0; i < SubtypeTestCache::kMaxInputs; i++) {
    stcs[i] = &SubtypeTestCache::Handle(zone, SubtypeTestCache::New(i + 1));
  }
 
  auto& class_c = Class::Handle(zone);
  auto& instance_c = Instance::Handle(zone);
  auto& closure_c = Closure::Handle(zone);
  auto& instance_class_id_or_signature = Object::Handle(zone);
  // Set up unique tavs for each of the TAV inputs.
  auto& instance_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  instance_type_arguments.SetTypeAt(0, Type::Handle(zone, Type::SmiType()));
  instance_type_arguments = instance_type_arguments.Canonicalize(thread);
  auto& instantiator_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  instantiator_type_arguments.SetTypeAt(0, Type::Handle(zone, Type::IntType()));
  instantiator_type_arguments =
      instantiator_type_arguments.Canonicalize(thread);
  auto& function_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  function_type_arguments.SetTypeAt(0, Type::Handle(zone, Type::Double()));
  function_type_arguments = function_type_arguments.Canonicalize(thread);
  auto& parent_function_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  parent_function_type_arguments.SetTypeAt(
      0, Type::Handle(zone, Type::StringType()));
  parent_function_type_arguments =
      parent_function_type_arguments.Canonicalize(thread);
  auto& delayed_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  delayed_type_arguments.SetTypeAt(0, Type::Handle(zone, Type::BoolType()));
  delayed_type_arguments = delayed_type_arguments.Canonicalize(thread);
  auto& got_result = Bool::Handle(zone);
  for (intptr_t i = 0; i < num_classes; ++i) {
    // Just so we're testing both true and false values, as we're not actually
    // using the results to determine subtype/assignability.
    const auto& expected_result = (i % 2 == 0) ? Bool::True() : Bool::False();
 
    auto const class_name = OS::SCreate(zone, "C%" Pd "", i);
    class_c = GetClass(root_lib, class_name);
    ASSERT(!class_c.IsNull());
    {
      SafepointWriteRwLocker ml(thread,
                                thread->isolate_group()->program_lock());
      ClassFinalizer::FinalizeClass(class_c);
    }
    auto const instance_name = OS::SCreate(zone, "createInstanceC%" Pd "", i);
    instance_c ^= Invoke(root_lib, instance_name);
    EXPECT(!instance_c.IsClosure());
    instance_class_id_or_signature = Smi::New(instance_c.GetClassId());
 
    for (intptr_t i = 0; i < 5; i++) {
      SubtypeTestCacheEntryTest(
          thread, *stcs[i], instance_class_id_or_signature, type_instance_d_int,
          instance_type_arguments, instantiator_type_arguments,
          function_type_arguments, parent_function_type_arguments,
          delayed_type_arguments, expected_result, &got_result);
    }
 
    auto const function_name = OS::SCreate(zone, "createClosureC%" Pd "", i);
    closure_c ^= Invoke(root_lib, function_name);
 
    instance_class_id_or_signature = closure_c.function();
    instance_class_id_or_signature =
        Function::Cast(instance_class_id_or_signature).signature();
 

SumFloatsAndDoubles()

DART_EXPORT double dart::SumFloatsAndDoubles	(	float	a,
		double	b,
		float	c
	)

Definition at line 315 of file ffi_test_functions.cc.

                                                                   {
  std::cout << "SumFloatsAndDoubles(" << a << ", " << b << ", " << c << ")\n";
  const double retval = a + b + c;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumManyDoubles()

DART_EXPORT double dart::SumManyDoubles	(	double	a,
		double	b,
		double	c,
		double	d,
		double	e,
		double	f,
		double	g,
		double	h,
		double	i,
		double	j
	)

Definition at line 484 of file ffi_test_functions.cc.

                                            {
  std::cout << "SumManyDoubles(" << a << ", " << b << ", " << c << ", " << d
            << ", " << e << ", " << f << ", " << g << ", " << h << ", " << i
            << ", " << j << ")\n";
  const double retval = a + b + c + d + e + f + g + h + i + j;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumManyInts()

DART_EXPORT intptr_t dart::SumManyInts	(	intptr_t	a,
		intptr_t	b,
		intptr_t	c,
		intptr_t	d,
		intptr_t	e,
		intptr_t	f,
		intptr_t	g,
		intptr_t	h,
		intptr_t	i,
		intptr_t	j
	)

Definition at line 274 of file ffi_test_functions.cc.

                                             {
  std::cout << "SumManyInts(" << a << ", " << b << ", " << c << ", " << d
            << ", " << e << ", " << f << ", " << g << ", " << h << ", " << i
            << ", " << j << ")\n";
  const intptr_t retval = a + b + c + d + e + f + g + h + i + j;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumManyIntsOdd()

DART_EXPORT intptr_t dart::SumManyIntsOdd	(	intptr_t	a,
		intptr_t	b,
		intptr_t	c,
		intptr_t	d,
		intptr_t	e,
		intptr_t	f,
		intptr_t	g,
		intptr_t	h,
		intptr_t	i,
		intptr_t	j,
		intptr_t	k
	)

Definition at line 456 of file ffi_test_functions.cc.

                                                {
  std::cout << "SumManyInts(" << a << ", " << b << ", " << c << ", " << d
            << ", " << e << ", " << f << ", " << g << ", " << h << ", " << i
            << ", " << j << ", " << k << ")\n";
  const intptr_t retval =
      static_cast<uintptr_t>(a) + static_cast<uintptr_t>(b) +
      static_cast<uintptr_t>(c) + static_cast<uintptr_t>(d) +
      static_cast<uintptr_t>(e) + static_cast<uintptr_t>(f) +
      static_cast<uintptr_t>(g) + static_cast<uintptr_t>(h) +
      static_cast<uintptr_t>(i) + static_cast<uintptr_t>(j) +
      static_cast<uintptr_t>(k);
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumManyNumbers()

DART_EXPORT double dart::SumManyNumbers	(	intptr_t	a,
		float	b,
		intptr_t	c,
		double	d,
		intptr_t	e,
		float	f,
		intptr_t	g,
		double	h,
		intptr_t	i,
		float	j,
		intptr_t	k,
		double	l,
		intptr_t	m,
		float	n,
		intptr_t	o,
		double	p,
		intptr_t	q,
		float	r,
		intptr_t	s,
		double	t
	)

Definition at line 505 of file ffi_test_functions.cc.

                                            {
  std::cout << "SumManyNumbers(" << a << ", " << b << ", " << c << ", " << d
            << ", " << e << ", " << f << ", " << g << ", " << h << ", " << i
            << ", " << j << ", " << k << ", " << l << ", " << m << ", " << n
            << ", " << o << ", " << p << ", " << q << ", " << r << ", " << s
            << ", " << t << ")\n";
  const double retval = a + b + c + d + e + f + g + h + i + j + k + l + m + n +
                        o + p + q + r + s + t;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumManySmallInts()

DART_EXPORT int16_t dart::SumManySmallInts	(	int8_t	a,
		int16_t	b,
		int8_t	c,
		int16_t	d,
		int8_t	e,
		int16_t	f,
		int8_t	g,
		int16_t	h,
		int8_t	i,
		int16_t	j
	)

Definition at line 295 of file ffi_test_functions.cc.

                                                {
  std::cout << "SumManySmallInts(" << static_cast<int>(a) << ", " << b << ", "
            << static_cast<int>(c) << ", " << d << ", " << static_cast<int>(e)
            << ", " << f << ", " << static_cast<int>(g) << ", " << h << ", "
            << static_cast<int>(i) << ", " << j << ")\n";
  const int16_t retval = a + b + c + d + e + f + g + h + i + j;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumPlus42()

DART_EXPORT int32_t dart::SumPlus42	(	int32_t	a,
		int32_t	b
	)

Definition at line 71 of file ffi_test_functions.cc.

                                                    {
  std::cout << "SumPlus42(" << a << ", " << b << ")\n";
  const int32_t retval = 42 + a + b;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumReturnStruct9Uint8()

DART_EXPORT int64_t dart::SumReturnStruct9Uint8	(	Struct9Uint8(*)(Struct9Uint8 *)	callback,
		Struct9Uint8 *	in
	)

Definition at line 736 of file ffi_test_functions.cc.

                                        {
  std::cout << "SumReturnStruct9Uint8 in (" << in->a0 << ", " << in->a1 << ", "
            << in->a2 << ", " << in->a3 << ", " << in->a4 << ", " << in->a5
            << ", " << in->a6 << ", " << in->a7 << ", " << in->a8 << ")\n";
 
  Struct9Uint8 out = callback(in);
 
  std::cout << "SumReturnStruct9Uint8 out (" << out.a0 << ", " << out.a1 << ", "
            << out.a2 << ", " << out.a3 << ", " << out.a4 << ", " << out.a5
            << ", " << out.a6 << ", " << out.a7 << ", " << out.a8 << ")\n";
 
  return out.a0 + out.a1 + out.a2 + out.a3 + out.a4 + out.a5 + out.a6 + out.a7 +
         out.a8;
}

SumSmallNumbers()

DART_EXPORT int64_t dart::SumSmallNumbers	(	int8_t	a,
		int16_t	b,
		int32_t	c,
		uint8_t	d,
		uint16_t	e,
		uint32_t	f
	)

Definition at line 792 of file ffi_test_functions.cc.

                                                {
  std::cout << "SumSmallNumbers(" << static_cast<int>(a) << ", " << b << ", "
            << c << ", " << static_cast<int>(d) << ", " << e << ", " << f
            << ")\n";
  int64_t retval = 0;
  retval += a;
  retval += b;
  retval += c;
  retval += d;
  retval += e;
  retval += f;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumStruct9Uint8()

DART_EXPORT int64_t dart::SumStruct9Uint8

(

Struct9Uint8

s9

)

Definition at line 731 of file ffi_test_functions.cc.

                                                     {
  return s9.a0 + s9.a1 + s9.a2 + s9.a3 + s9.a4 + s9.a5 + s9.a6 + s9.a7 + s9.a8;
}

SumVeryLargeStruct()

DART_EXPORT int64_t dart::SumVeryLargeStruct

(

VeryLargeStruct *

vls

)

Definition at line 653 of file ffi_test_functions.cc.

                                                             {
  std::cout << "SumVeryLargeStruct(" << vls << ")\n";
  std::cout << "offsetof(a): " << offsetof(VeryLargeStruct, a) << "\n";
  std::cout << "offsetof(b): " << offsetof(VeryLargeStruct, b) << "\n";
  std::cout << "offsetof(c): " << offsetof(VeryLargeStruct, c) << "\n";
  std::cout << "offsetof(d): " << offsetof(VeryLargeStruct, d) << "\n";
  std::cout << "offsetof(e): " << offsetof(VeryLargeStruct, e) << "\n";
  std::cout << "offsetof(f): " << offsetof(VeryLargeStruct, f) << "\n";
  std::cout << "offsetof(g): " << offsetof(VeryLargeStruct, g) << "\n";
  std::cout << "offsetof(h): " << offsetof(VeryLargeStruct, h) << "\n";
  std::cout << "offsetof(i): " << offsetof(VeryLargeStruct, i) << "\n";
  std::cout << "offsetof(j): " << offsetof(VeryLargeStruct, j) << "\n";
  std::cout << "offsetof(k): " << offsetof(VeryLargeStruct, k) << "\n";
  std::cout << "offsetof(parent): " << offsetof(VeryLargeStruct, parent)
            << "\n";
  std::cout << "offsetof(numChildren): "
            << offsetof(VeryLargeStruct, numChildren) << "\n";
  std::cout << "offsetof(children): " << offsetof(VeryLargeStruct, children)
            << "\n";
  std::cout << "offsetof(smallLastField): "
            << offsetof(VeryLargeStruct, smallLastField) << "\n";
  std::cout << "sizeof(VeryLargeStruct): " << sizeof(VeryLargeStruct) << "\n";
 
  std::cout << "vls->a: " << static_cast<int>(vls->a) << "\n";
  std::cout << "vls->b: " << vls->b << "\n";
  std::cout << "vls->c: " << vls->c << "\n";
  std::cout << "vls->d: " << vls->d << "\n";
  std::cout << "vls->e: " << static_cast<int>(vls->e) << "\n";
  std::cout << "vls->f: " << vls->f << "\n";
  std::cout << "vls->g: " << vls->g << "\n";
  std::cout << "vls->h: " << vls->h << "\n";
  std::cout << "vls->i: " << vls->i << "\n";
  std::cout << "vls->j: " << vls->j << "\n";
  std::cout << "vls->k: " << vls->k << "\n";
  std::cout << "vls->parent: " << vls->parent << "\n";
  std::cout << "vls->numChildren: " << vls->numChildren << "\n";
  std::cout << "vls->children: " << vls->children << "\n";
  std::cout << "vls->smallLastField: " << static_cast<int>(vls->smallLastField)
            << "\n";
 
  int64_t retval = 0;
  retval += 0x0L + vls->a;
  retval += vls->b;
  retval += vls->c;
  retval += vls->d;
  retval += vls->e;
  retval += vls->f;
  retval += vls->g;
  retval += vls->h;
  retval += vls->i;
  retval += vls->j;
  retval += vls->k;
  retval += vls->smallLastField;
  std::cout << retval << "\n";
  if (vls->parent != nullptr) {
    std::cout << "has parent\n";
    retval += vls->parent->a;
  }
  std::cout << "has " << vls->numChildren << " children\n";
  for (intptr_t i = 0; i < vls->numChildren; i++) {
    retval += vls->children[i].a;
  }
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumVeryManyFloatsDoubles()

DART_EXPORT double dart::SumVeryManyFloatsDoubles	(	float	a01,
		double	a02,
		float	a03,
		double	a04,
		float	a05,
		double	a06,
		float	a07,
		double	a08,
		float	a09,
		double	a10,
		float	a11,
		double	a12,
		float	a13,
		double	a14,
		float	a15,
		double	a16,
		float	a17,
		double	a18,
		float	a19,
		double	a20,
		float	a21,
		double	a22,
		float	a23,
		double	a24,
		float	a25,
		double	a26,
		float	a27,
		double	a28,
		float	a29,
		double	a30,
		float	a31,
		double	a32,
		float	a33,
		double	a34,
		float	a35,
		double	a36,
		float	a37,
		double	a38,
		float	a39,
		double	a40
	)

Definition at line 394 of file ffi_test_functions.cc.

                                                        {
  std::cout << "SumVeryManyFloatsDoubles(" << a01 << ", " << a02 << ", " << a03
            << ", " << a04 << ", " << a05 << ", " << a06 << ", " << a07 << ", "
            << a08 << ", " << a09 << ", " << a10 << ", " << a11 << ", " << a12
            << ", " << a13 << ", " << a14 << ", " << a15 << ", " << a16 << ", "
            << a17 << ", " << a18 << ", " << a19 << ", " << a20 << ", " << a21
            << ", " << a22 << ", " << a23 << ", " << a24 << ", " << a25 << ", "
            << a26 << ", " << a27 << ", " << a28 << ", " << a29 << ", " << a30
            << ", " << a31 << ", " << a32 << ", " << a33 << ", " << a34 << ", "
            << a35 << ", " << a36 << ", " << a37 << ", " << a38 << ", " << a39
            << ", " << a40 << ")\n";
  const double retval = a01 + a02 + a03 + a04 + a05 + a06 + a07 + a08 + a09 +
                        a10 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 +
                        a19 + a20 + a21 + a22 + a23 + a24 + a25 + a26 + a27 +
                        a28 + a29 + a30 + a31 + a32 + a33 + a34 + a35 + a36 +
                        a37 + a38 + a39 + a40;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SumVeryManySmallInts()

DART_EXPORT int16_t dart::SumVeryManySmallInts	(	int8_t	a01,
		int16_t	a02,
		int8_t	a03,
		int16_t	a04,
		int8_t	a05,
		int16_t	a06,
		int8_t	a07,
		int16_t	a08,
		int8_t	a09,
		int16_t	a10,
		int8_t	a11,
		int16_t	a12,
		int8_t	a13,
		int16_t	a14,
		int8_t	a15,
		int16_t	a16,
		int8_t	a17,
		int16_t	a18,
		int8_t	a19,
		int16_t	a20,
		int8_t	a21,
		int16_t	a22,
		int8_t	a23,
		int16_t	a24,
		int8_t	a25,
		int16_t	a26,
		int8_t	a27,
		int16_t	a28,
		int8_t	a29,
		int16_t	a30,
		int8_t	a31,
		int16_t	a32,
		int8_t	a33,
		int16_t	a34,
		int8_t	a35,
		int16_t	a36,
		int8_t	a37,
		int16_t	a38,
		int8_t	a39,
		int16_t	a40
	)

Definition at line 323 of file ffi_test_functions.cc.

                                                      {
  std::cout << "SumVeryManySmallInts(" << static_cast<int>(a01) << ", " << a02
            << ", " << static_cast<int>(a03) << ", " << a04 << ", "
            << static_cast<int>(a05) << ", " << a06 << ", "
            << static_cast<int>(a07) << ", " << a08 << ", "
            << static_cast<int>(a09) << ", " << a10 << ", "
            << static_cast<int>(a11) << ", " << a12 << ", "
            << static_cast<int>(a13) << ", " << a14 << ", "
            << static_cast<int>(a15) << ", " << a16 << ", "
            << static_cast<int>(a17) << ", " << a18 << ", "
            << static_cast<int>(a19) << ", " << a20 << ", "
            << static_cast<int>(a21) << ", " << a22 << ", "
            << static_cast<int>(a23) << ", " << a24 << ", "
            << static_cast<int>(a25) << ", " << a26 << ", "
            << static_cast<int>(a27) << ", " << a28 << ", "
            << static_cast<int>(a29) << ", " << a30 << ", "
            << static_cast<int>(a31) << ", " << a32 << ", "
            << static_cast<int>(a33) << ", " << a34 << ", "
            << static_cast<int>(a35) << ", " << a36 << ", "
            << static_cast<int>(a37) << ", " << a38 << ", "
            << static_cast<int>(a39) << ", " << a40 << ")\n";
  const int16_t retval = a01 + a02 + a03 + a04 + a05 + a06 + a07 + a08 + a09 +
                         a10 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 +
                         a19 + a20 + a21 + a22 + a23 + a24 + a25 + a26 + a27 +
                         a28 + a29 + a30 + a31 + a32 + a33 + a34 + a35 + a36 +
                         a37 + a38 + a39 + a40;
  std::cout << "returning " << retval << "\n";
  return retval;
}

SymbolExists()

static bool dart::SymbolExists ( void *  handle, const char *  symbol  )

static

Definition at line 145 of file ffi_dynamic_library.cc.

                                                           {
  char* error = nullptr;
#if !defined(DART_HOST_OS_WINDOWS)
  Utils::ResolveSymbolInDynamicLibrary(handle, symbol, &error);
#else
  if (handle == nullptr) {
    LookupSymbolInProcess(symbol, &error);
  } else {
    Utils::ResolveSymbolInDynamicLibrary(handle, symbol, &error);
  }
#endif
  if (error != nullptr) {
    free(error);
    return false;
  }
  return true;
}

TagsFromUntaggedObject()

DART_FORCE_INLINE uword dart::TagsFromUntaggedObject

(

UntaggedObject *

obj

)

Definition at line 224 of file object_graph_copy.cc.

                                                  {
  return obj->tags_;
}

TakeBoolPointer()

DART_EXPORT bool dart::TakeBoolPointer	(	bool *	data,
		size_t	length
	)

Definition at line 810 of file ffi_test_functions_generated_2.cc.

                                                            {
  bool result = false;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << static_cast<int>(data[i]) << "\n";
    result ^= static_cast<int>(data[i]);
  }
  return result;
}

TakeBoolPointerMany()

DART_EXPORT bool dart::TakeBoolPointerMany	(	bool *	data0,
		bool *	data1,
		bool *	data2,
		bool *	data3,
		bool *	data4,
		bool *	data5,
		bool *	data6,
		bool *	data7,
		bool *	data8,
		bool *	data9,
		bool *	data10,
		bool *	data11,
		bool *	data12,
		bool *	data13,
		bool *	data14,
		bool *	data15,
		bool *	data16,
		bool *	data17,
		bool *	data18,
		bool *	data19
	)

Definition at line 823 of file ffi_test_functions_generated_2.cc.

                                                   {
  bool result = false;
  std::cout << "data0[0] = " << static_cast<int>(data0[0]) << "\n";
  result ^= static_cast<int>(data0[0]);
  std::cout << "data1[0] = " << static_cast<int>(data1[0]) << "\n";
  result ^= static_cast<int>(data1[0]);
  std::cout << "data2[0] = " << static_cast<int>(data2[0]) << "\n";
  result ^= static_cast<int>(data2[0]);
  std::cout << "data3[0] = " << static_cast<int>(data3[0]) << "\n";
  result ^= static_cast<int>(data3[0]);
  std::cout << "data4[0] = " << static_cast<int>(data4[0]) << "\n";
  result ^= static_cast<int>(data4[0]);
  std::cout << "data5[0] = " << static_cast<int>(data5[0]) << "\n";
  result ^= static_cast<int>(data5[0]);
  std::cout << "data6[0] = " << static_cast<int>(data6[0]) << "\n";
  result ^= static_cast<int>(data6[0]);
  std::cout << "data7[0] = " << static_cast<int>(data7[0]) << "\n";
  result ^= static_cast<int>(data7[0]);
  std::cout << "data8[0] = " << static_cast<int>(data8[0]) << "\n";
  result ^= static_cast<int>(data8[0]);
  std::cout << "data9[0] = " << static_cast<int>(data9[0]) << "\n";
  result ^= static_cast<int>(data9[0]);
  std::cout << "data10[0] = " << static_cast<int>(data10[0]) << "\n";
  result ^= static_cast<int>(data10[0]);
  std::cout << "data11[0] = " << static_cast<int>(data11[0]) << "\n";
  result ^= static_cast<int>(data11[0]);
  std::cout << "data12[0] = " << static_cast<int>(data12[0]) << "\n";
  result ^= static_cast<int>(data12[0]);
  std::cout << "data13[0] = " << static_cast<int>(data13[0]) << "\n";
  result ^= static_cast<int>(data13[0]);
  std::cout << "data14[0] = " << static_cast<int>(data14[0]) << "\n";
  result ^= static_cast<int>(data14[0]);
  std::cout << "data15[0] = " << static_cast<int>(data15[0]) << "\n";
  result ^= static_cast<int>(data15[0]);
  std::cout << "data16[0] = " << static_cast<int>(data16[0]) << "\n";
  result ^= static_cast<int>(data16[0]);
  std::cout << "data17[0] = " << static_cast<int>(data17[0]) << "\n";
  result ^= static_cast<int>(data17[0]);
  std::cout << "data18[0] = " << static_cast<int>(data18[0]) << "\n";
  result ^= static_cast<int>(data18[0]);
  std::cout << "data19[0] = " << static_cast<int>(data19[0]) << "\n";
  result ^= static_cast<int>(data19[0]);
  return result;
}

TakeDartVmNode()

std::unique_ptr< inspect::Node > dart::TakeDartVmNode

(

)

TakeDoublePointer()

DART_EXPORT double dart::TakeDoublePointer	(	double *	data,
		size_t	length
	)

Definition at line 733 of file ffi_test_functions_generated_2.cc.

                                                                  {
  double result = 0.0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << data[i] << "\n";
    result += data[i];
  }
  return result;
}

TakeDoublePointerMany()

DART_EXPORT double dart::TakeDoublePointerMany	(	double *	data0,
		double *	data1,
		double *	data2,
		double *	data3,
		double *	data4,
		double *	data5,
		double *	data6,
		double *	data7,
		double *	data8,
		double *	data9,
		double *	data10,
		double *	data11,
		double *	data12,
		double *	data13,
		double *	data14,
		double *	data15,
		double *	data16,
		double *	data17,
		double *	data18,
		double *	data19
	)

Definition at line 746 of file ffi_test_functions_generated_2.cc.

                                                         {
  double result = 0.0;
  std::cout << "data0[0] = " << data0[0] << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << data1[0] << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << data2[0] << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << data3[0] << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << data4[0] << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << data5[0] << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << data6[0] << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << data7[0] << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << data8[0] << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << data9[0] << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << data10[0] << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << data11[0] << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << data12[0] << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << data13[0] << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << data14[0] << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << data15[0] << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << data16[0] << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << data17[0] << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << data18[0] << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << data19[0] << "\n";
  result += data19[0];
  return result;
}

TakeFloatPointer()

DART_EXPORT float dart::TakeFloatPointer	(	float *	data,
		size_t	length
	)

Definition at line 656 of file ffi_test_functions_generated_2.cc.

                                                               {
  float result = 0.0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << data[i] << "\n";
    result += data[i];
  }
  return result;
}

TakeFloatPointerMany()

DART_EXPORT float dart::TakeFloatPointerMany	(	float *	data0,
		float *	data1,
		float *	data2,
		float *	data3,
		float *	data4,
		float *	data5,
		float *	data6,
		float *	data7,
		float *	data8,
		float *	data9,
		float *	data10,
		float *	data11,
		float *	data12,
		float *	data13,
		float *	data14,
		float *	data15,
		float *	data16,
		float *	data17,
		float *	data18,
		float *	data19
	)

Definition at line 669 of file ffi_test_functions_generated_2.cc.

                                                      {
  float result = 0.0;
  std::cout << "data0[0] = " << data0[0] << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << data1[0] << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << data2[0] << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << data3[0] << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << data4[0] << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << data5[0] << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << data6[0] << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << data7[0] << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << data8[0] << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << data9[0] << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << data10[0] << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << data11[0] << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << data12[0] << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << data13[0] << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << data14[0] << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << data15[0] << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << data16[0] << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << data17[0] << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << data18[0] << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << data19[0] << "\n";
  result += data19[0];
  return result;
}

TakeInt16Pointer()

DART_EXPORT int16_t dart::TakeInt16Pointer	(	int16_t *	data,
		size_t	length
	)

Definition at line 117 of file ffi_test_functions_generated_2.cc.

                                                                   {
  int16_t result = 0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << data[i] << "\n";
    result += data[i];
  }
  return result;
}

TakeInt16PointerMany()

DART_EXPORT int16_t dart::TakeInt16PointerMany	(	int16_t *	data0,
		int16_t *	data1,
		int16_t *	data2,
		int16_t *	data3,
		int16_t *	data4,
		int16_t *	data5,
		int16_t *	data6,
		int16_t *	data7,
		int16_t *	data8,
		int16_t *	data9,
		int16_t *	data10,
		int16_t *	data11,
		int16_t *	data12,
		int16_t *	data13,
		int16_t *	data14,
		int16_t *	data15,
		int16_t *	data16,
		int16_t *	data17,
		int16_t *	data18,
		int16_t *	data19
	)

Definition at line 130 of file ffi_test_functions_generated_2.cc.

                                                          {
  int16_t result = 0;
  std::cout << "data0[0] = " << data0[0] << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << data1[0] << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << data2[0] << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << data3[0] << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << data4[0] << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << data5[0] << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << data6[0] << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << data7[0] << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << data8[0] << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << data9[0] << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << data10[0] << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << data11[0] << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << data12[0] << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << data13[0] << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << data14[0] << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << data15[0] << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << data16[0] << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << data17[0] << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << data18[0] << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << data19[0] << "\n";
  result += data19[0];
  return result;
}

TakeInt32Pointer()

DART_EXPORT int32_t dart::TakeInt32Pointer	(	int32_t *	data,
		size_t	length
	)

Definition at line 194 of file ffi_test_functions_generated_2.cc.

                                                                   {
  int32_t result = 0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << data[i] << "\n";
    result += data[i];
  }
  return result;
}

TakeInt32PointerMany()

DART_EXPORT int32_t dart::TakeInt32PointerMany	(	int32_t *	data0,
		int32_t *	data1,
		int32_t *	data2,
		int32_t *	data3,
		int32_t *	data4,
		int32_t *	data5,
		int32_t *	data6,
		int32_t *	data7,
		int32_t *	data8,
		int32_t *	data9,
		int32_t *	data10,
		int32_t *	data11,
		int32_t *	data12,
		int32_t *	data13,
		int32_t *	data14,
		int32_t *	data15,
		int32_t *	data16,
		int32_t *	data17,
		int32_t *	data18,
		int32_t *	data19
	)

Definition at line 207 of file ffi_test_functions_generated_2.cc.

                                                          {
  int32_t result = 0;
  std::cout << "data0[0] = " << data0[0] << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << data1[0] << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << data2[0] << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << data3[0] << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << data4[0] << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << data5[0] << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << data6[0] << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << data7[0] << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << data8[0] << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << data9[0] << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << data10[0] << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << data11[0] << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << data12[0] << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << data13[0] << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << data14[0] << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << data15[0] << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << data16[0] << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << data17[0] << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << data18[0] << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << data19[0] << "\n";
  result += data19[0];
  return result;
}

TakeInt64Pointer()

DART_EXPORT int64_t dart::TakeInt64Pointer	(	int64_t *	data,
		size_t	length
	)

Definition at line 271 of file ffi_test_functions_generated_2.cc.

                                                                   {
  int64_t result = 0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << data[i] << "\n";
    result += data[i];
  }
  return result;
}

TakeInt64PointerMany()

DART_EXPORT int64_t dart::TakeInt64PointerMany	(	int64_t *	data0,
		int64_t *	data1,
		int64_t *	data2,
		int64_t *	data3,
		int64_t *	data4,
		int64_t *	data5,
		int64_t *	data6,
		int64_t *	data7,
		int64_t *	data8,
		int64_t *	data9,
		int64_t *	data10,
		int64_t *	data11,
		int64_t *	data12,
		int64_t *	data13,
		int64_t *	data14,
		int64_t *	data15,
		int64_t *	data16,
		int64_t *	data17,
		int64_t *	data18,
		int64_t *	data19
	)

Definition at line 284 of file ffi_test_functions_generated_2.cc.

                                                          {
  int64_t result = 0;
  std::cout << "data0[0] = " << data0[0] << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << data1[0] << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << data2[0] << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << data3[0] << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << data4[0] << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << data5[0] << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << data6[0] << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << data7[0] << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << data8[0] << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << data9[0] << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << data10[0] << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << data11[0] << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << data12[0] << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << data13[0] << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << data14[0] << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << data15[0] << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << data16[0] << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << data17[0] << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << data18[0] << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << data19[0] << "\n";
  result += data19[0];
  return result;
}

TakeInt8Pointer()

DART_EXPORT int8_t dart::TakeInt8Pointer	(	int8_t *	data,
		size_t	length
	)

Definition at line 40 of file ffi_test_functions_generated_2.cc.

                                                                {
  int8_t result = 0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << static_cast<int>(data[i]) << "\n";
    result += data[i];
  }
  return result;
}

TakeInt8PointerMany()

DART_EXPORT int8_t dart::TakeInt8PointerMany	(	int8_t *	data0,
		int8_t *	data1,
		int8_t *	data2,
		int8_t *	data3,
		int8_t *	data4,
		int8_t *	data5,
		int8_t *	data6,
		int8_t *	data7,
		int8_t *	data8,
		int8_t *	data9,
		int8_t *	data10,
		int8_t *	data11,
		int8_t *	data12,
		int8_t *	data13,
		int8_t *	data14,
		int8_t *	data15,
		int8_t *	data16,
		int8_t *	data17,
		int8_t *	data18,
		int8_t *	data19
	)

Definition at line 53 of file ffi_test_functions_generated_2.cc.

                                                       {
  int8_t result = 0;
  std::cout << "data0[0] = " << static_cast<int>(data0[0]) << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << static_cast<int>(data1[0]) << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << static_cast<int>(data2[0]) << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << static_cast<int>(data3[0]) << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << static_cast<int>(data4[0]) << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << static_cast<int>(data5[0]) << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << static_cast<int>(data6[0]) << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << static_cast<int>(data7[0]) << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << static_cast<int>(data8[0]) << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << static_cast<int>(data9[0]) << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << static_cast<int>(data10[0]) << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << static_cast<int>(data11[0]) << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << static_cast<int>(data12[0]) << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << static_cast<int>(data13[0]) << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << static_cast<int>(data14[0]) << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << static_cast<int>(data15[0]) << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << static_cast<int>(data16[0]) << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << static_cast<int>(data17[0]) << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << static_cast<int>(data18[0]) << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << static_cast<int>(data19[0]) << "\n";
  result += data19[0];
  return result;
}

TakeMaxUint16()

DART_EXPORT intptr_t dart::TakeMaxUint16

(

uint16_t

x

)

Definition at line 142 of file ffi_test_functions.cc.

                                               {
  std::cout << "TakeMaxUint16(" << x << ")\n";
  return x == 0xffff ? 1 : 0;
}

TakeMaxUint32()

DART_EXPORT intptr_t dart::TakeMaxUint32

(

uint32_t

x

)

Definition at line 147 of file ffi_test_functions.cc.

                                               {
  std::cout << "TakeMaxUint32(" << x << ")\n";
  return x == 0xffffffff ? 1 : 0;
}

TakeMaxUint8()

DART_EXPORT intptr_t dart::TakeMaxUint8

(

uint8_t

x

)

Definition at line 137 of file ffi_test_functions.cc.

                                             {
  std::cout << "TakeMaxUint8(" << static_cast<int>(x) << ")\n";
  return x == 0xff ? 1 : 0;
}

TakeMaxUint8x10()

DART_EXPORT intptr_t dart::TakeMaxUint8x10	(	uint8_t	a,
		uint8_t	b,
		uint8_t	c,
		uint8_t	d,
		uint8_t	e,
		uint8_t	f,
		uint8_t	g,
		uint8_t	h,
		uint8_t	i,
		uint8_t	j
	)

Definition at line 174 of file ffi_test_functions.cc.

                                                {
  std::cout << "TakeMaxUint8x10(" << static_cast<int>(a) << ", "
            << static_cast<int>(b) << ", " << static_cast<int>(c) << ", "
            << static_cast<int>(d) << ", " << static_cast<int>(e) << ", "
            << static_cast<int>(f) << ", " << static_cast<int>(g) << ", "
            << static_cast<int>(h) << ", " << static_cast<int>(i) << ", "
            << static_cast<int>(j) << ")\n";
  return (a == 0xff && b == 0xff && c == 0xff && d == 0xff && e == 0xff &&
          f == 0xff && g == 0xff && h == 0xff && i == 0xff && j == 0xff)
             ? 1
             : 0;
}

TakeMinInt16()

DART_EXPORT intptr_t dart::TakeMinInt16

(

int16_t

x

)

Definition at line 159 of file ffi_test_functions.cc.

                                             {
  std::cout << "TakeMinInt16(" << x << ")\n";
  const int64_t expected = -0x8000;
  const int64_t received = x;
  return expected == received ? 1 : 0;
}

TakeMinInt32()

DART_EXPORT intptr_t dart::TakeMinInt32

(

int32_t

x

)

Definition at line 166 of file ffi_test_functions.cc.

                                             {
  std::cout << "TakeMinInt32(" << x << ")\n";
  const int64_t expected = INT32_MIN;
  const int64_t received = x;
  return expected == received ? 1 : 0;
}

TakeMinInt8()

DART_EXPORT intptr_t dart::TakeMinInt8

(

int8_t

x

)

Definition at line 152 of file ffi_test_functions.cc.

                                           {
  std::cout << "TakeMinInt8(" << static_cast<int>(x) << ")\n";
  const int64_t expected = -0x80;
  const int64_t received = x;
  return expected == received ? 1 : 0;
}

TakeString()

DART_EXPORT char dart::TakeString

(

char *

my_string

)

Definition at line 1334 of file ffi_test_functions.cc.

                                             {
  std::cout << "TakeString(" << my_string << ")\n";
  return my_string[4];
}

TakeStruct2BytesIntPointerMany()

DART_EXPORT int16_t dart::TakeStruct2BytesIntPointerMany	(	Struct2BytesInt *	data0,
		Struct2BytesInt *	data1,
		Struct2BytesInt *	data2,
		Struct2BytesInt *	data3,
		Struct2BytesInt *	data4,
		Struct2BytesInt *	data5,
		Struct2BytesInt *	data6,
		Struct2BytesInt *	data7,
		Struct2BytesInt *	data8,
		Struct2BytesInt *	data9,
		Struct2BytesInt *	data10,
		Struct2BytesInt *	data11,
		Struct2BytesInt *	data12,
		Struct2BytesInt *	data13,
		Struct2BytesInt *	data14,
		Struct2BytesInt *	data15,
		Struct2BytesInt *	data16,
		Struct2BytesInt *	data17,
		Struct2BytesInt *	data18,
		Struct2BytesInt *	data19
	)

Definition at line 891 of file ffi_test_functions_generated_2.cc.

                                                                            {
  int16_t result = 0;
  std::cout << "data0->a0 = " << data0->a0 << "\n";
  result += data0->a0;
  std::cout << "data1->a0 = " << data1->a0 << "\n";
  result += data1->a0;
  std::cout << "data2->a0 = " << data2->a0 << "\n";
  result += data2->a0;
  std::cout << "data3->a0 = " << data3->a0 << "\n";
  result += data3->a0;
  std::cout << "data4->a0 = " << data4->a0 << "\n";
  result += data4->a0;
  std::cout << "data5->a0 = " << data5->a0 << "\n";
  result += data5->a0;
  std::cout << "data6->a0 = " << data6->a0 << "\n";
  result += data6->a0;
  std::cout << "data7->a0 = " << data7->a0 << "\n";
  result += data7->a0;
  std::cout << "data8->a0 = " << data8->a0 << "\n";
  result += data8->a0;
  std::cout << "data9->a0 = " << data9->a0 << "\n";
  result += data9->a0;
  std::cout << "data10->a0 = " << data10->a0 << "\n";
  result += data10->a0;
  std::cout << "data11->a0 = " << data11->a0 << "\n";
  result += data11->a0;
  std::cout << "data12->a0 = " << data12->a0 << "\n";
  result += data12->a0;
  std::cout << "data13->a0 = " << data13->a0 << "\n";
  result += data13->a0;
  std::cout << "data14->a0 = " << data14->a0 << "\n";
  result += data14->a0;
  std::cout << "data15->a0 = " << data15->a0 << "\n";
  result += data15->a0;
  std::cout << "data16->a0 = " << data16->a0 << "\n";
  result += data16->a0;
  std::cout << "data17->a0 = " << data17->a0 << "\n";
  result += data17->a0;
  std::cout << "data18->a0 = " << data18->a0 << "\n";
  result += data18->a0;
  std::cout << "data19->a0 = " << data19->a0 << "\n";
  result += data19->a0;
  return result;
}

TakeUint16Pointer()

DART_EXPORT uint16_t dart::TakeUint16Pointer	(	uint16_t *	data,
		size_t	length
	)

Definition at line 425 of file ffi_test_functions_generated_2.cc.

                                                                      {
  uint16_t result = 0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << data[i] << "\n";
    result += data[i];
  }
  return result;
}

TakeUint16PointerMany()

DART_EXPORT uint16_t dart::TakeUint16PointerMany	(	uint16_t *	data0,
		uint16_t *	data1,
		uint16_t *	data2,
		uint16_t *	data3,
		uint16_t *	data4,
		uint16_t *	data5,
		uint16_t *	data6,
		uint16_t *	data7,
		uint16_t *	data8,
		uint16_t *	data9,
		uint16_t *	data10,
		uint16_t *	data11,
		uint16_t *	data12,
		uint16_t *	data13,
		uint16_t *	data14,
		uint16_t *	data15,
		uint16_t *	data16,
		uint16_t *	data17,
		uint16_t *	data18,
		uint16_t *	data19
	)

Definition at line 438 of file ffi_test_functions_generated_2.cc.

                                                             {
  uint16_t result = 0;
  std::cout << "data0[0] = " << data0[0] << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << data1[0] << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << data2[0] << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << data3[0] << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << data4[0] << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << data5[0] << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << data6[0] << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << data7[0] << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << data8[0] << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << data9[0] << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << data10[0] << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << data11[0] << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << data12[0] << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << data13[0] << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << data14[0] << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << data15[0] << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << data16[0] << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << data17[0] << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << data18[0] << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << data19[0] << "\n";
  result += data19[0];
  return result;
}

TakeUint32Pointer()

DART_EXPORT uint32_t dart::TakeUint32Pointer	(	uint32_t *	data,
		size_t	length
	)

Definition at line 502 of file ffi_test_functions_generated_2.cc.

                                                                      {
  uint32_t result = 0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << data[i] << "\n";
    result += data[i];
  }
  return result;
}

TakeUint32PointerMany()

DART_EXPORT uint32_t dart::TakeUint32PointerMany	(	uint32_t *	data0,
		uint32_t *	data1,
		uint32_t *	data2,
		uint32_t *	data3,
		uint32_t *	data4,
		uint32_t *	data5,
		uint32_t *	data6,
		uint32_t *	data7,
		uint32_t *	data8,
		uint32_t *	data9,
		uint32_t *	data10,
		uint32_t *	data11,
		uint32_t *	data12,
		uint32_t *	data13,
		uint32_t *	data14,
		uint32_t *	data15,
		uint32_t *	data16,
		uint32_t *	data17,
		uint32_t *	data18,
		uint32_t *	data19
	)

Definition at line 515 of file ffi_test_functions_generated_2.cc.

                                                             {
  uint32_t result = 0;
  std::cout << "data0[0] = " << data0[0] << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << data1[0] << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << data2[0] << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << data3[0] << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << data4[0] << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << data5[0] << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << data6[0] << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << data7[0] << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << data8[0] << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << data9[0] << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << data10[0] << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << data11[0] << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << data12[0] << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << data13[0] << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << data14[0] << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << data15[0] << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << data16[0] << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << data17[0] << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << data18[0] << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << data19[0] << "\n";
  result += data19[0];
  return result;
}

TakeUint64Pointer()

DART_EXPORT uint64_t dart::TakeUint64Pointer	(	uint64_t *	data,
		size_t	length
	)

Definition at line 579 of file ffi_test_functions_generated_2.cc.

                                                                      {
  uint64_t result = 0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << data[i] << "\n";
    result += data[i];
  }
  return result;
}

TakeUint64PointerMany()

DART_EXPORT uint64_t dart::TakeUint64PointerMany	(	uint64_t *	data0,
		uint64_t *	data1,
		uint64_t *	data2,
		uint64_t *	data3,
		uint64_t *	data4,
		uint64_t *	data5,
		uint64_t *	data6,
		uint64_t *	data7,
		uint64_t *	data8,
		uint64_t *	data9,
		uint64_t *	data10,
		uint64_t *	data11,
		uint64_t *	data12,
		uint64_t *	data13,
		uint64_t *	data14,
		uint64_t *	data15,
		uint64_t *	data16,
		uint64_t *	data17,
		uint64_t *	data18,
		uint64_t *	data19
	)

Definition at line 592 of file ffi_test_functions_generated_2.cc.

                                                             {
  uint64_t result = 0;
  std::cout << "data0[0] = " << data0[0] << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << data1[0] << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << data2[0] << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << data3[0] << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << data4[0] << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << data5[0] << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << data6[0] << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << data7[0] << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << data8[0] << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << data9[0] << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << data10[0] << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << data11[0] << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << data12[0] << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << data13[0] << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << data14[0] << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << data15[0] << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << data16[0] << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << data17[0] << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << data18[0] << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << data19[0] << "\n";
  result += data19[0];
  return result;
}

TakeUint8Pointer()

DART_EXPORT uint8_t dart::TakeUint8Pointer	(	uint8_t *	data,
		size_t	length
	)

Definition at line 348 of file ffi_test_functions_generated_2.cc.

                                                                   {
  uint8_t result = 0;
  if (length > 100) {
    std::cout << "Mangled arguments\n";
    return result;
  }
  for (size_t i = 0; i < length; i++) {
    std::cout << "data[" << i << "] = " << static_cast<int>(data[i]) << "\n";
    result += data[i];
  }
  return result;
}

TakeUint8PointerMany()

DART_EXPORT uint8_t dart::TakeUint8PointerMany	(	uint8_t *	data0,
		uint8_t *	data1,
		uint8_t *	data2,
		uint8_t *	data3,
		uint8_t *	data4,
		uint8_t *	data5,
		uint8_t *	data6,
		uint8_t *	data7,
		uint8_t *	data8,
		uint8_t *	data9,
		uint8_t *	data10,
		uint8_t *	data11,
		uint8_t *	data12,
		uint8_t *	data13,
		uint8_t *	data14,
		uint8_t *	data15,
		uint8_t *	data16,
		uint8_t *	data17,
		uint8_t *	data18,
		uint8_t *	data19
	)

Definition at line 361 of file ffi_test_functions_generated_2.cc.

                                                          {
  uint8_t result = 0;
  std::cout << "data0[0] = " << static_cast<int>(data0[0]) << "\n";
  result += data0[0];
  std::cout << "data1[0] = " << static_cast<int>(data1[0]) << "\n";
  result += data1[0];
  std::cout << "data2[0] = " << static_cast<int>(data2[0]) << "\n";
  result += data2[0];
  std::cout << "data3[0] = " << static_cast<int>(data3[0]) << "\n";
  result += data3[0];
  std::cout << "data4[0] = " << static_cast<int>(data4[0]) << "\n";
  result += data4[0];
  std::cout << "data5[0] = " << static_cast<int>(data5[0]) << "\n";
  result += data5[0];
  std::cout << "data6[0] = " << static_cast<int>(data6[0]) << "\n";
  result += data6[0];
  std::cout << "data7[0] = " << static_cast<int>(data7[0]) << "\n";
  result += data7[0];
  std::cout << "data8[0] = " << static_cast<int>(data8[0]) << "\n";
  result += data8[0];
  std::cout << "data9[0] = " << static_cast<int>(data9[0]) << "\n";
  result += data9[0];
  std::cout << "data10[0] = " << static_cast<int>(data10[0]) << "\n";
  result += data10[0];
  std::cout << "data11[0] = " << static_cast<int>(data11[0]) << "\n";
  result += data11[0];
  std::cout << "data12[0] = " << static_cast<int>(data12[0]) << "\n";
  result += data12[0];
  std::cout << "data13[0] = " << static_cast<int>(data13[0]) << "\n";
  result += data13[0];
  std::cout << "data14[0] = " << static_cast<int>(data14[0]) << "\n";
  result += data14[0];
  std::cout << "data15[0] = " << static_cast<int>(data15[0]) << "\n";
  result += data15[0];
  std::cout << "data16[0] = " << static_cast<int>(data16[0]) << "\n";
  result += data16[0];
  std::cout << "data17[0] = " << static_cast<int>(data17[0]) << "\n";
  result += data17[0];
  std::cout << "data18[0] = " << static_cast<int>(data18[0]) << "\n";
  result += data18[0];
  std::cout << "data19[0] = " << static_cast<int>(data19[0]) << "\n";
  result += data19[0];
  return result;
}

TakeUnion2BytesIntPointerMany()

DART_EXPORT int16_t dart::TakeUnion2BytesIntPointerMany	(	Union2BytesInt *	data0,
		Union2BytesInt *	data1,
		Union2BytesInt *	data2,
		Union2BytesInt *	data3,
		Union2BytesInt *	data4,
		Union2BytesInt *	data5,
		Union2BytesInt *	data6,
		Union2BytesInt *	data7,
		Union2BytesInt *	data8,
		Union2BytesInt *	data9,
		Union2BytesInt *	data10,
		Union2BytesInt *	data11,
		Union2BytesInt *	data12,
		Union2BytesInt *	data13,
		Union2BytesInt *	data14,
		Union2BytesInt *	data15,
		Union2BytesInt *	data16,
		Union2BytesInt *	data17,
		Union2BytesInt *	data18,
		Union2BytesInt *	data19
	)

Definition at line 959 of file ffi_test_functions_generated_2.cc.

                                                                          {
  int16_t result = 0;
  std::cout << "data0->a0 = " << data0->a0 << "\n";
  result += data0->a0;
  std::cout << "data1->a0 = " << data1->a0 << "\n";
  result += data1->a0;
  std::cout << "data2->a0 = " << data2->a0 << "\n";
  result += data2->a0;
  std::cout << "data3->a0 = " << data3->a0 << "\n";
  result += data3->a0;
  std::cout << "data4->a0 = " << data4->a0 << "\n";
  result += data4->a0;
  std::cout << "data5->a0 = " << data5->a0 << "\n";
  result += data5->a0;
  std::cout << "data6->a0 = " << data6->a0 << "\n";
  result += data6->a0;
  std::cout << "data7->a0 = " << data7->a0 << "\n";
  result += data7->a0;
  std::cout << "data8->a0 = " << data8->a0 << "\n";
  result += data8->a0;
  std::cout << "data9->a0 = " << data9->a0 << "\n";
  result += data9->a0;
  std::cout << "data10->a0 = " << data10->a0 << "\n";
  result += data10->a0;
  std::cout << "data11->a0 = " << data11->a0 << "\n";
  result += data11->a0;
  std::cout << "data12->a0 = " << data12->a0 << "\n";
  result += data12->a0;
  std::cout << "data13->a0 = " << data13->a0 << "\n";
  result += data13->a0;
  std::cout << "data14->a0 = " << data14->a0 << "\n";
  result += data14->a0;
  std::cout << "data15->a0 = " << data15->a0 << "\n";
  result += data15->a0;
  std::cout << "data16->a0 = " << data16->a0 << "\n";
  result += data16->a0;
  std::cout << "data17->a0 = " << data17->a0 << "\n";
  result += data17->a0;
  std::cout << "data18->a0 = " << data18->a0 << "\n";
  result += data18->a0;
  std::cout << "data19->a0 = " << data19->a0 << "\n";
  result += data19->a0;
  return result;
}

TEST_CASE() [1/600]

dart::TEST_CASE

(

AbstractType_InstantiatedFutureOrIsNormalized

)

Definition at line 7738 of file object_test.cc.

  {
    const auto& type_nullable_int =
        Type::Handle(object_store->nullable_int_type());
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_nullable_int, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        normalized_future_or(type_nullable_int, Nullability::kNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
}
 
TEST_CASE(AbstractType_InstantiatedFutureOrIsNormalized) {
  const char* kScript = R"(
import 'dart:async';
 
FutureOr<T>? foo<T>() { return null; }
FutureOr<T?> bar<T>() { return null; }
)";
 
  Dart_Handle api_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(api_lib);
  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();
  ObjectStore* const object_store = IsolateGroup::Current()->object_store();
 
  const auto& null_tav = Object::null_type_arguments();
  auto instantiate_future_or =
      [&](const AbstractType& generic,
          const AbstractType& param) -> AbstractTypePtr {
    const auto& tav = TypeArguments::Handle(TypeArguments::New(1));
    tav.SetTypeAt(0, param);
    return generic.InstantiateFrom(null_tav, tav, kCurrentAndEnclosingFree,
                                   Heap::kNew);
  };
 
  const auto& root_lib =
      Library::CheckedHandle(zone, Api::UnwrapHandle(api_lib));
  EXPECT(!root_lib.IsNull());
  const auto& foo = Function::Handle(zone, GetFunction(root_lib, "foo"));
  const auto& bar = Function::Handle(zone, GetFunction(root_lib, "bar"));
  const auto& foo_sig = FunctionType::Handle(zone, foo.signature());
  const auto& bar_sig = FunctionType::Handle(zone, bar.signature());
 
  const auto& nullable_future_or_T =
      AbstractType::Handle(zone, foo_sig.result_type());
  const auto& future_or_nullable_T =
      AbstractType::Handle(zone, bar_sig.result_type());
 
  const auto& type_nullable_object =
      Type::Handle(object_store->nullable_object_type());
  const auto& type_non_nullable_object =
      Type::Handle(object_store->non_nullable_object_type());
  const auto& type_legacy_object =
      Type::Handle(object_store->legacy_object_type());
 
  // Testing same cases as AbstractType_NormalizeFutureOrType.
 
  // FutureOr<T>?[top type] = top type
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, Object::dynamic_type()));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::dynamic_type(), got);
  }
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, Object::void_type()));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::void_type(), got);
  }
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_nullable_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }
 
  // FutureOr<T?>[top type] = top type
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, Object::dynamic_type()));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::dynamic_type(), got);
  }
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, Object::void_type()));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::void_type(), got);
  }
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_nullable_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }
 
  // FutureOr<T?>[Object] = Object?
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_non_nullable_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }
 
  // FutureOr<T?>[Object*] = Object?
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_legacy_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }
 
  // FutureOr<T>?[Object] = Object?
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_non_nullable_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }
 
  // FutureOr<T>?[Object*] = Object?
 
  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_legacy_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }
 
  const auto& type_never = Type::Handle(object_store->never_type());
  const auto& type_null = Type::Handle(object_store->null_type());
 
  // FutureOr<T?>[Never] = Future<Null>?
 
  {
    const auto& expected =
        Type::Handle(CreateFutureType(type_null, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_never));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
 
  // FutureOr<T>?[Never] = Future<Never>?
 
  {
    const auto& expected =
        Type::Handle(CreateFutureType(type_never, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_never));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
 
  // FutureOr<T?>[Null] = Future<Null>?
 
  {
    const auto& expected =
        Type::Handle(CreateFutureType(type_null, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_null));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
 
  // FutureOr<T>?[Null] = Future<Null>?
 
  {
    const auto& expected =
        Type::Handle(CreateFutureType(type_null, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_null));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
 
  const auto& type_nullable_int =
      Type::Handle(object_store->nullable_int_type());
  const auto& type_non_nullable_int =
      Type::Handle(object_store->non_nullable_int_type());
 
  // FutureOr<T?>[int] = FutureOr<int?>
 
  {
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_nullable_int, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_non_nullable_int));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
 
  // FutureOr<T?>[int?] = FutureOr<int?>
 
  {
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_nullable_int, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_nullable_int));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
 
  // FutureOr<T>?[int?] = FutureOr<int?>
 
  {
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_nullable_int, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_nullable_int));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

TEST_CASE() [2/600]

dart::TEST_CASE

(

AMA_Test

)

Definition at line 15 of file ama_test.cc.

                    {
  // NOTE: These are expectations we should strive to maintain. Please reach out
  // to go/dart-ama before changing them.
#if defined(TARGET_ARCH_ARM64)
  COMPILE_ASSERT(R27 == PP);
  COMPILE_ASSERT(R15 == SPREG);
  COMPILE_ASSERT(R26 == THR);
  COMPILE_ASSERT(R21 == DISPATCH_TABLE_REG);
#endif
}

TEST_CASE() [3/600]

dart::TEST_CASE

(

ArrayLengthMaxElements

)

Definition at line 1907 of file object_test.cc.

                                  {
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "main() {\n"
                 "  return List.filled(%" Pd
                 ", null);\n"
                 "}\n",
                 Array::kMaxElements);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  if (Dart_IsError(result)) {
    EXPECT_ERROR(result, "Out of Memory");
  } else {
    const intptr_t kExpected = Array::kMaxElements;
    intptr_t actual = 0;
    EXPECT_VALID(Dart_ListLength(result, &actual));
    EXPECT_EQ(kExpected, actual);
  }
}

TEST_CASE() [4/600]

dart::TEST_CASE

(

ArrayLengthNegativeOne

)

Definition at line 1883 of file object_test.cc.

                                  {
  TestIllegalArrayLength(-1);
}

TEST_CASE() [5/600]

dart::TEST_CASE

(

ArrayLengthOneTooMany

)

Definition at line 1890 of file object_test.cc.

                                 {
  const intptr_t kOneTooMany = Array::kMaxElements + 1;
  ASSERT(kOneTooMany >= 0);
 
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "main() {\n"
                 "  return List.filled(%" Pd
                 ", null);\n"
                 "}\n",
                 kOneTooMany);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_ERROR(result, "Out of Memory");
}

TEST_CASE() [6/600]

dart::TEST_CASE

(

ArrayLengthSmiMin

)

Definition at line 1886 of file object_test.cc.

                             {
  TestIllegalArrayLength(kSmiMin);
}

TEST_CASE() [7/600]

dart::TEST_CASE

(

Base64Decode

)

Definition at line 12 of file base64_test.cc.

                        {
  intptr_t decoded_len;
  uint8_t* decoded_bytes = DecodeBase64("SGVsbG8sIHdvcmxkIQo=", &decoded_len);
  const char expected_bytes[] = "Hello, world!\n";
  intptr_t expected_len = strlen(expected_bytes);
  EXPECT(!memcmp(expected_bytes, decoded_bytes, expected_len));
  EXPECT_EQ(expected_len, decoded_len);
  free(decoded_bytes);
}

TEST_CASE() [8/600]

dart::TEST_CASE

(

Base64DecodeEmpty

)

Definition at line 27 of file base64_test.cc.

                             {
  intptr_t decoded_len;
  EXPECT(DecodeBase64("", &decoded_len) == nullptr);
}

TEST_CASE() [9/600]

dart::TEST_CASE

(

Base64DecodeMalformed

)

Definition at line 22 of file base64_test.cc.

                                 {
  intptr_t decoded_len;
  EXPECT(DecodeBase64("SomethingMalformed", &decoded_len) == nullptr);
}

TEST_CASE() [10/600]

dart::TEST_CASE

(

BaseWriteStream_Write

)

Definition at line 31 of file datastream_test.cc.

                                 {
  MallocWriteStream writer(1 * KB);
  for (intptr_t i = kSignedStart; i < kSignedEnd; i++) {
    writer.Write(i);
  }
  DEFINE_LARGE_CONSTANTS(intptr_t);
  writer.Write(all_ones);
  writer.Write(min);
  writer.Write(max);
  writer.Write(half_min);
  writer.Write(half_max);
  ReadStream reader(writer.buffer(), writer.bytes_written());
  for (intptr_t i = kSignedStart; i < kSignedEnd; i++) {
    const intptr_t r = reader.Read<intptr_t>();
    EXPECT_EQ(i, r);
  }
  const intptr_t read_all_ones = reader.Read<intptr_t>();
  EXPECT_EQ(all_ones, read_all_ones);
  const intptr_t read_min = reader.Read<intptr_t>();
  EXPECT_EQ(min, read_min);
  const intptr_t read_max = reader.Read<intptr_t>();
  EXPECT_EQ(max, read_max);
  const intptr_t read_half_min = reader.Read<intptr_t>();
  EXPECT_EQ(half_min, read_half_min);
  const intptr_t read_half_max = reader.Read<intptr_t>();
  EXPECT_EQ(half_max, read_half_max);
}

TEST_CASE() [11/600]

dart::TEST_CASE

(

BaseWriteStream_WriteLEB128

)

Definition at line 129 of file datastream_test.cc.

                                       {
  MallocWriteStream writer(1 * KB);
  for (uintptr_t i = 0; i < kUnsignedEnd; i++) {
    writer.WriteLEB128(i);
  }
  DEFINE_LARGE_CONSTANTS(uintptr_t);
  writer.WriteLEB128(all_ones);
  writer.WriteLEB128(min);
  writer.WriteLEB128(max);
  writer.WriteLEB128(half_min);
  writer.WriteLEB128(half_max);
  ReadStream reader(writer.buffer(), writer.bytes_written());
  for (uintptr_t i = 0; i < kUnsignedEnd; i++) {
    const uintptr_t r = reader.ReadLEB128();
    EXPECT_EQ(i, r);
  }
  const uintptr_t read_all_ones = reader.ReadLEB128();
  EXPECT_EQ(all_ones, read_all_ones);
  const uintptr_t read_min = reader.ReadLEB128();
  EXPECT_EQ(min, read_min);
  const uintptr_t read_max = reader.ReadLEB128();
  EXPECT_EQ(max, read_max);
  const uintptr_t read_half_min = reader.ReadLEB128();
  EXPECT_EQ(half_min, read_half_min);
  const uintptr_t read_half_max = reader.ReadLEB128();
  EXPECT_EQ(half_max, read_half_max);
}

TEST_CASE() [12/600]

dart::TEST_CASE

(

BaseWriteStream_WriteSLEB128

)

Definition at line 157 of file datastream_test.cc.

                                        {
  MallocWriteStream writer(1 * KB);
  for (intptr_t i = kSignedStart; i < kSignedEnd; i++) {
    writer.WriteSLEB128(i);
  }
  DEFINE_LARGE_CONSTANTS(intptr_t);
  writer.WriteSLEB128(all_ones);
  writer.WriteSLEB128(min);
  writer.WriteSLEB128(max);
  writer.WriteSLEB128(half_min);
  writer.WriteSLEB128(half_max);
  ReadStream reader(writer.buffer(), writer.bytes_written());
  for (intptr_t i = kSignedStart; i < kSignedEnd; i++) {
    const intptr_t r = reader.ReadSLEB128();
    EXPECT_EQ(i, r);
  }
  const intptr_t read_all_ones = reader.ReadSLEB128();
  EXPECT_EQ(all_ones, read_all_ones);
  const intptr_t read_min = reader.ReadSLEB128();
  EXPECT_EQ(min, read_min);
  const intptr_t read_max = reader.ReadSLEB128();
  EXPECT_EQ(max, read_max);
  const intptr_t read_half_min = reader.ReadSLEB128();
  EXPECT_EQ(half_min, read_half_min);
  const intptr_t read_half_max = reader.ReadSLEB128();
  EXPECT_EQ(half_max, read_half_max);
}

TEST_CASE() [13/600]

dart::TEST_CASE

(

BaseWriteStream_WriteUnsigned

)

Definition at line 59 of file datastream_test.cc.

                                         {
  MallocWriteStream writer(1 * KB);
  for (uintptr_t i = 0; i < kUnsignedEnd; i++) {
    writer.WriteUnsigned(i);
  }
  DEFINE_LARGE_CONSTANTS(uintptr_t);
  writer.WriteUnsigned(all_ones);
  writer.WriteUnsigned(min);
  writer.WriteUnsigned(max);
  writer.WriteUnsigned(half_min);
  writer.WriteUnsigned(half_max);
  ReadStream reader(writer.buffer(), writer.bytes_written());
  for (uintptr_t i = 0; i < kUnsignedEnd; i++) {
    const uintptr_t r = reader.ReadUnsigned<uintptr_t>();
    EXPECT_EQ(i, r);
  }
  const uintptr_t read_all_ones = reader.ReadUnsigned<uintptr_t>();
  EXPECT_EQ(all_ones, read_all_ones);
  const uintptr_t read_min = reader.ReadUnsigned<uintptr_t>();
  EXPECT_EQ(min, read_min);
  const uintptr_t read_max = reader.ReadUnsigned<uintptr_t>();
  EXPECT_EQ(max, read_max);
  const uintptr_t read_half_min = reader.ReadUnsigned<uintptr_t>();
  EXPECT_EQ(half_min, read_half_min);
  const uintptr_t read_half_max = reader.ReadUnsigned<uintptr_t>();
  EXPECT_EQ(half_max, read_half_max);
}

TEST_CASE() [14/600]

dart::TEST_CASE

(

BitSetBasic

)

Definition at line 43 of file bit_set_test.cc.

                       {
  TestBitSet<8>();
  TestBitSet<42>();
  TestBitSet<128>();
  TestBitSet<200>();
}

TEST_CASE() [15/600]

dart::TEST_CASE

(

BitVector

)

Definition at line 13 of file bit_vector_test.cc.

                     {
  {
    BitVector* v = new BitVector(Z, 15);
    v->Add(1);
    EXPECT_EQ(true, v->Contains(1));
    EXPECT_EQ(false, v->Contains(0));
    {
      BitVector::Iterator iter(v);
      EXPECT_EQ(1, iter.Current());
      iter.Advance();
      EXPECT(iter.Done());
    }
    v->Add(0);
    v->Add(1);
    EXPECT_EQ(true, v->Contains(0));
    EXPECT_EQ(true, v->Contains(1));
    {
      BitVector::Iterator iter(v);
      EXPECT_EQ(0, iter.Current());
      iter.Advance();
      EXPECT_EQ(1, iter.Current());
      iter.Advance();
      EXPECT(iter.Done());
    }
  }
 
  {
    BitVector* v = new BitVector(Z, 128);
    v->Add(49);
    v->Add(62);
    v->Add(63);
    v->Add(65);
    EXPECT_EQ(true, v->Contains(49));
    EXPECT_EQ(true, v->Contains(62));
    EXPECT_EQ(true, v->Contains(63));
    EXPECT_EQ(true, v->Contains(65));
    EXPECT_EQ(false, v->Contains(64));
    BitVector::Iterator iter(v);
    EXPECT_EQ(49, iter.Current());
    iter.Advance();
    EXPECT_EQ(62, iter.Current());
    iter.Advance();
    EXPECT_EQ(63, iter.Current());
    iter.Advance();
    EXPECT_EQ(65, iter.Current());
    iter.Advance();
    EXPECT(iter.Done());
  }
 
  {
    BitVector* a = new BitVector(Z, 128);
    BitVector* b = new BitVector(Z, 128);
    BitVector* c = new BitVector(Z, 128);
    b->Add(0);
    b->Add(32);
    b->Add(64);
    a->AddAll(b);
    EXPECT_EQ(true, a->Contains(0));
    EXPECT_EQ(true, a->Contains(32));
    EXPECT_EQ(true, a->Contains(64));
    EXPECT_EQ(false, a->Contains(96));
    EXPECT_EQ(false, a->Contains(127));
    b->Add(96);
    b->Add(127);
    c->Add(127);
    a->KillAndAdd(c, b);
    EXPECT_EQ(true, a->Contains(0));
    EXPECT_EQ(true, a->Contains(32));
    EXPECT_EQ(true, a->Contains(64));
    EXPECT_EQ(true, a->Contains(96));
    EXPECT_EQ(false, a->Contains(127));
    a->Remove(0);
    a->Remove(32);
    a->Remove(64);
    a->Remove(96);
    EXPECT_EQ(false, a->Contains(0));
    EXPECT_EQ(false, a->Contains(32));
    EXPECT_EQ(false, a->Contains(64));
    EXPECT_EQ(false, a->Contains(96));
  }
 
  {
    BitVector* a = new BitVector(Z, 34);
    BitVector* b = new BitVector(Z, 34);
    a->SetAll();
    b->Add(0);
    b->Add(1);
    b->Add(31);
    b->Add(32);
    a->Intersect(b);
    EXPECT_EQ(true, a->Equals(*b));
  }
 
  {
    BitVector* a = new BitVector(Z, 2);
    BitVector* b = new BitVector(Z, 2);
    a->SetAll();
    a->Remove(0);
    a->Remove(1);
    EXPECT_EQ(true, a->Equals(*b));
  }
 
  {
    BitVector* a = new BitVector(Z, 128);
    BitVector* b = new BitVector(Z, 128);
    b->Add(0);
    b->Add(32);
    b->Add(64);
    a->Add(0);
    a->Add(64);
    b->RemoveAll(a);
    EXPECT_EQ(false, b->Contains(0));
    EXPECT_EQ(true, b->Contains(32));
    EXPECT_EQ(false, b->Contains(64));
  }
}

TEST_CASE() [16/600]

dart::TEST_CASE

(

CheckHandleValidity

)

Definition at line 82 of file handles_test.cc.

                               {
#if defined(DEBUG)
  FLAG_trace_handles = true;
#endif
  Dart_Handle handle = nullptr;
  // Check validity using zone handles.
  {
    TransitionNativeToVM transition(thread);
    StackZone sz(thread);
    handle = reinterpret_cast<Dart_Handle>(&Smi::ZoneHandle(Smi::New(1)));
    {
      TransitionVMToNative to_native(thread);
      EXPECT_VALID(handle);
    }
  }
  EXPECT(!Api::IsValid(handle));
 
  // Check validity using scoped handles.
  {
    Dart_EnterScope();
    {
      TransitionNativeToVM transition(thread);
      HANDLESCOPE(thread);
      handle = reinterpret_cast<Dart_Handle>(&Smi::Handle(Smi::New(1)));
      {
        TransitionVMToNative to_native(thread);
        EXPECT_VALID(handle);
      }
    }
    Dart_ExitScope();
  }
  EXPECT(!Api::IsValid(handle));
 
  // Check validity using persistent handle.
  Dart_Handle scoped_handle;
  {
    TransitionNativeToVM transition(thread);
    scoped_handle = Api::NewHandle(thread, Smi::New(1));
  }
  Dart_PersistentHandle persistent_handle =
      Dart_NewPersistentHandle(scoped_handle);
  EXPECT_VALID(persistent_handle);
 
  Dart_DeletePersistentHandle(persistent_handle);
  EXPECT(!Api::IsValid(persistent_handle));
 
  // Check validity using weak persistent handle.
  handle = reinterpret_cast<Dart_Handle>(Dart_NewWeakPersistentHandle(
      Dart_NewStringFromCString("foo"), nullptr, 0, NoopCallback));
 
  EXPECT_NOTNULL(handle);
  EXPECT_VALID(handle);
 
  Dart_DeleteWeakPersistentHandle(
      reinterpret_cast<Dart_WeakPersistentHandle>(handle));
  EXPECT(!Api::IsValid(handle));
}

TEST_CASE() [17/600]

dart::TEST_CASE

(

Class_EndTokenPos

)

Definition at line 284 of file object_test.cc.

                             {
  const char* kScript =
      "\n"
      "class A {\n"
      "  /**\n"
      "   * Description of foo().\n"
      "   */\n"
      "  foo(a) { return '''\"}'''; }\n"
      "  // }\n"
      "  var bar = '\\'}';\n"
      "}\n";
  Dart_Handle lib_h = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib_h);
  TransitionNativeToVM transition(thread);
  Library& lib = Library::Handle();
  lib ^= Api::UnwrapHandle(lib_h);
  EXPECT(!lib.IsNull());
  const Class& cls =
      Class::Handle(lib.LookupClass(String::Handle(String::New("A"))));
  EXPECT(!cls.IsNull());
  const Error& error = Error::Handle(cls.EnsureIsFinalized(thread));
  EXPECT(error.IsNull());
  const TokenPosition end_token_pos = cls.end_token_pos();
  const Script& scr = Script::Handle(cls.script());
  intptr_t line;
  intptr_t col;
  EXPECT(scr.GetTokenLocation(end_token_pos, &line, &col));
  EXPECT_EQ(9, line);
  EXPECT_EQ(1, col);
}

TEST_CASE() [18/600]

dart::TEST_CASE

(

Class_GetInstantiationOf

)

Definition at line 7531 of file object_test.cc.

                                    {
  const char* kScript = R"(
    class B<T> {}
    class A1<X, Y> implements B<List<Y>> {}
    class A2<X, Y> extends A1<Y, X> {}
  )";
  Dart_Handle api_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(api_lib);
  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();
 
  const auto& root_lib =
      Library::CheckedHandle(zone, Api::UnwrapHandle(api_lib));
  EXPECT(!root_lib.IsNull());
  const auto& class_b = Class::Handle(zone, GetClass(root_lib, "B"));
  const auto& class_a1 = Class::Handle(zone, GetClass(root_lib, "A1"));
  const auto& class_a2 = Class::Handle(zone, GetClass(root_lib, "A2"));
 
  const auto& core_lib = Library::Handle(zone, Library::CoreLibrary());
  const auto& class_list = Class::Handle(zone, GetClass(core_lib, "List"));
 
  const auto& decl_type_b = Type::Handle(zone, class_b.DeclarationType());
  const auto& decl_type_list = Type::Handle(zone, class_list.DeclarationType());
  const auto& null_tav = Object::null_type_arguments();
 
  // Test that A1.GetInstantiationOf(B) returns B<List<A1::Y>>.
  {
    const auto& decl_type_a1 = Type::Handle(zone, class_a1.DeclarationType());
    const auto& decl_type_args_a1 =
        TypeArguments::Handle(zone, decl_type_a1.arguments());
    const auto& type_arg_a1_y =
        TypeParameter::CheckedHandle(zone, decl_type_args_a1.TypeAt(1));
    auto& tav_a1_y = TypeArguments::Handle(TypeArguments::New(1));
    tav_a1_y.SetTypeAt(0, type_arg_a1_y);
    tav_a1_y = tav_a1_y.Canonicalize(thread);
    auto& type_list_a1_y = Type::CheckedHandle(
        zone, decl_type_list.InstantiateFrom(tav_a1_y, null_tav, kAllFree,
                                             Heap::kNew));
    type_list_a1_y ^= type_list_a1_y.Canonicalize(thread);
    auto& tav_list_a1_y = TypeArguments::Handle(TypeArguments::New(1));
    tav_list_a1_y.SetTypeAt(0, type_list_a1_y);
    tav_list_a1_y = tav_list_a1_y.Canonicalize(thread);
    auto& type_b_list_a1_y = Type::CheckedHandle(
        zone, decl_type_b.InstantiateFrom(tav_list_a1_y, null_tav, kAllFree,
                                          Heap::kNew));
    type_b_list_a1_y ^= type_b_list_a1_y.Canonicalize(thread);
 
    const auto& inst_b_a1 =
        Type::Handle(zone, class_a1.GetInstantiationOf(zone, class_b));
    EXPECT(!inst_b_a1.IsNull());
    EXPECT_TYPES_EQUAL(type_b_list_a1_y, inst_b_a1);
  }
 
  // Test that A2.GetInstantiationOf(B) returns B<List<A2::X>>.
  {
    const auto& decl_type_a2 = Type::Handle(zone, class_a2.DeclarationType());
    const auto& decl_type_args_a2 =
        TypeArguments::Handle(zone, decl_type_a2.arguments());
    const auto& type_arg_a2_x =
        TypeParameter::CheckedHandle(zone, decl_type_args_a2.TypeAt(0));
    auto& tav_a2_x = TypeArguments::Handle(TypeArguments::New(1));
    tav_a2_x.SetTypeAt(0, type_arg_a2_x);
    tav_a2_x = tav_a2_x.Canonicalize(thread);
    auto& type_list_a2_x = Type::CheckedHandle(
        zone, decl_type_list.InstantiateFrom(tav_a2_x, null_tav, kAllFree,
                                             Heap::kNew));
    type_list_a2_x ^= type_list_a2_x.Canonicalize(thread);
    auto& tav_list_a2_x = TypeArguments::Handle(TypeArguments::New(1));
    tav_list_a2_x.SetTypeAt(0, type_list_a2_x);
    tav_list_a2_x = tav_list_a2_x.Canonicalize(thread);

TEST_CASE() [19/600]

dart::TEST_CASE

(

ClassHeapStats

)

Definition at line 103 of file heap_test.cc.

                          {
  const char* kScriptChars =
      "class A {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      ""
      "main() {\n"
      "  var x = new A();\n"
      "  return new A();\n"
      "}\n";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  auto isolate_group = IsolateGroup::Current();
  ClassTable* class_table = isolate_group->class_table();
  {
    // GC before main so allocations during the tests don't cause unexpected GC.
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectAllGarbage();
  }
  Dart_EnterScope();
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(!Dart_IsNull(result));
  intptr_t cid;
  {
    TransitionNativeToVM transition(thread);
    Library& lib = Library::Handle();
    lib ^= Api::UnwrapHandle(h_lib);
    EXPECT(!lib.IsNull());
    const Class& cls = Class::Handle(GetClass(lib, "A"));
    ASSERT(!cls.IsNull());
    cid = cls.id();
 
    {
      // Verify preconditions: allocated twice in new space.
      CountObjectsVisitor visitor(thread, class_table->NumCids());
      HeapIterationScope iter(thread);
      iter.IterateObjects(&visitor);
      isolate_group->VisitWeakPersistentHandles(&visitor);
      EXPECT_EQ(2, visitor.new_count_[cid]);
      EXPECT_EQ(0, visitor.old_count_[cid]);
    }
 
    // Perform GC.
    GCTestHelper::CollectNewSpace();
 
    {
      // Verify postconditions: Only one survived.
      CountObjectsVisitor visitor(thread, class_table->NumCids());
      HeapIterationScope iter(thread);
      iter.IterateObjects(&visitor);
      isolate_group->VisitWeakPersistentHandles(&visitor);
      EXPECT_EQ(1, visitor.new_count_[cid]);
      EXPECT_EQ(0, visitor.old_count_[cid]);
    }
 
    // Perform GC. The following is heavily dependent on the behaviour
    // of the GC: Retained instance of A will be promoted.
    GCTestHelper::CollectNewSpace();
 
    {
      // Verify postconditions: One promoted instance.
      CountObjectsVisitor visitor(thread, class_table->NumCids());
      HeapIterationScope iter(thread);
      iter.IterateObjects(&visitor);
      isolate_group->VisitWeakPersistentHandles(&visitor);
      EXPECT_EQ(0, visitor.new_count_[cid]);
      EXPECT_EQ(1, visitor.old_count_[cid]);
    }
 
    // Perform a GC on new space.
    GCTestHelper::CollectNewSpace();
 
    {
      // Verify postconditions:
      CountObjectsVisitor visitor(thread, class_table->NumCids());
      HeapIterationScope iter(thread);
      iter.IterateObjects(&visitor);
      isolate_group->VisitWeakPersistentHandles(&visitor);
      EXPECT_EQ(0, visitor.new_count_[cid]);
      EXPECT_EQ(1, visitor.old_count_[cid]);
    }
 
    GCTestHelper::CollectOldSpace();
 
    {
      // Verify postconditions:
      CountObjectsVisitor visitor(thread, class_table->NumCids());
      HeapIterationScope iter(thread);
      iter.IterateObjects(&visitor);
      isolate_group->VisitWeakPersistentHandles(&visitor);
      EXPECT_EQ(0, visitor.new_count_[cid]);
      EXPECT_EQ(1, visitor.old_count_[cid]);
    }
  }
  // Exit scope, freeing instance.
  Dart_ExitScope();
  {
    TransitionNativeToVM transition(thread);
    // Perform GC.
    GCTestHelper::CollectOldSpace();
    {
      // Verify postconditions:
      CountObjectsVisitor visitor(thread, class_table->NumCids());
      HeapIterationScope iter(thread);
      iter.IterateObjects(&visitor);
      isolate_group->VisitWeakPersistentHandles(&visitor);
      EXPECT_EQ(0, visitor.new_count_[cid]);
      EXPECT_EQ(0, visitor.old_count_[cid]);
    }
  }
}

TEST_CASE() [20/600]

dart::TEST_CASE

(

ClassHierarchyAnalysis

)

Definition at line 17 of file cha_test.cc.

                                  {
  const char* kScriptChars =
      "class A {"
      "  foo() { }"
      "  bar() { }"
      "}\n"
      "class B extends A {"
      "}\n"
      "class C extends B {"
      "  foo() { }"
      "}\n"
      "class D extends A {"
      "  foo() { }"
      "  bar() { }"
      "}\n";
 
  TestCase::LoadTestScript(kScriptChars, nullptr);
 
  TransitionNativeToVM transition(thread);
  EXPECT(ClassFinalizer::ProcessPendingClasses());
  const String& name = String::Handle(String::New(TestCase::url()));
  const Library& lib = Library::Handle(Library::LookupLibrary(thread, name));
  EXPECT(!lib.IsNull());
 
  const Class& class_a =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
  EXPECT(!class_a.IsNull());
  EXPECT(class_a.EnsureIsFinalized(thread) == Error::null());
 
  const Class& class_b =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "B"))));
  EXPECT(!class_b.IsNull());
 
  const Class& class_c =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "C"))));
  EXPECT(!class_c.IsNull());
  EXPECT(class_c.EnsureIsFinalized(thread) == Error::null());
 
  const Class& class_d =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "D"))));
  EXPECT(!class_d.IsNull());
  EXPECT(class_d.EnsureIsFinalized(thread) == Error::null());
 
  const String& function_foo_name = String::Handle(String::New("foo"));
  const String& function_bar_name = String::Handle(String::New("bar"));
 
  const Function& class_a_foo = Function::Handle(
      Resolver::ResolveDynamicFunction(Z, class_a, function_foo_name));
  EXPECT(!class_a_foo.IsNull());
 
  const Function& class_a_bar = Function::Handle(
      Resolver::ResolveDynamicFunction(Z, class_a, function_bar_name));
  EXPECT(!class_a_bar.IsNull());
 
  const Function& class_c_foo = Function::Handle(
      Resolver::ResolveDynamicFunction(Z, class_c, function_foo_name));
  EXPECT(!class_c_foo.IsNull());
 
  const Function& class_d_foo = Function::Handle(
      Resolver::ResolveDynamicFunction(Z, class_d, function_foo_name));
  EXPECT(!class_d_foo.IsNull());
 
  const Function& class_d_bar = Function::Handle(
      Resolver::ResolveDynamicFunction(Z, class_d, function_bar_name));
  EXPECT(!class_d_bar.IsNull());
 
  CHA cha(thread);
 
  EXPECT(cha.HasSubclasses(kInstanceCid));
  EXPECT(!cha.HasSubclasses(kSmiCid));
  EXPECT(!cha.HasSubclasses(kNullCid));
 
  EXPECT(CHA::HasSubclasses(class_a));
  EXPECT(CHA::HasSubclasses(class_b));
  EXPECT(!CHA::HasSubclasses(class_c));
  cha.AddToGuardedClassesForSubclassCount(class_c, /*subclass_count=*/0);
  EXPECT(!CHA::HasSubclasses(class_d));
  cha.AddToGuardedClassesForSubclassCount(class_d, /*subclass_count=*/0);
 
  EXPECT(!cha.IsGuardedClass(class_a.id()));
  EXPECT(!cha.IsGuardedClass(class_b.id()));
  EXPECT(cha.IsGuardedClass(class_c.id()));
  EXPECT(cha.IsGuardedClass(class_d.id()));
 
  const Class& closure_class =
      Class::Handle(IsolateGroup::Current()->object_store()->closure_class());
  EXPECT(!cha.HasSubclasses(closure_class.id()));
}

TEST_CASE() [21/600]

dart::TEST_CASE

(

CompareAndSwapUint32

)

Definition at line 82 of file atomic_test.cc.

                                {
  uint32_t old_value = 42;
  RelaxedAtomic<uint32_t> variable = {old_value};
  uint32_t new_value = 100;
  bool success = variable.compare_exchange_strong(old_value, new_value);
  EXPECT_EQ(true, success);
  EXPECT_EQ(static_cast<uword>(42), old_value);
 
  old_value = 50;
  success = variable.compare_exchange_strong(old_value, new_value);
  EXPECT_EQ(false, success);
  EXPECT_EQ(static_cast<uword>(100), old_value);
}

TEST_CASE() [22/600]

dart::TEST_CASE

(

CompareAndSwapWord

)

Definition at line 68 of file atomic_test.cc.

                              {
  uword old_value = 42;
  RelaxedAtomic<uword> variable = {old_value};
  uword new_value = 100;
  bool success = variable.compare_exchange_strong(old_value, new_value);
  EXPECT_EQ(true, success);
  EXPECT_EQ(static_cast<uword>(42), old_value);
 
  old_value = 50;
  success = variable.compare_exchange_strong(old_value, new_value);
  EXPECT_EQ(false, success);
  EXPECT_EQ(static_cast<uword>(100), old_value);
}

TEST_CASE() [23/600]

dart::TEST_CASE

(

ConstMap_larger

)

Definition at line 6969 of file object_test.cc.

                      {1: 42, 'foo': 499, null: 'bar'};
 
nonConstValue() => {1: 42, 'foo': 499, null: 'bar'};
 
void init() {
  constValue()[null];
}
)";
  HashMapNonConstEqualsConst(kScript);
}
 
TEST_CASE(ConstMap_larger) {
  const char* kScript = R"(
enum ExperimentalFlag {
  alternativeInvalidationStrategy,
  constFunctions,
  constantUpdate2018,
  constructorTearoffs,
  controlFlowCollections,
  extensionMethods,
  extensionTypes,
  genericMetadata,
  nonNullable,
  nonfunctionTypeAliases,
  setLiterals,
  spreadCollections,
  testExperiment,
  tripleShift,
  valueClass,
  variance,
}
 
const Map<ExperimentalFlag, bool> expiredExperimentalFlags = {
  ExperimentalFlag.alternativeInvalidationStrategy: false,
  ExperimentalFlag.constFunctions: false,
  ExperimentalFlag.constantUpdate2018: true,
  ExperimentalFlag.constructorTearoffs: false,
  ExperimentalFlag.controlFlowCollections: true,
  ExperimentalFlag.extensionMethods: false,
  ExperimentalFlag.extensionTypes: false,
  ExperimentalFlag.genericMetadata: false,
  ExperimentalFlag.nonNullable: false,
  ExperimentalFlag.nonfunctionTypeAliases: false,
  ExperimentalFlag.setLiterals: true,
  ExperimentalFlag.spreadCollections: true,
  ExperimentalFlag.testExperiment: false,
  ExperimentalFlag.tripleShift: false,
  ExperimentalFlag.valueClass: false,
  ExperimentalFlag.variance: false,
};
 
final Map<ExperimentalFlag, bool> expiredExperimentalFlagsNonConst = {
  ExperimentalFlag.alternativeInvalidationStrategy: false,
  ExperimentalFlag.constFunctions: false,
  ExperimentalFlag.constantUpdate2018: true,
  ExperimentalFlag.constructorTearoffs: false,
  ExperimentalFlag.controlFlowCollections: true,
  ExperimentalFlag.extensionMethods: false,
  ExperimentalFlag.extensionTypes: false,
  ExperimentalFlag.genericMetadata: false,
  ExperimentalFlag.nonNullable: false,
  ExperimentalFlag.nonfunctionTypeAliases: false,
  ExperimentalFlag.setLiterals: true,
  ExperimentalFlag.spreadCollections: true,
  ExperimentalFlag.testExperiment: false,
  ExperimentalFlag.tripleShift: false,
  ExperimentalFlag.valueClass: false,
  ExperimentalFlag.variance: false,
};

TEST_CASE() [24/600]

dart::TEST_CASE

(

ConstMap_nested

)

Definition at line 7039 of file object_test.cc.

            {
  constValue()[null];
}
)";
  HashMapNonConstEqualsConst(kScript);
}
 
TEST_CASE(ConstMap_nested) {
  const char* kScript = R"(
enum Abi {
  wordSize64,
  wordSize32Align32,
  wordSize32Align64,
}
 
enum NativeType {
  kNativeType,
  kNativeInteger,
  kNativeDouble,
  kPointer,
  kNativeFunction,
  kInt8,
  kInt16,
  kInt32,
  kInt64,
  kUint8,
  kUint16,
  kUint32,
  kUint64,
  kIntptr,
  kFloat,
  kDouble,
  kVoid,
  kOpaque,
  kStruct,
  kHandle,
}
 
const nonSizeAlignment = <Abi, Map<NativeType, int>>{
  Abi.wordSize64: {},
  Abi.wordSize32Align32: {
    NativeType.kDouble: 4,
    NativeType.kInt64: 4,
    NativeType.kUint64: 4
  },
  Abi.wordSize32Align64: {},
};
 
final nonSizeAlignmentNonConst = <Abi, Map<NativeType, int>>{
  Abi.wordSize64: {},
  Abi.wordSize32Align32: {
    NativeType.kDouble: 4,
    NativeType.kInt64: 4,
    NativeType.kUint64: 4
  },
  Abi.wordSize32Align64: {},
};

TEST_CASE() [25/600]

dart::TEST_CASE

(

ConstMap_null

)

Definition at line 6956 of file object_test.cc.

                      {1: 42, 'foo': 499, 2: 'bar'};
 
nonConstValue() => {1: 42, 'foo': 499, 2: 'bar'};
 
void init() {
  constValue()[null];
}
)";
  HashMapNonConstEqualsConst(kScript);
}
 
TEST_CASE(ConstMap_null) {

TEST_CASE() [26/600]

dart::TEST_CASE

(

ConstMap_small

)

Definition at line 6943 of file object_test.cc.

                                                               {
  HashBaseNonConstEqualsConst<Map, kMapCid, kConstMapCid>(script, check_data);
}
 
static void HashSetNonConstEqualsConst(const char* script,
                                       bool check_data = true) {
  HashBaseNonConstEqualsConst<Set, kSetCid, kConstSetCid>(script, check_data);
}
 
TEST_CASE(ConstMap_small) {

TEST_CASE() [27/600]

dart::TEST_CASE

(

ConstMap_vm

)

Definition at line 6769 of file object_test.cc.

                       {
  const char* kScript = R"(
enum ExperimentalFlag {
  alternativeInvalidationStrategy,
  constFunctions,
  constantUpdate2018,
  constructorTearoffs,
  controlFlowCollections,
  extensionMethods,
  extensionTypes,
  genericMetadata,
  nonNullable,
  nonfunctionTypeAliases,
  setLiterals,
  spreadCollections,
  testExperiment,
  tripleShift,
  valueClass,
  variance,
}
 
final Map<ExperimentalFlag?, bool> expiredExperimentalFlagsNonConst = {
  ExperimentalFlag.alternativeInvalidationStrategy: false,
  ExperimentalFlag.constFunctions: false,
  ExperimentalFlag.constantUpdate2018: true,
  ExperimentalFlag.constructorTearoffs: false,
  ExperimentalFlag.controlFlowCollections: true,
  ExperimentalFlag.extensionMethods: false,
  ExperimentalFlag.extensionTypes: false,
  ExperimentalFlag.genericMetadata: false,
  ExperimentalFlag.nonNullable: false,
  ExperimentalFlag.nonfunctionTypeAliases: false,
  ExperimentalFlag.setLiterals: true,
  ExperimentalFlag.spreadCollections: true,
  ExperimentalFlag.testExperiment: false,
  ExperimentalFlag.tripleShift: false,
  ExperimentalFlag.valueClass: false,
  ExperimentalFlag.variance: false,
};
 
makeNonConstMap() {
  return expiredExperimentalFlagsNonConst;
}
 
firstKey() {
  return ExperimentalFlag.alternativeInvalidationStrategy;
}
 
firstKeyHashCode() {
  return firstKey().hashCode;
}
 
firstKeyIdentityHashCode() {
  return identityHashCode(firstKey());
}
 
bool lookupSpreadCollections(Map map) =>
    map[ExperimentalFlag.spreadCollections];
 
bool? lookupNull(Map map) => map[null];
)";
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle non_const_result =
      Dart_Invoke(lib, NewString("makeNonConstMap"), 0, nullptr);
  EXPECT_VALID(non_const_result);
  Dart_Handle first_key_result =
      Dart_Invoke(lib, NewString("firstKey"), 0, nullptr);
  EXPECT_VALID(first_key_result);
  Dart_Handle first_key_hashcode_result =
      Dart_Invoke(lib, NewString("firstKeyHashCode"), 0, nullptr);
  EXPECT_VALID(first_key_hashcode_result);
  Dart_Handle first_key_identity_hashcode_result =
      Dart_Invoke(lib, NewString("firstKeyIdentityHashCode"), 0, nullptr);
  EXPECT_VALID(first_key_identity_hashcode_result);
 
  Dart_Handle const_argument;
 
  {
    TransitionNativeToVM transition(thread);
    const auto& non_const_map =
        Map::Cast(Object::Handle(Api::UnwrapHandle(non_const_result)));
    const auto& non_const_type_args =
        TypeArguments::Handle(non_const_map.GetTypeArguments());
    const auto& non_const_data = Array::Handle(non_const_map.data());
    const auto& const_map = Map::Handle(ConstructImmutableMap(
        non_const_data, Smi::Value(non_const_map.used_data()),
        non_const_type_args));
    ASSERT(non_const_map.GetClassId() == kMapCid);
    ASSERT(const_map.GetClassId() == kConstMapCid);
    ASSERT(!non_const_map.IsCanonical());
    ASSERT(const_map.IsCanonical());
 
    const_argument = Api::NewHandle(thread, const_map.ptr());
  }
 
  Dart_Handle lookup_result = Dart_Invoke(
      lib, NewString("lookupSpreadCollections"), 1, &const_argument);
  EXPECT_VALID(lookup_result);
  EXPECT_TRUE(lookup_result);
 
  Dart_Handle lookup_null_result =
      Dart_Invoke(lib, NewString("lookupNull"), 1, &const_argument);
  EXPECT_VALID(lookup_null_result);
  EXPECT_NULL(lookup_null_result);
 
  {
    TransitionNativeToVM transition(thread);
    const auto& non_const_object =
        Object::Handle(Api::UnwrapHandle(non_const_result));
    const auto& non_const_map = Map::Cast(non_const_object);

TEST_CASE() [28/600]

dart::TEST_CASE

(

ConstSet_larger

)

Definition at line 7228 of file object_test.cc.

                      {1, 2, 3, 5, 8, 13};
 
nonConstValue() => {1, 2, 3, 5, 8, 13};
 
void init() {
  constValue().contains(null);
}
)";
  HashSetNonConstEqualsConst(kScript);
}
 
TEST_CASE(ConstSet_larger) {
  const char* kScript = R"(
const Set<String> tokensThatMayFollowTypeArg = {
  '(',
  ')',
  ']',
  '}',
  ':',
  ';',
  ',',
  '.',
  '?',
  '==',
  '!=',
  '..',
  '?.',
  '\?\?',
  '?..',
  '&',
  '|',
  '^',
  '+',
  '*',
  '%',
  '/',
  '~/'
};
 
final Set<String> tokensThatMayFollowTypeArgNonConst = {
  '(',
  ')',
  ']',
  '}',
  ':',
  ';',
  ',',
  '.',
  '?',
  '==',
  '!=',
  '..',
  '?.',
  '\?\?',
  '?..',
  '&',
  '|',
  '^',
  '+',
  '*',
  '%',
  '/',
  '~/'
};

TEST_CASE() [29/600]

dart::TEST_CASE

(

ConstSet_small

)

Definition at line 7215 of file object_test.cc.

                          {

TEST_CASE() [30/600]

dart::TEST_CASE

(

ConstSet_vm

)

Definition at line 7157 of file object_test.cc.

                       {
  const char* kScript = R"(
makeNonConstSet() {
  return {1, 2, 3, 5, 8, 13};
}
 
bool containsFive(Set set) => set.contains(5);
)";
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle non_const_result =
      Dart_Invoke(lib, NewString("makeNonConstSet"), 0, nullptr);
  EXPECT_VALID(non_const_result);
 
  Dart_Handle const_argument;
 
  {
    TransitionNativeToVM transition(thread);
    const auto& non_const_object =
        Object::Handle(Api::UnwrapHandle(non_const_result));
    const auto& non_const_set = Set::Cast(non_const_object);
    ASSERT(non_const_set.GetClassId() == kSetCid);
    ASSERT(!non_const_set.IsCanonical());
 
    const auto& non_const_data = Array::Handle(non_const_set.data());
    const auto& non_const_type_args =
        TypeArguments::Handle(non_const_set.GetTypeArguments());
    const auto& const_set = Set::Handle(ConstructImmutableSet(
        non_const_data, Smi::Value(non_const_set.used_data()),
        non_const_type_args));
    ASSERT(const_set.GetClassId() == kConstSetCid);
    ASSERT(const_set.IsCanonical());
 
    const_argument = Api::NewHandle(thread, const_set.ptr());
  }
 
  Dart_Handle contains_5_result =
      Dart_Invoke(lib, NewString("containsFive"), 1, &const_argument);
  EXPECT_VALID(contains_5_result);
  EXPECT_TRUE(contains_5_result);
 
  {
    TransitionNativeToVM transition(thread);
    const auto& non_const_object =
        Object::Handle(Api::UnwrapHandle(non_const_result));
    const auto& non_const_set = Set::Cast(non_const_object);

TEST_CASE() [31/600]

dart::TEST_CASE

(

CStringIntMap

)

Definition at line 264 of file hash_map_test.cc.

                         {
  const char* const kConst1 = "test";
  const char* const kConst2 = "test 2";
 
  char* const str1 = OS::SCreate(nullptr, "%s", kConst1);
  char* const str2 = OS::SCreate(nullptr, "%s", kConst2);
  char* const str3 = OS::SCreate(nullptr, "%s", kConst1);
 
  // Make sure these strings are pointer-distinct, but C-string-equal.
  EXPECT_NE(str1, str3);
  EXPECT_STREQ(str1, str3);
 
  const intptr_t i1 = 1;
  const intptr_t i2 = 2;
 
  CStringIntMap map;
  EXPECT(map.IsEmpty());
 
  map.Insert({str1, i1});
  EXPECT_NOTNULL(map.Lookup(str1));
  EXPECT_EQ(i1, map.LookupValue(str1));
  EXPECT_NULLPTR(map.Lookup(str2));
  EXPECT_NOTNULL(map.Lookup(str3));
  EXPECT_EQ(i1, map.LookupValue(str3));
 
  map.Insert({str2, i2});
  EXPECT_NOTNULL(map.Lookup(str1));
  EXPECT_EQ(i1, map.LookupValue(str1));
  EXPECT_NOTNULL(map.Lookup(str2));
  EXPECT_EQ(i2, map.LookupValue(str2));
  EXPECT_NOTNULL(map.Lookup(str3));
  EXPECT_EQ(i1, map.LookupValue(str3));
 
  EXPECT(map.Remove(str3));
  EXPECT_NULLPTR(map.Lookup(str1));
  EXPECT_NOTNULL(map.Lookup(str2));
  EXPECT_EQ(i2, map.LookupValue(str2));
  EXPECT_NULLPTR(map.Lookup(str3));
 
  EXPECT(!map.Remove(str3));
  EXPECT(map.Remove(str2));
  EXPECT(map.IsEmpty());
 
  free(str3);
  free(str2);
  free(str1);
}

TEST_CASE() [32/600]

dart::TEST_CASE

(

CStringIntMapUpdate

)

Definition at line 312 of file hash_map_test.cc.

                               {
  const char* const kConst1 = "test";
  const char* const kConst2 = "test 2";
 
  char* str1 = OS::SCreate(nullptr, "%s", kConst1);
  char* str2 = OS::SCreate(nullptr, "%s", kConst2);
  char* str3 = OS::SCreate(nullptr, "%s", kConst1);
  char* str4 = OS::SCreate(nullptr, "%s", kConst1);  // Only used for lookup.
 
  // Make sure these strings are pointer-distinct, but C-string-equal.
  EXPECT_NE(str1, str3);
  EXPECT_NE(str1, str4);
  EXPECT_NE(str3, str4);
  EXPECT_STREQ(str1, str3);
  EXPECT_STREQ(str1, str4);
 
  CStringIntMapKeyValueTrait::Pair p1{str1, 1};
  CStringIntMapKeyValueTrait::Pair p2{str2, 2};
  CStringIntMapKeyValueTrait::Pair p3{str3, 3};
 
  CStringIntMap map;
  EXPECT(map.IsEmpty());
 
  map.Update(p1);
  EXPECT_NOTNULL(map.Lookup(str1));
  EXPECT_EQ(p1.value, map.LookupValue(str1));
  EXPECT_NULLPTR(map.Lookup(str2));
  EXPECT_NOTNULL(map.Lookup(str3));
  EXPECT_EQ(p1.value, map.LookupValue(str3));
  EXPECT_NOTNULL(map.Lookup(str4));
  EXPECT_EQ(p1.value, map.LookupValue(str4));
 
  map.Update(p2);
  EXPECT_NOTNULL(map.Lookup(str1));
  EXPECT_EQ(p1.value, map.LookupValue(str1));
  EXPECT_NOTNULL(map.Lookup(str2));
  EXPECT_EQ(p2.value, map.LookupValue(str2));
  EXPECT_NOTNULL(map.Lookup(str3));
  EXPECT_EQ(p1.value, map.LookupValue(str3));
  EXPECT_NOTNULL(map.Lookup(str4));
  EXPECT_EQ(p1.value, map.LookupValue(str4));
 
  // Check Lookup after Update.
  map.Update(p3);
  EXPECT_NOTNULL(map.Lookup(str1));
  EXPECT_EQ(p3.value, map.LookupValue(str1));
  EXPECT_NOTNULL(map.Lookup(str2));
  EXPECT_EQ(p2.value, map.LookupValue(str2));
  EXPECT_NOTNULL(map.Lookup(str3));
  EXPECT_EQ(p3.value, map.LookupValue(str3));
  EXPECT_NOTNULL(map.Lookup(str4));
  EXPECT_EQ(p3.value, map.LookupValue(str4));
 
  // Check that single Remove after only Updates ensures Lookup fails after.
  EXPECT(map.Remove(str3));
  EXPECT_NULLPTR(map.Lookup(str1));
  EXPECT_NOTNULL(map.Lookup(str2));
  EXPECT_EQ(p2.value, map.LookupValue(str2));
  EXPECT_NULLPTR(map.Lookup(str3));
  EXPECT_NULLPTR(map.Lookup(str4));
 
  EXPECT(!map.Remove(str3));
  EXPECT(map.Remove(str2));
  EXPECT(map.IsEmpty());
 
  // Quick double-check that these weren't side-effected by the implementation
  // of hash maps (p1 especially).
  EXPECT_EQ(str1, p1.key);
  EXPECT_EQ(1, p1.value);
  EXPECT_EQ(str2, p2.key);
  EXPECT_EQ(2, p2.value);
  EXPECT_EQ(str3, p3.key);
  EXPECT_EQ(3, p3.value);
 
  free(str4);
  free(str3);
  free(str2);
  free(str1);
}

TEST_CASE() [33/600]

dart::TEST_CASE

(

Dart_KillIsolate

)

Definition at line 138 of file dart_api_impl_test.cc.

                            {
  const char* kScriptChars =
      "int testMain() {\n"
      "  return 42;\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
  int64_t value = 0;
  EXPECT_VALID(Dart_IntegerToInt64(result, &value));
  EXPECT_EQ(42, value);
  Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
  Dart_KillIsolate(isolate);
  result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("isolate terminated by Isolate.kill", Dart_GetError(result));
}

TEST_CASE() [34/600]

dart::TEST_CASE

(

Dart_KillIsolatePriority

)

Definition at line 191 of file dart_api_impl_test.cc.

                                    {
  Monitor monitor;
  bool interrupted = false;
  Dart_Isolate isolate;
  Dart::thread_pool()->Run<InfiniteLoopTask>(&isolate, &monitor, &interrupted);
  {
    MonitorLocker ml(&monitor);
    ml.Wait();
  }
 
  Dart_KillIsolate(isolate);
 
  {
    MonitorLocker ml(&monitor);
    while (!interrupted) {
      ml.Wait();
    }
  }
  EXPECT(interrupted);
}

TEST_CASE() [35/600]

dart::TEST_CASE

(

Dart_SetFfiNativeResolver

)

Definition at line 10126 of file dart_api_impl_test.cc.

                          {
    ml.Wait();
  }
}
 
#if !defined(PRODUCT)
static void ReportTimelineEvents() {
  intptr_t flow_id_count = 1;
  const int64_t flow_ids[1] = {123};
 
  Dart_RecordTimelineEvent("T1", 0, 1, /*flow_id_count=*/0, nullptr,
                           Dart_Timeline_Event_Begin, 0, nullptr, nullptr);
  Dart_RecordTimelineEvent("T1", 10, 1, /*flow_id_count=*/0, nullptr,
                           Dart_Timeline_Event_End, /*argument_count=*/0,
                           nullptr, nullptr);
 
  Dart_RecordTimelineEvent("T2", 20, 2, /*flow_id_count=*/0, nullptr,

TEST_CASE() [36/600]

dart::TEST_CASE

(

Dart_SetFfiNativeResolver_DoesNotResolve

)

Definition at line 10169 of file dart_api_impl_test.cc.

TEST_CASE() [37/600]

dart::TEST_CASE

(

Dart_SetFfiNativeResolver_MissingResolver

)

Definition at line 10148 of file dart_api_impl_test.cc.

TEST_CASE() [38/600]

dart::TEST_CASE

(

DartAPI_ArrayValues

)

Definition at line 1527 of file dart_api_impl_test.cc.

                               {
  EXPECT(!Dart_IsList(Dart_Null()));
  const int kArrayLength = 10;
  Dart_Handle str = NewString("test");
  EXPECT(!Dart_IsList(str));
  Dart_Handle val = Dart_NewList(kArrayLength);
  EXPECT(Dart_IsList(val));
  intptr_t len = 0;
  Dart_Handle result = Dart_ListLength(val, &len);
  EXPECT_VALID(result);
  EXPECT_EQ(kArrayLength, len);
 
  // Check invalid array access.
  result = Dart_ListSetAt(val, (kArrayLength + 10), Dart_NewInteger(10));
  EXPECT(Dart_IsError(result));
  result = Dart_ListSetAt(val, -10, Dart_NewInteger(10));
  EXPECT(Dart_IsError(result));
  result = Dart_ListGetAt(val, (kArrayLength + 10));
  EXPECT(Dart_IsError(result));
  result = Dart_ListGetAt(val, -10);
  EXPECT(Dart_IsError(result));
 
  for (int i = 0; i < kArrayLength; i++) {
    result = Dart_ListSetAt(val, i, Dart_NewInteger(i));
    EXPECT_VALID(result);
  }
  for (int i = 0; i < kArrayLength; i++) {
    result = Dart_ListGetAt(val, i);
    EXPECT_VALID(result);
    int64_t value;
    result = Dart_IntegerToInt64(result, &value);
    EXPECT_VALID(result);
    EXPECT_EQ(i, value);
  }
}

TEST_CASE() [39/600]

dart::TEST_CASE

(

DartAPI_BooleanConstants

)

Definition at line 1340 of file dart_api_impl_test.cc.

                                    {
  Dart_Handle true_handle = Dart_True();
  EXPECT_VALID(true_handle);
  EXPECT(Dart_IsBoolean(true_handle));
 
  bool value = false;
  Dart_Handle result = Dart_BooleanValue(true_handle, &value);
  EXPECT_VALID(result);
  EXPECT(value);
 
  Dart_Handle false_handle = Dart_False();
  EXPECT_VALID(false_handle);
  EXPECT(Dart_IsBoolean(false_handle));
 
  result = Dart_BooleanValue(false_handle, &value);
  EXPECT_VALID(result);
  EXPECT(!value);
}

TEST_CASE() [40/600]

dart::TEST_CASE

(

DartAPI_BooleanValues

)

Definition at line 1317 of file dart_api_impl_test.cc.

                                 {
  Dart_Handle str = NewString("test");
  EXPECT(!Dart_IsBoolean(str));
 
  bool value = false;
  Dart_Handle result = Dart_BooleanValue(str, &value);
  EXPECT(Dart_IsError(result));
 
  Dart_Handle val1 = Dart_NewBoolean(true);
  EXPECT(Dart_IsBoolean(val1));
 
  result = Dart_BooleanValue(val1, &value);
  EXPECT_VALID(result);
  EXPECT(value);
 
  Dart_Handle val2 = Dart_NewBoolean(false);
  EXPECT(Dart_IsBoolean(val2));
 
  result = Dart_BooleanValue(val2, &value);
  EXPECT_VALID(result);
  EXPECT(!value);
}

TEST_CASE() [41/600]

dart::TEST_CASE

(

DartAPI_BreakpointLockRace

)

Definition at line 5756 of file object_test.cc.

        :
  IsolateGroup* isolate_group_;
  Dart_Isolate isolate_;
  std::atomic<bool>* done_;
};
 
TEST_CASE(DartAPI_BreakpointLockRace) {
  const char* kScriptChars =
      "class A {\n"
      "  a() {\n"
      "  }\n"
      "  b() {\n"
      "    a();\n"  // This is line 5.
      "  }\n"
      "}\n"
      "test() {\n"
      "  new A().b();\n"
      "}";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  // Run function A.b one time.
  Dart_Handle result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(result);
 
  // Launch second isolate so that running with stopped mutators during
  // deoptimizattion requests a safepoint.
  Dart_Isolate parent = Dart_CurrentIsolate();
  Dart_ExitIsolate();
  char* error = nullptr;
  Dart_Isolate child = Dart_CreateIsolateInGroup(parent, "child",
                                                 /*shutdown_callback=*/nullptr,
                                                 /*cleanup_callback=*/nullptr,
                                                 /*peer=*/nullptr, &error);
  EXPECT_NE(nullptr, child);
  EXPECT_EQ(nullptr, error);
  Dart_ExitIsolate();
  Dart_EnterIsolate(parent);
 
  // Run function A.b one time.
  std::atomic<bool> done = false;
  Dart::thread_pool()->Run<ToggleBreakpointTask>(IsolateGroup::Current(), child,
                                                 &done);
 
  while (!done) {
    ReloadParticipationScope allow_reload(thread);
    {
      TransitionNativeToVM transition(thread);
      const String& name = String::Handle(String::New(TestCase::url()));
      const Library& vmlib =
          Library::Handle(Library::LookupLibrary(thread, name));
      EXPECT(!vmlib.IsNull());
      const Class& class_a = Class::Handle(
          vmlib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
      Function& func_b = Function::Handle(GetFunction(class_a, "b"));
      func_b.CanBeInlined();
    }
  }
 
  // Make sure child isolate finishes.

TEST_CASE() [42/600]

dart::TEST_CASE

(

DartAPI_ByteBufferAccess

)

Definition at line 2156 of file dart_api_impl_test.cc.

                                    {
  EXPECT(!Dart_IsByteBuffer(Dart_True()));
  Dart_Handle byte_array = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
  EXPECT_VALID(byte_array);
  // Set through the List API.
  for (intptr_t i = 0; i < 10; ++i) {
    EXPECT_VALID(Dart_ListSetAt(byte_array, i, Dart_NewInteger(i + 1)));
  }
  Dart_Handle byte_buffer = Dart_NewByteBuffer(byte_array);
  EXPECT_VALID(byte_buffer);
  EXPECT(Dart_IsByteBuffer(byte_buffer));
  EXPECT(!Dart_IsTypedData(byte_buffer));
 
  Dart_Handle byte_buffer_data = Dart_GetDataFromByteBuffer(byte_buffer);
  EXPECT_VALID(byte_buffer_data);
  EXPECT(!Dart_IsByteBuffer(byte_buffer_data));
  EXPECT(Dart_IsTypedData(byte_buffer_data));
 
  intptr_t length = 0;
  Dart_Handle result = Dart_ListLength(byte_buffer_data, &length);
  EXPECT_VALID(result);
  EXPECT_EQ(10, length);
 
  for (intptr_t i = 0; i < 10; ++i) {
    // Get through the List API.
    Dart_Handle integer_obj = Dart_ListGetAt(byte_buffer_data, i);
    EXPECT_VALID(integer_obj);
    int64_t int64_t_value = -1;
    EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
    EXPECT_EQ(i + 1, int64_t_value);
  }
 
  // Some negative tests.
  result = Dart_NewByteBuffer(Dart_True());
  EXPECT(Dart_IsError(result));
  result = Dart_NewByteBuffer(byte_buffer);
  EXPECT(Dart_IsError(result));
  result = Dart_GetDataFromByteBuffer(Dart_False());
  EXPECT(Dart_IsError(result));
  result = Dart_GetDataFromByteBuffer(byte_array);
  EXPECT(Dart_IsError(result));
}

TEST_CASE() [43/600]

dart::TEST_CASE

(

DartAPI_ByteDataAccess

)

Definition at line 2218 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars = R"(
import 'dart:typed_data';
class Expect {
  static equals(a, b) {
    if (a != b) {
      throw 'not equal. expected: $a, got: $b';
    }
  }
}
@pragma("vm:external-name", "CreateByteData")
external ByteData createByteData();
ByteData main() {
  var length = 16;
  var a = createByteData();
  Expect.equals(length, a.lengthInBytes);
  for (int i = 0; i < length; i+=1) {
    a.setInt8(i, 0x42);
  }
  for (int i = 0; i < length; i+=2) {
    Expect.equals(0x4242, a.getInt16(i));
  }
  return a;
}
)";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle result =
      Dart_SetNativeResolver(lib, &ByteDataNativeResolver, nullptr);
  EXPECT_VALID(result);
 
  // Invoke 'main' function.
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
}

TEST_CASE() [44/600]

dart::TEST_CASE

(

DartAPI_ByteDataDirectAccessUnverified

)

Definition at line 2795 of file dart_api_impl_test.cc.

                                                  {
  FLAG_verify_acquired_data = false;
  TestByteDataDirectAccess();
}

TEST_CASE() [45/600]

dart::TEST_CASE

(

DartAPI_ByteDataDirectAccessVerified

)

Definition at line 2800 of file dart_api_impl_test.cc.

                                                {
  FLAG_verify_acquired_data = true;
  TestByteDataDirectAccess();
}

TEST_CASE() [46/600]

dart::TEST_CASE

(

DartAPI_ClassLibrary

)

Definition at line 1304 of file dart_api_impl_test.cc.

                                {
  Dart_Handle lib = Dart_LookupLibrary(NewString("dart:core"));
  EXPECT_VALID(lib);
  Dart_Handle type = Dart_GetNonNullableType(lib, NewString("int"), 0, nullptr);
  EXPECT_VALID(type);
  Dart_Handle result = Dart_ClassLibrary(type);
  EXPECT_VALID(result);
  Dart_Handle lib_url = Dart_LibraryUrl(result);
  const char* str = nullptr;
  Dart_StringToCString(lib_url, &str);
  EXPECT_STREQ("dart:core", str);
}

TEST_CASE() [47/600]

dart::TEST_CASE

(

DartAPI_ClosureFunction

)

Definition at line 1229 of file dart_api_impl_test.cc.

                                   {
  const char* kScriptChars = "int getInt() { return 1; }\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  Dart_Handle closure = Dart_GetField(lib, NewString("getInt"));
  EXPECT_VALID(closure);
  EXPECT(Dart_IsClosure(closure));
  Dart_Handle closure_str = Dart_ToString(closure);
  const char* result = "";
  Dart_StringToCString(closure_str, &result);
  EXPECT(strstr(result, "getInt") != nullptr);
 
  Dart_Handle function = Dart_ClosureFunction(closure);
  EXPECT_VALID(function);
  EXPECT(Dart_IsFunction(function));
  Dart_Handle func_str = Dart_ToString(function);
  Dart_StringToCString(func_str, &result);
  EXPECT(strstr(result, "getInt"));
}

TEST_CASE() [48/600]

dart::TEST_CASE

(

DartAPI_CollectOneNewSpacePeer

)

Definition at line 8965 of file dart_api_impl_test.cc.

                               {
  uint8_t chars8[1] = {'a'};
  uint16_t chars16[1] = {'a'};
  int32_t chars32[1] = {'a'};
 
  EXPECT_ERROR(Dart_NewList(-1),
               "expects argument 'length' to be in the range");
  EXPECT_ERROR(Dart_NewList(Array::kMaxElements + 1),
               "expects argument 'length' to be in the range");
  EXPECT_ERROR(Dart_NewStringFromUTF8(chars8, -1),
               "expects argument 'length' to be in the range");
  EXPECT_ERROR(Dart_NewStringFromUTF8(chars8, OneByteString::kMaxElements + 1),

TEST_CASE() [49/600]

dart::TEST_CASE

(

DartAPI_CollectOneOldSpacePeer

)

Definition at line 9189 of file dart_api_impl_test.cc.

  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
    EXPECT_EQ(0, heap->PeerCount());
  }
}
 
// Allocates several objects in new space.  Performs successive
// garbage collections and checks that the peer count is stable.
TEST_CASE(DartAPI_CopyNewSpacePeers) {
  const int kPeerCount = 10;
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_Handle s[kPeerCount];
  for (int i = 0; i < kPeerCount; ++i) {
    s[i] = NewString("a string");
    EXPECT_VALID(s[i]);
    EXPECT(Dart_IsString(s[i]));
    void* o = &o;
    EXPECT_VALID(Dart_GetPeer(s[i], &o));
    EXPECT(o == nullptr);
  }
  EXPECT_EQ(0, heap->PeerCount());

TEST_CASE() [50/600]

dart::TEST_CASE

(

DartAPI_CollectTwoNewSpacePeers

)

Definition at line 9042 of file dart_api_impl_test.cc.

                                   {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_Handle str = NewString("a string");
  EXPECT_VALID(str);
  EXPECT(Dart_IsString(str));
  EXPECT_EQ(0, heap->PeerCount());
  void* out = &out;
  EXPECT_VALID(Dart_GetPeer(str, &out));
  EXPECT(out == nullptr);
  int peer = 1234;
  EXPECT_VALID(Dart_SetPeer(str, &peer));

TEST_CASE() [51/600]

dart::TEST_CASE

(

DartAPI_CollectTwoOldSpacePeers

)

Definition at line 9270 of file dart_api_impl_test.cc.

                                   {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_Handle str = AllocateOldString("str");
  EXPECT_VALID(str);
  EXPECT(Dart_IsString(str));
  EXPECT_EQ(0, heap->PeerCount());
  void* out = &out;
  EXPECT(Dart_GetPeer(str, &out));
  EXPECT(out == nullptr);
  int peer = 1234;
  EXPECT_VALID(Dart_SetPeer(str, &peer));
  EXPECT_EQ(1, heap->PeerCount());
  out = &out;
  EXPECT_VALID(Dart_GetPeer(str, &out));
  EXPECT(out == reinterpret_cast<void*>(&peer));
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(1, heap->PeerCount());
  }
  EXPECT_VALID(Dart_GetPeer(str, &out));
  EXPECT(out == reinterpret_cast<void*>(&peer));
  EXPECT_VALID(Dart_SetPeer(str, nullptr));
  out = &out;
  EXPECT_VALID(Dart_GetPeer(str, &out));

TEST_CASE() [52/600]

dart::TEST_CASE

(

DartAPI_CopyNewSpacePeers

)

Definition at line 9082 of file dart_api_impl_test.cc.

                                          {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_EnterScope();
  {
    CHECK_API_SCOPE(thread);
    Dart_Handle str = NewString("a string");
    EXPECT_VALID(str);
    EXPECT(Dart_IsString(str));
    EXPECT_EQ(0, heap->PeerCount());
    void* out = &out;
    EXPECT_VALID(Dart_GetPeer(str, &out));
    EXPECT(out == nullptr);
    int peer = 1234;
    EXPECT_VALID(Dart_SetPeer(str, &peer));
    EXPECT_EQ(1, heap->PeerCount());
    out = &out;
    EXPECT_VALID(Dart_GetPeer(str, &out));
    EXPECT(out == reinterpret_cast<void*>(&peer));
    {

TEST_CASE() [53/600]

dart::TEST_CASE

(

DartAPI_CopyUTF8EncodingOfString

)

Definition at line 1684 of file dart_api_impl_test.cc.

                                            {
  const char* kScriptChars =
      "String lowSurrogate() {"
      "  return '\\u{1D11E}'[1];"
      "}";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle str1 = Dart_Invoke(lib, NewString("lowSurrogate"), 0, nullptr);
  EXPECT_VALID(str1);
 
  uint8_t* utf8_encoded = nullptr;
  intptr_t utf8_length = 0;
  Dart_Handle result = Dart_StringToUTF8(str1, &utf8_encoded, &utf8_length);
  EXPECT_VALID(result);
  EXPECT_EQ(3, utf8_length);
 
  intptr_t utf8_copy_length = 0;
  result = Dart_StringUTF8Length(str1, &utf8_copy_length);
  uint8_t* utf8_encoded_copy = Dart_ScopeAllocate(utf8_copy_length);
  result =
      Dart_CopyUTF8EncodingOfString(str1, utf8_encoded_copy, utf8_copy_length);
  EXPECT_VALID(result);
  EXPECT_EQ(0, memcmp(utf8_encoded, utf8_encoded_copy, utf8_length));
}

TEST_CASE() [54/600]

dart::TEST_CASE

(

DartAPI_CurrentStackTraceInfo

)

Definition at line 591 of file dart_api_impl_test.cc.

                                         {
  const char* kScriptChars = R"(
@pragma("vm:external-name", "CurrentStackTraceNative")
external inspectStack();
foo(n) => n == 1 ? inspectStack() : foo(n-1);
testMain() => foo(100);
  )";
 
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, &CurrentStackTraceNativeLookup);
  Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsInteger(result));
  int64_t value = 0;
  EXPECT_VALID(Dart_IntegerToInt64(result, &value));
  EXPECT_EQ(42, value);
}

TEST_CASE() [55/600]

dart::TEST_CASE

(

DartAPI_DebugName

)

Definition at line 4840 of file dart_api_impl_test.cc.

                             {
  Dart_Handle debug_name = Dart_DebugName();
  EXPECT_VALID(debug_name);
  EXPECT(Dart_IsString(debug_name));
}

TEST_CASE() [56/600]

dart::TEST_CASE

(

DartAPI_DeepStackTraceInfo

)

Definition at line 318 of file dart_api_impl_test.cc.

                                      {
  const char* kScriptChars =
      "foo(n) => n == 1 ? throw new Error() : foo(n-1);\n"
      "testMain() => foo(100);\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle error = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
 
  EXPECT(Dart_IsError(error));
 
  Dart_StackTrace stacktrace;
  Dart_Handle result = Dart_GetStackTraceFromError(error, &stacktrace);
  EXPECT_VALID(result);
 
  intptr_t frame_count = 0;
  result = Dart_StackTraceLength(stacktrace, &frame_count);
  EXPECT_VALID(result);
  EXPECT_EQ(101, frame_count);
  // Test something bigger than the preallocated size to verify nothing was
  // truncated.
  EXPECT(101 > StackTrace::kPreallocatedStackdepth);
 
  Dart_Handle function_name;
  Dart_Handle script_url;
  intptr_t line_number = 0;
  intptr_t column_number = 0;
  const char* cstr = "";
 
  // Top frame at positioned at throw.
  Dart_ActivationFrame frame;
  result = Dart_GetActivationFrame(stacktrace, 0, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("foo", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_SUBSTRING("test-lib", cstr);
  EXPECT_EQ(1, line_number);
  EXPECT_EQ(20, column_number);
 
  // Middle frames positioned at the recursive call.
  for (intptr_t frame_index = 1; frame_index < (frame_count - 1);
       frame_index++) {
    result = Dart_GetActivationFrame(stacktrace, frame_index, &frame);
    EXPECT_VALID(result);
    result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                      &line_number, &column_number);
    EXPECT_VALID(result);
    Dart_StringToCString(function_name, &cstr);
    EXPECT_STREQ("foo", cstr);
    Dart_StringToCString(script_url, &cstr);
    EXPECT_SUBSTRING("test-lib", cstr);
    EXPECT_EQ(1, line_number);
    EXPECT_EQ(40, column_number);
  }
 
  // Bottom frame positioned at testMain().
  result = Dart_GetActivationFrame(stacktrace, frame_count - 1, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("testMain", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_SUBSTRING("test-lib", cstr);
  EXPECT_EQ(2, line_number);
  EXPECT_EQ(15, column_number);
 
  // Out-of-bounds frames.
  result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
  EXPECT(Dart_IsError(result));
  result = Dart_GetActivationFrame(stacktrace, -1, &frame);
  EXPECT(Dart_IsError(result));
}

TEST_CASE() [57/600]

dart::TEST_CASE

(

DartAPI_DoubleValues

)

Definition at line 1359 of file dart_api_impl_test.cc.

                                {
  const double kDoubleVal1 = 201.29;
  const double kDoubleVal2 = 101.19;
  Dart_Handle val1 = Dart_NewDouble(kDoubleVal1);
  EXPECT(Dart_IsDouble(val1));
  Dart_Handle val2 = Dart_NewDouble(kDoubleVal2);
  EXPECT(Dart_IsDouble(val2));
  double out1, out2;
  Dart_Handle result = Dart_DoubleValue(val1, &out1);
  EXPECT_VALID(result);
  EXPECT_EQ(kDoubleVal1, out1);
  result = Dart_DoubleValue(val2, &out2);
  EXPECT_VALID(result);
  EXPECT_EQ(kDoubleVal2, out2);
}

TEST_CASE() [58/600]

dart::TEST_CASE

(

DartAPI_EmptyString

)

Definition at line 926 of file dart_api_impl_test.cc.

                               {
  Dart_Handle empty = Dart_EmptyString();
  EXPECT_VALID(empty);
  EXPECT(!Dart_IsNull(empty));
  EXPECT(Dart_IsString(empty));
  intptr_t length = -1;
  EXPECT_VALID(Dart_StringLength(empty, &length));
  EXPECT_EQ(0, length);
}

TEST_CASE() [59/600]

dart::TEST_CASE

(

DartAPI_EnsureUnwindErrorHandled_WhenKilled

)

Definition at line 727 of file dart_api_impl_test.cc.

                                                       {
  const char* kScriptChars = R"(
import 'dart:isolate';
 
exitRightNow() {
  Isolate.current.kill(priority: Isolate.immediate);
}
 
@pragma("vm:external-name", "Test_nativeFunc")
external void nativeFunc(closure);
 
void Func1() {
  nativeFunc(() => exitRightNow());
}
)";
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, &JustPropagateError_lookup);
  Dart_Handle result;
 
  result = Dart_Invoke(lib, NewString("Func1"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING("isolate terminated by Isolate.kill", Dart_GetError(result));
 
  result = Dart_Invoke(lib, NewString("Func1"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING("No api calls are allowed while unwind is in progress",
                   Dart_GetError(result));
}

TEST_CASE() [60/600]

dart::TEST_CASE

(

DartAPI_EnsureUnwindErrorHandled_WhenSendAndExit

)

Definition at line 756 of file dart_api_impl_test.cc.

                                                            {
  const char* kScriptChars = R"(
import 'dart:isolate';
 
sendAndExitNow() {
  final receivePort = ReceivePort();
  Isolate.exit(receivePort.sendPort, true);
}
 
@pragma("vm:external-name", "Test_nativeFunc")
external void nativeFunc(closure);
 
void Func1() {
  nativeFunc(() => sendAndExitNow());
}
)";
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, &JustPropagateError_lookup);
  Dart_Handle result;
 
  result = Dart_Invoke(lib, NewString("Func1"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING("isolate terminated by Isolate.exit", Dart_GetError(result));
 
  result = Dart_Invoke(lib, NewString("Func1"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING("No api calls are allowed while unwind is in progress",
                   Dart_GetError(result));
}

TEST_CASE() [61/600]

dart::TEST_CASE

(

DartAPI_Error

)

Definition at line 906 of file dart_api_impl_test.cc.

                         {
  Dart_Handle error;
  {
    TransitionNativeToVM transition(thread);
    error = Api::NewError("An %s", "error");
  }
  EXPECT(Dart_IsError(error));
  EXPECT_STREQ("An error", Dart_GetError(error));
}

TEST_CASE() [62/600]

dart::TEST_CASE

(

DartAPI_ErrorHandleBasics

)

Definition at line 212 of file dart_api_impl_test.cc.

                                     {
  const char* kScriptChars =
      "void testMain() {\n"
      "  throw new Exception(\"bad news\");\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle instance = Dart_True();
  Dart_Handle error = Api::NewError("myerror");
  Dart_Handle exception = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
 
  EXPECT_VALID(instance);
  EXPECT(Dart_IsError(error));
  EXPECT(Dart_IsError(exception));
 
  EXPECT(!Dart_ErrorHasException(instance));
  EXPECT(!Dart_ErrorHasException(error));
  EXPECT(Dart_ErrorHasException(exception));
 
  EXPECT_STREQ("", Dart_GetError(instance));
  EXPECT_STREQ("myerror", Dart_GetError(error));
  EXPECT_STREQ(ZONE_STR("Unhandled exception:\n"
                        "Exception: bad news\n"
                        "#0      testMain (%s:2:3)",
                        TestCase::url()),
               Dart_GetError(exception));
 
  EXPECT(Dart_IsError(Dart_ErrorGetException(instance)));
  EXPECT(Dart_IsError(Dart_ErrorGetException(error)));
  EXPECT_VALID(Dart_ErrorGetException(exception));
  EXPECT(Dart_IsError(Dart_ErrorGetStackTrace(instance)));
  EXPECT(Dart_IsError(Dart_ErrorGetStackTrace(error)));
  EXPECT_VALID(Dart_ErrorGetStackTrace(exception));
}

TEST_CASE() [63/600]

dart::TEST_CASE

(

DartAPI_ErrorHandleTypes

)

Definition at line 611 of file dart_api_impl_test.cc.

                                    {
  Dart_Handle not_error = NewString("NotError");
  Dart_Handle api_error = Dart_NewApiError("ApiError");
  Dart_Handle exception_error =
      Dart_NewUnhandledExceptionError(NewString("ExceptionError"));
  Dart_Handle compile_error = Dart_NewCompilationError("CompileError");
  Dart_Handle fatal_error;
  {
    TransitionNativeToVM transition(thread);
    const String& fatal_message = String::Handle(String::New("FatalError"));
    fatal_error = Api::NewHandle(thread, UnwindError::New(fatal_message));
  }
 
  EXPECT_VALID(not_error);
  EXPECT(Dart_IsError(api_error));
  EXPECT(Dart_IsError(exception_error));
  EXPECT(Dart_IsError(compile_error));
  EXPECT(Dart_IsError(fatal_error));
 
  EXPECT(!Dart_IsApiError(not_error));
  EXPECT(Dart_IsApiError(api_error));
  EXPECT(!Dart_IsApiError(exception_error));
  EXPECT(!Dart_IsApiError(compile_error));
  EXPECT(!Dart_IsApiError(fatal_error));
 
  EXPECT(!Dart_IsUnhandledExceptionError(not_error));
  EXPECT(!Dart_IsUnhandledExceptionError(api_error));
  EXPECT(Dart_IsUnhandledExceptionError(exception_error));
  EXPECT(!Dart_IsUnhandledExceptionError(compile_error));
  EXPECT(!Dart_IsUnhandledExceptionError(fatal_error));
 
  EXPECT(!Dart_IsCompilationError(not_error));
  EXPECT(!Dart_IsCompilationError(api_error));
  EXPECT(!Dart_IsCompilationError(exception_error));
  EXPECT(Dart_IsCompilationError(compile_error));
  EXPECT(!Dart_IsCompilationError(fatal_error));
 
  EXPECT(!Dart_IsFatalError(not_error));
  EXPECT(!Dart_IsFatalError(api_error));
  EXPECT(!Dart_IsFatalError(exception_error));
  EXPECT(!Dart_IsFatalError(compile_error));
  EXPECT(Dart_IsFatalError(fatal_error));
 
  EXPECT_STREQ("", Dart_GetError(not_error));
  EXPECT_STREQ("ApiError", Dart_GetError(api_error));
  EXPECT_SUBSTRING("Unhandled exception:\nExceptionError",
                   Dart_GetError(exception_error));
  EXPECT_STREQ("CompileError", Dart_GetError(compile_error));
  EXPECT_STREQ("FatalError", Dart_GetError(fatal_error));
}

TEST_CASE() [64/600]

dart::TEST_CASE

(

DartAPI_ExternalAllocationDuringNoCallbackScope

)

Definition at line 3011 of file dart_api_impl_test.cc.

                                                           {
  Dart_Handle bytes = Dart_NewTypedData(Dart_TypedData_kUint8, 100);
  EXPECT_VALID(bytes);
 
  intptr_t gc_count_before = Thread::Current()->heap()->Collections(Heap::kNew);
 
  Dart_TypedData_Type type;
  void* data;
  intptr_t len;
  Dart_Handle result = Dart_TypedDataAcquireData(bytes, &type, &data, &len);
  EXPECT_VALID(result);
 
  Dart_WeakPersistentHandle weak =
      Dart_NewWeakPersistentHandle(bytes, nullptr, 100 * MB, NopCallback);
  EXPECT_VALID(reinterpret_cast<Dart_Handle>(weak));
 
  EXPECT_EQ(gc_count_before,
            Thread::Current()->heap()->Collections(Heap::kNew));
 
  result = Dart_TypedDataReleaseData(bytes);
  EXPECT_VALID(result);
 
  EXPECT_LT(gc_count_before,
            Thread::Current()->heap()->Collections(Heap::kNew));
}

TEST_CASE() [65/600]

dart::TEST_CASE

(

DartAPI_ExternalByteDataAccess

)

Definition at line 2281 of file dart_api_impl_test.cc.

                                          {
  // TODO(asiva): Once we have getInt16LE and getInt16BE support use the
  // appropriate getter instead of the host endian format used now.
  const char* kScriptChars = R"(
import 'dart:typed_data';
class Expect {
  static equals(a, b) {
    if (a != b) {
      throw 'not equal. expected: $a, got: $b';
    }
  }
}
@pragma("vm:external-name", "CreateExternalByteData")
external ByteData createExternalByteData();
ByteData main() {
  var length = 16;
  var a = createExternalByteData();
  Expect.equals(length, a.lengthInBytes);
  for (int i = 0; i < length; i+=2) {
    Expect.equals(0x4241, a.getInt16(i, Endian.little));
  }
  for (int i = 0; i < length; i+=2) {
    a.setInt8(i, 0x24);
    a.setInt8(i + 1, 0x28);
  }
  for (int i = 0; i < length; i+=2) {
    Expect.equals(0x2824, a.getInt16(i, Endian.little));
  }
  return a;
}
)";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle result =
      Dart_SetNativeResolver(lib, &ExternalByteDataNativeResolver, nullptr);
  EXPECT_VALID(result);
 
  // Invoke 'main' function.
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
 
  for (intptr_t i = 0; i < kExtLength; i += 2) {
    EXPECT_EQ(0x24, data[i]);
    EXPECT_EQ(0x28, data[i + 1]);
  }
}

TEST_CASE() [66/600]

dart::TEST_CASE

(

DartAPI_ExternalByteDataFinalizer

)

Definition at line 2336 of file dart_api_impl_test.cc.

                                             {
  // Check finalizer associated with the underlying array instead of the
  // wrapper.
  const char* kScriptChars =
      "var array;\n"
      "extractAndSaveArray(byteData) {\n"
      "  array = byteData.buffer.asUint8List();\n"
      "}\n"
      "releaseArray() {\n"
      "  array = null;\n"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  {
    Dart_EnterScope();
 
    const intptr_t kBufferSize = 100;
    void* buffer = malloc(kBufferSize);
    // The buffer becomes readable by Dart, so ensure it is initialized to
    // satisfy our eager MSAN check.
    memset(buffer, 0, kBufferSize);
    Dart_Handle byte_data = Dart_NewExternalTypedDataWithFinalizer(
        Dart_TypedData_kByteData, buffer, kBufferSize, buffer, kBufferSize,
        ByteDataFinalizer);
 
    Dart_Handle result =
        Dart_Invoke(lib, NewString("extractAndSaveArray"), 1, &byte_data);
    EXPECT_VALID(result);
 
    // ByteData wrapper is still reachable from the scoped handle.
    EXPECT(!byte_data_finalizer_run);
 
    // The ByteData wrapper is now unreachable, but the underlying
    // ExternalUint8List is still alive.
    Dart_ExitScope();
  }
 
  {
    TransitionNativeToVM transition(Thread::Current());
    GCTestHelper::CollectAllGarbage();
  }
 
  EXPECT(!byte_data_finalizer_run);
 
  Dart_Handle result = Dart_Invoke(lib, NewString("releaseArray"), 0, nullptr);
  EXPECT_VALID(result);
 
  {
    TransitionNativeToVM transition(Thread::Current());
    GCTestHelper::CollectAllGarbage();
  }
 
  EXPECT(byte_data_finalizer_run);
}

TEST_CASE() [67/600]

dart::TEST_CASE

(

DartAPI_ExternalClampedTypedDataAccess

)

Definition at line 3102 of file dart_api_impl_test.cc.

                                                  {
  uint8_t data[] = {0, 11, 22, 33, 44, 55, 66, 77};
  intptr_t data_length = ARRAY_SIZE(data);
 
  Dart_Handle obj = Dart_NewExternalTypedData(Dart_TypedData_kUint8Clamped,
                                              data, data_length);
  ExternalTypedDataAccessTests(obj, Dart_TypedData_kUint8Clamped, data,
                               data_length);
}

TEST_CASE() [68/600]

dart::TEST_CASE

(

DartAPI_ExternalTypedDataAccess

)

Definition at line 3093 of file dart_api_impl_test.cc.

                                           {
  uint8_t data[] = {0, 11, 22, 33, 44, 55, 66, 77};
  intptr_t data_length = ARRAY_SIZE(data);
 
  Dart_Handle obj =
      Dart_NewExternalTypedData(Dart_TypedData_kUint8, data, data_length);
  ExternalTypedDataAccessTests(obj, Dart_TypedData_kUint8, data, data_length);
}

TEST_CASE() [69/600]

dart::TEST_CASE

(

DartAPI_ExternalTypedDataCallback

)

Definition at line 3155 of file dart_api_impl_test.cc.

                                             {
  int peer = 0;
  {
    Dart_EnterScope();
    uint8_t data[] = {1, 2, 3, 4};
    Dart_Handle obj = Dart_NewExternalTypedDataWithFinalizer(
        Dart_TypedData_kUint8, data, ARRAY_SIZE(data), &peer, sizeof(data),
        ExternalTypedDataFinalizer);
    EXPECT_VALID(obj);
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    EXPECT(peer == 0);
    GCTestHelper::CollectNewSpace();
    EXPECT(peer == 42);
  }
}

TEST_CASE() [70/600]

dart::TEST_CASE

(

DartAPI_ExternalTypedDataPretenure

)

Definition at line 1709 of file dart_api_impl_test.cc.

                                              {
  {
    Dart_EnterScope();
    const int kBigLength = 16 * MB / 8;
    int64_t* big_data = new int64_t[kBigLength]();
    Dart_Handle big =
        Dart_NewExternalTypedData(Dart_TypedData_kInt64, big_data, kBigLength);
    EXPECT_VALID(big);
    const int kSmallLength = 16 * KB / 8;
    int64_t* small_data = new int64_t[kSmallLength]();
    Dart_Handle small = Dart_NewExternalTypedData(Dart_TypedData_kInt64,
                                                  small_data, kSmallLength);
    EXPECT_VALID(small);
    {
      CHECK_API_SCOPE(thread);
      TransitionNativeToVM transition(thread);
      HANDLESCOPE(thread);
      ExternalTypedData& handle = ExternalTypedData::Handle();
      handle ^= Api::UnwrapHandle(big);
      EXPECT(handle.IsOld());
      handle ^= Api::UnwrapHandle(small);
      EXPECT(handle.IsNew());
    }
    Dart_ExitScope();
    delete[] big_data;
    delete[] small_data;
  }
}

TEST_CASE() [71/600]

dart::TEST_CASE

(

DartAPI_ExternalUint8ClampedArrayAccess

)

Definition at line 3112 of file dart_api_impl_test.cc.

                                                   {
  const char* kScriptChars =
      "testClamped(List a) {\n"
      "  if (a[1] != 11) return false;\n"
      "  a[1] = 3;\n"
      "  if (a[1] != 3) return false;\n"
      "  a[1] = -12;\n"
      "  if (a[1] != 0) return false;\n"
      "  a[1] = 1200;\n"
      "  if (a[1] != 255) return false;\n"
      "  return true;\n"
      "}\n";
 
  uint8_t data[] = {0, 11, 22, 33, 44, 55, 66, 77};
  intptr_t data_length = ARRAY_SIZE(data);
  Dart_Handle obj = Dart_NewExternalTypedData(Dart_TypedData_kUint8Clamped,
                                              data, data_length);
  EXPECT_VALID(obj);
  Dart_Handle result;
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle args[1];
  args[0] = obj;
  result = Dart_Invoke(lib, NewString("testClamped"), 1, args);
 
  // Check that result is true.
  EXPECT_VALID(result);
  EXPECT(Dart_IsBoolean(result));
  bool value = false;
  result = Dart_BooleanValue(result, &value);
  EXPECT_VALID(result);
  EXPECT(value);
}

TEST_CASE() [72/600]

dart::TEST_CASE

(

DartAPI_FieldAccess

)

Definition at line 5149 of file dart_api_impl_test.cc.

                               {
  const char* kScriptChars =
      "class BaseFields {\n"
      "  BaseFields()\n"
      "    : this.inherited_fld = 'inherited' {\n"
      "  }\n"
      "  var inherited_fld;\n"
      "  static var non_inherited_fld;\n"
      "}\n"
      "\n"
      "class Fields extends BaseFields {\n"
      "  Fields()\n"
      "    : this.instance_fld = 'instance',\n"
      "      this._instance_fld = 'hidden instance',\n"
      "      this.final_instance_fld = 'final instance',\n"
      "      this._final_instance_fld = 'hidden final instance' {\n"
      "    instance_getset_fld = 'instance getset';\n"
      "    _instance_getset_fld = 'hidden instance getset';\n"
      "  }\n"
      "\n"
      "  static Init() {\n"
      "    static_fld = 'static';\n"
      "    _static_fld = 'hidden static';\n"
      "    static_getset_fld = 'static getset';\n"
      "    _static_getset_fld = 'hidden static getset';\n"
      "  }\n"
      "\n"
      "  var instance_fld;\n"
      "  var _instance_fld;\n"
      "  final final_instance_fld;\n"
      "  final _final_instance_fld;\n"
      "  static var static_fld;\n"
      "  static var _static_fld;\n"
      "  static const const_static_fld = 'const static';\n"
      "  static const _const_static_fld = 'hidden const static';\n"
      "\n"
      "  get instance_getset_fld { return _gs_fld1; }\n"
      "  void set instance_getset_fld(var value) { _gs_fld1 = value; }\n"
      "  get _instance_getset_fld { return _gs_fld2; }\n"
      "  void set _instance_getset_fld(var value) { _gs_fld2 = value; }\n"
      "  var _gs_fld1;\n"
      "  var _gs_fld2;\n"
      "\n"
      "  static get static_getset_fld { return _gs_fld3; }\n"
      "  static void set static_getset_fld(var value) { _gs_fld3 = value; }\n"
      "  static get _static_getset_fld { return _gs_fld4; }\n"
      "  static void set _static_getset_fld(var value) { _gs_fld4 = value; }\n"
      "  static var _gs_fld3;\n"
      "  static var _gs_fld4;\n"
      "}\n"
      "var top_fld;\n"
      "var _top_fld;\n"
      "const const_top_fld = 'const top';\n"
      "const _const_top_fld = 'hidden const top';\n"
      "\n"
      "get top_getset_fld { return _gs_fld5; }\n"
      "void set top_getset_fld(var value) { _gs_fld5 = value; }\n"
      "get _top_getset_fld { return _gs_fld6; }\n"
      "void set _top_getset_fld(var value) { _gs_fld6 = value; }\n"
      "var _gs_fld5;\n"
      "var _gs_fld6;\n"
      "\n"
      "Fields test() {\n"
      "  Fields.Init();\n"
      "  top_fld = 'top';\n"
      "  _top_fld = 'hidden top';\n"
      "  top_getset_fld = 'top getset';\n"
      "  _top_getset_fld = 'hidden top getset';\n"
      "  return new Fields();\n"
      "}\n";
  const char* kImportedScriptChars =
      "library library_name;\n"
      "var imported_fld = 'imported';\n"
      "var _imported_fld = 'hidden imported';\n"
      "get imported_getset_fld { return _gs_fld1; }\n"
      "void set imported_getset_fld(var value) { _gs_fld1 = value; }\n"
      "get _imported_getset_fld { return _gs_fld2; }\n"
      "void set _imported_getset_fld(var value) { _gs_fld2 = value; }\n"
      "var _gs_fld1;\n"
      "var _gs_fld2;\n"
      "void test2() {\n"
      "  imported_getset_fld = 'imported getset';\n"
      "  _imported_getset_fld = 'hidden imported getset';\n"
      "}\n";
 
  // Shared setup.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("Fields"), 0, nullptr);
  EXPECT_VALID(type);
  Dart_Handle instance = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(instance);
  Dart_Handle name;
 
  // Load imported lib.
  Dart_Handle imported_lib =
      TestCase::LoadTestLibrary("library_url", kImportedScriptChars);
  EXPECT_VALID(imported_lib);
  Dart_Handle result = Dart_FinalizeLoading(false);
  EXPECT_VALID(result);
  result = Dart_Invoke(imported_lib, NewString("test2"), 0, nullptr);
  EXPECT_VALID(result);
 
  // Instance field.
  name = NewString("instance_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(type, name);
  TestFieldOk(instance, name, false, "instance");
 
  // Hidden instance field.
  name = NewString("_instance_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(type, name);
  TestFieldOk(instance, name, false, "hidden instance");
 
  // Final instance field.
  name = NewString("final_instance_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(type, name);
  TestFieldOk(instance, name, true, "final instance");
 
  // Hidden final instance field.
  name = NewString("_final_instance_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(type, name);
  TestFieldOk(instance, name, true, "hidden final instance");
 
  // Inherited field.
  name = NewString("inherited_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(type, name);
  TestFieldOk(instance, name, false, "inherited");
 
  // Instance get/set field.
  name = NewString("instance_getset_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(type, name);
  TestFieldOk(instance, name, false, "instance getset");
 
  // Hidden instance get/set field.
  name = NewString("_instance_getset_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(type, name);
  TestFieldOk(instance, name, false, "hidden instance getset");
 
  // Static field.
  name = NewString("static_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(type, name, false, "static");
 
  // Hidden static field.
  name = NewString("_static_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(type, name, false, "hidden static");
 
  // Static final field.
  name = NewString("const_static_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(type, name, true, "const static");
 
  // Hidden static const field.
  name = NewString("_const_static_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(type, name, true, "hidden const static");
 
  // Static non-inherited field.  Not found at any level.
  name = NewString("non_inherited_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(instance, name);
  TestFieldNotFound(type, name);
 
  // Static get/set field.
  name = NewString("static_getset_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(type, name, false, "static getset");
 
  // Hidden static get/set field.
  name = NewString("_static_getset_fld");
  TestFieldNotFound(lib, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(type, name, false, "hidden static getset");
 
  // Top-Level field.
  name = NewString("top_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(lib, name, false, "top");
 
  // Hidden top-level field.
  name = NewString("_top_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(lib, name, false, "hidden top");
 
  // Top-Level final field.
  name = NewString("const_top_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(lib, name, true, "const top");
 
  // Hidden top-level final field.
  name = NewString("_const_top_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(lib, name, true, "hidden const top");
 
  // Top-Level get/set field.
  name = NewString("top_getset_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(lib, name, false, "top getset");
 
  // Hidden top-level get/set field.
  name = NewString("_top_getset_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldOk(lib, name, false, "hidden top getset");
 
  // Imported top-Level field.
  name = NewString("imported_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldNotFound(lib, name);
 
  // Hidden imported top-level field.  Not found at any level.
  name = NewString("_imported_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldNotFound(lib, name);
 
  // Imported top-Level get/set field.
  name = NewString("imported_getset_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldNotFound(lib, name);
 
  // Hidden imported top-level get/set field.  Not found at any level.
  name = NewString("_imported_getset_fld");
  TestFieldNotFound(type, name);
  TestFieldNotFound(instance, name);
  TestFieldNotFound(lib, name);
}

TEST_CASE() [73/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandle

)

Definition at line 3604 of file dart_api_impl_test.cc.

                                     {
  void* peer = reinterpret_cast<void*>(0);
  Dart_Handle local_new_ref = Dart_Null();
  finalizable_new_ref = Dart_NewFinalizableHandle(local_new_ref, peer, 0,
                                                  FinalizableHandleCallback);
  finalizable_new_ref_peer = peer;
 
  peer = reinterpret_cast<void*>(1);
  Dart_Handle local_old_ref = Dart_Null();
  finalizable_old_ref = Dart_NewFinalizableHandle(local_old_ref, peer, 0,
                                                  FinalizableHandleCallback);
  finalizable_old_ref_peer = peer;
 
  {
    Dart_EnterScope();
 
    Dart_Handle new_ref, old_ref;
    {
      // GCs due to allocations or weak handle creation can cause early
      // promotion and interfere with the scenario this test is verifying.
      ForceGrowthScope force_growth(thread);
 
      // Create an object in new space.
      new_ref = AllocateNewString("new string");
      EXPECT_VALID(new_ref);
 
      // Create an object in old space.
      old_ref = AllocateOldString("old string");
      EXPECT_VALID(old_ref);
 
      // Create a weak ref to the new space object.
      peer = reinterpret_cast<void*>(2);
      finalizable_new_ref = Dart_NewFinalizableHandle(
          new_ref, peer, 0, FinalizableHandleCallback);
      finalizable_new_ref_peer = peer;
 
      // Create a weak ref to the old space object.
      peer = reinterpret_cast<void*>(3);
      finalizable_old_ref = Dart_NewFinalizableHandle(
          old_ref, peer, 0, FinalizableHandleCallback);
      finalizable_old_ref_peer = peer;
    }
 
    {
      TransitionNativeToVM transition(thread);
      // Garbage collect new space.
      GCTestHelper::CollectNewSpace();
    }
 
    // Nothing should be invalidated or cleared.
    EXPECT_VALID(new_ref);
    EXPECT(!Dart_IsNull(new_ref));
    EXPECT_VALID(old_ref);
    EXPECT(!Dart_IsNull(old_ref));
 
    {
      TransitionNativeToVM transition(thread);
      // Garbage collect old space.
      GCTestHelper::CollectOldSpace();
    }
 
    // Nothing should be invalidated or cleared.
    EXPECT_VALID(new_ref);
    EXPECT(!Dart_IsNull(new_ref));
    EXPECT_VALID(old_ref);
    EXPECT(!Dart_IsNull(old_ref));
 
    // Delete local (strong) references.
    Dart_ExitScope();
  }
 
  {
    TransitionNativeToVM transition(thread);
    // Garbage collect new space again.
    GCTestHelper::CollectNewSpace();
  }
 
  {
    Dart_EnterScope();
    // Weak ref to new space object should now be cleared.
    EXPECT(finalizable_new_ref == nullptr);
    Dart_ExitScope();
  }
 
  {
    TransitionNativeToVM transition(thread);
    // Garbage collect old space again.
    GCTestHelper::CollectOldSpace();
  }
 
  {
    Dart_EnterScope();
    // Weak ref to old space object should now be cleared.
    EXPECT(finalizable_new_ref == nullptr);
    EXPECT(finalizable_old_ref == nullptr);
    Dart_ExitScope();
  }
 
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectAllGarbage();
  }
}

TEST_CASE() [74/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandleCallback

)

Definition at line 3957 of file dart_api_impl_test.cc.

                                             {
  int peer = 0;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("new string");
    EXPECT_VALID(obj);
    Dart_NewFinalizableHandle(obj, &peer, 0, FinalizableHandlePeerFinalizer);
    EXPECT(peer == 0);
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
    EXPECT(peer == 42);
  }
}

TEST_CASE() [75/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandleCleanupFinalizer

)

Definition at line 3897 of file dart_api_impl_test.cc.

                                                     {
  Heap* heap = IsolateGroup::Current()->heap();
 
  const char* kTestString1 = "Test String1";
  Dart_EnterScope();
  CHECK_API_SCOPE(thread);
  Dart_Handle ref1 = Dart_NewStringFromCString(kTestString1);
  persistent_handle1 = Dart_NewPersistentHandle(ref1);
  Dart_Handle ref2 = Dart_NewStringFromCString(kTestString1);
  int peer2 = 0;
  weak_persistent_handle2 =
      Dart_NewWeakPersistentHandle(ref2, &peer2, 0, NopCallback);
  int peer3 = 0;
  {
    Dart_EnterScope();
    Dart_Handle ref3 = Dart_NewStringFromCString(kTestString1);
    finalizable_handle3 = Dart_NewFinalizableHandle(
        ref3, &peer3, 0, FinalizableHandlePeerCleanupFinalizer);
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectAllGarbage();
    EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
    EXPECT(peer3 == 42);
  }
  Dart_ExitScope();
}

TEST_CASE() [76/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandleErrors

)

Definition at line 3768 of file dart_api_impl_test.cc.

                                           {
  Dart_EnterScope();
 
  // nullptr callback.
  Dart_Handle obj1 = NewString("new string");
  EXPECT_VALID(obj1);
  Dart_FinalizableHandle ref1 =
      Dart_NewFinalizableHandle(obj1, nullptr, 0, nullptr);
  EXPECT_EQ(ref1, static_cast<void*>(nullptr));
 
  // Immediate object.
  Dart_Handle obj2 = Dart_NewInteger(0);
  EXPECT_VALID(obj2);
  Dart_FinalizableHandle ref2 =
      Dart_NewFinalizableHandle(obj2, nullptr, 0, FinalizableHandleCallback);
  EXPECT_EQ(ref2, static_cast<void*>(nullptr));
 
  // Pointer object.
  Dart_Handle ffi_lib = Dart_LookupLibrary(NewString("dart:ffi"));
  Dart_Handle pointer_type =
      Dart_GetNonNullableType(ffi_lib, NewString("Pointer"), 0, nullptr);
  Dart_Handle obj3 = Dart_Allocate(pointer_type);
  EXPECT_VALID(obj3);
  Dart_FinalizableHandle ref3 =
      Dart_NewFinalizableHandle(obj3, nullptr, 0, FinalizableHandleCallback);
  EXPECT_EQ(ref3, static_cast<void*>(nullptr));
 
  // Subtype of Struct or Union object.
  const char* kScriptChars = R"(
      import 'dart:ffi';
 
      final class MyStruct extends Struct {
        external Pointer notEmpty;
      }
 
      final class MyUnion extends Union {
        external Pointer notEmpty;
      }
  )";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle my_struct_type =
      Dart_GetNonNullableType(lib, NewString("MyStruct"), 0, nullptr);
  Dart_Handle obj4 = Dart_Allocate(my_struct_type);
  EXPECT_VALID(obj4);
  Dart_FinalizableHandle ref4 =
      Dart_NewFinalizableHandle(obj4, nullptr, 0, FinalizableHandleCallback);
  EXPECT_EQ(ref4, static_cast<void*>(nullptr));
 
  Dart_Handle my_union_type =
      Dart_GetNonNullableType(lib, NewString("MyUnion"), 0, nullptr);
  Dart_Handle obj5 = Dart_Allocate(my_union_type);
  EXPECT_VALID(obj5);
  Dart_FinalizableHandle ref5 =
      Dart_NewFinalizableHandle(obj4, nullptr, 0, FinalizableHandleCallback);
  EXPECT_EQ(ref5, static_cast<void*>(nullptr));
 
  Dart_ExitScope();
}

TEST_CASE() [77/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandleExternalAllocationSize

)

Definition at line 4144 of file dart_api_impl_test.cc.

                                                           {
  Heap* heap = IsolateGroup::Current()->heap();
  EXPECT_EQ(heap->ExternalInWords(Heap::kNew), 0);
  EXPECT_EQ(heap->ExternalInWords(Heap::kOld), 0);
  const intptr_t kWeak1ExternalSize = 1 * KB;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("weakly referenced string");
    EXPECT_VALID(obj);
    Dart_NewFinalizableHandle(obj, nullptr, kWeak1ExternalSize, NopCallback);
    Dart_ExitScope();
  }
  Dart_PersistentHandle strong_ref = nullptr;
  const intptr_t kWeak2ExternalSize = 2 * KB;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("strongly referenced string");
    EXPECT_VALID(obj);
    strong_ref = Dart_NewPersistentHandle(obj);
    Dart_NewFinalizableHandle(obj, nullptr, kWeak2ExternalSize, NopCallback);
    EXPECT_VALID(AsHandle(strong_ref));
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    EXPECT_EQ(heap->ExternalInWords(Heap::kNew),
              (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
    EXPECT_EQ(heap->ExternalInWords(Heap::kOld), 0);
    // Collect weakly referenced string.
    GCTestHelper::CollectNewSpace();
    EXPECT_EQ(heap->ExternalInWords(Heap::kNew),
              kWeak2ExternalSize / kWordSize);
    EXPECT_EQ(heap->ExternalInWords(Heap::kOld), 0);
    // Promote strongly referenced string.
    GCTestHelper::CollectNewSpace();
    EXPECT_EQ(heap->ExternalInWords(Heap::kNew), 0);
    EXPECT_EQ(heap->ExternalInWords(Heap::kOld),
              kWeak2ExternalSize / kWordSize);
  }
  Dart_DeletePersistentHandle(strong_ref);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(heap->ExternalInWords(Heap::kNew), 0);
    EXPECT_EQ(heap->ExternalInWords(Heap::kOld), 0);
  }
}

TEST_CASE() [78/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandleExternalAllocationSizeNewspaceGC

)

Definition at line 4234 of file dart_api_impl_test.cc.

                                                                     {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_FinalizableHandle weak1 = nullptr;
  Dart_PersistentHandle strong1 = nullptr;
  // Large enough to exceed any new space limit. Not actually allocated.
  const intptr_t kWeak1ExternalSize = 500 * MB;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("weakly referenced string");
    EXPECT_VALID(obj);
    // Triggers a scavenge immediately, since kWeak1ExternalSize is above limit.
    weak1 = Dart_NewFinalizableHandle(obj, nullptr, kWeak1ExternalSize,
                                      NopCallback);
    strong1 = Dart_NewPersistentHandle(obj);
    // ... but the object is still alive and not yet promoted, so external size
    // in new space is still above the limit. Thus, even the following tiny
    // external allocation will trigger another scavenge.
    Dart_FinalizableHandle trigger =
        Dart_NewFinalizableHandle(obj, nullptr, 1, NopCallback);
    Dart_DeleteFinalizableHandle(trigger, obj);
    // After the two scavenges above, 'obj' should now be promoted, hence its
    // external size charged to old space.
    {
      CHECK_API_SCOPE(thread);
      TransitionNativeToVM transition(thread);
      HANDLESCOPE(thread);
      String& handle = String::Handle(thread->zone());
      handle ^= Api::UnwrapHandle(obj);
      EXPECT(handle.IsOld());
    }
    EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
    EXPECT(heap->ExternalInWords(Heap::kOld) == kWeak1ExternalSize / kWordSize);
    Dart_ExitScope();
  }
  Dart_DeleteFinalizableHandle(weak1, strong1);
  Dart_DeletePersistentHandle(strong1);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  }
}

TEST_CASE() [79/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandleExternalAllocationSizeOddReferents

)

Definition at line 4391 of file dart_api_impl_test.cc.

                                                                       {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_FinalizableHandle weak1 = nullptr;
  Dart_PersistentHandle strong1 = nullptr;
  const intptr_t kWeak1ExternalSize = 1 * KB;
  Dart_FinalizableHandle weak2 = nullptr;
  Dart_PersistentHandle strong2 = nullptr;
  const intptr_t kWeak2ExternalSize = 2 * KB;
  EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  {
    Dart_EnterScope();
    Dart_Handle dart_true = Dart_True();  // VM heap object.
    EXPECT_VALID(dart_true);
    weak1 = Dart_NewFinalizableHandle(dart_true, nullptr, kWeak1ExternalSize,
                                      UnreachedCallback);
    strong1 = Dart_NewPersistentHandle(dart_true);
    Dart_Handle zero = Dart_False();  // VM heap object.
    EXPECT_VALID(zero);
    weak2 = Dart_NewFinalizableHandle(zero, nullptr, kWeak2ExternalSize,
                                      UnreachedCallback);
    strong2 = Dart_NewPersistentHandle(zero);
    // Both should be charged to old space.
    EXPECT(heap->ExternalInWords(Heap::kOld) ==
           (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
    Dart_ExitScope();
  }
  Dart_DeleteFinalizableHandle(weak1, strong1);
  Dart_DeletePersistentHandle(strong1);
  Dart_DeleteFinalizableHandle(weak2, strong2);
  Dart_DeletePersistentHandle(strong2);
  EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  }
}

TEST_CASE() [80/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandleExternalAllocationSizeOldspaceGC

)

Definition at line 4320 of file dart_api_impl_test.cc.

                                                                     {
  // Check that external allocation in old space can trigger GC.
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_EnterScope();
  Dart_Handle live = AllocateOldString("live");
  EXPECT_VALID(live);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::WaitForGCTasks();  // Finalize GC for accurate live size.
    EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  }
  const intptr_t kSmallExternalSize = 1 * KB;
  {
    Dart_EnterScope();
    Dart_Handle dead = AllocateOldString("dead");
    EXPECT_VALID(dead);
    Dart_NewFinalizableHandle(dead, nullptr, kSmallExternalSize, NopCallback);
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::WaitForGCTasks();  // Finalize GC for accurate live size.
    EXPECT_EQ(kSmallExternalSize,
              heap->ExternalInWords(Heap::kOld) * kWordSize);
  }
  // Large enough to trigger GC in old space. Not actually allocated.
  const intptr_t kHugeExternalSize = (kWordSize == 4) ? 513 * MB : 1025 * MB;
  Dart_NewFinalizableHandle(live, nullptr, kHugeExternalSize, NopCallback);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::WaitForGCTasks();  // Finalize GC for accurate live size.
    // Expect small garbage to be collected.
    EXPECT_EQ(kHugeExternalSize, heap->ExternalInWords(Heap::kOld) * kWordSize);
  }
  Dart_ExitScope();
}

TEST_CASE() [81/600]

dart::TEST_CASE

(

DartAPI_FinalizableHandleNoCallback

)

Definition at line 3998 of file dart_api_impl_test.cc.

                                               {
  Dart_FinalizableHandle weak_ref = nullptr;
  Dart_PersistentHandle strong_ref = nullptr;
  int peer = 0;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("new string");
    EXPECT_VALID(obj);
    weak_ref = Dart_NewFinalizableHandle(obj, &peer, 0,
                                         FinalizableHandlePeerFinalizer);
    strong_ref = Dart_NewPersistentHandle(obj);
    Dart_ExitScope();
  }
  // A finalizer is not invoked on a deleted handle.  Therefore, the
  // peer value should not change after the referent is collected.
  Dart_DeleteFinalizableHandle(weak_ref, strong_ref);
  Dart_DeletePersistentHandle(strong_ref);
  EXPECT(peer == 0);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT(peer == 0);
    GCTestHelper::CollectNewSpace();
    EXPECT(peer == 0);
  }
}

TEST_CASE() [82/600]

dart::TEST_CASE

(

DartAPI_Float32x4List

)

Definition at line 3246 of file dart_api_impl_test.cc.

                                 {
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "Float32x4List float32x4() {\n"
      "  return new Float32x4List(10);\n"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle obj = Dart_Invoke(lib, NewString("float32x4"), 0, nullptr);
  EXPECT_VALID(obj);
  CheckFloat32x4Data(obj);
 
  obj = Dart_NewTypedData(Dart_TypedData_kFloat32x4, 10);
  EXPECT_VALID(obj);
  CheckFloat32x4Data(obj);
 
  int peer = 0;
  float data[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
  // Push a scope so that we can collect the local handle created as part of
  // Dart_NewExternalTypedData.
  Dart_EnterScope();
  {
    Dart_Handle lcl = Dart_NewExternalTypedDataWithFinalizer(
        Dart_TypedData_kFloat32x4, data, 10, &peer, sizeof(data),
        ExternalTypedDataFinalizer);
    CheckFloat32x4Data(lcl);
  }
  Dart_ExitScope();
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
    EXPECT(peer == 42);
  }
}

TEST_CASE() [83/600]

dart::TEST_CASE

(

DartAPI_FunctionIsStatic

)

Definition at line 1191 of file dart_api_impl_test.cc.

                                    {
  const char* kScriptChars =
      "int getInt() { return 1; }\n"
      "class Foo { String getString() => 'foobar'; }\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  Dart_Handle closure = Dart_GetField(lib, NewString("getInt"));
  EXPECT_VALID(closure);
  if (Dart_IsClosure(closure)) {
    closure = Dart_ClosureFunction(closure);
    EXPECT_VALID(closure);
  }
 
  bool is_static = false;
  Dart_Handle result = Dart_FunctionIsStatic(closure, &is_static);
  EXPECT_VALID(result);
  EXPECT(is_static);
 
  Dart_Handle klass =
      Dart_GetNonNullableType(lib, NewString("Foo"), 0, nullptr);
  EXPECT_VALID(klass);
 
  Dart_Handle instance = Dart_Allocate(klass);
 
  closure = Dart_GetField(instance, NewString("getString"));
  EXPECT_VALID(closure);
  if (Dart_IsClosure(closure)) {
    closure = Dart_ClosureFunction(closure);
    EXPECT_VALID(closure);
  }
 
  result = Dart_FunctionIsStatic(closure, &is_static);
  EXPECT_VALID(result);
  EXPECT(!is_static);
}

TEST_CASE() [84/600]

dart::TEST_CASE

(

DartAPI_FunctionName

)

Definition at line 1089 of file dart_api_impl_test.cc.

                                {
  const char* kScriptChars = "int getInt() { return 1; }\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  Dart_Handle closure = Dart_GetField(lib, NewString("getInt"));
  EXPECT_VALID(closure);
  if (Dart_IsClosure(closure)) {
    closure = Dart_ClosureFunction(closure);
    EXPECT_VALID(closure);
  }
 
  Dart_Handle name = Dart_FunctionName(closure);
  EXPECT_VALID(name);
  const char* result_str = "";
  Dart_StringToCString(name, &result_str);
  EXPECT_STREQ(result_str, "getInt");
}

TEST_CASE() [85/600]

dart::TEST_CASE

(

DartAPI_FunctionOwner

)

Definition at line 1109 of file dart_api_impl_test.cc.

                                 {
  const char* kScriptChars = "int getInt() { return 1; }\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  Dart_Handle closure = Dart_GetField(lib, NewString("getInt"));
  EXPECT_VALID(closure);
  if (Dart_IsClosure(closure)) {
    closure = Dart_ClosureFunction(closure);
    EXPECT_VALID(closure);
  }
 
  const char* url = "";
  Dart_Handle owner = Dart_FunctionOwner(closure);
  EXPECT_VALID(owner);
  Dart_Handle owner_url = Dart_LibraryUrl(owner);
  EXPECT_VALID(owner_url);
  Dart_StringToCString(owner_url, &url);
 
  const char* lib_url = "";
  Dart_Handle library_url = Dart_LibraryUrl(lib);
  EXPECT_VALID(library_url);
  Dart_StringToCString(library_url, &lib_url);
 
  EXPECT_STREQ(url, lib_url);
}

TEST_CASE() [86/600]

dart::TEST_CASE

(

DartAPI_GetField_CheckIsolate

)

Definition at line 5928 of file dart_api_impl_test.cc.

                                         {
  const char* kScriptChars =
      "class TestClass  {\n"
      "  static int fld2 = 11;\n"
      "  static void testMain() {\n"
      "  }\n"
      "}\n";
  Dart_Handle result;
  int64_t value = 0;
 
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("TestClass"), 0, nullptr);
  EXPECT_VALID(type);
 
  result = Dart_GetField(type, NewString("fld2"));
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(11, value);
}

TEST_CASE() [87/600]

dart::TEST_CASE

(

DartAPI_GetNativeArgumentCount

)

Definition at line 7269 of file dart_api_impl_test.cc.

                                          {
  const char* kScriptChars = R"(
class MyObject {
  @pragma("vm:external-name", "Name_Does_Not_Matter")
  external int method1(int i, int j);
}
testMain() {
  MyObject obj = new MyObject();
  return obj.method1(77, 125);
})";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, gnac_lookup);
 
  Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsInteger(result));
 
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);

TEST_CASE() [88/600]

dart::TEST_CASE

(

DartAPI_GetNativeArguments

)

Definition at line 7212 of file dart_api_impl_test.cc.

                                      {
  const char* kScriptChars = R"(
import 'dart:nativewrappers';
base class MyObject extends NativeFieldWrapperClass2 {
  @pragma("vm:external-name", "NativeArgument_Create")
  external static MyObject createObject();
  @pragma("vm:external-name", "NativeArgument_Access")
  external int accessFields(int arg1,
                   int arg2,
                   bool arg3,
                   double arg4,
                   String arg5,
                   String arg6,
                   MyObject arg7);
}
int testMain(String extstr) {
  String str = 'abcdefg';
  MyObject obj1 = MyObject.createObject();
  MyObject obj2 = MyObject.createObject();
  return obj1.accessFields(77,
                           0x8000000000000000,
                           true,
                           3.14,
                           str,
                           extstr,
                           obj2);
})";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, native_args_lookup);
 
  const char* ascii_str = "string";
  intptr_t ascii_str_length = strlen(ascii_str);
  Dart_Handle str = Dart_NewStringFromUTF8(
      reinterpret_cast<const uint8_t*>(ascii_str), ascii_str_length);
 
  Dart_Handle args[1];
  args[0] = str;
  Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 1, args);

TEST_CASE() [89/600]

dart::TEST_CASE

(

DartAPI_GetNonNullableType

)

Definition at line 7411 of file dart_api_impl_test.cc.

                                      {
  const char* kScriptChars =
      "library testlib;\n"
      "class Class {\n"
      "  static var name = 'Class';\n"
      "}\n"
      "\n"
      "class _Class {\n"
      "  static var name = '_Class';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Lookup a class.
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("Class"), 0, nullptr);
  EXPECT_VALID(type);
  bool result = false;
  EXPECT_VALID(Dart_IsNonNullableType(type, &result));
  EXPECT(result);
  Dart_Handle name = Dart_ToString(type);
  EXPECT_VALID(name);
  const char* name_cstr = "";
  EXPECT_VALID(Dart_StringToCString(name, &name_cstr));
  EXPECT_STREQ("Class", name_cstr);
 
  name = Dart_GetField(type, NewString("name"));
  EXPECT_VALID(name);
  EXPECT_VALID(Dart_StringToCString(name, &name_cstr));
  EXPECT_STREQ("Class", name_cstr);
 
  // Lookup a private class.
  type = Dart_GetNonNullableType(lib, NewString("_Class"), 0, nullptr);
  EXPECT_VALID(type);
  result = false;
  EXPECT_VALID(Dart_IsNonNullableType(type, &result));
  EXPECT(result);
 
  name = Dart_GetField(type, NewString("name"));
  EXPECT_VALID(name);
  name_cstr = "";
  EXPECT_VALID(Dart_StringToCString(name, &name_cstr));
  EXPECT_STREQ("_Class", name_cstr);
 
  // Lookup a class that does not exist.
  type = Dart_GetNonNullableType(lib, NewString("DoesNotExist"), 0, nullptr);
  EXPECT(Dart_IsError(type));
  EXPECT_STREQ("Type 'DoesNotExist' not found in library 'testlib'.",
               Dart_GetError(type));
 
  // Lookup a class from an error library.  The error propagates.
  type = Dart_GetNonNullableType(Api::NewError("myerror"), NewString("Class"),
                                 0, nullptr);
  EXPECT(Dart_IsError(type));
  EXPECT_STREQ("myerror", Dart_GetError(type));
 
  // Lookup a type using an error class name.  The error propagates.
  type = Dart_GetNonNullableType(lib, Api::NewError("myerror"), 0, nullptr);

TEST_CASE() [90/600]

dart::TEST_CASE

(

DartAPI_GetNullableType

)

Definition at line 7351 of file dart_api_impl_test.cc.

                                   {
  const char* kScriptChars =
      "library testlib;\n"
      "class Class {\n"
      "  static var name = 'Class';\n"
      "}\n"
      "\n"
      "class _Class {\n"
      "  static var name = '_Class';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Lookup a class.
  Dart_Handle type = Dart_GetNullableType(lib, NewString("Class"), 0, nullptr);
  EXPECT_VALID(type);
  bool result = false;
  EXPECT_VALID(Dart_IsNullableType(type, &result));
  EXPECT(result);
  Dart_Handle name = Dart_ToString(type);
  EXPECT_VALID(name);
  const char* name_cstr = "";
  EXPECT_VALID(Dart_StringToCString(name, &name_cstr));
  EXPECT_STREQ("Class?", name_cstr);
 
  name = Dart_GetField(type, NewString("name"));
  EXPECT_VALID(name);
  EXPECT_VALID(Dart_StringToCString(name, &name_cstr));
  EXPECT_STREQ("Class", name_cstr);
 
  // Lookup a private class.
  type = Dart_GetNullableType(lib, NewString("_Class"), 0, nullptr);
  EXPECT_VALID(type);
  result = false;
  EXPECT_VALID(Dart_IsNullableType(type, &result));
 
  name = Dart_GetField(type, NewString("name"));
  EXPECT_VALID(name);
  name_cstr = "";
  EXPECT_VALID(Dart_StringToCString(name, &name_cstr));
  EXPECT_STREQ("_Class", name_cstr);
 
  // Lookup a class that does not exist.
  type = Dart_GetNullableType(lib, NewString("DoesNotExist"), 0, nullptr);
  EXPECT(Dart_IsError(type));
  EXPECT_STREQ("Type 'DoesNotExist' not found in library 'testlib'.",
               Dart_GetError(type));
 
  // Lookup a class from an error library.  The error propagates.
  type = Dart_GetNullableType(Api::NewError("myerror"), NewString("Class"), 0,
                              nullptr);
  EXPECT(Dart_IsError(type));
  EXPECT_STREQ("myerror", Dart_GetError(type));
 
  // Lookup a type using an error class name.  The error propagates.
  type = Dart_GetNullableType(lib, Api::NewError("myerror"), 0, nullptr);

TEST_CASE() [91/600]

dart::TEST_CASE

(

DartAPI_GetStaticField_RunsInitializer

)

Definition at line 5886 of file dart_api_impl_test.cc.

                                                  {
  const char* kScriptChars =
      "class TestClass  {\n"
      "  static const int fld1 = 7;\n"
      "  static int fld2 = 11;\n"
      "  static void testMain() {\n"
      "  }\n"
      "}\n";
  Dart_Handle result;
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("TestClass"), 0, nullptr);
  EXPECT_VALID(type);
 
  // Invoke a function which returns an object.
  result = Dart_Invoke(type, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
 
  // For uninitialized fields, the getter is returned
  result = Dart_GetField(type, NewString("fld1"));
  EXPECT_VALID(result);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(7, value);
 
  result = Dart_GetField(type, NewString("fld2"));
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(11, value);
 
  // Overwrite fld2
  result = Dart_SetField(type, NewString("fld2"), Dart_NewInteger(13));
  EXPECT_VALID(result);
 
  // We now get the new value for fld2, not the initializer
  result = Dart_GetField(type, NewString("fld2"));
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(13, value);
}

TEST_CASE() [92/600]

dart::TEST_CASE

(

DartAPI_GetStaticMethodClosure

)

Definition at line 1251 of file dart_api_impl_test.cc.

                                          {
  const char* kScriptChars =
      "class Foo {\n"
      "  static int getInt() {\n"
      "    return 1;\n"
      "  }\n"
      "  double getDouble() {\n"
      "    return 1.0;\n"
      "  }\n"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle foo_cls = Dart_GetClass(lib, NewString("Foo"));
  EXPECT_VALID(foo_cls);
 
  Dart_Handle closure =
      Dart_GetStaticMethodClosure(lib, foo_cls, NewString("getInt"));
  EXPECT_VALID(closure);
  EXPECT(Dart_IsClosure(closure));
  Dart_Handle closure_str = Dart_ToString(closure);
  const char* result = "";
  Dart_StringToCString(closure_str, &result);
  EXPECT_SUBSTRING("getInt", result);
 
  Dart_Handle function = Dart_ClosureFunction(closure);
  EXPECT_VALID(function);
  EXPECT(Dart_IsFunction(function));
  Dart_Handle func_str = Dart_ToString(function);
  Dart_StringToCString(func_str, &result);
  EXPECT_SUBSTRING("getInt", result);
 
  Dart_Handle cls = Dart_FunctionOwner(function);
  EXPECT_VALID(cls);
  EXPECT(Dart_IsInstance(cls));
  Dart_Handle cls_str = Dart_ClassName(cls);
  Dart_StringToCString(cls_str, &result);
  EXPECT_SUBSTRING("Foo", result);
 
  EXPECT_ERROR(Dart_ClassName(Dart_Null()),
               "Dart_ClassName expects argument 'cls_type' to be non-null.");
  EXPECT_ERROR(
      Dart_GetStaticMethodClosure(Dart_Null(), foo_cls, NewString("getInt")),
      "Dart_GetStaticMethodClosure expects argument 'library' to be non-null.");
  EXPECT_ERROR(
      Dart_GetStaticMethodClosure(lib, Dart_Null(), NewString("getInt")),
      "Dart_GetStaticMethodClosure expects argument 'cls_type' to be "
      "non-null.");
  EXPECT_ERROR(Dart_GetStaticMethodClosure(lib, foo_cls, Dart_Null()),
               "Dart_GetStaticMethodClosure expects argument 'function_name' "
               "to be non-null.");
}

TEST_CASE() [93/600]

dart::TEST_CASE

(

DartAPI_HeapSampling_APIAllocations

)

Definition at line 10324 of file dart_api_impl_test.cc.

                                                             {
  return nullptr;
}
 
TEST_CASE(Dart_SetFfiNativeResolver_DoesNotResolve) {
  const char* kScriptChars = R"(
    import 'dart:ffi';
    @Native<Void Function()>(symbol: 'DoesNotResolve')
    external void doesNotResolve();
    main() => doesNotResolve();
    )";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  Dart_Handle result = Dart_SetFfiNativeResolver(lib, &NopResolver);
  EXPECT_VALID(result);
 
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_ERROR(result, "Couldn't resolve function: 'DoesNotResolve'");
}
 
TEST_CASE(DartAPI_UserTags) {
  Dart_Handle default_tag = Dart_GetDefaultUserTag();
  EXPECT_VALID(default_tag);
 
  auto default_label =
      Utils::CStringUniquePtr(Dart_GetUserTagLabel(default_tag), std::free);
  EXPECT_STREQ(default_label.get(), "Default");
 
  Dart_Handle current_tag = Dart_GetCurrentUserTag();
  EXPECT(Dart_IdentityEquals(default_tag, current_tag));
 
  auto current_label =
      Utils::CStringUniquePtr(Dart_GetUserTagLabel(current_tag), std::free);
  EXPECT_STREQ(default_label.get(), current_label.get());
 
  Dart_Handle new_tag = Dart_NewUserTag("Foo");
  EXPECT_VALID(new_tag);
 
  auto new_tag_label =
      Utils::CStringUniquePtr(Dart_GetUserTagLabel(new_tag), std::free);
  EXPECT_STREQ(new_tag_label.get(), "Foo");
 
  Dart_Handle old_tag = Dart_SetCurrentUserTag(new_tag);
  EXPECT_VALID(old_tag);
 
  auto old_label =
      Utils::CStringUniquePtr(Dart_GetUserTagLabel(old_tag), std::free);
  EXPECT_STREQ(old_label.get(), default_label.get());
 
  current_tag = Dart_GetCurrentUserTag();
  EXPECT(Dart_IdentityEquals(new_tag, current_tag));
 
  current_label =
      Utils::CStringUniquePtr(Dart_GetUserTagLabel(current_tag), std::free);
  EXPECT_STREQ(current_label.get(), new_tag_label.get());
 
  EXPECT(Dart_GetUserTagLabel(Dart_Null()) == nullptr);
 
  EXPECT_ERROR(Dart_NewUserTag(nullptr),
               "Dart_NewUserTag expects argument 'label' to be non-null");
 
  EXPECT_ERROR(
      Dart_SetCurrentUserTag(Dart_Null()),
      "Dart_SetCurrentUserTag expects argument 'user_tag' to be non-null");
}
 
#endif  // !PRODUCT
 
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
 
static void* last_allocation_context = nullptr;

TEST_CASE() [94/600]

dart::TEST_CASE

(

DartAPI_HeapSampling_NonTrivialSamplingPeriod

)

Definition at line 10399 of file dart_api_impl_test.cc.

                                                    {
  last_allocation_cls = cls_name;
  return strdup(cls_name);
}
 
static void HeapSamplingDelete(void* data) {
  free(data);
}
 
void HeapSamplingReport(void* context, void* data) {
  last_allocation_context = context;
  if (strcmp(reinterpret_cast<char*>(data), expected_allocation_cls) == 0) {
    found_allocation = true;
  }
  heap_samples++;
}
 
void ResetHeapSamplingState(const char* expected_cls = nullptr) {
  heap_samples = 0;
  expected_allocation_cls = expected_cls;
  found_allocation = false;
  last_allocation_context = nullptr;
  last_allocation_cls = nullptr;
}
 
// Threads won't pick up heap sampling profiler state changes until they
// process outstanding VM interrupts. Invoke this method after calling
// any of the following APIs in a test to ensure changes are applied:
//
//  - Dart_EnableHeapSampling()
//  - Dart_DisableHeapSampling()
//  - Dart_SetHeapSamplingPeriod(...)
void HandleInterrupts(Thread* thread) {
  TransitionNativeToVM transition(thread);
  thread->HandleInterrupts();
}
 
void InitHeapSampling(Thread* thread, const char* expected_cls) {
  ResetHeapSamplingState(expected_cls);
  Dart_RegisterHeapSamplingCallback(HeapSamplingCreate, HeapSamplingDelete);
  Dart_EnableHeapSampling();
  // Start with sampling on every byte allocated.
  Dart_SetHeapSamplingPeriod(1);
  HandleInterrupts(thread);
}
 
TEST_CASE(DartAPI_HeapSampling_UserDefinedClass) {
  DisableBackgroundCompilationScope scope;
  const char* kScriptChars = R"(
    class Bar {}
    final list = [];
    foo() {
      for (int i = 0; i < 100000; ++i) {
        list.add(Bar());
      }
    }

TEST_CASE() [95/600]

dart::TEST_CASE

(

DartAPI_HeapSampling_UserDefinedClass

)

Definition at line 10291 of file dart_api_impl_test.cc.

                                                     {
  const char* kScriptChars = R"(
    import 'dart:ffi';
    @Native<IntPtr Function(Double)>(symbol: 'EchoInt', isLeaf:true)
    external int echoInt(double x);
    main() => echoInt(7.0);
    )";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
 
  // With no resolver, we resolve in process. Expect to not find the symbol
  // in processes. Error message depends on architecture.

TEST_CASE() [96/600]

dart::TEST_CASE

(

DartAPI_IdentityEquals

)

Definition at line 972 of file dart_api_impl_test.cc.

                                  {
  Dart_Handle five = Dart_NewInteger(5);
  Dart_Handle five_again = Dart_NewInteger(5);
  Dart_Handle mint = Dart_NewInteger(0xFFFFFFFF);
  Dart_Handle mint_again = Dart_NewInteger(0xFFFFFFFF);
  Dart_Handle abc = NewString("abc");
  Dart_Handle abc_again = NewString("abc");
  Dart_Handle xyz = NewString("xyz");
  Dart_Handle dart_core = NewString("dart:core");
  Dart_Handle dart_mirrors = NewString("dart:mirrors");
 
  // Same objects.
  EXPECT(Dart_IdentityEquals(five, five));
  EXPECT(Dart_IdentityEquals(mint, mint));
  EXPECT(Dart_IdentityEquals(abc, abc));
  EXPECT(Dart_IdentityEquals(xyz, xyz));
 
  // Equal objects with special spec rules.
  EXPECT(Dart_IdentityEquals(five, five_again));
  EXPECT(Dart_IdentityEquals(mint, mint_again));
 
  // Equal objects without special spec rules.
  EXPECT(!Dart_IdentityEquals(abc, abc_again));
 
  // Different objects.
  EXPECT(!Dart_IdentityEquals(five, mint));
  EXPECT(!Dart_IdentityEquals(abc, xyz));
 
  // Case where identical() is not the same as pointer equality.
  Dart_Handle nan1 = Dart_NewDouble(NAN);
  Dart_Handle nan2 = Dart_NewDouble(NAN);
  EXPECT(Dart_IdentityEquals(nan1, nan2));
 
  // Non-instance objects.
  {
    CHECK_API_SCOPE(thread);
    Dart_Handle lib1 = Dart_LookupLibrary(dart_core);
    Dart_Handle lib2 = Dart_LookupLibrary(dart_mirrors);
 
    EXPECT(Dart_IdentityEquals(lib1, lib1));
    EXPECT(Dart_IdentityEquals(lib2, lib2));
    EXPECT(!Dart_IdentityEquals(lib1, lib2));
 
    // Mix instance and non-instance.
    EXPECT(!Dart_IdentityEquals(lib1, nan1));
    EXPECT(!Dart_IdentityEquals(nan1, lib1));
  }
}

TEST_CASE() [97/600]

dart::TEST_CASE

(

DartAPI_IllegalNewSendPort

)

Definition at line 7990 of file dart_api_impl_test.cc.

TEST_CASE() [98/600]

dart::TEST_CASE

(

DartAPI_IllegalPost

)

Definition at line 7996 of file dart_api_impl_test.cc.

TEST_CASE() [99/600]

dart::TEST_CASE

(

DartAPI_ImplicitNativeFieldAccess

)

Definition at line 5775 of file dart_api_impl_test.cc.

                                             {
  const char* nullable_tag = TestCase::NullableTag();
  // clang-format off
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "import 'dart:nativewrappers';"
                  "final class NativeFields extends "
                  "NativeFieldWrapperClass4 {\n"
                  "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
                  "  int%s fld0;\n"
                  "  int fld1;\n"
                  "  final int fld2;\n"
                  "  static int%s fld3;\n"
                  "  static const int fld4 = 10;\n"
                  "}\n"
                  "NativeFields testMain() {\n"
                  "  NativeFields obj = new NativeFields(10, 20);\n"
                  "  return obj;\n"
                  "}\n",
                  nullable_tag, nullable_tag),
      std::free);
  // clang-format on
  // Load up a test script in the test library.
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars.get(), native_field_lookup);
 
  // Invoke a function which returns an object of type NativeFields.
  Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(retobj);
 
  // Now access and set various instance fields of the returned object.
  TestNativeFields(retobj);
}

TEST_CASE() [100/600]

dart::TEST_CASE

(

DartAPI_ImplicitReferencesNewSpace

)

Definition at line 4596 of file dart_api_impl_test.cc.

                                              {
  Dart_PersistentHandle strong = nullptr;
  Dart_WeakPersistentHandle strong_weak = nullptr;
 
  Dart_EnterScope();
  {
    CHECK_API_SCOPE(thread);
 
    Dart_Handle local = AllocateOldString("strongly reachable");
    strong = Dart_NewPersistentHandle(local);
    strong_weak = Dart_NewWeakPersistentHandle(local, nullptr, 0, NopCallback);
 
    EXPECT(!Dart_IsNull(AsHandle(strong)));
    EXPECT_VALID(AsHandle(strong));
    EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
    EXPECT_VALID(AsHandle(strong_weak));
    EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
 
    weak1 =
        Dart_NewWeakPersistentHandle(AllocateNewString("weakly reachable 1"),
                                     &weak1, 0, ImplicitReferencesCallback);
    EXPECT(!Dart_IsNull(AsHandle(weak1)));
    EXPECT_VALID(AsHandle(weak1));
 
    weak2 =
        Dart_NewWeakPersistentHandle(AllocateNewString("weakly reachable 2"),
                                     &weak2, 0, ImplicitReferencesCallback);
    EXPECT(!Dart_IsNull(AsHandle(weak2)));
    EXPECT_VALID(AsHandle(weak2));
 
    weak3 =
        Dart_NewWeakPersistentHandle(AllocateNewString("weakly reachable 3"),
                                     &weak3, 0, ImplicitReferencesCallback);
    EXPECT(!Dart_IsNull(AsHandle(weak3)));
    EXPECT_VALID(AsHandle(weak3));
  }
  Dart_ExitScope();
 
  {
    Dart_EnterScope();
    EXPECT_VALID(AsHandle(strong_weak));
    EXPECT_VALID(AsHandle(weak1));
    EXPECT_VALID(AsHandle(weak2));
    EXPECT_VALID(AsHandle(weak3));
    Dart_ExitScope();
  }
 
  Dart_DeleteWeakPersistentHandle(strong_weak);
  Dart_DeleteWeakPersistentHandle(weak1);
  Dart_DeleteWeakPersistentHandle(weak2);
  Dart_DeleteWeakPersistentHandle(weak3);
}

TEST_CASE() [101/600]

dart::TEST_CASE

(

DartAPI_ImplicitReferencesOldSpace

)

Definition at line 4528 of file dart_api_impl_test.cc.

                                              {
  Dart_PersistentHandle strong = nullptr;
  Dart_WeakPersistentHandle strong_weak = nullptr;
 
  Dart_EnterScope();
  {
    CHECK_API_SCOPE(thread);
 
    Dart_Handle local = AllocateOldString("strongly reachable");
    strong = Dart_NewPersistentHandle(local);
    strong_weak = Dart_NewWeakPersistentHandle(local, nullptr, 0, NopCallback);
 
    EXPECT(!Dart_IsNull(AsHandle(strong)));
    EXPECT_VALID(AsHandle(strong));
    EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
    EXPECT_VALID(AsHandle(strong_weak));
    EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
 
    weak1 =
        Dart_NewWeakPersistentHandle(AllocateOldString("weakly reachable 1"),
                                     &weak1, 0, ImplicitReferencesCallback);
    EXPECT(!Dart_IsNull(AsHandle(weak1)));
    EXPECT_VALID(AsHandle(weak1));
 
    weak2 =
        Dart_NewWeakPersistentHandle(AllocateOldString("weakly reachable 2"),
                                     &weak2, 0, ImplicitReferencesCallback);
    EXPECT(!Dart_IsNull(AsHandle(weak2)));
    EXPECT_VALID(AsHandle(weak2));
 
    weak3 =
        Dart_NewWeakPersistentHandle(AllocateOldString("weakly reachable 3"),
                                     &weak3, 0, ImplicitReferencesCallback);
    EXPECT(!Dart_IsNull(AsHandle(weak3)));
    EXPECT_VALID(AsHandle(weak3));
  }
  Dart_ExitScope();
 
  {
    Dart_EnterScope();
    EXPECT_VALID(AsHandle(strong_weak));
    EXPECT_VALID(AsHandle(weak1));
    EXPECT_VALID(AsHandle(weak2));
    EXPECT_VALID(AsHandle(weak3));
    Dart_ExitScope();
  }
 
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
  }
 
  {
    Dart_EnterScope();
    // New space collection should not affect old space objects
    EXPECT_VALID(AsHandle(strong_weak));
    EXPECT(!Dart_IsNull(AsHandle(weak1)));
    EXPECT(!Dart_IsNull(AsHandle(weak2)));
    EXPECT(!Dart_IsNull(AsHandle(weak3)));
    Dart_ExitScope();
  }
 
  Dart_DeleteWeakPersistentHandle(strong_weak);
  Dart_DeleteWeakPersistentHandle(weak1);
  Dart_DeleteWeakPersistentHandle(weak2);
  Dart_DeleteWeakPersistentHandle(weak3);
}

TEST_CASE() [102/600]

dart::TEST_CASE

(

DartAPI_ImportLibrary2

)

Definition at line 7757 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars =
      "import 'library1_dart';\n"
      "var foo;\n"
      "main() { foo = 0; }\n";
  const char* kLibrary1Chars =
      "library library1_dart;\n"
      "import 'library2_dart';\n"
      "var foo;\n";
  const char* kLibrary2Chars =
      "library library2_dart;\n"
      "import 'library1_dart';\n"
      "var foo;\n";
  Dart_Handle result;
  Dart_Handle lib;
 
  // Create a test library and Load up a test script in it.
  Dart_SourceFile sourcefiles[] = {

TEST_CASE() [103/600]

dart::TEST_CASE

(

DartAPI_ImportLibrary3

)

Definition at line 7792 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars =
      "import 'file:///library2_dart';\n"
      "import 'file:///library1_dart';\n"
      "var foo_top = 10;  // foo has dup def. So should be an error.\n"
      "main() { foo = 0; }\n";
  const char* kLibrary1Chars =
      "library library1_dart;\n"
      "var foo;";
  const char* kLibrary2Chars =
      "library library2_dart;\n"
      "var foo;";
  Dart_Handle result;
  Dart_Handle lib;
 
  // Create a test library and Load up a test script in it.
  Dart_SourceFile sourcefiles[] = {
      {RESOLVED_USER_TEST_URI, kScriptChars},
      {"file:///library2_dart", kLibrary2Chars},
      {"file:///library1_dart", kLibrary1Chars},
  };

TEST_CASE() [104/600]

dart::TEST_CASE

(

DartAPI_ImportLibrary4

)

Definition at line 7830 of file dart_api_impl_test.cc.

                                            :4:10:"
               " Error: Setter not found: 'foo'");
  return;
 
  result = Dart_FinalizeLoading(false);
  EXPECT_VALID(result);
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING("NoSuchMethodError", Dart_GetError(result));
}
 
// Test that if the same name is imported from two libraries, it is
// not an error if that name is not used.
TEST_CASE(DartAPI_ImportLibrary4) {
  const char* kScriptChars =
      "import 'library2_dart';\n"
      "import 'library1_dart';\n"
      "main() {  }\n";
  const char* kLibrary1Chars =
      "library library1_dart;\n"
      "var foo;";
  const char* kLibrary2Chars =
      "library library2_dart;\n"
      "var foo;";
  Dart_Handle result;
  Dart_Handle lib;
 
  // Create a test library and Load up a test script in it.
  Dart_SourceFile sourcefiles[] = {

TEST_CASE() [105/600]

dart::TEST_CASE

(

DartAPI_ImportLibrary5

)

Definition at line 7861 of file dart_api_impl_test.cc.

      {"file:///library2_dart", kLibrary2Chars},
      {"file:///library1_dart", kLibrary1Chars},
  };
  int sourcefiles_count = sizeof(sourcefiles) / sizeof(Dart_SourceFile);
  lib = TestCase::LoadTestScriptWithDFE(sourcefiles_count, sourcefiles, nullptr,
                                        true);
  EXPECT_VALID(lib);
 
  result = Dart_FinalizeLoading(false);
  EXPECT_VALID(result);
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
}
 
TEST_CASE(DartAPI_ImportLibrary5) {
  const char* kScriptChars =
      "import 'lib.dart';\n"
      "abstract class Y {\n"
      "  void set handler(void callback(List<int> x));\n"
      "}\n"
      "void main() {}\n";
  const char* kLibraryChars =
      "library lib.dart;\n"
      "abstract class X {\n"
      "  void set handler(void callback(List<int> x));\n"
      "}\n";
  Dart_Handle result;
  Dart_Handle lib;
 
  // Create a test library and Load up a test script in it.

TEST_CASE() [106/600]

dart::TEST_CASE

(

DartAPI_InjectNativeFields2

)

Definition at line 5452 of file dart_api_impl_test.cc.

                                       {
  // clang-format off
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "class NativeFields extends NativeFieldsWrapper {\n"
                  "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
                  "  int fld1;\n"
                  "  final int fld;\n"
                  "  static int%s fld3;\n"
                  "  static const int fld4 = 10;\n"
                  "}\n"
                  "NativeFields testMain() {\n"
                  "  NativeFields obj = new NativeFields(10, 20);\n"
                  "  return obj;\n"
                  "}\n",
                  TestCase::NullableTag()), std::free);
  // clang-format on
 
  Dart_Handle result;
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars.get(), nullptr,
                                             USER_TEST_URI, false);
 
  // Invoke a function which returns an object of type NativeFields.
  result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
 
  // We expect this to fail as class "NativeFields" extends
  // "NativeFieldsWrapper" and there is no definition of it either
  // in the dart code or through the native field injection mechanism.
  EXPECT(Dart_IsError(result));
}

TEST_CASE() [107/600]

dart::TEST_CASE

(

DartAPI_InjectNativeFields3

)

Definition at line 5484 of file dart_api_impl_test.cc.

                                       {
  // clang-format off
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "import 'dart:nativewrappers';"
                  "final class NativeFields "
                  "extends NativeFieldWrapperClass2 {\n"
                  "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
                  "  int fld1;\n"
                  "  final int fld2;\n"
                  "  static int%s fld3;\n"
                  "  static const int fld4 = 10;\n"
                  "}\n"
                  "NativeFields testMain() {\n"
                  "  NativeFields obj = new NativeFields(10, 20);\n"
                  "  return obj;\n"
                  "}\n",
                  TestCase::NullableTag()), std::free);
  // clang-format on
  Dart_Handle result;
  const int kNumNativeFields = 2;
 
  // Load up a test script in the test library.
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars.get(), native_field_lookup);
 
  // Invoke a function which returns an object of type NativeFields.
  result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
  CHECK_API_SCOPE(thread);
  TransitionNativeToVM transition(thread);
  HANDLESCOPE(thread);
  Instance& obj = Instance::Handle();
  obj ^= Api::UnwrapHandle(result);
  const Class& cls = Class::Handle(obj.clazz());
  // We expect the newly created "NativeFields" object to have
  // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
  // Hence the size of an instance of "NativeFields" should be
  // (1 + 2) * kWordSize + size of object header.
  // We check to make sure the instance size computed by the VM matches
  // our expectations.
  intptr_t header_size = sizeof(UntaggedObject);
  EXPECT_EQ(
      Utils::RoundUp(((1 + 2) * kWordSize) + header_size, kObjectAlignment),
      cls.host_instance_size());
  EXPECT_EQ(kNumNativeFields, cls.num_native_fields());
}

TEST_CASE() [108/600]

dart::TEST_CASE

(

DartAPI_InjectNativeFields4

)

Definition at line 5532 of file dart_api_impl_test.cc.

                                       {
  // clang-format off
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "class NativeFields extends NativeFieldsWrapperClass2 {\n"
                  "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
                  "  int fld1;\n"
                  "  final int fld;\n"
                  "  static int%s fld3;\n"
                  "  static const int fld4 = 10;\n"
                  "}\n"
                  "NativeFields testMain() {\n"
                  "  NativeFields obj = new NativeFields(10, 20);\n"
                  "  return obj;\n"
                  "}\n",
                  TestCase::NullableTag()), std::free);
  // clang-format on
  Dart_Handle result;
  // Load up a test script in the test library.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars.get(), nullptr);
 
  // Invoke a function which returns an object of type NativeFields.
  result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
 
  USE(result);
#if 0
  // TODO(12455) Need better validation.
  // We expect the test script to fail finalization with the error below:
  EXPECT(Dart_IsError(result));
  Dart_Handle expected_error = DartUtils::NewError(
      "'dart:test-lib': Error: line 1 pos 36: "
      "class 'NativeFields' is trying to extend a native fields class, "
      "but library '%s' has no native resolvers",
      TestCase::url());
  EXPECT_SUBSTRING(Dart_GetError(expected_error), Dart_GetError(result));
#endif
}

TEST_CASE() [109/600]

dart::TEST_CASE

(

DartAPI_InjectNativeFieldsSuperClass

)

Definition at line 5671 of file dart_api_impl_test.cc.

                                                {
  const char* kScriptChars =
      "import 'dart:nativewrappers';"
      "base class NativeFieldsSuper extends NativeFieldWrapperClass1 {\n"
      "  NativeFieldsSuper() : fld1 = 42 {}\n"
      "  int fld1;\n"
      "}\n"
      "base class NativeFields extends NativeFieldsSuper {\n"
      "  fld() => fld1;\n"
      "}\n"
      "int testMain() {\n"
      "  NativeFields obj = new NativeFields();\n"
      "  return obj.fld();\n"
      "}\n";
  Dart_Handle result;
  // Load up a test script in the test library.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, native_field_lookup);
 
  // Invoke a function which returns an object of type NativeFields.
  result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
 
  EXPECT_VALID(result);
  EXPECT(Dart_IsInteger(result));
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(42, value);
}

TEST_CASE() [110/600]

dart::TEST_CASE

(

DartAPI_InstanceGetType

)

Definition at line 1053 of file dart_api_impl_test.cc.

                                   {
  Zone* zone = thread->zone();
  // Get the handle from a valid instance handle.
  Dart_Handle type = Dart_InstanceGetType(Dart_Null());
  EXPECT_VALID(type);
  EXPECT(Dart_IsType(type));
  {
    TransitionNativeToVM transition(thread);
    const Type& null_type_obj = Api::UnwrapTypeHandle(zone, type);
    EXPECT(null_type_obj.ptr() == Type::NullType());
  }
 
  Dart_Handle instance = Dart_True();
  type = Dart_InstanceGetType(instance);
  EXPECT_VALID(type);
  EXPECT(Dart_IsType(type));
  {
    TransitionNativeToVM transition(thread);
    const Type& bool_type_obj = Api::UnwrapTypeHandle(zone, type);
    EXPECT(bool_type_obj.ptr() == Type::BoolType());
  }
 
  // Errors propagate.
  Dart_Handle error = Dart_NewApiError("MyError");
  Dart_Handle error_type = Dart_InstanceGetType(error);
  EXPECT_ERROR(error_type, "MyError");
 
  // Get the handle from a non-instance handle.
  Dart_Handle dart_core = NewString("dart:core");
  Dart_Handle obj = Dart_LookupLibrary(dart_core);
  Dart_Handle type_type = Dart_InstanceGetType(obj);
  EXPECT_ERROR(type_type,
               "Dart_InstanceGetType expects argument 'instance' to be of "
               "type Instance.");
}

TEST_CASE() [111/600]

dart::TEST_CASE

(

DartAPI_InstanceOf

)

Definition at line 7473 of file dart_api_impl_test.cc.

                              {
  const char* kScriptChars =
      "class OtherClass {\n"
      "  static returnNull() { return null; }\n"
      "}\n"
      "class InstanceOfTest {\n"
      "  InstanceOfTest() {}\n"
      "  static InstanceOfTest testMain() {\n"
      "    return new InstanceOfTest();\n"
      "  }\n"
      "}\n";
  Dart_Handle result;
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Fetch InstanceOfTest class.
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("InstanceOfTest"), 0, nullptr);
  EXPECT_VALID(type);
 
  // Invoke a function which returns an object of type InstanceOf..
  Dart_Handle instanceOfTestObj =
      Dart_Invoke(type, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(instanceOfTestObj);
 
  // Now check instanceOfTestObj reported as an instance of
  // InstanceOfTest class.
  bool is_instance = false;
  result = Dart_ObjectIsType(instanceOfTestObj, type, &is_instance);
  EXPECT_VALID(result);
  EXPECT(is_instance);
 
  // Fetch OtherClass and check if instanceOfTestObj is instance of it.
  Dart_Handle otherType =
      Dart_GetNonNullableType(lib, NewString("OtherClass"), 0, nullptr);
  EXPECT_VALID(otherType);
 
  result = Dart_ObjectIsType(instanceOfTestObj, otherType, &is_instance);
  EXPECT_VALID(result);
  EXPECT(!is_instance);
 
  // Check that primitives are not instances of InstanceOfTest class.
  result = Dart_ObjectIsType(NewString("a string"), otherType, &is_instance);
  EXPECT_VALID(result);
  EXPECT(!is_instance);
 
  result = Dart_ObjectIsType(Dart_NewInteger(42), otherType, &is_instance);
  EXPECT_VALID(result);
  EXPECT(!is_instance);
 
  result = Dart_ObjectIsType(Dart_NewBoolean(true), otherType, &is_instance);
  EXPECT_VALID(result);
  EXPECT(!is_instance);
 
  // Check that null is not an instance of InstanceOfTest class.
  Dart_Handle null =
      Dart_Invoke(otherType, NewString("returnNull"), 0, nullptr);
  EXPECT_VALID(null);
 
  result = Dart_ObjectIsType(null, otherType, &is_instance);
  EXPECT_VALID(result);
  EXPECT(!is_instance);
 
  // Check that error is returned if null is passed as a class argument.

TEST_CASE() [112/600]

dart::TEST_CASE

(

DartAPI_InstanceValues

)

Definition at line 1045 of file dart_api_impl_test.cc.

                                  {
  EXPECT(Dart_IsInstance(NewString("test")));
  EXPECT(Dart_IsInstance(Dart_True()));
 
  // By convention, our Is*() functions exclude null.
  EXPECT(!Dart_IsInstance(Dart_Null()));
}

TEST_CASE() [113/600]

dart::TEST_CASE

(

DartAPI_IntegerFitsIntoInt64

)

Definition at line 1483 of file dart_api_impl_test.cc.

                                        {
  Dart_Handle max = Dart_NewInteger(kMaxInt64);
  EXPECT(Dart_IsInteger(max));
  bool fits = false;
  Dart_Handle result = Dart_IntegerFitsIntoInt64(max, &fits);
  EXPECT_VALID(result);
  EXPECT(fits);
 
  Dart_Handle above_max = Dart_NewIntegerFromHexCString("0x10000000000000000");
  EXPECT(Dart_IsApiError(above_max));
 
  Dart_Handle min = Dart_NewInteger(kMinInt64);
  EXPECT(Dart_IsInteger(min));
  fits = false;
  result = Dart_IntegerFitsIntoInt64(min, &fits);
  EXPECT_VALID(result);
  EXPECT(fits);
 
  Dart_Handle below_min = Dart_NewIntegerFromHexCString("-0x10000000000000001");
  EXPECT(Dart_IsApiError(below_min));
}

TEST_CASE() [114/600]

dart::TEST_CASE

(

DartAPI_IntegerFitsIntoUint64

)

Definition at line 1505 of file dart_api_impl_test.cc.

                                         {
  Dart_Handle max = Dart_NewIntegerFromUint64(kMaxUint64);
  EXPECT(Dart_IsApiError(max));
 
  Dart_Handle above_max = Dart_NewIntegerFromHexCString("0x10000000000000000");
  EXPECT(Dart_IsApiError(above_max));
 
  Dart_Handle min = Dart_NewInteger(0);
  EXPECT(Dart_IsInteger(min));
  bool fits = false;
  Dart_Handle result = Dart_IntegerFitsIntoUint64(min, &fits);
  EXPECT_VALID(result);
  EXPECT(fits);
 
  Dart_Handle below_min = Dart_NewIntegerFromHexCString("-1");
  EXPECT(Dart_IsInteger(below_min));
  fits = true;
  result = Dart_IntegerFitsIntoUint64(below_min, &fits);
  EXPECT_VALID(result);
  EXPECT(!fits);
}

TEST_CASE() [115/600]

dart::TEST_CASE

(

DartAPI_IntegerToHexCString

)

Definition at line 1455 of file dart_api_impl_test.cc.

                                       {
  const struct {
    int64_t i;
    const char* s;
  } kIntTestCases[] = {
      {0, "0x0"},
      {1, "0x1"},
      {-1, "-0x1"},
      {0x123, "0x123"},
      {-0xABCDEF, "-0xABCDEF"},
      {DART_INT64_C(-0x7FFFFFFFFFFFFFFF), "-0x7FFFFFFFFFFFFFFF"},
      {kMaxInt64, "0x7FFFFFFFFFFFFFFF"},
      {kMinInt64, "-0x8000000000000000"},
  };
 
  const size_t kNumberOfIntTestCases =
      sizeof(kIntTestCases) / sizeof(kIntTestCases[0]);
 
  for (size_t i = 0; i < kNumberOfIntTestCases; ++i) {
    Dart_Handle val = Dart_NewInteger(kIntTestCases[i].i);
    EXPECT_VALID(val);
    const char* chars = nullptr;
    Dart_Handle result = Dart_IntegerToHexCString(val, &chars);
    EXPECT_VALID(result);
    EXPECT_STREQ(kIntTestCases[i].s, chars);
  }
}

TEST_CASE() [116/600]

dart::TEST_CASE

(

DartAPI_IntegerValues

)

Definition at line 1407 of file dart_api_impl_test.cc.

                                 {
  const int64_t kIntegerVal1 = 100;
  const int64_t kIntegerVal2 = 0xffffffff;
  const char* kIntegerVal3 = "0x123456789123456789123456789";
  const uint64_t kIntegerVal4 = 0xffffffffffffffff;
  const int64_t kIntegerVal5 = -0x7fffffffffffffff;
 
  Dart_Handle val1 = Dart_NewInteger(kIntegerVal1);
  EXPECT(Dart_IsInteger(val1));
  bool fits = false;
  Dart_Handle result = Dart_IntegerFitsIntoInt64(val1, &fits);
  EXPECT_VALID(result);
  EXPECT(fits);
 
  int64_t out = 0;
  result = Dart_IntegerToInt64(val1, &out);
  EXPECT_VALID(result);
  EXPECT_EQ(kIntegerVal1, out);
 
  Dart_Handle val2 = Dart_NewInteger(kIntegerVal2);
  EXPECT(Dart_IsInteger(val2));
  result = Dart_IntegerFitsIntoInt64(val2, &fits);
  EXPECT_VALID(result);
  EXPECT(fits);
 
  result = Dart_IntegerToInt64(val2, &out);
  EXPECT_VALID(result);
  EXPECT_EQ(kIntegerVal2, out);
 
  Dart_Handle val3 = Dart_NewIntegerFromHexCString(kIntegerVal3);
  EXPECT(Dart_IsApiError(val3));
 
  Dart_Handle val4 = Dart_NewIntegerFromUint64(kIntegerVal4);
  EXPECT(Dart_IsApiError(val4));
 
  Dart_Handle val5 = Dart_NewInteger(-1);
  EXPECT_VALID(val5);
  uint64_t out5 = 0;
  result = Dart_IntegerToUint64(val5, &out5);
  EXPECT(Dart_IsError(result));
 
  Dart_Handle val6 = Dart_NewInteger(kIntegerVal5);
  EXPECT_VALID(val6);
  uint64_t out6 = 0;
  result = Dart_IntegerToUint64(val6, &out6);
  EXPECT(Dart_IsError(result));
}

TEST_CASE() [117/600]

dart::TEST_CASE

(

DartAPI_InvalidGetSetPeer

)

Definition at line 8909 of file dart_api_impl_test.cc.

                 {
        @pragma('vm:external-name', 'StaticNativeFoo1')
        external static int foo1();
 
        @pragma('vm:external-name', 'StaticNativeFoo2')
        external static int foo2(int i);
 
        @pragma('vm:external-name', 'StaticNativeFoo3')
        external static int foo3([int k = 10000, int l = 1]);
 
        @pragma('vm:external-name', 'StaticNativeFoo4')
        external static int foo4(int i, [int j = 10, int k = 1]);
 
        int bar1() { var func = foo1; return func(); }
        int bar2(int i) { var func = foo2; return func(i); }
        int bar30() { var func = foo3; return func(); }
        int bar31(int i) { var func = foo3; return func(i); }
        int bar32(int i, int j) { var func = foo3; return func(i, j); }
        int bar41(int i) {
          var func = foo4; return func(i); }
        int bar42(int i, int j) {
          var func = foo4; return func(i, j); }
        int bar43(int i, int j, int k) {
          var func = foo4; return func(i, j, k); }
      }
      class Expect {

TEST_CASE() [118/600]

dart::TEST_CASE

(

DartAPI_Invoke

)

Definition at line 6592 of file dart_api_impl_test.cc.

                          {
  const char* kScriptChars =
      "class BaseMethods {\n"
      "  inheritedMethod(arg) => 'inherited $arg';\n"
      "  static nonInheritedMethod(arg) => 'noninherited $arg';\n"
      "}\n"
      "\n"
      "class Methods extends BaseMethods {\n"
      "  instanceMethod(arg) => 'instance $arg';\n"
      "  _instanceMethod(arg) => 'hidden instance $arg';\n"
      "  static staticMethod(arg) => 'static $arg';\n"
      "  static _staticMethod(arg) => 'hidden static $arg';\n"
      "}\n"
      "\n"
      "topMethod(arg) => 'top $arg';\n"
      "_topMethod(arg) => 'hidden top $arg';\n"
      "\n"
      "Methods test() {\n"
      "  return new Methods();\n"
      "}\n";
 
  // Shared setup.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("Methods"), 0, nullptr);
  EXPECT_VALID(type);
  Dart_Handle instance = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(instance);
  Dart_Handle args[1];
  args[0] = NewString("!!!");
  Dart_Handle bad_args[2];
  bad_args[0] = NewString("bad1");
  bad_args[1] = NewString("bad2");
  Dart_Handle result;
  Dart_Handle name;
  const char* str;
 
  // Instance method.
  name = NewString("instanceMethod");
  EXPECT(Dart_IsError(Dart_Invoke(lib, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(type, name, 1, args)));
  result = Dart_Invoke(instance, name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("instance !!!", str);
 
  // Instance method, wrong arg count.
  EXPECT_ERROR(Dart_Invoke(instance, name, 2, bad_args),
               "Class 'Methods' has no instance method 'instanceMethod'"
               " with matching arguments");
 
  name = PrivateLibName(lib, "_instanceMethod");
  EXPECT(Dart_IsError(Dart_Invoke(lib, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(type, name, 1, args)));
  result = Dart_Invoke(instance, name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("hidden instance !!!", str);
 
  // Inherited method.
  name = NewString("inheritedMethod");
  EXPECT(Dart_IsError(Dart_Invoke(lib, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(type, name, 1, args)));
  result = Dart_Invoke(instance, name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("inherited !!!", str);
 
  // Static method.
  name = NewString("staticMethod");
  EXPECT(Dart_IsError(Dart_Invoke(lib, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(instance, name, 1, args)));
  result = Dart_Invoke(type, name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("static !!!", str);
 
  // Static method, wrong arg count.
  EXPECT_ERROR(Dart_Invoke(type, name, 2, bad_args),
               "NoSuchMethodError: No static method 'staticMethod' with "
               "matching arguments");
 
  // Hidden static method.
  name = NewString("_staticMethod");
  EXPECT(Dart_IsError(Dart_Invoke(lib, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(instance, name, 1, args)));
  result = Dart_Invoke(type, name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("hidden static !!!", str);
 
  // Static non-inherited method.  Not found at any level.
  name = NewString("non_inheritedMethod");
  EXPECT(Dart_IsError(Dart_Invoke(lib, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(instance, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(type, name, 1, args)));
 
  // Top-Level method.
  name = NewString("topMethod");
  EXPECT(Dart_IsError(Dart_Invoke(type, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(instance, name, 1, args)));
  result = Dart_Invoke(lib, name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("top !!!", str);
 
  // Top-level method, wrong arg count.
  EXPECT_ERROR(Dart_Invoke(lib, name, 2, bad_args),
               "NoSuchMethodError: No top-level method 'topMethod' with "
               "matching arguments");
 
  // Hidden top-level method.
  name = NewString("_topMethod");
  EXPECT(Dart_IsError(Dart_Invoke(type, name, 1, args)));
  EXPECT(Dart_IsError(Dart_Invoke(instance, name, 1, args)));
  result = Dart_Invoke(lib, name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("hidden top !!!", str);
}

TEST_CASE() [119/600]

dart::TEST_CASE

(

DartAPI_Invoke_BadArgs

)

Definition at line 6785 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars =
      "class BaseMethods {\n"
      "  inheritedMethod(int arg) => 'inherited $arg';\n"
      "  static nonInheritedMethod(int arg) => 'noninherited $arg';\n"
      "}\n"
      "\n"
      "class Methods extends BaseMethods {\n"
      "  instanceMethod(int arg) => 'instance $arg';\n"
      "  _instanceMethod(int arg) => 'hidden instance $arg';\n"
      "  static staticMethod(int arg) => 'static $arg';\n"
      "  static _staticMethod(int arg) => 'hidden static $arg';\n"
      "}\n"
      "\n"
      "topMethod(int arg) => 'top $arg';\n"
      "_topMethod(int arg) => 'hidden top $arg';\n"
      "\n"
      "Methods test() {\n"
      "  return new Methods();\n"
      "}\n";
 
#if defined(PRODUCT)
  const char* error_msg =
      "type '_OneByteString' is not a subtype of type 'int' of 'arg'";
#else
  const char* error_msg =
      "type 'String' is not a subtype of type 'int' of 'arg'";
#endif  // defined(PRODUCT)
 
  // Shared setup.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("Methods"), 0, nullptr);
  EXPECT_VALID(type);
  Dart_Handle instance = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(instance);
  Dart_Handle args[1];
  args[0] = NewString("!!!");
  Dart_Handle result;
  Dart_Handle name;
 
  // Instance method.
  name = NewString("instanceMethod");
  result = Dart_Invoke(instance, name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING(error_msg, Dart_GetError(result));
 
  name = PrivateLibName(lib, "_instanceMethod");
  result = Dart_Invoke(instance, name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING(error_msg, Dart_GetError(result));
 
  // Inherited method.
  name = NewString("inheritedMethod");
  result = Dart_Invoke(instance, name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING(error_msg, Dart_GetError(result));
 
  // Static method.
  name = NewString("staticMethod");
  result = Dart_Invoke(type, name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING(error_msg, Dart_GetError(result));
 
  // Hidden static method.
  name = NewString("_staticMethod");
  result = Dart_Invoke(type, name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING(error_msg, Dart_GetError(result));
 
  // Top-Level method.
  name = NewString("topMethod");
  result = Dart_Invoke(lib, name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING(error_msg, Dart_GetError(result));
 
  // Hidden top-level method.
  name = NewString("_topMethod");
  result = Dart_Invoke(lib, name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING(error_msg, Dart_GetError(result));
}

TEST_CASE() [120/600]

dart::TEST_CASE

(

DartAPI_Invoke_FunnyArgs

)

Definition at line 6739 of file dart_api_impl_test.cc.

                                    {
  const char* kScriptChars = "test(arg) => 'hello $arg';\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle func_name = NewString("test");
  Dart_Handle args[1];
  const char* str;
 
  // Make sure that valid args yield valid results.
  args[0] = NewString("!!!");
  Dart_Handle result = Dart_Invoke(lib, func_name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("hello !!!", str);
 
  // Make sure that null is legal.
  args[0] = Dart_Null();
  result = Dart_Invoke(lib, func_name, 1, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("hello null", str);
 
  // Pass an error handle as the target.  The error is propagated.
  result = Dart_Invoke(Api::NewError("myerror"), func_name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("myerror", Dart_GetError(result));
 
  // Pass an error handle as the function name.  The error is propagated.
  result = Dart_Invoke(lib, Api::NewError("myerror"), 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("myerror", Dart_GetError(result));
 
  // Pass a non-instance handle as a parameter..
  args[0] = lib;
  result = Dart_Invoke(lib, func_name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("Dart_Invoke expects arguments[0] to be an Instance handle.",
               Dart_GetError(result));
 
  // Pass an error handle as a parameter.  The error is propagated.
  args[0] = Api::NewError("myerror");
  result = Dart_Invoke(lib, func_name, 1, args);
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("myerror", Dart_GetError(result));
}

TEST_CASE() [121/600]

dart::TEST_CASE

(

DartAPI_Invoke_Null

)

Definition at line 6868 of file dart_api_impl_test.cc.

                               {
  Dart_Handle result =
      Dart_Invoke(Dart_Null(), NewString("toString"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsString(result));
 
  const char* value = "";
  EXPECT_VALID(Dart_StringToCString(result, &value));
  EXPECT_STREQ("null", value);
 
  Dart_Handle function_name = NewString("NoNoNo");
  result = Dart_Invoke(Dart_Null(), function_name, 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
 
  result = Dart_GetField(Dart_Null(), NewString("toString"));
  EXPECT_VALID(result);
  EXPECT(Dart_IsClosure(result));
 
  result =
      Dart_SetField(Dart_Null(), NewString("nullHasNoSetters"), Dart_Null());
  // Not that Dart_SetField expects a non-null receiver.
  EXPECT_ERROR(
      result,
      "NoSuchMethodError: The setter 'nullHasNoSetters=' was called on null");
}

TEST_CASE() [122/600]

dart::TEST_CASE

(

DartAPI_Invoke_PrivateStatic

)

Definition at line 6713 of file dart_api_impl_test.cc.

                                        {
  const char* kScriptChars =
      "class Methods {\n"
      "  static _staticMethod(arg) => 'hidden static $arg';\n"
      "}\n"
      "\n";
 
  // Shared setup.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("Methods"), 0, nullptr);
  Dart_Handle result;
  EXPECT_VALID(type);
  Dart_Handle name = NewString("_staticMethod");
  EXPECT_VALID(name);
 
  Dart_Handle args[1];
  args[0] = NewString("!!!");
  result = Dart_Invoke(type, name, 1, args);
  EXPECT_VALID(result);
 
  const char* str = nullptr;
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("hidden static !!!", str);
}

TEST_CASE() [123/600]

dart::TEST_CASE

(

DartAPI_InvokeClosure

)

Definition at line 6963 of file dart_api_impl_test.cc.

                                 {
  const char* kScriptChars =
      "class InvokeClosure {\n"
      "  InvokeClosure(int i, int j) : fld1 = i, fld2 = j {}\n"
      "  Function method1(int i) {\n"
      "    f(int j) => j + i + fld1 + fld2 + fld4; \n"
      "    return f;\n"
      "  }\n"
      "  static Function method2(int i) {\n"
      "    n(int j) { throw new Exception('I am an exception'); return 1; }\n"
      "    return n;\n"
      "  }\n"
      "  int fld1;\n"
      "  final int fld2;\n"
      "  static const int fld4 = 10;\n"
      "}\n"
      "Function testMain1() {\n"
      "  InvokeClosure obj = new InvokeClosure(10, 20);\n"
      "  return obj.method1(10);\n"
      "}\n"
      "Function testMain2() {\n"
      "  return InvokeClosure.method2(10);\n"
      "}\n";
  Dart_Handle result;
  CHECK_API_SCOPE(thread);
 
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Invoke a function which returns a closure.
  Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, nullptr);
  EXPECT_VALID(retobj);
 
  EXPECT(Dart_IsClosure(retobj));
  EXPECT(!Dart_IsClosure(Dart_NewInteger(101)));
 
  // Now invoke the closure and check the result.
  Dart_Handle dart_arguments[1];
  dart_arguments[0] = Dart_NewInteger(1);
  result = Dart_InvokeClosure(retobj, 1, dart_arguments);
  EXPECT_VALID(result);
  EXPECT(Dart_IsInteger(result));
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(51, value);
 
  // Invoke closure with wrong number of args, should result in exception.
  result = Dart_InvokeClosure(retobj, 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
 
  // Invoke a function which returns a closure.
  retobj = Dart_Invoke(lib, NewString("testMain2"), 0, nullptr);
  EXPECT_VALID(retobj);
 
  EXPECT(Dart_IsClosure(retobj));
  EXPECT(!Dart_IsClosure(NewString("abcdef")));
 
  // Now invoke the closure and check the result (should be an exception).
  dart_arguments[0] = Dart_NewInteger(1);
  result = Dart_InvokeClosure(retobj, 1, dart_arguments);
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
}

TEST_CASE() [124/600]

dart::TEST_CASE

(

DartAPI_InvokeClosure_Issue44205

)

Definition at line 6354 of file dart_api_impl_test.cc.

                                            {
  const char* kScriptChars =
      "class InvokeClosure {\n"
      "  InvokeClosure(int i, int j) : fld1 = i, fld2 = j {}\n"
      "  Function method1(int i) {\n"
      "    f(int j) => j + i + fld1 + fld2 + fld4; \n"
      "    return f;\n"
      "  }\n"
      "  int fld1;\n"
      "  final int fld2;\n"
      "  static const int fld4 = 10;\n"
      "}\n"
      "Function testMain1() {\n"
      "  InvokeClosure obj = new InvokeClosure(10, 20);\n"
      "  return obj.method1(10);\n"
      "}\n";
  Dart_Handle result;
  CHECK_API_SCOPE(thread);
 
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  // Invoke a function which returns a closure.
  Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, nullptr);
  EXPECT_VALID(retobj);
 
  // Now invoke the closure and check the result.
  Dart_Handle dart_arguments[1];
  dart_arguments[0] = Dart_EmptyString();
  result = Dart_InvokeClosure(retobj, 1, dart_arguments);
  EXPECT_ERROR(result, "String' is not a subtype of type 'int' of 'j'");
}

TEST_CASE() [125/600]

dart::TEST_CASE

(

DartAPI_InvokeConstructor_Issue44205

)

Definition at line 6310 of file dart_api_impl_test.cc.

                                                {
  const char* kScriptChars =
      "class MyIntClass {\n"
      "  MyIntClass(this.value);\n"
      "  int value;\n"
      "}\n"
      "\n"
      "class MyClass<T> {\n"
      "  T value;\n"
      "  MyClass(this.value);\n"
      "}\n"
      "\n"
      "Type getIntType() { return int; }\n"
      "\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle int_wrapper_type =
      Dart_GetNonNullableType(lib, NewString("MyIntClass"), 0, nullptr);
  EXPECT_VALID(int_wrapper_type);
 
  Dart_Handle args[1];
  args[0] = Dart_EmptyString();
  Dart_Handle result = Dart_Allocate(int_wrapper_type);
  EXPECT_VALID(result);
 
  result = Dart_InvokeConstructor(result, Dart_EmptyString(), 1, args);
  EXPECT_ERROR(result, "String' is not a subtype of type 'int' of 'value'");
 
  Dart_Handle int_type = Dart_Invoke(lib, NewString("getIntType"), 0, args);
  EXPECT_VALID(int_type);
  Dart_Handle type_args = Dart_NewList(1);
  EXPECT_VALID(type_args);
  EXPECT_VALID(Dart_ListSetAt(type_args, 0, int_type));
  Dart_Handle my_class_type =
      Dart_GetNonNullableType(lib, NewString("MyClass"), 1, &type_args);
  EXPECT_VALID(my_class_type);
 
  result = Dart_Allocate(my_class_type);
  EXPECT_VALID(result);
  result = Dart_InvokeConstructor(result, Dart_EmptyString(), 1, args);
  EXPECT_ERROR(result, "String' is not a subtype of type 'int' of 'value'");
}

TEST_CASE() [126/600]

dart::TEST_CASE

(

DartAPI_InvokeImportedFunction

)

Definition at line 9846 of file dart_api_impl_test.cc.

                                                             {
  Dart_NotifyDestroyed();
}
 
static Dart_NativeFunction NotifyDestroyed_native_lookup(
    Dart_Handle name,
    int argument_count,
    bool* auto_setup_scope) {

TEST_CASE() [127/600]

dart::TEST_CASE

(

DartAPI_InvokeNoSuchMethod

)

Definition at line 6895 of file dart_api_impl_test.cc.

                                      {
  const char* kScriptChars =
      "class Expect {\n"
      "  static equals(a, b) {\n"
      "    if (a != b) {\n"
      "      throw 'not equal. expected: $a, got: $b';\n"
      "    }\n"
      "  }\n"
      "}\n"
      "class TestClass {\n"
      "  static int fld1 = 0;\n"
      "  void noSuchMethod(Invocation invocation) {\n"
      // This relies on the Symbol.toString() method returning a String of the
      // form 'Symbol("name")'. This is to avoid having to import
      // dart:_internal just to get access to the name of the symbol.
      "    var name = invocation.memberName.toString();\n"
      "    name = name.split('\"')[1];\n"
      "    if (name == 'fld') {\n"
      "      Expect.equals(true, invocation.isGetter);\n"
      "      Expect.equals(false, invocation.isMethod);\n"
      "      Expect.equals(false, invocation.isSetter);\n"
      "    } else if (name == 'setfld') {\n"
      "      Expect.equals(true, invocation.isSetter);\n"
      "      Expect.equals(false, invocation.isMethod);\n"
      "      Expect.equals(false, invocation.isGetter);\n"
      "    } else if (name == 'method') {\n"
      "      Expect.equals(true, invocation.isMethod);\n"
      "      Expect.equals(false, invocation.isSetter);\n"
      "      Expect.equals(false, invocation.isGetter);\n"
      "    }\n"
      "    TestClass.fld1 += 1;\n"
      "  }\n"
      "  static TestClass testMain() {\n"
      "    return new TestClass();\n"
      "  }\n"
      "}\n";
  Dart_Handle result;
  Dart_Handle instance;
  // Create a test library and Load up a test script in it.
  // The test library must have a dart: url so it can import dart:_internal.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("TestClass"), 0, nullptr);
  EXPECT_VALID(type);
 
  // Invoke a function which returns an object.
  instance = Dart_Invoke(type, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(instance);
 
  // Try to get a field that does not exist, should call noSuchMethod.
  result = Dart_GetField(instance, NewString("fld"));
  EXPECT_VALID(result);
 
  // Try to set a field that does not exist, should call noSuchMethod.
  result = Dart_SetField(instance, NewString("setfld"), Dart_NewInteger(13));
  EXPECT_VALID(result);
 
  // Try to invoke a method that does not exist, should call noSuchMethod.
  result = Dart_Invoke(instance, NewString("method"), 0, nullptr);
  EXPECT_VALID(result);
 
  result = Dart_GetField(type, NewString("fld1"));
  EXPECT_VALID(result);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(3, value);
}

TEST_CASE() [128/600]

dart::TEST_CASE

(

DartAPI_InvokeVMServiceMethod

)

Definition at line 9868 of file dart_api_impl_test.cc.

                                   {
  const char* kScriptChars = R"(
import 'dart:isolate';
@pragma("vm:external-name", "Test_nativeFunc")
external void notifyDetach();
void main() {
  var v;
  for (var i = 0; i < 100; i++) {
    var t = [];
    for (var j = 0; j < 10000; j++) {
      t.add(List.filled(100, null));
    }
    v = t;
    notifyDetach();
  }
})";
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, &NotifyDestroyed_native_lookup);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
}
 
static void SetPerformanceModeDefault(Dart_NativeArguments args) {
  Dart_SetPerformanceMode(Dart_PerformanceMode_Default);
}
static void SetPerformanceModeLatency(Dart_NativeArguments args) {
  Dart_SetPerformanceMode(Dart_PerformanceMode_Latency);

TEST_CASE() [129/600]

dart::TEST_CASE

(

DartAPI_InvokeVMServiceMethod_Loop

)

Definition at line 9933 of file dart_api_impl_test.cc.

                                                             {
  Dart_NotifyLowMemory();
}
 
static Dart_NativeFunction NotifyLowMemory_native_lookup(
    Dart_Handle name,

TEST_CASE() [130/600]

dart::TEST_CASE

(

DartAPI_IsFuture

)

Definition at line 1980 of file dart_api_impl_test.cc.

                            {
  const char* kScriptChars =
      "import 'dart:async';"
      "Future testMain() {"
      "  return new Completer().future;"
      "}";
  Dart_Handle result;
 
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Invoke a function which returns an object of type Future.
  result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsFuture(result));
 
  EXPECT(!Dart_IsFuture(lib));  // Non-instance.
  Dart_Handle anInteger = Dart_NewInteger(0);
  EXPECT(!Dart_IsFuture(anInteger));
  Dart_Handle aString = NewString("I am not a Future");
  EXPECT(!Dart_IsFuture(aString));
  Dart_Handle null = Dart_Null();
  EXPECT(!Dart_IsFuture(null));
}

TEST_CASE() [131/600]

dart::TEST_CASE

(

DartAPI_IsolateServiceID

)

Definition at line 4846 of file dart_api_impl_test.cc.

                                    {
  Dart_Isolate isolate = Dart_CurrentIsolate();
  const char* id = Dart_IsolateServiceId(isolate);
  EXPECT(id != nullptr);
  int64_t main_port = Dart_GetMainPortId();
  EXPECT_STREQ(ZONE_STR("isolates/%" Pd64, main_port), id);
  free(const_cast<char*>(id));
}

TEST_CASE() [132/600]

dart::TEST_CASE

(

DartAPI_IsString

)

Definition at line 1563 of file dart_api_impl_test.cc.

                            {
  uint8_t latin1[] = {'o', 'n', 'e', 0xC2, 0xA2};
 
  Dart_Handle latin1str = Dart_NewStringFromUTF8(latin1, ARRAY_SIZE(latin1));
  EXPECT_VALID(latin1str);
  EXPECT(Dart_IsString(latin1str));
  EXPECT(Dart_IsStringLatin1(latin1str));
  intptr_t len = -1;
  EXPECT_VALID(Dart_StringLength(latin1str, &len));
  EXPECT_EQ(4, len);
  intptr_t char_size;
  intptr_t str_len;
  void* peer;
  EXPECT_VALID(
      Dart_StringGetProperties(latin1str, &char_size, &str_len, &peer));
  EXPECT_EQ(1, char_size);
  EXPECT_EQ(4, str_len);
  EXPECT(!peer);
 
  uint8_t data8[] = {'o', 'n', 'e', 0x7F};
 
  Dart_Handle str8 = Dart_NewStringFromUTF8(data8, ARRAY_SIZE(data8));
  EXPECT_VALID(str8);
  EXPECT(Dart_IsString(str8));
  EXPECT(Dart_IsStringLatin1(str8));
 
  uint8_t latin1_array[] = {0, 0, 0, 0, 0};
  len = 5;
  Dart_Handle result = Dart_StringToLatin1(str8, latin1_array, &len);
  EXPECT_VALID(result);
  EXPECT_EQ(4, len);
  for (intptr_t i = 0; i < len; i++) {
    EXPECT_EQ(data8[i], latin1_array[i]);
  }
 
  uint16_t data16[] = {'t', 'w', 'o', 0xFFFF};
 
  Dart_Handle str16 = Dart_NewStringFromUTF16(data16, ARRAY_SIZE(data16));
  EXPECT_VALID(str16);
  EXPECT(Dart_IsString(str16));
  EXPECT(!Dart_IsStringLatin1(str16));
  EXPECT_VALID(Dart_StringGetProperties(str16, &char_size, &str_len, &peer));
  EXPECT_EQ(2, char_size);
  EXPECT_EQ(4, str_len);
  EXPECT(!peer);
 
  int32_t data32[] = {'f', 'o', 'u', 'r', 0x10FFFF};
 
  Dart_Handle str32 = Dart_NewStringFromUTF32(data32, ARRAY_SIZE(data32));
  EXPECT_VALID(str32);
  EXPECT(Dart_IsString(str32));
}

TEST_CASE() [133/600]

dart::TEST_CASE

(

DartAPI_IsTearOff

)

Definition at line 1137 of file dart_api_impl_test.cc.

                             {
  const char* kScriptChars =
      "int getInt() { return 1; }\n"
      "getTearOff() => getInt;\n"
      "Function foo = () { print('baz'); };\n"
      "class Baz {\n"
      "  static int foo() => 42;\n"
      "  getTearOff() => bar;\n"
      "  int bar() => 24;\n"
      "}\n"
      "Baz getBaz() => Baz();\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  // Check tear-off of top-level static method.
  Dart_Handle get_tear_off = Dart_GetField(lib, NewString("getTearOff"));
  EXPECT_VALID(get_tear_off);
  EXPECT(Dart_IsTearOff(get_tear_off));
  Dart_Handle tear_off = Dart_InvokeClosure(get_tear_off, 0, nullptr);
  EXPECT_VALID(tear_off);
  EXPECT(Dart_IsTearOff(tear_off));
 
  // Check anonymous closures are not considered tear-offs.
  Dart_Handle anonymous_closure = Dart_GetField(lib, NewString("foo"));
  EXPECT_VALID(anonymous_closure);
  EXPECT(!Dart_IsTearOff(anonymous_closure));
 
  Dart_Handle baz_cls = Dart_GetClass(lib, NewString("Baz"));
  EXPECT_VALID(baz_cls);
 
  // Check tear-off for a static method in a class.
  Dart_Handle closure =
      Dart_GetStaticMethodClosure(lib, baz_cls, NewString("foo"));
  EXPECT_VALID(closure);
  EXPECT(Dart_IsTearOff(closure));
 
  // Flutter will use Dart_IsTearOff in conjunction with Dart_ClosureFunction
  // and Dart_FunctionIsStatic to prevent anonymous closures from being used to
  // generate callback handles. We'll test that case here, just to be sure.
  Dart_Handle function = Dart_ClosureFunction(closure);
  EXPECT_VALID(function);
  bool is_static = false;
  Dart_Handle result = Dart_FunctionIsStatic(function, &is_static);
  EXPECT_VALID(result);
  EXPECT(is_static);
 
  // Check tear-off for an instance method in a class.
  Dart_Handle instance = Dart_Invoke(lib, NewString("getBaz"), 0, nullptr);
  EXPECT_VALID(instance);
  closure = Dart_Invoke(instance, NewString("getTearOff"), 0, nullptr);
  EXPECT_VALID(closure);
  EXPECT(Dart_IsTearOff(closure));
}

TEST_CASE() [134/600]

dart::TEST_CASE

(

DartAPI_LibraryUrl

)

Definition at line 7630 of file dart_api_impl_test.cc.

                                          : library 'noodles.dart' not found.");
}
 
TEST_CASE(DartAPI_LibraryUrl) {
  const char* kLibrary1Chars = "library library1_name;";
  Dart_Handle lib = TestCase::LoadTestLibrary("library1_url", kLibrary1Chars);
  Dart_Handle error = Dart_NewApiError("incoming error");
  EXPECT_VALID(lib);
 
  Dart_Handle result = Dart_LibraryUrl(Dart_Null());
  EXPECT_ERROR(result,
               "Dart_LibraryUrl expects argument 'library' to be non-null.");
 
  result = Dart_LibraryUrl(Dart_True());
  EXPECT_ERROR(
      result,
      "Dart_LibraryUrl expects argument 'library' to be of type Library.");
 
  result = Dart_LibraryUrl(error);
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("incoming error", Dart_GetError(result));
 
  result = Dart_LibraryUrl(lib);
  EXPECT_VALID(result);
  EXPECT(Dart_IsString(result));
  const char* cstr = nullptr;

TEST_CASE() [135/600]

dart::TEST_CASE

(

DartAPI_ListAccess

)

Definition at line 1738 of file dart_api_impl_test.cc.

                              {
  const char* kScriptChars =
      "List testMain() {"
      "  List a = List.empty(growable: true);"
      "  a.add(10);"
      "  a.add(20);"
      "  a.add(30);"
      "  return a;"
      "}"
      ""
      "List immutable() {"
      "  return const [0, 1, 2];"
      "}";
  Dart_Handle result;
 
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Invoke a function which returns an object of type List.
  result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
 
  // First ensure that the returned object is an array.
  Dart_Handle list_access_test_obj = result;
 
  EXPECT(Dart_IsList(list_access_test_obj));
 
  // Get length of array object.
  intptr_t len = 0;
  result = Dart_ListLength(list_access_test_obj, &len);
  EXPECT_VALID(result);
  EXPECT_EQ(3, len);
 
  // Access elements in the array.
  int64_t value;
 
  result = Dart_ListGetAt(list_access_test_obj, 0);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(10, value);
 
  result = Dart_ListGetAt(list_access_test_obj, 1);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(20, value);
 
  result = Dart_ListGetAt(list_access_test_obj, 2);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(30, value);
 
  // Set some elements in the array.
  result = Dart_ListSetAt(list_access_test_obj, 0, Dart_NewInteger(0));
  EXPECT_VALID(result);
  result = Dart_ListSetAt(list_access_test_obj, 1, Dart_NewInteger(1));
  EXPECT_VALID(result);
  result = Dart_ListSetAt(list_access_test_obj, 2, Dart_NewInteger(2));
  EXPECT_VALID(result);
 
  // Get length of array object.
  result = Dart_ListLength(list_access_test_obj, &len);
  EXPECT_VALID(result);
  EXPECT_EQ(3, len);
 
  // Now try and access these elements in the array.
  result = Dart_ListGetAt(list_access_test_obj, 0);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(0, value);
 
  result = Dart_ListGetAt(list_access_test_obj, 1);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(1, value);
 
  result = Dart_ListGetAt(list_access_test_obj, 2);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(2, value);
 
  uint8_t native_array[3];
  result = Dart_ListGetAsBytes(list_access_test_obj, 0, native_array, 3);
  EXPECT_VALID(result);
  EXPECT_EQ(0, native_array[0]);
  EXPECT_EQ(1, native_array[1]);
  EXPECT_EQ(2, native_array[2]);
 
  native_array[0] = 10;
  native_array[1] = 20;
  native_array[2] = 30;
  result = Dart_ListSetAsBytes(list_access_test_obj, 0, native_array, 3);
  EXPECT_VALID(result);
  result = Dart_ListGetAsBytes(list_access_test_obj, 0, native_array, 3);
  EXPECT_VALID(result);
  EXPECT_EQ(10, native_array[0]);
  EXPECT_EQ(20, native_array[1]);
  EXPECT_EQ(30, native_array[2]);
  result = Dart_ListGetAt(list_access_test_obj, 2);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(30, value);
 
  // Check if we get an exception when accessing beyond limit.
  result = Dart_ListGetAt(list_access_test_obj, 4);
  EXPECT(Dart_IsError(result));
 
  // Check if we can get a range of values.
  result = Dart_ListGetRange(list_access_test_obj, 8, 4, nullptr);
  EXPECT(Dart_IsError(result));
  const int kRangeOffset = 1;
  const int kRangeLength = 2;
  Dart_Handle values[kRangeLength];
 
  result = Dart_ListGetRange(list_access_test_obj, 8, 4, values);
  EXPECT(Dart_IsError(result));
 
  result = Dart_ListGetRange(list_access_test_obj, kRangeOffset, kRangeLength,
                             values);
  EXPECT_VALID(result);
 
  result = Dart_IntegerToInt64(values[0], &value);
  EXPECT_VALID(result);
  EXPECT_EQ(20, value);
 
  result = Dart_IntegerToInt64(values[1], &value);
  EXPECT_VALID(result);
  EXPECT_EQ(30, value);
 
  // Check that we get an exception (and not a fatal error) when
  // calling ListSetAt and ListSetAsBytes with an immutable list.
  list_access_test_obj = Dart_Invoke(lib, NewString("immutable"), 0, nullptr);
  EXPECT_VALID(list_access_test_obj);
  EXPECT(Dart_IsList(list_access_test_obj));
 
  result = Dart_ListSetAsBytes(list_access_test_obj, 0, native_array, 3);
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_IsUnhandledExceptionError(result));
 
  result = Dart_ListSetAt(list_access_test_obj, 0, Dart_NewInteger(42));
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_IsUnhandledExceptionError(result));
}

TEST_CASE() [136/600]

dart::TEST_CASE

(

DartAPI_LookupLibrary

)

Definition at line 7588 of file dart_api_impl_test.cc.

                                 {
  const char* kScriptChars =
      "import 'library1_dart';"
      "main() {}";
  const char* kLibrary1 = "file:///library1_dart";
  const char* kLibrary1Chars =
      "library library1;"
      "final x = 0;";
 
  Dart_Handle url;
  Dart_Handle result;
 
  // Create a test library and load up a test script in it.
  TestCase::AddTestLib("file:///library1_dart", kLibrary1Chars);
  // LoadTestScript resets the LibraryTagHandler, which we don't want when
  // using the VM compiler, so we only use it with the Dart frontend for this
  // test.
  result = TestCase::LoadTestScript(kScriptChars, nullptr, TestCase::url());
  EXPECT_VALID(result);
 
  url = NewString(kLibrary1);
  result = Dart_LookupLibrary(url);
  EXPECT_VALID(result);
 
  result = Dart_LookupLibrary(Dart_Null());
  EXPECT_ERROR(result,
               "Dart_LookupLibrary expects argument 'url' to be non-null.");
 
  result = Dart_LookupLibrary(Dart_True());
  EXPECT_ERROR(
      result,
      "Dart_LookupLibrary expects argument 'url' to be of type String.");
 
  result = Dart_LookupLibrary(Dart_NewApiError("incoming error"));
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("incoming error", Dart_GetError(result));
 
  url = NewString("noodles.dart");

TEST_CASE() [137/600]

dart::TEST_CASE

(

DartAPI_MalformedStringToUTF8

)

Definition at line 1637 of file dart_api_impl_test.cc.

                                         {
  // 1D11E = treble clef
  // [0] should be high surrogate D834
  // [1] should be low surrogate DD1E
  // Strings are allowed to have individual or out of order surrogates, even
  // if that doesn't make sense as renderable characters.
  const char* kScriptChars =
      "String lowSurrogate() {"
      "  return '\\u{1D11E}'[1];"
      "}"
      "String highSurrogate() {"
      "  return '\\u{1D11E}'[0];"
      "}"
      "String reversed() => lowSurrogate() + highSurrogate();";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle str1 = Dart_Invoke(lib, NewString("lowSurrogate"), 0, nullptr);
  EXPECT_VALID(str1);
 
  uint8_t* utf8_encoded = nullptr;
  intptr_t utf8_length = 0;
  Dart_Handle result = Dart_StringToUTF8(str1, &utf8_encoded, &utf8_length);
  EXPECT_VALID(result);
  EXPECT_EQ(3, utf8_length);
  // Unpaired surrogate is encoded as replacement character.
  EXPECT_EQ(239, static_cast<intptr_t>(utf8_encoded[0]));
  EXPECT_EQ(191, static_cast<intptr_t>(utf8_encoded[1]));
  EXPECT_EQ(189, static_cast<intptr_t>(utf8_encoded[2]));
 
  Dart_Handle str2 = Dart_NewStringFromUTF8(utf8_encoded, utf8_length);
  EXPECT_VALID(str2);  // Replacement character, but still valid
 
  Dart_Handle reversed = Dart_Invoke(lib, NewString("reversed"), 0, nullptr);
  EXPECT_VALID(reversed);  // This is also allowed.
  uint8_t* utf8_encoded_reversed = nullptr;
  intptr_t utf8_length_reversed = 0;
  result = Dart_StringToUTF8(reversed, &utf8_encoded_reversed,
                             &utf8_length_reversed);
  EXPECT_VALID(result);
  EXPECT_EQ(6, utf8_length_reversed);
  // Two unpaired surrogates are encoded as two replacement characters.
  uint8_t expected[6] = {239, 191, 189, 239, 191, 189};
  for (int i = 0; i < 6; i++) {
    EXPECT_EQ(expected[i], utf8_encoded_reversed[i]);
  }
}

TEST_CASE() [138/600]

dart::TEST_CASE

(

DartAPI_MapAccess

)

Definition at line 1888 of file dart_api_impl_test.cc.

                             {
  EXPECT(!Dart_IsMap(Dart_Null()));
  const char* kScriptChars =
      "Map testMain() {"
      "  return {"
      "    'a' : 1,"
      "    'b' : null,"
      "  };"
      "}";
  Dart_Handle result;
 
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Invoke a function which returns an object of type Map.
  result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
 
  // First ensure that the returned object is a map.
  Dart_Handle map = result;
  Dart_Handle a = NewString("a");
  Dart_Handle b = NewString("b");
  Dart_Handle c = NewString("c");
 
  EXPECT(Dart_IsMap(map));
  EXPECT(!Dart_IsMap(a));
 
  // Access values in the map.
  int64_t value;
  result = Dart_MapGetAt(map, a);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(value, 1);
 
  result = Dart_MapGetAt(map, b);
  EXPECT(Dart_IsNull(result));
 
  result = Dart_MapGetAt(map, c);
  EXPECT(Dart_IsNull(result));
 
  EXPECT(Dart_IsError(Dart_MapGetAt(a, a)));
 
  // Test for presence of keys.
  bool contains = false;
  result = Dart_MapContainsKey(map, a);
  EXPECT_VALID(result);
  result = Dart_BooleanValue(result, &contains);
  EXPECT_VALID(result);
  EXPECT(contains);
 
  contains = false;
  result = Dart_MapContainsKey(map, NewString("b"));
  EXPECT_VALID(result);
  result = Dart_BooleanValue(result, &contains);
  EXPECT_VALID(result);
  EXPECT(contains);
 
  contains = true;
  result = Dart_MapContainsKey(map, NewString("c"));
  EXPECT_VALID(result);
  result = Dart_BooleanValue(result, &contains);
  EXPECT_VALID(result);
  EXPECT(!contains);
 
  EXPECT(Dart_IsError(Dart_MapContainsKey(a, a)));
 
  // Enumerate keys. (Note literal maps guarantee key order.)
  Dart_Handle keys = Dart_MapKeys(map);
  EXPECT_VALID(keys);
 
  intptr_t len = 0;
  bool equals;
  result = Dart_ListLength(keys, &len);
  EXPECT_VALID(result);
  EXPECT_EQ(2, len);
 
  result = Dart_ListGetAt(keys, 0);
  EXPECT(Dart_IsString(result));
  equals = false;
  EXPECT_VALID(Dart_ObjectEquals(result, a, &equals));
  EXPECT(equals);
 
  result = Dart_ListGetAt(keys, 1);
  EXPECT(Dart_IsString(result));
  equals = false;
  EXPECT_VALID(Dart_ObjectEquals(result, b, &equals));
  EXPECT(equals);
 
  EXPECT(Dart_IsError(Dart_MapKeys(a)));
}

TEST_CASE() [139/600]

dart::TEST_CASE

(

DartAPI_Multiroot_FailWhenUriIsWrong

)

Definition at line 7934 of file dart_api_impl_test.cc.

                                                        {
      script ^= lib_scripts.At(i);
      uri = script.url();
      const char* uri_str = uri.ToCString();
      EXPECT(strstr(uri_str, "foo:///") == uri_str);
    }
  }
  result = Dart_FinalizeLoading(false);
  EXPECT_VALID(result);
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
}
 
TEST_CASE(DartAPI_Multiroot_FailWhenUriIsWrong) {
  const char* kScriptChars =
      "import 'lib.dart';\n"
      "void main() {}\n";
  const char* kLibraryChars = "library lib.dart;\n";
  Dart_Handle lib;
 
  Dart_SourceFile sourcefiles[] = {
      {"file:///bar/main.dart", kScriptChars},

TEST_CASE() [140/600]

dart::TEST_CASE

(

DartAPI_Multiroot_Valid

)

Definition at line 7892 of file dart_api_impl_test.cc.

      {RESOLVED_USER_TEST_URI, kScriptChars},
      {"file:///lib.dart", kLibraryChars},
  };
  int sourcefiles_count = sizeof(sourcefiles) / sizeof(Dart_SourceFile);
  lib = TestCase::LoadTestScriptWithDFE(sourcefiles_count, sourcefiles, nullptr,
                                        true);
  EXPECT_VALID(lib);
 
  result = Dart_FinalizeLoading(false);
  EXPECT_VALID(result);
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
}
 
TEST_CASE(DartAPI_Multiroot_Valid) {
  const char* kScriptChars =
      "import 'lib.dart';\n"
      "void main() {}\n";
  const char* kLibraryChars = "library lib.dart;\n";
  Dart_Handle result;
  Dart_Handle lib;
 
  Dart_SourceFile sourcefiles[] = {
      {"file:///bar/main.dart", kScriptChars},
      {"file:///baz/lib.dart", kLibraryChars},
      {"file:///bar/.packages", ""},
  };
  int sourcefiles_count = sizeof(sourcefiles) / sizeof(Dart_SourceFile);
  lib = TestCase::LoadTestScriptWithDFE(
      sourcefiles_count, sourcefiles, nullptr, /* finalize= */ true,
      /* incrementally= */ true, /* allow_compile_errors= */ false,
      "foo:///main.dart",
      /* multiroot_filepaths= */ "/bar,/baz",
      /* multiroot_scheme= */ "foo");
  EXPECT_VALID(lib);
  {
    TransitionNativeToVM transition(thread);
    Library& lib_obj = Library::Handle();
    lib_obj ^= Api::UnwrapHandle(lib);
    EXPECT_STREQ("foo:///main.dart", String::Handle(lib_obj.url()).ToCString());
    const Array& lib_scripts = Array::Handle(lib_obj.LoadedScripts());

TEST_CASE() [141/600]

dart::TEST_CASE

(

DartAPI_NativeFieldAccess

)

Definition at line 4453 of file dart_api_impl_test.cc.

                                     {
  const char* kScriptChars = R"(
    import 'dart:ffi';
    import 'dart:nativewrappers';
    base class SecretKeeper extends NativeFieldWrapperClass1 {
      SecretKeeper(int secret) { _keepSecret(secret); }
      @pragma("vm:external-name", "SecretKeeper_KeepSecret")
      external void _keepSecret(int secret);
    }
    // Argument auto-conversion will wrap `o` in `_getNativeField()`.
    @Native<IntPtr Function(Pointer<Void>)>(symbol: 'returnPtrAsInt')
    external int returnPtrAsInt(NativeFieldWrapperClass1 o);
    main() => returnPtrAsInt(SecretKeeper(321));
  )";
 
  Dart_Handle result;
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, SecretKeeperNativeResolver);
 
  result = Dart_SetFfiNativeResolver(lib, &SecretKeeperFfiNativeResolver);
  EXPECT_VALID(result);
 
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
 
  EXPECT_VALID(result);
  EXPECT(Dart_IsInteger(result));
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(321, value);
}

TEST_CASE() [142/600]

dart::TEST_CASE

(

DartAPI_NativeFieldAccess_Throws

)

Definition at line 4487 of file dart_api_impl_test.cc.

                                            {
  const char* kScriptChars = R"(
    import 'dart:ffi';
    import 'dart:nativewrappers';
    base class ForgetfulSecretKeeper extends NativeFieldWrapperClass1 {
      ForgetfulSecretKeeper(int secret) { /* Forget to init. native field. */ }
    }
    // Argument auto-conversion will wrap `o` in `_getNativeField()`.
    @Native<IntPtr Function(Pointer<Void>)>(symbol: 'returnPtrAsInt')
    external int returnPtrAsInt(NativeFieldWrapperClass1 o);
    main() => returnPtrAsInt(ForgetfulSecretKeeper(321));
  )";
 
  Dart_Handle result;
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, SecretKeeperNativeResolver);
 
  result = Dart_SetFfiNativeResolver(lib, &SecretKeeperFfiNativeResolver);
  EXPECT_VALID(result);
 
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
 
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_IsUnhandledExceptionError(result));
}

TEST_CASE() [143/600]

dart::TEST_CASE

(

DartAPI_NativeFunctionClosure

)

Definition at line 8744 of file dart_api_impl_test.cc.

                                                                     {
    return &NativeFoo1;
  } else if (strncmp(function_name, kNativeFoo2, strlen(kNativeFoo2)) == 0) {
    return &NativeFoo2;
  } else if (strncmp(function_name, kNativeFoo3, strlen(kNativeFoo3)) == 0) {
    return &NativeFoo3;
  } else if (strncmp(function_name, kNativeFoo4, strlen(kNativeFoo4)) == 0) {
    return &NativeFoo4;
  } else {
    UNREACHABLE();
    return nullptr;
  }
}
 
TEST_CASE(DartAPI_NativeFunctionClosure) {
  const char* kScriptChars =
      R"(
      class Test {
        @pragma('vm:external-name', 'NativeFoo1')
        external int foo1();
 
        @pragma('vm:external-name', 'NativeFoo2')

TEST_CASE() [144/600]

dart::TEST_CASE

(

DartAPI_NativePort_Loop

)

Definition at line 9964 of file dart_api_impl_test.cc.

TEST_CASE() [145/600]

dart::TEST_CASE

(

DartAPI_NativePortPostExternalTypedData

)

Definition at line 8243 of file dart_api_impl_test.cc.

                                             {
    EXPECT_EQ((0x41 + i), message->value.as_typed_data.values[i]);
  }
}
 
static void FinalizeTypedData(void* isolate_callback_data, void* peer) {
  delete[] reinterpret_cast<int8_t*>(peer);
}
 
TEST_CASE(DartAPI_NativePortPostExternalTypedData) {
  int8_t* extTypedData = new int8_t[kSendLength];
  for (int i = 0; i < kSendLength; i++) {
    extTypedData[i] = 0x41 + i;
  }
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "import 'dart:isolate';\n"
      "void callPort(SendPort port, Uint8List data) {\n"
      "  port.send(data);\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
 
  Dart_Port port_id =
      Dart_NewNativePort("Port123", NewNativePort_ExternalTypedData, true);
 
  Dart_Handle send_port = Dart_NewSendPort(port_id);
  EXPECT_VALID(send_port);
 
  Dart_Handle extdata = Dart_NewExternalTypedDataWithFinalizer(
      Dart_TypedData_kUint8, extTypedData, kSendLength, extTypedData,
      kSendLength, FinalizeTypedData);
  EXPECT_VALID(extdata);
 

TEST_CASE() [146/600]

dart::TEST_CASE

(

DartAPI_NativePortPostInteger

)

Definition at line 8108 of file dart_api_impl_test.cc.

                                                                {
  // Gets a null message.
  EXPECT_NOTNULL(message);
  EXPECT_EQ(Dart_CObject_kArray, message->type);
  EXPECT_EQ(Dart_CObject_kSendPort, message->value.as_array.values[0]->type);
 
  // Post integer value.
  Dart_PostInteger(message->value.as_array.values[0]->value.as_send_port.id,
                   321);
}
 
TEST_CASE(DartAPI_NativePortPostInteger) {
  const char* kScriptChars =
      "import 'dart:isolate';\n"
      "void callPort(SendPort port) {\n"
      "  var receivePort = new RawReceivePort();\n"
      "  var replyPort = receivePort.sendPort;\n"
      "  port.send(<dynamic>[replyPort]);\n"
      "  receivePort.handler = (message) {\n"
      "    receivePort.close();\n"
      "    throw new Exception(message);\n"
      "  };\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
 
  Dart_Port port_id1 =
      Dart_NewNativePort("Port123", NewNativePort_sendInteger123, true);
  Dart_Port port_id2 =
      Dart_NewNativePort("Port321", NewNativePort_sendInteger321, true);
 
  Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
  EXPECT_VALID(send_port1);
  Dart_Handle send_port2 = Dart_NewSendPort(port_id2);
  EXPECT_VALID(send_port2);
 
  // Test first port.
  Dart_Handle dart_args[1];
  dart_args[0] = send_port1;
  Dart_Handle result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
  EXPECT_VALID(result);
  result = Dart_RunLoop();
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
  EXPECT_SUBSTRING("Exception: 123\n", Dart_GetError(result));
 
  // result second port.

TEST_CASE() [147/600]

dart::TEST_CASE

(

DartAPI_NativePortPostTransferrableTypedData

)

Definition at line 8184 of file dart_api_impl_test.cc.

                                                                {
  // Gets a send port message.
  EXPECT_NOTNULL(message);
  EXPECT_EQ(Dart_CObject_kArray, message->type);
  EXPECT_EQ(1, message->value.as_array.length);
  Dart_CObject* cobj = message->value.as_array.values[0];
  EXPECT_EQ(Dart_CObject_kTypedData, cobj->type);
  EXPECT_EQ(Dart_TypedData_kUint8, cobj->value.as_typed_data.type);
  EXPECT_EQ(10, cobj->value.as_typed_data.length);
  EXPECT_EQ(42, cobj->value.as_typed_data.values[0]);
  free(const_cast<uint8_t*>(cobj->value.as_typed_data.values));
}
 
TEST_CASE(DartAPI_NativePortPostTransferrableTypedData) {
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "import 'dart:isolate';\n"
      "void callPort(SendPort port1, SendPort port2) {\n"
      "  final td1 ="
      "     TransferableTypedData.fromList([Uint8List(10)..[0] = 42]);\n"
      "  final td2 ="
      "     TransferableTypedData.fromList([Uint8List(10)..[0] = 42]);\n"
      "  port1.send(td1);\n"
      "  port2.send([td2]);\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
 
  Dart_Port port_id1 =
      Dart_NewNativePort("Port123", NewNativePort_Transferrable1, true);
  Dart_Port port_id2 =
      Dart_NewNativePort("Port321", NewNativePort_Transferrable2, true);
 
  Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
  EXPECT_VALID(send_port1);
  Dart_Handle send_port2 = Dart_NewSendPort(port_id2);
  EXPECT_VALID(send_port2);
 
  // Test first port.

TEST_CASE() [148/600]

dart::TEST_CASE

(

DartAPI_NativePortPostUserClass

)

Definition at line 8288 of file dart_api_impl_test.cc.

                                                             {
  UNREACHABLE();
}
 
TEST_CASE(DartAPI_NativePortPostUserClass) {
  const char* kScriptChars =
      "import 'dart:isolate';\n"
      "class ABC {}\n"
      "void callPort(SendPort port) {\n"
      "  port.send(new ABC());\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
 
  Dart_Port port_id =
      Dart_NewNativePort("Port123", UnreachableMessageHandler, true);
 
  // Test send with port open.
  {
    Dart_Handle send_port = Dart_NewSendPort(port_id);
    EXPECT_VALID(send_port);
    Dart_Handle dart_args[1];
    dart_args[0] = send_port;
    Dart_Handle result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
    EXPECT_ERROR(result, "Invalid argument");
  }

TEST_CASE() [149/600]

dart::TEST_CASE

(

DartAPI_NativePortReceiveInteger

)

Definition at line 8391 of file dart_api_impl_test.cc.

                                                                      {
  EXPECT_NOTNULL(message);
 
  if ((message->type == Dart_CObject_kArray) &&
      (message->value.as_array.values[0]->type == Dart_CObject_kSendPort)) {
    // Post integer value.
    Dart_PostInteger(message->value.as_array.values[0]->value.as_send_port.id,
                     123);
  } else {
    EXPECT_EQ(message->type, Dart_CObject_kInt32);
    EXPECT_EQ(message->value.as_int32, 321);
  }
}
 
TEST_CASE(DartAPI_NativePortReceiveInteger) {
  const char* kScriptChars =
      "import 'dart:isolate';\n"
      "void callPort(SendPort port) {\n"
      "  var receivePort = new RawReceivePort();\n"
      "  var replyPort = receivePort.sendPort;\n"
      "  port.send(321);\n"
      "  port.send(<dynamic>[replyPort]);\n"
      "  receivePort.handler = (message) {\n"
      "    receivePort.close();\n"
      "    throw new Exception(message);\n"
      "  };\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
 
  Dart_Port port_id1 =
      Dart_NewNativePort("PortNull", NewNativePort_nativeReceiveInteger, true);
  Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
  EXPECT_VALID(send_port1);
 
  // Test first port.

TEST_CASE() [150/600]

dart::TEST_CASE

(

DartAPI_NativePortReceiveNull

)

Definition at line 8339 of file dart_api_impl_test.cc.

                                                                   {
  EXPECT_NOTNULL(message);
 
  if ((message->type == Dart_CObject_kArray) &&
      (message->value.as_array.values[0]->type == Dart_CObject_kSendPort)) {
    // Post integer value.
    Dart_PostInteger(message->value.as_array.values[0]->value.as_send_port.id,
                     123);
  } else {
    EXPECT_EQ(message->type, Dart_CObject_kNull);
  }
}
 
TEST_CASE(DartAPI_NativePortReceiveNull) {
  const char* kScriptChars =
      "import 'dart:isolate';\n"
      "void callPort(SendPort port) {\n"
      "  var receivePort = new RawReceivePort();\n"
      "  var replyPort = receivePort.sendPort;\n"
      "  port.send(null);\n"
      "  port.send(<dynamic>[replyPort]);\n"
      "  receivePort.handler = (message) {\n"
      "    receivePort.close();\n"
      "    throw new Exception(message);\n"
      "  };\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
 
  Dart_Port port_id1 =
      Dart_NewNativePort("PortNull", NewNativePort_nativeReceiveNull, true);
  Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
  EXPECT_VALID(send_port1);
 
  // Test first port.

TEST_CASE() [151/600]

dart::TEST_CASE

(

DartAPI_NativeStaticFunctionClosure

)

Definition at line 8836 of file dart_api_impl_test.cc.

                                                        {
  Dart_EnterScope();
  intptr_t i = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(0, i);
  Dart_SetReturnValue(args, Dart_NewInteger(0));
  Dart_ExitScope();
}
 
static void StaticNativeFoo2(Dart_NativeArguments args) {
  Dart_EnterScope();
  intptr_t i = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(1, i);
  Dart_Handle arg = Dart_GetNativeArgument(args, 0);
  Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg)));
  Dart_ExitScope();
}
 
static void StaticNativeFoo3(Dart_NativeArguments args) {
  Dart_EnterScope();
  intptr_t i = Dart_GetNativeArgumentCount(args);

TEST_CASE() [152/600]

dart::TEST_CASE

(

DartAPI_NegativeNativeFieldAccess

)

Definition at line 5809 of file dart_api_impl_test.cc.

                                             {
  // clang-format off
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "import 'dart:nativewrappers';\n"
                  "class NativeFields {\n"
                  "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
                  "  int fld1;\n"
                  "  final int fld2;\n"
                  "  static int%s fld3;\n"
                  "  static const int fld4 = 10;\n"
                  "}\n"
                  "NativeFields testMain1() {\n"
                  "  NativeFields obj = new NativeFields(10, 20);\n"
                  "  return obj;\n"
                  "}\n"
                  "Function testMain2() {\n"
                  "  return () {};\n"
                  "}\n",
                  TestCase::NullableTag()),
      std::free);
  // clang-format on
 
  Dart_Handle result;
  CHECK_API_SCOPE(thread);
 
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars.get(), nullptr);
 
  // Invoke a function which returns an object of type NativeFields.
  Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, nullptr);
  EXPECT_VALID(retobj);
 
  // Now access and set various native instance fields of the returned object.
  // All of these tests are expected to return failure as there are no
  // native fields in an instance of NativeFields.
  const int kNativeFld0 = 0;
  const int kNativeFld1 = 1;
  const int kNativeFld2 = 2;
  const int kNativeFld3 = 3;
  const int kNativeFld4 = 4;
  intptr_t value = 0;
  result = Dart_GetNativeInstanceField(retobj, kNativeFld4, &value);
  EXPECT(Dart_IsError(result));
  result = Dart_GetNativeInstanceField(retobj, kNativeFld0, &value);
  EXPECT(Dart_IsError(result));
  result = Dart_GetNativeInstanceField(retobj, kNativeFld1, &value);
  EXPECT(Dart_IsError(result));
  result = Dart_GetNativeInstanceField(retobj, kNativeFld2, &value);
  EXPECT(Dart_IsError(result));
  result = Dart_SetNativeInstanceField(retobj, kNativeFld4, 40);
  EXPECT(Dart_IsError(result));
  result = Dart_SetNativeInstanceField(retobj, kNativeFld3, 40);
  EXPECT(Dart_IsError(result));
  result = Dart_SetNativeInstanceField(retobj, kNativeFld0, 400);
  EXPECT(Dart_IsError(result));
 
  // Invoke a function which returns a closure object.
  retobj = Dart_Invoke(lib, NewString("testMain2"), 0, nullptr);
  EXPECT_VALID(retobj);
 
  result = Dart_GetNativeInstanceField(retobj, kNativeFld4, &value);
  EXPECT(Dart_IsError(result));
  result = Dart_GetNativeInstanceField(retobj, kNativeFld0, &value);
  EXPECT(Dart_IsError(result));
  result = Dart_GetNativeInstanceField(retobj, kNativeFld1, &value);
  EXPECT(Dart_IsError(result));
  result = Dart_GetNativeInstanceField(retobj, kNativeFld2, &value);
  EXPECT(Dart_IsError(result));
  result = Dart_SetNativeInstanceField(retobj, kNativeFld4, 40);
  EXPECT(Dart_IsError(result));
  result = Dart_SetNativeInstanceField(retobj, kNativeFld3, 40);
  EXPECT(Dart_IsError(result));
  result = Dart_SetNativeInstanceField(retobj, kNativeFld0, 400);
  EXPECT(Dart_IsError(result));
}

TEST_CASE() [153/600]

dart::TEST_CASE

(

DartAPI_New

)

Definition at line 5975 of file dart_api_impl_test.cc.

                       {
  const char* kScriptChars =
      "class MyClass implements MyExtraHop {\n"
      "  MyClass() : foo = 7 {}\n"
      "  MyClass.named(value) : foo = value {}\n"
      "  MyClass._hidden(value) : foo = -value {}\n"
      "  MyClass.exception(value) : foo = value {\n"
      "    throw 'ConstructorDeath';\n"
      "  }\n"
      "  factory MyClass.multiply(value) {\n"
      "    return new MyClass.named(value * 100);\n"
      "  }\n"
      "  var foo;\n"
      "}\n"
      "\n"
      "abstract class MyExtraHop implements MyInterface {\n"
      "  factory MyExtraHop.hop(value) = MyClass.named;\n"
      "}\n"
      "\n"
      "abstract class MyInterface {\n"
      "  factory MyInterface.named(value) = MyExtraHop.hop;\n"
      "  factory MyInterface.multiply(value) = MyClass.multiply;\n"
      "  MyInterface.notfound(value);\n"
      "}\n"
      "\n"
      "class _MyClass {\n"
      "  _MyClass._() : foo = 7 {}\n"
      "  var foo;\n"
      "}\n"
      "\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("MyClass"), 0, nullptr);
  EXPECT_VALID(type);
  Dart_Handle intf =
      Dart_GetNonNullableType(lib, NewString("MyInterface"), 0, nullptr);
  EXPECT_VALID(intf);
  Dart_Handle private_type =
      Dart_GetNonNullableType(lib, NewString("_MyClass"), 0, nullptr);
  EXPECT_VALID(private_type);
 
  Dart_Handle args[1];
  args[0] = Dart_NewInteger(11);
  Dart_Handle bad_args[1];
  bad_args[0] = Dart_NewApiError("myerror");
 
  // Allocate and Invoke the unnamed constructor passing in Dart_Null.
  Dart_Handle result = Dart_New(type, Dart_Null(), 0, nullptr);
  EXPECT_VALID(result);
  bool instanceOf = false;
  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
  EXPECT(instanceOf);
  int64_t int_value = 0;
  Dart_Handle foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(7, int_value);
 
  // Allocate without a constructor.
  Dart_Handle obj = Dart_Allocate(type);
  EXPECT_VALID(obj);
  instanceOf = false;
  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
  EXPECT(instanceOf);
  foo = Dart_GetField(obj, NewString("foo"));
  EXPECT(Dart_IsNull(foo));
 
  // Allocate and Invoke the unnamed constructor passing in an empty string.
  result = Dart_New(type, Dart_EmptyString(), 0, nullptr);
  EXPECT_VALID(result);
  instanceOf = false;
  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
  EXPECT(instanceOf);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(7, int_value);
 
  // Allocate object and invoke the unnamed constructor with an empty string.
  obj = Dart_Allocate(type);
  EXPECT_VALID(obj);
  instanceOf = false;
  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
  EXPECT(instanceOf);
  // Use the empty string to invoke the unnamed constructor.
  result = Dart_InvokeConstructor(obj, Dart_EmptyString(), 0, nullptr);
  EXPECT_VALID(result);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(7, int_value);
  // use Dart_Null to invoke the unnamed constructor.
  result = Dart_InvokeConstructor(obj, Dart_Null(), 0, nullptr);
  EXPECT_VALID(result);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(7, int_value);
 
  // Invoke a named constructor.
  result = Dart_New(type, NewString("named"), 1, args);
  EXPECT_VALID(result);
  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
  EXPECT(instanceOf);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(11, int_value);
 
  // Allocate object and invoke a named constructor.
  obj = Dart_Allocate(type);
  EXPECT_VALID(obj);
  instanceOf = false;
  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
  EXPECT(instanceOf);
  result = Dart_InvokeConstructor(obj, NewString("named"), 1, args);
  EXPECT_VALID(result);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(11, int_value);
 
  // Invoke a hidden named constructor.
  result = Dart_New(type, NewString("_hidden"), 1, args);
  EXPECT_VALID(result);
  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
  EXPECT(instanceOf);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(-11, int_value);
 
  // Invoke a hidden named constructor on a hidden type.
  result = Dart_New(private_type, NewString("_"), 0, nullptr);
  EXPECT_VALID(result);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(7, int_value);
 
  // Allocate object and invoke a hidden named constructor.
  obj = Dart_Allocate(type);
  EXPECT_VALID(obj);
  instanceOf = false;
  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
  EXPECT(instanceOf);
  result = Dart_InvokeConstructor(obj, NewString("_hidden"), 1, args);
  EXPECT_VALID(result);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(-11, int_value);
 
  // Allocate object and Invoke a constructor which throws an exception.
  obj = Dart_Allocate(type);
  EXPECT_VALID(obj);
  instanceOf = false;
  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
  EXPECT(instanceOf);
  result = Dart_InvokeConstructor(obj, NewString("exception"), 1, args);
  EXPECT_ERROR(result, "ConstructorDeath");
 
  // Invoke a factory constructor.
  result = Dart_New(type, NewString("multiply"), 1, args);
  EXPECT_VALID(result);
  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
  EXPECT(instanceOf);
  int_value = 0;
  foo = Dart_GetField(result, NewString("foo"));
  EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
  EXPECT_EQ(1100, int_value);
 
  // Pass an error class object.  Error is passed through.
  result = Dart_New(Dart_NewApiError("myerror"), NewString("named"), 1, args);
  EXPECT_ERROR(result, "myerror");
 
  // Pass a bad class object.
  result = Dart_New(Dart_Null(), NewString("named"), 1, args);
  EXPECT_ERROR(result, "Dart_New expects argument 'type' to be non-null.");
 
  // Pass a negative arg count.
  result = Dart_New(type, NewString("named"), -1, args);
  EXPECT_ERROR(
      result,
      "Dart_New expects argument 'number_of_arguments' to be non-negative.");
 
  // Pass the wrong arg count.
  result = Dart_New(type, NewString("named"), 0, nullptr);
  EXPECT_ERROR(
      result,
      "Dart_New: wrong argument count for constructor 'MyClass.named': "
      "0 passed, 1 expected.");
 
  // Pass a bad argument.  Error is passed through.
  result = Dart_New(type, NewString("named"), 1, bad_args);
  EXPECT_ERROR(result, "myerror");
 
  // Pass a bad constructor name.
  result = Dart_New(type, Dart_NewInteger(55), 1, args);
  EXPECT_ERROR(
      result,
      "Dart_New expects argument 'constructor_name' to be of type String.");
 
  // Invoke a missing constructor.
  result = Dart_New(type, NewString("missing"), 1, args);
  EXPECT_ERROR(result,
               "Dart_New: could not find constructor 'MyClass.missing'.");
 
  // Invoke a constructor which throws an exception.
  result = Dart_New(type, NewString("exception"), 1, args);
  EXPECT_ERROR(result, "ConstructorDeath");
 
  // Invoke a constructor that is missing in the interface.
  result = Dart_New(intf, Dart_Null(), 0, nullptr);
  EXPECT_ERROR(result, "Dart_New: could not find constructor 'MyInterface.'.");
 
  // Invoke abstract constructor that is present in the interface.
  result = Dart_New(intf, NewString("notfound"), 1, args);
  EXPECT_VALID(result);
  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
  EXPECT(!instanceOf);
}

TEST_CASE() [154/600]

dart::TEST_CASE

(

DartAPI_New_Issue42939

)

Definition at line 6200 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars =
      "class MyClass implements MyExtraHop {\n"
      "  MyClass() : foo = 7 {}\n"
      "  MyClass.named(value) : foo = value {}\n"
      "  MyClass._hidden(value) : foo = -value {}\n"
      "  MyClass.exception(value) : foo = value {\n"
      "    throw 'ConstructorDeath';\n"
      "  }\n"
      "  factory MyClass.multiply(value) {\n"
      "    return new MyClass.named(value * 100);\n"
      "  }\n"
      "  var foo;\n"
      "}\n"
      "\n"
      "abstract class MyExtraHop implements MyInterface {\n"
      "  factory MyExtraHop.hop(value) = MyClass.named;\n"
      "}\n"
      "\n"
      "abstract class MyInterface {\n"
      "  factory MyInterface.named(value) = MyExtraHop.hop;\n"
      "  factory MyInterface.multiply(value) = MyClass.multiply;\n"
      "  MyInterface.notfound(value);\n"
      "}\n"
      "\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("MyClass"), 0, nullptr);
  EXPECT_VALID(type);
  Dart_Handle intf =
      Dart_GetNonNullableType(lib, NewString("MyInterface"), 0, nullptr);
  EXPECT_VALID(intf);
 
  Dart_Handle args[1];
  args[0] = Dart_NewInteger(11);
 
  // Invoke two-hop redirecting factory constructor.
  bool instanceOf = false;
  Dart_Handle result = Dart_New(intf, NewString("named"), 1, args);
  EXPECT_VALID(result);
  if (!Dart_IsError(result)) {
    EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
    EXPECT(instanceOf);
    int64_t int_value = 0;
    Dart_Handle foo = Dart_GetField(result, NewString("foo"));
    EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
    EXPECT_EQ(11, int_value);
  }
 
  // Invoke one-hop redirecting factory constructor.
  result = Dart_New(intf, NewString("multiply"), 1, args);
  EXPECT_VALID(result);
  if (!Dart_IsError(result)) {
    EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
    EXPECT(instanceOf);
    int64_t int_value = 0;
    Dart_Handle foo = Dart_GetField(result, NewString("foo"));
    EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
    EXPECT_EQ(1100, int_value);
  }
}

TEST_CASE() [155/600]

dart::TEST_CASE

(

DartAPI_New_Issue44205

)

Definition at line 6263 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars =
      "class MyIntClass {\n"
      "  MyIntClass(this.value);\n"
      "  int value;\n"
      "}\n"
      "\n"
      "class MyClass<T> {\n"
      "  T value;\n"
      "  MyClass(this.value);\n"
      "  factory MyClass.foo(T x) => MyClass<T>(x);\n"
      "}\n"
      "\n"
      "Type getIntType() { return int; }\n"
      "\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle int_wrapper_type =
      Dart_GetNonNullableType(lib, NewString("MyIntClass"), 0, nullptr);
  EXPECT_VALID(int_wrapper_type);
 
  Dart_Handle args[1];
  args[0] = Dart_EmptyString();
 
  Dart_Handle result = Dart_New(int_wrapper_type, Dart_EmptyString(), 1, args);
  EXPECT_ERROR(result, "String' is not a subtype of type 'int' of 'value'");
 
  Dart_Handle int_type = Dart_Invoke(lib, NewString("getIntType"), 0, args);
  EXPECT_VALID(int_type);
  Dart_Handle type_args = Dart_NewList(1);
  EXPECT_VALID(type_args);
  EXPECT_VALID(Dart_ListSetAt(type_args, 0, int_type));
  Dart_Handle my_class_type =
      Dart_GetNonNullableType(lib, NewString("MyClass"), 1, &type_args);
  EXPECT_VALID(my_class_type);
 
  // Generic generative constructor
  args[0] = Dart_EmptyString();
  result = Dart_New(my_class_type, Dart_EmptyString(), 1, args);
  EXPECT_ERROR(result, "String' is not a subtype of type 'int' of 'value'");
 
  // Generic factory constructor
  result = Dart_New(my_class_type, NewString("foo"), 1, args);
  EXPECT_ERROR(result, "String' is not a subtype of type 'int' of 'x'");
}

TEST_CASE() [156/600]

dart::TEST_CASE

(

DartAPI_NewListOf

)

Definition at line 6388 of file dart_api_impl_test.cc.

                             {
  const char* kScriptChars =
      "String expectListOfString(List<String> o) => '${o.first}';\n"
      "String expectListOfDynamic(List<dynamic> o) => '${o.first}';\n"
      "String expectListOfInt(List<int> o) => '${o.first}';\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  const int kNumArgs = 1;
  Dart_Handle args[kNumArgs];
  const char* str;
  Dart_Handle result;
  Dart_Handle string_list = Dart_NewListOf(Dart_CoreType_String, 1);
  if (!Dart_IsError(string_list)) {
    args[0] = string_list;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("expectListOfString"), kNumArgs, args);
    EXPECT_VALID(result);
    result = Dart_StringToCString(result, &str);
    EXPECT_VALID(result);
    EXPECT_STREQ("null", str);
  } else {
    EXPECT_ERROR(string_list,
                 "Cannot use legacy types with --sound-null-safety enabled. "
                 "Use Dart_NewListOfType or Dart_NewListOfTypeFilled instead.");
  }
 
  Dart_Handle dynamic_list = Dart_NewListOf(Dart_CoreType_Dynamic, 1);
  EXPECT_VALID(dynamic_list);
  args[0] = dynamic_list;
  result = Dart_Invoke(lib, NewString("expectListOfDynamic"), kNumArgs, args);
  EXPECT_VALID(result);
  result = Dart_StringToCString(result, &str);
  EXPECT_STREQ("null", str);
 
  Dart_Handle int_list = Dart_NewListOf(Dart_CoreType_Int, 1);
  if (!Dart_IsError(int_list)) {
    args[0] = int_list;
    result = Dart_Invoke(lib, NewString("expectListOfInt"), kNumArgs, args);
    EXPECT_VALID(result);
    result = Dart_StringToCString(result, &str);
    EXPECT_STREQ("null", str);
  } else {
    EXPECT_ERROR(int_list,
                 "Cannot use legacy types with --sound-null-safety enabled. "
                 "Use Dart_NewListOfType or Dart_NewListOfTypeFilled instead.");
  }
}

TEST_CASE() [157/600]

dart::TEST_CASE

(

DartAPI_NewListOfType

)

Definition at line 6436 of file dart_api_impl_test.cc.

                                 {
  const char* kScriptChars =
      "class ZXHandle {}\n"
      "class ChannelReadResult {\n"
      "  final List<ZXHandle?> handles;\n"
      "  ChannelReadResult(this.handles);\n"
      "}\n"
      "void expectListOfString(List<String> _) {}\n"
      "void expectListOfDynamic(List<dynamic> _) {}\n"
      "void expectListOfVoid(List<void> _) {}\n"
      "void expectListOfNever(List<Never> _) {}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle zxhandle_type =
      Dart_GetNullableType(lib, NewString("ZXHandle"), 0, nullptr);
  EXPECT_VALID(zxhandle_type);
 
  Dart_Handle zxhandle = Dart_New(zxhandle_type, Dart_Null(), 0, nullptr);
  EXPECT_VALID(zxhandle);
 
  Dart_Handle zxhandle_list = Dart_NewListOfType(zxhandle_type, 1);
  EXPECT_VALID(zxhandle_list);
 
  EXPECT_VALID(Dart_ListSetAt(zxhandle_list, 0, zxhandle));
 
  Dart_Handle readresult_type =
      Dart_GetNonNullableType(lib, NewString("ChannelReadResult"), 0, nullptr);
  EXPECT_VALID(zxhandle_type);
 
  const int kNumArgs = 1;
  Dart_Handle args[kNumArgs];
  args[0] = zxhandle_list;
  EXPECT_VALID(Dart_New(readresult_type, Dart_Null(), kNumArgs, args));
 
  EXPECT_ERROR(
      Dart_NewListOfType(Dart_Null(), 1),
      "Dart_NewListOfType expects argument 'element_type' to be non-null.");
  EXPECT_ERROR(
      Dart_NewListOfType(Dart_True(), 1),
      "Dart_NewListOfType expects argument 'element_type' to be of type Type.");
 
  Dart_Handle dart_core = Dart_LookupLibrary(NewString("dart:core"));
  EXPECT_VALID(dart_core);
 
  Dart_Handle string_type =
      Dart_GetNonNullableType(dart_core, NewString("String"), 0, nullptr);
  EXPECT_VALID(string_type);
  Dart_Handle string_list = Dart_NewListOfType(string_type, 0);
  EXPECT_VALID(string_list);
  args[0] = string_list;
  EXPECT_VALID(
      Dart_Invoke(lib, NewString("expectListOfString"), kNumArgs, args));
 
  Dart_Handle dynamic_type = Dart_TypeDynamic();
  EXPECT_VALID(dynamic_type);
  Dart_Handle dynamic_list = Dart_NewListOfType(dynamic_type, 0);
  EXPECT_VALID(dynamic_list);
  args[0] = dynamic_list;
  EXPECT_VALID(
      Dart_Invoke(lib, NewString("expectListOfDynamic"), kNumArgs, args));
 
  Dart_Handle void_type = Dart_TypeVoid();
  EXPECT_VALID(void_type);
  Dart_Handle void_list = Dart_NewListOfType(void_type, 0);
  EXPECT_VALID(void_list);
  args[0] = void_list;
  EXPECT_VALID(Dart_Invoke(lib, NewString("expectListOfVoid"), kNumArgs, args));
 
  Dart_Handle never_type = Dart_TypeNever();
  EXPECT_VALID(never_type);
  Dart_Handle never_list = Dart_NewListOfType(never_type, 0);
  EXPECT_VALID(never_list);
  args[0] = never_list;
  EXPECT_VALID(
      Dart_Invoke(lib, NewString("expectListOfNever"), kNumArgs, args));
}

TEST_CASE() [158/600]

dart::TEST_CASE

(

DartAPI_NewListOfTypeFilled

)

Definition at line 6513 of file dart_api_impl_test.cc.

                                       {
  const char* kScriptChars =
      "class ZXHandle {}\n"
      "class ChannelReadResult {\n"
      "  final List<ZXHandle> handles;\n"
      "  ChannelReadResult(this.handles);\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle zxhandle_type =
      Dart_GetNonNullableType(lib, NewString("ZXHandle"), 0, nullptr);
  EXPECT_VALID(zxhandle_type);
 
  Dart_Handle nullable_zxhandle_type =
      Dart_GetNullableType(lib, NewString("ZXHandle"), 0, nullptr);
  EXPECT_VALID(nullable_zxhandle_type);
 
  Dart_Handle integer = Dart_NewInteger(42);
  EXPECT_VALID(integer);
 
  Dart_Handle zxhandle = Dart_New(zxhandle_type, Dart_Null(), 0, nullptr);
  EXPECT_VALID(zxhandle);
 
  Dart_Handle zxhandle_list =
      Dart_NewListOfTypeFilled(zxhandle_type, zxhandle, 1);
  EXPECT_VALID(zxhandle_list);
 
  Dart_Handle result = Dart_ListGetAt(zxhandle_list, 0);
  EXPECT_VALID(result);
 
  EXPECT(Dart_IdentityEquals(result, zxhandle));
 
  Dart_Handle readresult_type =
      Dart_GetNonNullableType(lib, NewString("ChannelReadResult"), 0, nullptr);
  EXPECT_VALID(zxhandle_type);
 
  const int kNumArgs = 1;
  Dart_Handle args[kNumArgs];
  args[0] = zxhandle_list;
  EXPECT_VALID(Dart_New(readresult_type, Dart_Null(), kNumArgs, args));
 
  EXPECT_ERROR(Dart_NewListOfTypeFilled(Dart_Null(), Dart_Null(), 1),
               "Dart_NewListOfTypeFilled expects argument 'element_type' to be "
               "non-null.");
  EXPECT_ERROR(Dart_NewListOfTypeFilled(Dart_True(), Dart_Null(), 1),
               "Dart_NewListOfTypeFilled expects argument 'element_type' to be "
               "of type Type.");
  EXPECT_ERROR(
      Dart_NewListOfTypeFilled(zxhandle_type, Dart_Null(), 1),
      "Dart_NewListOfTypeFilled expects argument 'fill_object' to be non-null"
      " for a non-nullable 'element_type'");
  EXPECT_ERROR(
      Dart_NewListOfTypeFilled(zxhandle_type, integer, 1),
      "Dart_NewListOfTypeFilled expects argument 'fill_object' to have the same"
      " type as 'element_type'.");
 
  EXPECT_VALID(
      Dart_NewListOfTypeFilled(nullable_zxhandle_type, Dart_Null(), 1));
 
  // Null is always valid as the fill argument if we're creating an empty list.
  EXPECT_VALID(Dart_NewListOfTypeFilled(zxhandle_type, Dart_Null(), 0));
 
  // Test creation of a non nullable list of strings.
  Dart_Handle corelib = Dart_LookupLibrary(NewString("dart:core"));
  EXPECT_VALID(corelib);
  Dart_Handle string_type =
      Dart_GetNonNullableType(corelib, NewString("String"), 0, nullptr);
  EXPECT_VALID(Dart_NewListOfTypeFilled(string_type, Dart_EmptyString(), 2));
}

TEST_CASE() [159/600]

dart::TEST_CASE

(

DartAPI_NewString

)

Definition at line 1616 of file dart_api_impl_test.cc.

                             {
  const char* ascii = "string";
  Dart_Handle ascii_str = NewString(ascii);
  EXPECT_VALID(ascii_str);
  EXPECT(Dart_IsString(ascii_str));
 
  const char* null = nullptr;
  Dart_Handle null_str = NewString(null);
  EXPECT(Dart_IsError(null_str));
 
  uint8_t data[] = {0xE4, 0xBA, 0x8c};  // U+4E8C.
  Dart_Handle utf8_str = Dart_NewStringFromUTF8(data, ARRAY_SIZE(data));
  EXPECT_VALID(utf8_str);
  EXPECT(Dart_IsString(utf8_str));
 
  uint8_t invalid[] = {0xE4, 0xBA};  // underflow.
  Dart_Handle invalid_str =
      Dart_NewStringFromUTF8(invalid, ARRAY_SIZE(invalid));
  EXPECT(Dart_IsError(invalid_str));
}

TEST_CASE() [160/600]

dart::TEST_CASE

(

DartAPI_NewString_Null

)

Definition at line 8884 of file dart_api_impl_test.cc.

                       {
    return nullptr;
  }
  const char* function_name = obj.ToCString();
  const char* kNativeFoo1 = "StaticNativeFoo1";
  const char* kNativeFoo2 = "StaticNativeFoo2";
  const char* kNativeFoo3 = "StaticNativeFoo3";
  const char* kNativeFoo4 = "StaticNativeFoo4";
  if (strncmp(function_name, kNativeFoo1, strlen(kNativeFoo1)) == 0) {
    return &StaticNativeFoo1;
  } else if (strncmp(function_name, kNativeFoo2, strlen(kNativeFoo2)) == 0) {
    return &StaticNativeFoo2;
  } else if (strncmp(function_name, kNativeFoo3, strlen(kNativeFoo3)) == 0) {
    return &StaticNativeFoo3;
  } else if (strncmp(function_name, kNativeFoo4, strlen(kNativeFoo4)) == 0) {
    return &StaticNativeFoo4;
  } else {
    UNREACHABLE();
    return nullptr;
  }
}

TEST_CASE() [161/600]

dart::TEST_CASE

(

DartAPI_NewUnmodifiableExternalTypedDataWithFinalizer

)

Definition at line 2805 of file dart_api_impl_test.cc.

                                                                 {
  const char* kScriptChars = R"(
class Expect {
  static equals(a, b) {
    if (a != b) {
      throw 'not equal. expected: $a, got: $b';
    }
  }
  static throws(block) {
    bool threw = false;
    try { block(); } catch (e) { threw = true; }
    if (!threw) throw 'did not throw';
  }
}
testList(data) {
  for (var i = 0; i < data.length; i++) {
    Expect.equals(i, data[i]);
    Expect.throws(() => data[i] = 0);
  }
}
testBytes(data) {
  for (var i = 0; i < data.length; i++) {
    Expect.equals(i, data.getUint8(i));
    Expect.throws(() => data.setUint8(i, 0));
  }
})";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  {
    uint8_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kUint8, &data[0], ARRAY_SIZE(data), nullptr, 0, nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kUint8, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    int8_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kInt8, &data[0], ARRAY_SIZE(data), nullptr, 0, nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kInt8, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    uint16_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kUint16, &data[0], ARRAY_SIZE(data), nullptr, 0,
        nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kUint16, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    int16_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kInt16, &data[0], ARRAY_SIZE(data), nullptr, 0, nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kInt16, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    uint32_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kUint32, &data[0], ARRAY_SIZE(data), nullptr, 0,
        nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kUint32, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    int32_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kInt32, &data[0], ARRAY_SIZE(data), nullptr, 0, nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kInt32, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    uint64_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kUint64, &data[0], ARRAY_SIZE(data), nullptr, 0,
        nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kUint64, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    int64_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kInt64, &data[0], ARRAY_SIZE(data), nullptr, 0, nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kInt64, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    float data[] = {0.0f, 1.0f, 2.0f, 3.0f};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kFloat32, &data[0], ARRAY_SIZE(data), nullptr, 0,
        nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kFloat32, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), 1, &typed_data);
    EXPECT_VALID(result);
    EXPECT_VALID(result);
  }
 
  {
    double data[] = {0.0, 1.0, 2.0, 3.0};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kFloat64, &data[0], ARRAY_SIZE(data), nullptr, 0,
        nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kFloat64, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testList"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
 
  {
    uint8_t data[] = {0, 1, 2, 3};
    Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
        Dart_TypedData_kByteData, &data[0], ARRAY_SIZE(data), nullptr, 0,
        nullptr);
    EXPECT_VALID(typed_data);
    EXPECT_EQ(Dart_TypedData_kByteData, Dart_GetTypeOfTypedData(typed_data));
    Dart_Handle args[1];
    args[0] = typed_data;
    Dart_Handle result =
        Dart_Invoke(lib, NewString("testBytes"), ARRAY_SIZE(args), args);
    EXPECT_VALID(result);
  }
}

TEST_CASE() [162/600]

dart::TEST_CASE

(

DartAPI_NotifyDestroyed

)

Definition at line 9742 of file dart_api_impl_test.cc.

  {
    result = Dart_SetEnabledTimelineCategory("Isolate");
    EXPECT_EQ(true, result);
    JSONStream js;
    JSONObject obj(&js);
    JSONArray jstream(&obj, "available");

TEST_CASE() [163/600]

dart::TEST_CASE

(

DartAPI_NotifyIdleLong

)

Definition at line 9709 of file dart_api_impl_test.cc.

                                      {
  bool result;
  {
    result = Dart_SetEnabledTimelineCategory("all");
    EXPECT_EQ(true, result);
    JSONStream js;
    JSONObject obj(&js);
    JSONArray jstream(&obj, "available");
    Timeline::PrintFlagsToJSONArray(&jstream);
    const char* js_str = js.ToCString();
#define TIMELINE_STREAM_CHECK(name, ...) EXPECT_SUBSTRING(#name, js_str);
    TIMELINE_STREAM_LIST(TIMELINE_STREAM_CHECK)
#undef TIMELINE_STREAM_CHECK

TEST_CASE() [164/600]

dart::TEST_CASE

(

DartAPI_NotifyIdleShort

)

Definition at line 9677 of file dart_api_impl_test.cc.

                              {
        ReportAsyncEventArguments& arguments =
            *reinterpret_cast<ReportAsyncEventArguments*>(arguments_ptr);
        Dart_RecordTimelineEvent("async2", /*timestamp0=*/0, /*async_id=*/2, 0,
                                 nullptr, Dart_Timeline_Event_Async_Instant,
                                 /*argument_count=*/0, nullptr, nullptr);
        MonitorLocker ml(&arguments.synchronization_monitor);
        arguments.join_id =
            OSThread::GetCurrentThreadJoinId(OSThread::Current());
        ml.Notify();
      },
      reinterpret_cast<uword>(&report_async_event_2_arguments));
  recorder.PrintPerfettoTimeline(&js, filter);
 
  MonitorLocker ml(&synchronization_monitor);
  while (report_async_event_1_arguments.join_id ==
             OSThread::kInvalidThreadJoinId ||
         report_async_event_2_arguments.join_id ==
             OSThread::kInvalidThreadJoinId) {

TEST_CASE() [165/600]

dart::TEST_CASE

(

DartAPI_NotifyLowMemory

)

Definition at line 9819 of file dart_api_impl_test.cc.

                                                            {
  Dart_NotifyIdle(Dart_TimelineGetMicros() + 100 * kMicrosecondsPerMillisecond);
}
 
static Dart_NativeFunction NotifyIdleLong_native_lookup(
    Dart_Handle name,
    int argument_count,
    bool* auto_setup_scope) {
  return NotifyIdleLongNative;
}
 
TEST_CASE(DartAPI_NotifyIdleLong) {
  const char* kScriptChars = R"(
@pragma("vm:external-name", "Test_nativeFunc")

TEST_CASE() [166/600]

dart::TEST_CASE

(

DartAPI_Null

)

Definition at line 916 of file dart_api_impl_test.cc.

                        {
  Dart_Handle null = Dart_Null();
  EXPECT_VALID(null);
  EXPECT(Dart_IsNull(null));
 
  Dart_Handle str = NewString("test");
  EXPECT_VALID(str);
  EXPECT(!Dart_IsNull(str));
}

TEST_CASE() [167/600]

dart::TEST_CASE

(

DartAPI_NumberValues

)

Definition at line 1375 of file dart_api_impl_test.cc.

                                {
  // TODO(antonm): add various kinds of ints (smi, mint, bigint).
  const char* kScriptChars =
      "int getInt() { return 1; }\n"
      "double getDouble() { return 1.0; }\n"
      "bool getBool() { return false; }\n"
      "getNull() { return null; }\n";
  Dart_Handle result;
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Check int case.
  result = Dart_Invoke(lib, NewString("getInt"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsNumber(result));
 
  // Check double case.
  result = Dart_Invoke(lib, NewString("getDouble"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsNumber(result));
 
  // Check bool case.
  result = Dart_Invoke(lib, NewString("getBool"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(!Dart_IsNumber(result));
 
  // Check null case.
  result = Dart_Invoke(lib, NewString("getNull"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(!Dart_IsNumber(result));
}

TEST_CASE() [168/600]

dart::TEST_CASE

(

DartAPI_ObjectEquals

)

Definition at line 1021 of file dart_api_impl_test.cc.

                                {
  bool equal = false;
  Dart_Handle five = NewString("5");
  Dart_Handle five_again = NewString("5");
  Dart_Handle seven = NewString("7");
 
  // Same objects.
  EXPECT_VALID(Dart_ObjectEquals(five, five, &equal));
  EXPECT(equal);
 
  // Equal objects.
  EXPECT_VALID(Dart_ObjectEquals(five, five_again, &equal));
  EXPECT(equal);
 
  // Different objects.
  EXPECT_VALID(Dart_ObjectEquals(five, seven, &equal));
  EXPECT(!equal);
 
  // Case where identity is not equality.
  Dart_Handle nan = Dart_NewDouble(NAN);
  EXPECT_VALID(Dart_ObjectEquals(nan, nan, &equal));
  EXPECT(!equal);
}

TEST_CASE() [169/600]

dart::TEST_CASE

(

DartAPI_OneNewSpacePeer

)

Definition at line 8940 of file dart_api_impl_test.cc.

                     {
        Test obj = new Test();
        Expect.equals(0, Test.foo1());
        Expect.equals(0, obj.bar1());
 
        Expect.equals(10, Test.foo2(10));
        Expect.equals(10, obj.bar2(10));
 
        Expect.equals(10001, Test.foo3());
        Expect.equals(10001, obj.bar30());
        Expect.equals(2, Test.foo3(1));
        Expect.equals(2, obj.bar31(1));
        Expect.equals(4, Test.foo3(2, 2));
        Expect.equals(4, obj.bar32(2, 2));
 
        Expect.equals(12, Test.foo4(1));
        Expect.equals(12, obj.bar41(1));
        Expect.equals(3, Test.foo4(1, 1));
        Expect.equals(3, obj.bar42(1, 1));

TEST_CASE() [170/600]

dart::TEST_CASE

(

DartAPI_OneOldSpacePeer

)

Definition at line 9157 of file dart_api_impl_test.cc.

                                           {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_EnterScope();
  {
    CHECK_API_SCOPE(thread);
    Dart_Handle s1 = NewString("s1");
    EXPECT_VALID(s1);
    EXPECT(Dart_IsString(s1));
    EXPECT_EQ(0, heap->PeerCount());
    void* o1 = &o1;
    EXPECT(Dart_GetPeer(s1, &o1));
    EXPECT(o1 == nullptr);
    int p1 = 1234;
    EXPECT_VALID(Dart_SetPeer(s1, &p1));
    EXPECT_EQ(1, heap->PeerCount());

TEST_CASE() [171/600]

dart::TEST_CASE

(

DartAPI_OnePromotedPeer

)

Definition at line 9116 of file dart_api_impl_test.cc.

  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
    EXPECT_EQ(0, heap->PeerCount());
  }
}
 
// Allocates two objects in new space and assigns them peers.  Removes
// the peers and checks that the count of peer objects is decremented
// by two.
TEST_CASE(DartAPI_TwoNewSpacePeers) {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_Handle s1 = NewString("s1");
  EXPECT_VALID(s1);
  EXPECT(Dart_IsString(s1));
  void* o1 = &o1;
  EXPECT_VALID(Dart_GetPeer(s1, &o1));
  EXPECT(o1 == nullptr);
  EXPECT_EQ(0, heap->PeerCount());
  int p1 = 1234;
  EXPECT_VALID(Dart_SetPeer(s1, &p1));
  EXPECT_EQ(1, heap->PeerCount());
  EXPECT_VALID(Dart_GetPeer(s1, &o1));
  EXPECT(o1 == reinterpret_cast<void*>(&p1));
  Dart_Handle s2 = NewString("a string");
  EXPECT_VALID(s2);
  EXPECT(Dart_IsString(s2));
  EXPECT_EQ(1, heap->PeerCount());
  void* o2 = &o2;
  EXPECT(Dart_GetPeer(s2, &o2));
  EXPECT(o2 == nullptr);
  int p2 = 5678;

TEST_CASE() [172/600]

dart::TEST_CASE

(

DartAPI_OptimizedExternalByteDataAccess

)

Definition at line 2420 of file dart_api_impl_test.cc.

                                                   {
  const char* kScriptChars = R"(
import 'dart:typed_data';
class Expect {
  static equals(a, b) {
    if (a != b) {
      throw 'not equal. expected: $a, got: $b';
    }
  }
}
@pragma("vm:external-name", "CreateExternalByteData")
external ByteData createExternalByteData();
access(ByteData a) {
  Expect.equals(0x04030201, a.getUint32(0, Endian.little));
  Expect.equals(0x08070605, a.getUint32(4, Endian.little));
  Expect.equals(0x0c0b0a09, a.getUint32(8, Endian.little));
  Expect.equals(0x100f0e0d, a.getUint32(12, Endian.little));
}
ByteData main() {
  var length = 16;
  var a = createExternalByteData();
  Expect.equals(length, a.lengthInBytes);
  for (int i = 0; i < 20; i++) {
    access(a);
  }
  return a;
}
)";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle result =
      Dart_SetNativeResolver(lib, &OptExternalByteDataNativeResolver, nullptr);
  EXPECT_VALID(result);
 
  // Invoke 'main' function.
  int old_oct = FLAG_optimization_counter_threshold;
  FLAG_optimization_counter_threshold = 5;
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  FLAG_optimization_counter_threshold = old_oct;
}

TEST_CASE() [173/600]

dart::TEST_CASE

(

DartAPI_OutOfMemoryStackTraceInfo

)

Definition at line 477 of file dart_api_impl_test.cc.

                                             {
  const char* kScriptChars =
      "var number_of_ints = 134000000;\n"
      "testMain() {\n"
      "  new List<int>(number_of_ints)\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle error = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
 
  EXPECT(Dart_IsError(error));
 
  Dart_StackTrace stacktrace;
  Dart_Handle result = Dart_GetStackTraceFromError(error, &stacktrace);
  EXPECT(Dart_IsError(result));  // No StackTrace for OutOfMemory.
}

TEST_CASE() [174/600]

dart::TEST_CASE

(

DartAPI_PostCObject_DoesNotRunFinalizerOnFailure

)

Definition at line 8006 of file dart_api_impl_test.cc.

                               {
  Dart_Handle message = Dart_True();
  bool success = Dart_Post(ILLEGAL_PORT, message);
  EXPECT(!success);
}
 
static void UnreachableFinalizer(void* isolate_callback_data, void* peer) {
  UNREACHABLE();
}
 
TEST_CASE(DartAPI_PostCObject_DoesNotRunFinalizerOnFailure) {
  char* my_str =
      Utils::StrDup("Ownership of this memory remains with the caller");
 

TEST_CASE() [175/600]

dart::TEST_CASE

(

DartAPI_PropagateCompileTimeError

)

Definition at line 818 of file dart_api_impl_test.cc.

                                             {
  const char* kScriptChars = R"(
raiseCompileError() {
  return missing_semicolon
}
 
@pragma("vm:external-name", "Test_nativeFunc")
external void nativeFunc(closure);
 
void Func1() {
  nativeFunc(() => raiseCompileError());
}
)";
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, &PropagateError_native_lookup);
  Dart_Handle result;
 
  // Use Dart_PropagateError to propagate the error.
  use_throw_exception = false;
  use_set_return = false;
 
  result = Dart_Invoke(lib, NewString("Func1"), 0, nullptr);
  EXPECT(Dart_IsError(result));
 
  EXPECT_SUBSTRING("Expected ';' after this.", Dart_GetError(result));
 
  // Use Dart_SetReturnValue to propagate the error.
  use_throw_exception = false;
  use_set_return = true;
 
  result = Dart_Invoke(lib, NewString("Func1"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING("Expected ';' after this.", Dart_GetError(result));
 
  // Use Dart_ThrowException to propagate the error.
  use_throw_exception = true;
  use_set_return = false;
 
  result = Dart_Invoke(lib, NewString("Func1"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING("Expected ';' after this.", Dart_GetError(result));
}

TEST_CASE() [176/600]

dart::TEST_CASE

(

DartAPI_PropagateError

)

Definition at line 861 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars = R"(
void throwException() {
  throw new Exception('myException');
}
 
@pragma("vm:external-name", "Test_nativeFunc")
external void nativeFunc(closure);
 
void Func2() {
  nativeFunc(() => throwException());
}
)";
  Dart_Handle lib =
      TestCase::LoadTestScript(kScriptChars, &PropagateError_native_lookup);
  Dart_Handle result;
 
  // Use Dart_PropagateError to propagate the error.
  use_throw_exception = false;
  use_set_return = false;
 
  result = Dart_Invoke(lib, NewString("Func2"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
  EXPECT_SUBSTRING("myException", Dart_GetError(result));
 
  // Use Dart_SetReturnValue to propagate the error.
  use_throw_exception = false;
  use_set_return = true;
 
  result = Dart_Invoke(lib, NewString("Func2"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
  EXPECT_SUBSTRING("myException", Dart_GetError(result));
 
  // Use Dart_ThrowException to propagate the error.
  use_throw_exception = true;
  use_set_return = false;
 
  result = Dart_Invoke(lib, NewString("Func2"), 0, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
  EXPECT_SUBSTRING("myException", Dart_GetError(result));
}

TEST_CASE() [177/600]

dart::TEST_CASE

(

DartAPI_RangeLimits

)

Definition at line 8859 of file dart_api_impl_test.cc.

                                                        {
  Dart_EnterScope();
  intptr_t i = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(3, i);
  Dart_Handle arg1 = Dart_GetNativeArgument(args, 0);
  Dart_Handle arg2 = Dart_GetNativeArgument(args, 1);
  Dart_Handle arg3 = Dart_GetNativeArgument(args, 2);
  Dart_SetReturnValue(
      args, Dart_NewInteger(GetValue(arg1) + GetValue(arg2) + GetValue(arg3)));
  Dart_ExitScope();
}
 
static Dart_NativeFunction MyStaticNativeClosureResolver(
    Dart_Handle name,
    int arg_count,
    bool* auto_setup_scope) {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = false;

TEST_CASE() [178/600]

dart::TEST_CASE

(

DartAPI_RootLibrary

)

Definition at line 7541 of file dart_api_impl_test.cc.

                               {
  const char* kScriptChars =
      "library testlib;"
      "main() {"
      "  return 12345;"
      "}";
 
  Dart_Handle root_lib = Dart_RootLibrary();
  EXPECT_VALID(root_lib);
  EXPECT(Dart_IsNull(root_lib));
 
  // Load a script.
  EXPECT_VALID(LoadScript(TestCase::url(), kScriptChars));
 
  root_lib = Dart_RootLibrary();
  Dart_Handle lib_uri = Dart_LibraryUrl(root_lib);
  EXPECT_VALID(lib_uri);
  EXPECT(!Dart_IsNull(lib_uri));
  const char* uri_cstr = "";
  EXPECT_VALID(Dart_StringToCString(lib_uri, &uri_cstr));
  EXPECT_STREQ(TestCase::url(), uri_cstr);
 
  Dart_Handle core_uri = Dart_NewStringFromCString("dart:core");
  Dart_Handle core_lib = Dart_LookupLibrary(core_uri);
  EXPECT_VALID(core_lib);
  EXPECT(Dart_IsLibrary(core_lib));
 
  Dart_Handle result = Dart_SetRootLibrary(core_uri);  // Not a library.
  EXPECT(Dart_IsError(result));
  root_lib = Dart_RootLibrary();
  lib_uri = Dart_LibraryUrl(root_lib);
  EXPECT_VALID(Dart_StringToCString(lib_uri, &uri_cstr));
  EXPECT_STREQ(TestCase::url(), uri_cstr);  // Root library didn't change.
 
  result = Dart_SetRootLibrary(core_lib);
  EXPECT_VALID(result);
  root_lib = Dart_RootLibrary();
  lib_uri = Dart_LibraryUrl(root_lib);
  EXPECT_VALID(Dart_StringToCString(lib_uri, &uri_cstr));
  EXPECT_STREQ("dart:core", uri_cstr);  // Root library did change.
 
  result = Dart_SetRootLibrary(Dart_Null());
  EXPECT_VALID(result);

TEST_CASE() [179/600]

dart::TEST_CASE

(

DartAPI_SetField_BadType

)

Definition at line 5429 of file dart_api_impl_test.cc.

                                    {
  const char* kScriptChars =
      TestCase::IsNNBD() ? "late int foo;\n" : "int foo;\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle name = NewString("foo");
  Dart_Handle result = Dart_SetField(lib, name, Dart_True());
  EXPECT(Dart_IsError(result));
  EXPECT_SUBSTRING("type 'bool' is not a subtype of type 'int' of 'foo'",
                   Dart_GetError(result));
}

TEST_CASE() [180/600]

dart::TEST_CASE

(

DartAPI_SetField_CheckIsolate

)

Definition at line 5950 of file dart_api_impl_test.cc.

                                         {
  const char* kScriptChars =
      "class TestClass  {\n"
      "  static int fld2 = 11;\n"
      "  static void testMain() {\n"
      "  }\n"
      "}\n";
  Dart_Handle result;
  int64_t value = 0;
 
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("TestClass"), 0, nullptr);
  EXPECT_VALID(type);
 
  result = Dart_SetField(type, NewString("fld2"), Dart_NewInteger(13));
  EXPECT_VALID(result);
 
  result = Dart_GetField(type, NewString("fld2"));
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(13, value);
}

TEST_CASE() [181/600]

dart::TEST_CASE

(

DartAPI_SetField_FunnyValue

)

Definition at line 5397 of file dart_api_impl_test.cc.

                                       {
  const char* kScriptChars = "var top;\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle name = NewString("top");
  bool value;
 
  // Test that you can set the field to a good value.
  EXPECT_VALID(Dart_SetField(lib, name, Dart_True()));
  Dart_Handle result = Dart_GetField(lib, name);
  EXPECT_VALID(result);
  EXPECT(Dart_IsBoolean(result));
  EXPECT_VALID(Dart_BooleanValue(result, &value));
  EXPECT(value);
 
  // Test that you can set the field to null
  EXPECT_VALID(Dart_SetField(lib, name, Dart_Null()));
  result = Dart_GetField(lib, name);
  EXPECT_VALID(result);
  EXPECT(Dart_IsNull(result));
 
  // Pass a non-instance handle.
  result = Dart_SetField(lib, name, lib);
  EXPECT_ERROR(
      result, "Dart_SetField expects argument 'value' to be of type Instance.");
 
  // Pass an error handle.  The error is contagious.
  result = Dart_SetField(lib, name, Api::NewError("myerror"));
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("myerror", Dart_GetError(result));
}

TEST_CASE() [182/600]

dart::TEST_CASE

(

DartAPI_SetNativeResolver

)

Definition at line 7685 of file dart_api_impl_test.cc.

                                     {
  const char* kScriptChars =
      R"(
      class Test {
        @pragma('vm:external-name', 'SomeNativeFunction')
        external static foo();
 
        @pragma('vm:external-name', 'SomeNativeFunction2')
        external static bar();
 
        @pragma('vm:external-name', 'SomeNativeFunction3')
        external static baz();
      }
  )";
  Dart_Handle error = Dart_NewApiError("incoming error");
  Dart_Handle result;
 
  // Load a test script.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
  result = Dart_FinalizeLoading(false);
  EXPECT_VALID(result);
  EXPECT(Dart_IsLibrary(lib));
  Dart_Handle type =
      Dart_GetNonNullableType(lib, NewString("Test"), 0, nullptr);
  EXPECT_VALID(type);
 
  result = Dart_SetNativeResolver(Dart_Null(), &MyNativeResolver1, nullptr);
  EXPECT_ERROR(
      result,
      "Dart_SetNativeResolver expects argument 'library' to be non-null.");
 
  result = Dart_SetNativeResolver(Dart_True(), &MyNativeResolver1, nullptr);
  EXPECT_ERROR(result,
               "Dart_SetNativeResolver expects argument 'library' to be of "
               "type Library.");
 
  result = Dart_SetNativeResolver(error, &MyNativeResolver1, nullptr);
  EXPECT(Dart_IsError(result));
  EXPECT_STREQ("incoming error", Dart_GetError(result));
 
  result = Dart_SetNativeResolver(lib, &MyNativeResolver1, nullptr);
  EXPECT_VALID(result);
 
  // Call a function and make sure native resolution works.
  result = Dart_Invoke(type, NewString("foo"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsInteger(result));
  int64_t value = 0;
  EXPECT_VALID(Dart_IntegerToInt64(result, &value));
  EXPECT_EQ(654321, value);
 
  // A second call succeeds.
  result = Dart_SetNativeResolver(lib, &MyNativeResolver2, nullptr);
  EXPECT_VALID(result);
 
  // 'foo' has already been resolved so gets the old value.
  result = Dart_Invoke(type, NewString("foo"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsInteger(result));
  value = 0;
  EXPECT_VALID(Dart_IntegerToInt64(result, &value));
  EXPECT_EQ(654321, value);
 
  // 'bar' has not yet been resolved so gets the new value.
  result = Dart_Invoke(type, NewString("bar"), 0, nullptr);

TEST_CASE() [183/600]

dart::TEST_CASE

(

DartAPI_SetPerformanceMode

)

Definition at line 9784 of file dart_api_impl_test.cc.

                                                             {
  Dart_NotifyIdle(Dart_TimelineGetMicros() + 10 * kMicrosecondsPerMillisecond);
}
 
static Dart_NativeFunction NotifyIdleShort_native_lookup(
    Dart_Handle name,
    int argument_count,
    bool* auto_setup_scope) {
  return NotifyIdleShortNative;
}
 
TEST_CASE(DartAPI_NotifyIdleShort) {
  const char* kScriptChars = R"(

TEST_CASE() [184/600]

dart::TEST_CASE

(

DartAPI_SetStickyError

)

Definition at line 4865 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars = "main() => throw 'HI';";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle retobj = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT(Dart_IsError(retobj));
  EXPECT(Dart_IsUnhandledExceptionError(retobj));
  EXPECT(!Dart_HasStickyError());
  EXPECT(Dart_GetStickyError() == Dart_Null());
  Dart_SetStickyError(retobj);
  EXPECT(Dart_HasStickyError());
  EXPECT(Dart_GetStickyError() != Dart_Null());
  Dart_SetStickyError(Dart_Null());
  EXPECT(!Dart_HasStickyError());
  EXPECT(Dart_GetStickyError() == Dart_Null());
}

TEST_CASE() [185/600]

dart::TEST_CASE

(

DartAPI_SlowFinalizer

)

Definition at line 3180 of file dart_api_impl_test.cc.

                                 {
  intptr_t count = 0;
  for (intptr_t i = 0; i < 10; i++) {
    Dart_EnterScope();
    Dart_Handle str1 = Dart_NewStringFromCString("Live fast");
    Dart_NewFinalizableHandle(str1, &count, 0, SlowFinalizer);
    Dart_Handle str2 = Dart_NewStringFromCString("Die young");
    Dart_NewFinalizableHandle(str2, &count, 0, SlowFinalizer);
    Dart_ExitScope();
 
    {
      TransitionNativeToVM transition(thread);
      GCTestHelper::CollectAllGarbage();
    }
  }
 
  EXPECT_EQ(20, count);
}

TEST_CASE() [186/600]

dart::TEST_CASE

(

DartAPI_SlowWeakPersistentHandle

)

Definition at line 3205 of file dart_api_impl_test.cc.

                                            {
  Dart_WeakPersistentHandle handles[20];
  intptr_t count = 0;
 
  for (intptr_t i = 0; i < 10; i++) {
    Dart_EnterScope();
    Dart_Handle str1 = Dart_NewStringFromCString("Live fast");
    handles[i] =
        Dart_NewWeakPersistentHandle(str1, &count, 0, SlowWeakPersistentHandle);
    Dart_Handle str2 = Dart_NewStringFromCString("Die young");
    handles[i + 10] =
        Dart_NewWeakPersistentHandle(str2, &count, 0, SlowWeakPersistentHandle);
    Dart_ExitScope();
 
    {
      TransitionNativeToVM transition(thread);
      GCTestHelper::CollectAllGarbage();
    }
  }
 
  EXPECT_EQ(20, count);
 
  for (intptr_t i = 0; i < 20; i++) {
    Dart_DeleteWeakPersistentHandle(handles[i]);
  }
}

TEST_CASE() [187/600]

dart::TEST_CASE

(

DartAPI_StackOverflowStackTraceInfoArrowFunction

)

Definition at line 466 of file dart_api_impl_test.cc.

                                                            {
  int line = 2;
  int col = 3;
  VerifyStackOverflowStackTraceInfo(
      "class C {\n"
      "  static foo(int i) => foo(i);\n"
      "}\n"
      "testMain() => C.foo(10);\n",
      "C.foo", "testMain", line, col);
}

TEST_CASE() [188/600]

dart::TEST_CASE

(

DartAPI_StackOverflowStackTraceInfoBraceFunction1

)

Definition at line 442 of file dart_api_impl_test.cc.

                                                             {
  int line = 2;
  int col = 3;
  VerifyStackOverflowStackTraceInfo(
      "class C {\n"
      "  static foo(int i) { foo(i); }\n"
      "}\n"
      "testMain() => C.foo(10);\n",
      "C.foo", "testMain", line, col);
}

TEST_CASE() [189/600]

dart::TEST_CASE

(

DartAPI_StackOverflowStackTraceInfoBraceFunction2

)

Definition at line 453 of file dart_api_impl_test.cc.

                                                             {
  int line = 2;
  int col = 3;
  VerifyStackOverflowStackTraceInfo(
      "class C {\n"
      "  static foo(int i, int j) {\n"
      "    foo(i, j);\n"
      "  }\n"
      "}\n"
      "testMain() => C.foo(10, 11);\n",
      "C.foo", "testMain", line, col);
}

TEST_CASE() [190/600]

dart::TEST_CASE

(

DartAPI_StackTraceInfo

)

Definition at line 248 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars =
      "bar() => throw new Error();\n"
      "foo() => bar();\n"
      "testMain() => foo();\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle error = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
 
  EXPECT(Dart_IsError(error));
 
  Dart_StackTrace stacktrace;
  Dart_Handle result = Dart_GetStackTraceFromError(error, &stacktrace);
  EXPECT_VALID(result);
 
  intptr_t frame_count = 0;
  result = Dart_StackTraceLength(stacktrace, &frame_count);
  EXPECT_VALID(result);
  EXPECT_EQ(3, frame_count);
 
  Dart_Handle function_name;
  Dart_Handle script_url;
  intptr_t line_number = 0;
  intptr_t column_number = 0;
  const char* cstr = "";
 
  Dart_ActivationFrame frame;
  result = Dart_GetActivationFrame(stacktrace, 0, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("bar", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_SUBSTRING("test-lib", cstr);
  EXPECT_EQ(1, line_number);
  EXPECT_EQ(10, column_number);
 
  result = Dart_GetActivationFrame(stacktrace, 1, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("foo", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_SUBSTRING("test-lib", cstr);
  EXPECT_EQ(2, line_number);
  EXPECT_EQ(10, column_number);
 
  result = Dart_GetActivationFrame(stacktrace, 2, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ("testMain", cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_SUBSTRING("test-lib", cstr);
  EXPECT_EQ(3, line_number);
  EXPECT_EQ(15, column_number);
 
  // Out-of-bounds frames.
  result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
  EXPECT(Dart_IsError(result));
  result = Dart_GetActivationFrame(stacktrace, -1, &frame);
  EXPECT(Dart_IsError(result));
}

TEST_CASE() [191/600]

dart::TEST_CASE

(

DartAPI_StringFromExternalTypedData

)

Definition at line 9311 of file dart_api_impl_test.cc.

                                          {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_EnterScope();
  {
    Thread* T = Thread::Current();
    CHECK_API_SCOPE(T);
    Dart_Handle str = AllocateOldString("str");
    EXPECT_VALID(str);
    EXPECT(Dart_IsString(str));
    EXPECT_EQ(0, heap->PeerCount());
    void* out = &out;
    EXPECT(Dart_GetPeer(str, &out));
    EXPECT(out == nullptr);
    int peer = 1234;
    EXPECT_VALID(Dart_SetPeer(str, &peer));
    EXPECT_EQ(1, heap->PeerCount());
    out = &out;
    EXPECT_VALID(Dart_GetPeer(str, &out));
    EXPECT(out == reinterpret_cast<void*>(&peer));
    {
      TransitionNativeToVM transition(thread);
      GCTestHelper::CollectOldSpace();
      EXPECT_EQ(1, heap->PeerCount());
    }
    EXPECT_VALID(Dart_GetPeer(str, &out));
    EXPECT(out == reinterpret_cast<void*>(&peer));
  }
  Dart_ExitScope();
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(0, heap->PeerCount());
  }
}
 
// Allocates two objects in old space and assigns them peers.  Removes
// the peers and checks that the count of peer objects is decremented
// by two.
TEST_CASE(DartAPI_TwoOldSpacePeers) {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_Handle s1 = AllocateOldString("s1");
  EXPECT_VALID(s1);
  EXPECT(Dart_IsString(s1));
  EXPECT_EQ(0, heap->PeerCount());
  void* o1 = &o1;
  EXPECT(Dart_GetPeer(s1, &o1));
  EXPECT(o1 == nullptr);
  int p1 = 1234;
  EXPECT_VALID(Dart_SetPeer(s1, &p1));
  EXPECT_EQ(1, heap->PeerCount());
  o1 = &o1;
  EXPECT_VALID(Dart_GetPeer(s1, &o1));
  EXPECT(o1 == reinterpret_cast<void*>(&p1));
  Dart_Handle s2 = AllocateOldString("s2");
  EXPECT_VALID(s2);
  EXPECT(Dart_IsString(s2));
  EXPECT_EQ(1, heap->PeerCount());
  void* o2 = &o2;
  EXPECT(Dart_GetPeer(s2, &o2));
  EXPECT(o2 == nullptr);
  int p2 = 5678;
  EXPECT_VALID(Dart_SetPeer(s2, &p2));
  EXPECT_EQ(2, heap->PeerCount());
  o2 = &o2;
  EXPECT_VALID(Dart_GetPeer(s2, &o2));
  EXPECT(o2 == reinterpret_cast<void*>(&p2));
  EXPECT_VALID(Dart_SetPeer(s1, nullptr));
  EXPECT_EQ(1, heap->PeerCount());
  o1 = &o1;
  EXPECT(Dart_GetPeer(s1, &o1));

TEST_CASE() [192/600]

dart::TEST_CASE

(

DartAPI_TestNativeFieldsAccess

)

Definition at line 5627 of file dart_api_impl_test.cc.

                                          {
  const char* nullable_tag = TestCase::NullableTag();
  // clang-format off
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(
          nullptr, R"(
          import 'dart:nativewrappers';
          base class NativeFields extends NativeFieldWrapperClass2 {
            NativeFields(int i, int j) : fld1 = i, fld2 = j {}
            int fld1;
            final int fld2;
            static int%s fld3;
            static const int fld4 = 10;
            @pragma('vm:external-name', 'TestNativeFieldsAccess_init')
            external int%s initNativeFlds();
            @pragma('vm:external-name', 'TestNativeFieldsAccess_access')
            external int%s accessNativeFlds(int%s i);
          }
          class NoNativeFields {
            int neitherATypedDataNorNull = 0;
            @pragma('vm:external-name', 'TestNativeFieldsAccess_invalidAccess')
            external invalidAccess();
          }
          NativeFields testMain() {
            NativeFields obj = new NativeFields(10, 20);
            obj.initNativeFlds();
            obj.accessNativeFlds(null);
            new NoNativeFields().invalidAccess();
            return obj;
          }
          )",
          nullable_tag, nullable_tag, nullable_tag, nullable_tag),
      std::free);
  // clang-format on
 
  // Load up a test script in the test library.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars.get(),
                                             TestNativeFieldsAccess_lookup);
 
  // Invoke a function which returns an object of type NativeFields.
  Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
  EXPECT_VALID(result);
}

TEST_CASE() [193/600]

dart::TEST_CASE

(

DartAPI_ThrowException

)

Definition at line 7042 of file dart_api_impl_test.cc.

                                  {
  const char* kScriptChars =
      R"(
      @pragma('vm:external-name', 'ThrowException_native')
      external int test();
    )";
 
  Dart_Handle result;
  intptr_t size = thread->ZoneSizeInBytes();
  Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
  // Load up a test script which extends the native wrapper class.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, native_lookup);
 
  // Throwing an exception here should result in an error.
  result = Dart_ThrowException(NewString("This doesn't work"));
  EXPECT_ERROR(result, "No Dart frames on stack, cannot throw exception");
  EXPECT(!Dart_ErrorHasException(result));
 
  // Invoke 'test' and check for an uncaught exception.
  result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_ERROR(result, "Hello from ExceptionNative!");
  EXPECT(Dart_ErrorHasException(result));
 

TEST_CASE() [194/600]

dart::TEST_CASE

(

DartAPI_TimelineAsync

)

Definition at line 9487 of file dart_api_impl_test.cc.

  {
    uint16_t data[64];
    for (int i = 0; i < 64; i++) {
      data[i] = 0x2000 + i * 4;
    }
    // Non-LATIN-1 in external Uint16List.
    Dart_Handle external =
        Dart_NewExternalTypedData(Dart_TypedData_kUint16, data, 64);
    EXPECT_VALID(external);
    Dart_Handle dart_args[1];
    dart_args[0] = external;
    Dart_Handle result = Dart_Invoke(lib, NewString("test"), 1, dart_args);
    EXPECT_VALID(result);
    EXPECT(Dart_IsString(result));

TEST_CASE() [195/600]

dart::TEST_CASE

(

DartAPI_TimelineAsyncDisabled

)

Definition at line 9470 of file dart_api_impl_test.cc.

  {
    uint16_t data[64];
    for (int i = 0; i < 64; i++) {
      data[i] = i * 4;
    }
    // LATIN-1 in external Uint16List.
    Dart_Handle external =
        Dart_NewExternalTypedData(Dart_TypedData_kUint16, data, 64);
    EXPECT_VALID(external);
    Dart_Handle dart_args[1];
    dart_args[0] = external;

TEST_CASE() [196/600]

dart::TEST_CASE

(

DartAPI_TimelineBegin

)

Definition at line 9411 of file dart_api_impl_test.cc.

TEST_CASE() [197/600]

dart::TEST_CASE

(

DartAPI_TimelineCategories

)

Definition at line 9589 of file dart_api_impl_test.cc.

                            :\"testInstantEvent\"", json);
  EXPECT_SUBSTRING("\"ph\":\"i\"", json);
  EXPECT_SUBSTRING("\"ts\":1000", json);
}
 
TEST_CASE(DartAPI_TimelineAsyncDisabled) {
  // Grab embedder stream.
  TimelineStream* stream = Timeline::GetEmbedderStream();
  // Make sure it is disabled.
  stream->set_enabled(false);
  int64_t async_id = 99;
  Dart_RecordTimelineEvent("testAsyncEvent", 0, async_id, 0, nullptr,
                           Dart_Timeline_Event_Async_Begin, 0, nullptr,
                           nullptr);
  // Check that testAsync is not in the output.
  TimelineEventRecorder* recorder = Timeline::recorder();
  JSONStream js;
  TimelineEventFilter filter;
  recorder->PrintJSON(&js, &filter);
  EXPECT_NOTSUBSTRING("testAsyncEvent", js.ToCString());
}
 
TEST_CASE(DartAPI_TimelineAsync) {
  Isolate* isolate = Isolate::Current();
  // Grab embedder stream.
  TimelineStream* stream = Timeline::GetEmbedderStream();
  // Make sure it is enabled.
  stream->set_enabled(true);
  int64_t async_id = 99;
  Dart_RecordTimelineEvent("testAsyncEvent", 1000, async_id, 0, nullptr,
                           Dart_Timeline_Event_Async_Begin, 0, nullptr,
                           nullptr);
 
  // Check that it is in the output.
  TimelineEventRecorder* recorder = Timeline::recorder();
  JSONStream js;
  IsolateTimelineEventFilter filter(isolate->main_port());
  recorder->PrintJSON(&js, &filter);
  const char* json = js.ToCString();
  EXPECT_SUBSTRING("\"name\":\"testAsyncEvent\"", json);
  EXPECT_SUBSTRING("\"ph\":\"b\"", json);
  EXPECT_SUBSTRING("\"ts\":1000", json);
  EXPECT_SUBSTRING("\"id\":\"63\"", json);  // Hex for some reason.
}
 
#if defined(SUPPORT_PERFETTO) && !defined(PRODUCT)
TEST_CASE(DartAPI_TimelineAsyncInstantRace) {
  struct ReportAsyncEventArguments {
    Monitor& synchronization_monitor;
    ThreadJoinId join_id = OSThread::kInvalidThreadJoinId;
  };
 
  Monitor synchronization_monitor;
  ReportAsyncEventArguments report_async_event_1_arguments{
      synchronization_monitor};
  ReportAsyncEventArguments report_async_event_2_arguments{
      synchronization_monitor};
  TimelineEventRecorder& recorder = *Timeline::recorder();
  JSONStream js;
  TimelineEventFilter filter;
 
  // Grab embedder stream.
  TimelineStream* stream = Timeline::GetEmbedderStream();
  // Make sure it is enabled.
  stream->set_enabled(true);
  // Try concurrently writing async events and reading from the async track
  // metadata map. It is not possible to assert anything about the outcome,
  // because of scheduling uncertainty. This test is just used to ensure that
  // TSAN checks the async track metadata map code.
  OSThread::Start(
      "ReportAsyncEvent1",
      [](uword arguments_ptr) {

TEST_CASE() [198/600]

dart::TEST_CASE

(

DartAPI_TimelineClock

)

Definition at line 9576 of file dart_api_impl_test.cc.

                          :1000", json);
}
 
TEST_CASE(DartAPI_TimelineInstant) {
  Isolate* isolate = Isolate::Current();
  // Grab embedder stream.
  TimelineStream* stream = Timeline::GetEmbedderStream();
  // Make sure it is enabled.
  stream->set_enabled(true);
  Dart_RecordTimelineEvent("testInstantEvent", 1000, 1, 0, nullptr,
                           Dart_Timeline_Event_Instant, 0, nullptr, nullptr);
  // Check that it is in the output.

TEST_CASE() [199/600]

dart::TEST_CASE

(

DartAPI_TimelineDuration

)

Definition at line 9390 of file dart_api_impl_test.cc.

                                           {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_EnterScope();
  {
    Thread* T = Thread::Current();
    CHECK_API_SCOPE(T);
    Dart_Handle s1 = AllocateOldString("s1");
    EXPECT_VALID(s1);
    EXPECT(Dart_IsString(s1));
    EXPECT_EQ(0, heap->PeerCount());
    void* o1 = &o1;
    EXPECT(Dart_GetPeer(s1, &o1));

TEST_CASE() [200/600]

dart::TEST_CASE

(

DartAPI_TimelineEnd

)

Definition at line 9431 of file dart_api_impl_test.cc.

  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(0, heap->PeerCount());
  }
}
 
TEST_CASE(DartAPI_StringFromExternalTypedData) {
  const char* kScriptChars =
      "test(external) {\n"
      "  var str1 = new String.fromCharCodes(external);\n"
      "  var str2 = new String.fromCharCodes(new List.from(external));\n"
      "  if (str2 != str1) throw 'FAIL';\n"
      "  return str1;\n"
      "}\n"
      "testView8(external) {\n"
      "  return test(external.buffer.asUint8List());\n"
      "}\n"

TEST_CASE() [201/600]

dart::TEST_CASE

(

DartAPI_TimelineEvents_Serialization

)

Definition at line 10038 of file dart_api_impl_test.cc.

                                               {

TEST_CASE() [202/600]

dart::TEST_CASE

(

DartAPI_TimelineInstant

)

Definition at line 9451 of file dart_api_impl_test.cc.

  {
    uint8_t data[64];
    for (int i = 0; i < 64; i++) {
      data[i] = i * 4;
    }
    // LATIN-1 in external Uint8List.
    Dart_Handle external =
        Dart_NewExternalTypedData(Dart_TypedData_kUint8, data, 64);
    EXPECT_VALID(external);
    Dart_Handle dart_args[1];
    dart_args[0] = external;
    Dart_Handle result = Dart_Invoke(lib, NewString("test"), 1, dart_args);
    EXPECT_VALID(result);
    EXPECT(Dart_IsString(result));

TEST_CASE() [203/600]

dart::TEST_CASE

(

DartAPI_TwoNewSpacePeers

)

Definition at line 9003 of file dart_api_impl_test.cc.

                                  {
  Dart_Handle str = Dart_NewStringFromUTF8(nullptr, 0);
  EXPECT_VALID(str);
  EXPECT(Dart_IsString(str));
  intptr_t len = -1;
  EXPECT_VALID(Dart_StringLength(str, &len));
  EXPECT_EQ(0, len);
 
  str = Dart_NewStringFromUTF16(nullptr, 0);
  EXPECT_VALID(str);
  EXPECT(Dart_IsString(str));
  len = -1;
  EXPECT_VALID(Dart_StringLength(str, &len));
  EXPECT_EQ(0, len);
 
  str = Dart_NewStringFromUTF32(nullptr, 0);
  EXPECT_VALID(str);
  EXPECT(Dart_IsString(str));
  len = -1;
  EXPECT_VALID(Dart_StringLength(str, &len));
  EXPECT_EQ(0, len);
}
 
// Try to allocate a peer with a handles to objects of prohibited
// subtypes.
TEST_CASE(DartAPI_InvalidGetSetPeer) {

TEST_CASE() [204/600]

dart::TEST_CASE

(

DartAPI_TwoOldSpacePeers

)

Definition at line 9227 of file dart_api_impl_test.cc.

  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
    EXPECT_EQ(kPeerCount, heap->PeerCount());
    GCTestHelper::CollectNewSpace();
    EXPECT_EQ(kPeerCount, heap->PeerCount());
  }
}
 
// Allocates an object in new space and assigns it a peer.  Promotes
// the peer to old space.  Removes the peer and check that the count
// of peer objects is decremented by one.
TEST_CASE(DartAPI_OnePromotedPeer) {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_Handle str = NewString("a string");
  EXPECT_VALID(str);
  EXPECT(Dart_IsString(str));
  EXPECT_EQ(0, heap->PeerCount());
  void* out = &out;
  EXPECT(Dart_GetPeer(str, &out));
  EXPECT(out == nullptr);
  int peer = 1234;
  EXPECT_VALID(Dart_SetPeer(str, &peer));
  out = &out;
  EXPECT(Dart_GetPeer(str, &out));
  EXPECT(out == reinterpret_cast<void*>(&peer));
  EXPECT_EQ(1, heap->PeerCount());
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
    GCTestHelper::CollectNewSpace();
  }
  {
    CHECK_API_SCOPE(thread);

TEST_CASE() [205/600]

dart::TEST_CASE

(

DartAPI_TypedDataAccess

)

Definition at line 2083 of file dart_api_impl_test.cc.

                                   {
  EXPECT_EQ(Dart_TypedData_kInvalid, Dart_GetTypeOfTypedData(Dart_True()));
  EXPECT_EQ(Dart_TypedData_kInvalid,
            Dart_GetTypeOfExternalTypedData(Dart_False()));
  Dart_Handle byte_array1 = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
  EXPECT_VALID(byte_array1);
  EXPECT_EQ(Dart_TypedData_kUint8, Dart_GetTypeOfTypedData(byte_array1));
  EXPECT_EQ(Dart_TypedData_kInvalid,
            Dart_GetTypeOfExternalTypedData(byte_array1));
  EXPECT(Dart_IsList(byte_array1));
  EXPECT(!Dart_IsTypedData(Dart_True()));
  EXPECT(Dart_IsTypedData(byte_array1));
  EXPECT(!Dart_IsByteBuffer(byte_array1));
 
  intptr_t length = 0;
  Dart_Handle result = Dart_ListLength(byte_array1, &length);
  EXPECT_VALID(result);
  EXPECT_EQ(10, length);
 
  result = Dart_ListSetAt(byte_array1, -1, Dart_NewInteger(1));
  EXPECT(Dart_IsError(result));
 
  result = Dart_ListSetAt(byte_array1, 10, Dart_NewInteger(1));
  EXPECT(Dart_IsError(result));
 
  // Set through the List API.
  for (intptr_t i = 0; i < 10; ++i) {
    EXPECT_VALID(Dart_ListSetAt(byte_array1, i, Dart_NewInteger(i + 1)));
  }
  for (intptr_t i = 0; i < 10; ++i) {
    // Get through the List API.
    Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
    EXPECT_VALID(integer_obj);
    int64_t int64_t_value = -1;
    EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
    EXPECT_EQ(i + 1, int64_t_value);
  }
 
  Dart_Handle byte_array2 = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
  bool is_equal = false;
  Dart_ObjectEquals(byte_array1, byte_array2, &is_equal);
  EXPECT(!is_equal);
 
  // Set through the List API.
  for (intptr_t i = 0; i < 10; ++i) {
    result = Dart_ListSetAt(byte_array1, i, Dart_NewInteger(i + 2));
    EXPECT_VALID(result);
    result = Dart_ListSetAt(byte_array2, i, Dart_NewInteger(i + 2));
    EXPECT_VALID(result);
  }
  for (intptr_t i = 0; i < 10; ++i) {
    // Get through the List API.
    Dart_Handle e1 = Dart_ListGetAt(byte_array1, i);
    Dart_Handle e2 = Dart_ListGetAt(byte_array2, i);
    is_equal = false;
    Dart_ObjectEquals(e1, e2, &is_equal);
    EXPECT(is_equal);
  }
 
  uint8_t data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  for (intptr_t i = 0; i < 10; ++i) {
    EXPECT_VALID(Dart_ListSetAt(byte_array1, i, Dart_NewInteger(10 - i)));
  }
  Dart_ListGetAsBytes(byte_array1, 0, data, 10);
  for (intptr_t i = 0; i < 10; ++i) {
    Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
    EXPECT_VALID(integer_obj);
    int64_t int64_t_value = -1;
    EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
    EXPECT_EQ(10 - i, int64_t_value);
  }
}

TEST_CASE() [206/600]

dart::TEST_CASE

(

DartAPI_TypedDataDirectAccess1Unverified

)

Definition at line 2646 of file dart_api_impl_test.cc.

                                                    {
  FLAG_verify_acquired_data = false;
  TestTypedDataDirectAccess1();
}

TEST_CASE() [207/600]

dart::TEST_CASE

(

DartAPI_TypedDataDirectAccess1Verified

)

Definition at line 2651 of file dart_api_impl_test.cc.

                                                  {
  FLAG_verify_acquired_data = true;
  TestTypedDataDirectAccess1();
}

TEST_CASE() [208/600]

dart::TEST_CASE

(

DartAPI_TypedDataDirectAccessUnverified

)

Definition at line 2504 of file dart_api_impl_test.cc.

                                                   {
  FLAG_verify_acquired_data = false;
  TestTypedDataDirectAccess();
}

TEST_CASE() [209/600]

dart::TEST_CASE

(

DartAPI_TypedDataDirectAccessVerified

)

Definition at line 2509 of file dart_api_impl_test.cc.

                                                 {
  FLAG_verify_acquired_data = true;
  TestTypedDataDirectAccess();
}

TEST_CASE() [210/600]

dart::TEST_CASE

(

DartAPI_TypedDataViewDirectAccessUnverified

)

Definition at line 2694 of file dart_api_impl_test.cc.

                                                       {
  FLAG_verify_acquired_data = false;
  TestTypedDataViewDirectAccess();
}

TEST_CASE() [211/600]

dart::TEST_CASE

(

DartAPI_TypedDataViewDirectAccessVerified

)

Definition at line 2699 of file dart_api_impl_test.cc.

                                                     {
  FLAG_verify_acquired_data = true;
  TestTypedDataViewDirectAccess();
}

TEST_CASE() [212/600]

dart::TEST_CASE

(

DartAPI_TypedDataViewListGetAsBytes

)

Definition at line 2005 of file dart_api_impl_test.cc.

                                               {
  const int kSize = 1000;
 
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "List testMain(int size) {\n"
      "  var a = new Int8List(size);\n"
      "  var view = new Int8List.view(a.buffer, 0, size);\n"
      "  return view;\n"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Test with a typed data view object.
  Dart_Handle dart_args[1];
  dart_args[0] = Dart_NewInteger(kSize);
  Dart_Handle view_obj = Dart_Invoke(lib, NewString("testMain"), 1, dart_args);
  EXPECT_VALID(view_obj);
  for (intptr_t i = 0; i < kSize; ++i) {
    EXPECT_VALID(Dart_ListSetAt(view_obj, i, Dart_NewInteger(i & 0xff)));
  }
  uint8_t* data = new uint8_t[kSize];
  EXPECT_VALID(Dart_ListGetAsBytes(view_obj, 0, data, kSize));
  for (intptr_t i = 0; i < kSize; ++i) {
    EXPECT_EQ(i & 0xff, data[i]);
  }
 
  Dart_Handle result = Dart_ListGetAsBytes(view_obj, 0, data, kSize + 1);
  EXPECT(Dart_IsError(result));
  delete[] data;
}

TEST_CASE() [213/600]

dart::TEST_CASE

(

DartAPI_TypedDataViewListIsTypedData

)

Definition at line 2037 of file dart_api_impl_test.cc.

                                                {
  const int kSize = 1000;
 
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "List testMain(int size) {\n"
      "  var a = new Int8List(size);\n"
      "  var view = new Int8List.view(a.buffer, 0, size);\n"
      "  return view;\n"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Create a typed data view object.
  Dart_Handle dart_args[1];
  dart_args[0] = Dart_NewInteger(kSize);
  Dart_Handle view_obj = Dart_Invoke(lib, NewString("testMain"), 1, dart_args);
  EXPECT_VALID(view_obj);
  // Test that the API considers it a TypedData object.
  EXPECT(Dart_IsTypedData(view_obj));
  EXPECT_EQ(Dart_TypedData_kInt8, Dart_GetTypeOfTypedData(view_obj));
}

TEST_CASE() [214/600]

dart::TEST_CASE

(

DartAPI_TypeDynamic

)

Definition at line 936 of file dart_api_impl_test.cc.

                               {
  Dart_Handle type = Dart_TypeDynamic();
  EXPECT_VALID(type);
  EXPECT(Dart_IsType(type));
 
  Dart_Handle str = Dart_ToString(type);
  EXPECT_VALID(str);
  const char* cstr = nullptr;
  EXPECT_VALID(Dart_StringToCString(str, &cstr));
  EXPECT_STREQ("dynamic", cstr);
}

TEST_CASE() [215/600]

dart::TEST_CASE

(

DartAPI_TypeGetNonParametricTypes

)

Definition at line 4881 of file dart_api_impl_test.cc.

                                             {
  const char* kScriptChars =
      "class MyClass0 {\n"
      "}\n"
      "\n"
      "class MyClass1 implements MyInterface1 {\n"
      "}\n"
      "\n"
      "class MyClass2 implements MyInterface0, MyInterface1 {\n"
      "}\n"
      "\n"
      "abstract class MyInterface0 {\n"
      "}\n"
      "\n"
      "abstract class MyInterface1 implements MyInterface0 {\n"
      "}\n"
      "MyClass0 getMyClass0() { return new MyClass0(); }\n"
      "MyClass1 getMyClass1() { return new MyClass1(); }\n"
      "MyClass2 getMyClass2() { return new MyClass2(); }\n"
      "Type getMyClass0Type() { return new MyClass0().runtimeType; }\n"
      "Type getMyClass1Type() { return new MyClass1().runtimeType; }\n"
      "Type getMyClass2Type() { return new MyClass2().runtimeType; }\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  bool instanceOf = false;
 
  // First get the type objects of these non parameterized types.
  Dart_Handle type0 =
      Dart_GetNonNullableType(lib, NewString("MyClass0"), 0, nullptr);
  EXPECT_VALID(type0);
  Dart_Handle type1 =
      Dart_GetNonNullableType(lib, NewString("MyClass1"), 0, nullptr);
  EXPECT_VALID(type1);
  Dart_Handle type2 =
      Dart_GetNonNullableType(lib, NewString("MyClass2"), 0, nullptr);
  EXPECT_VALID(type2);
  Dart_Handle type3 =
      Dart_GetNonNullableType(lib, NewString("MyInterface0"), 0, nullptr);
  EXPECT_VALID(type3);
  Dart_Handle type4 =
      Dart_GetNonNullableType(lib, NewString("MyInterface1"), 0, nullptr);
  EXPECT_VALID(type4);
 
  // Now create objects of these non parameterized types and check
  // that the validity of the type of the created object.
  // MyClass0 type.
  Dart_Handle type0_obj =
      Dart_Invoke(lib, NewString("getMyClass0"), 0, nullptr);
  EXPECT_VALID(type0_obj);
  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type0, &instanceOf));
  EXPECT(instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type1, &instanceOf));
  EXPECT(!instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type2, &instanceOf));
  EXPECT(!instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type3, &instanceOf));
  EXPECT(!instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type4, &instanceOf));
  EXPECT(!instanceOf);
  type0_obj = Dart_Invoke(lib, NewString("getMyClass0Type"), 0, nullptr);
  EXPECT_VALID(type0_obj);
  EXPECT(Dart_IdentityEquals(type0, type0_obj));
 
  // MyClass1 type.
  Dart_Handle type1_obj =
      Dart_Invoke(lib, NewString("getMyClass1"), 0, nullptr);
  EXPECT_VALID(type1_obj);
  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type1, &instanceOf));
  EXPECT(instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type0, &instanceOf));
  EXPECT(!instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type2, &instanceOf));
  EXPECT(!instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type3, &instanceOf));
  EXPECT(instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type4, &instanceOf));
  EXPECT(instanceOf);
  type1_obj = Dart_Invoke(lib, NewString("getMyClass1Type"), 0, nullptr);
  EXPECT_VALID(type1_obj);
  EXPECT(Dart_IdentityEquals(type1, type1_obj));
 
  // MyClass2 type.
  Dart_Handle type2_obj =
      Dart_Invoke(lib, NewString("getMyClass2"), 0, nullptr);
  EXPECT_VALID(type2_obj);
  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type2, &instanceOf));
  EXPECT(instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type0, &instanceOf));
  EXPECT(!instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type1, &instanceOf));
  EXPECT(!instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type3, &instanceOf));
  EXPECT(instanceOf);
  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type4, &instanceOf));
  EXPECT(instanceOf);
  type2_obj = Dart_Invoke(lib, NewString("getMyClass2Type"), 0, nullptr);
  EXPECT_VALID(type2_obj);
  EXPECT(Dart_IdentityEquals(type2, type2_obj));
}

TEST_CASE() [216/600]

dart::TEST_CASE

(

DartAPI_TypeGetParameterizedTypes

)

Definition at line 4980 of file dart_api_impl_test.cc.

                                             {
  const char* kScriptChars =
      "class MyClass0<A, B> {\n"
      "}\n"
      "\n"
      "class MyClass1<A, C> {\n"
      "}\n"
      "Type type<T>() => T;"
      "MyClass0 getMyClass0() {\n"
      "  return new MyClass0<int, double>();\n"
      "}\n"
      "Type getMyClass0Type() {\n"
      "  return type<MyClass0<int, double>>();\n"
      "}\n"
      "MyClass1 getMyClass1() {\n"
      "  return new MyClass1<List<int>, List>();\n"
      "}\n"
      "Type getMyClass1Type() {\n"
      "  return type<MyClass1<List<int>, List>>();\n"
      "}\n"
      "MyClass0 getMyClass0_1() {\n"
      "  return new MyClass0<double, int>();\n"
      "}\n"
      "Type getMyClass0_1Type() {\n"
      "  return type<MyClass0<double, int>>();\n"
      "}\n"
      "MyClass1 getMyClass1_1() {\n"
      "  return new MyClass1<List<int>, List<double>>();\n"
      "}\n"
      "Type getMyClass1_1Type() {\n"
      "  return type<MyClass1<List<int>, List<double>>>();\n"
      "}\n"
      "Type getIntType() { return int; }\n"
      "Type getDoubleType() { return double; }\n"
      "Type getListIntType() { return type<List<int>>(); }\n"
      "Type getListType() { return List; }\n";
 
  Dart_Handle corelib = Dart_LookupLibrary(NewString("dart:core"));
  EXPECT_VALID(corelib);
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Now instantiate MyClass0 and MyClass1 types with the same type arguments
  // used in the code above.
  Dart_Handle type_args = Dart_NewList(2);
  Dart_Handle int_type = Dart_Invoke(lib, NewString("getIntType"), 0, nullptr);
  EXPECT_VALID(int_type);
  EXPECT_VALID(Dart_ListSetAt(type_args, 0, int_type));
  Dart_Handle double_type =
      Dart_Invoke(lib, NewString("getDoubleType"), 0, nullptr);
  EXPECT_VALID(double_type);
  EXPECT_VALID(Dart_ListSetAt(type_args, 1, double_type));
  Dart_Handle myclass0_type =
      TestCase::IsNNBD()
          ? Dart_GetNonNullableType(lib, NewString("MyClass0"), 2, &type_args)
          : Dart_GetType(lib, NewString("MyClass0"), 2, &type_args);
  EXPECT_VALID(myclass0_type);
 
  type_args = Dart_NewList(2);
  Dart_Handle list_int_type =
      Dart_Invoke(lib, NewString("getListIntType"), 0, nullptr);
  EXPECT_VALID(list_int_type);
  EXPECT_VALID(Dart_ListSetAt(type_args, 0, list_int_type));
  Dart_Handle list_type =
      Dart_Invoke(lib, NewString("getListType"), 0, nullptr);
  EXPECT_VALID(list_type);
  EXPECT_VALID(Dart_ListSetAt(type_args, 1, list_type));
  Dart_Handle myclass1_type =
      TestCase::IsNNBD()
          ? Dart_GetNonNullableType(lib, NewString("MyClass1"), 2, &type_args)
          : Dart_GetType(lib, NewString("MyClass1"), 2, &type_args);
  EXPECT_VALID(myclass1_type);
 
  // Now create objects of the type and validate the object type matches
  // the one returned above. Also get the runtime type of the object and
  // verify that it matches the type returned above. Note: we use
  // Dart_ObjectEquals instead of Dart_IdentityEquals since we are comparing
  // type literals with non-literals which would fail in unsound null safety
  // mode.
  // MyClass0<int, double> type.
  Dart_Handle type0_obj =
      Dart_Invoke(lib, NewString("getMyClass0"), 0, nullptr);
  EXPECT_VALID(type0_obj);
  bool instanceOf = false;
  EXPECT_VALID(Dart_ObjectIsType(type0_obj, myclass0_type, &instanceOf));
  EXPECT(instanceOf);
  type0_obj = Dart_Invoke(lib, NewString("getMyClass0Type"), 0, nullptr);
  EXPECT_VALID(type0_obj);
 
  bool equal = false;
  EXPECT_VALID(Dart_ObjectEquals(type0_obj, myclass0_type, &equal));
  EXPECT(equal);
 
  // MyClass1<List<int>, List> type.
  Dart_Handle type1_obj =
      Dart_Invoke(lib, NewString("getMyClass1"), 0, nullptr);
  EXPECT_VALID(type1_obj);
  EXPECT_VALID(Dart_ObjectIsType(type1_obj, myclass1_type, &instanceOf));
  EXPECT(instanceOf);
  type1_obj = Dart_Invoke(lib, NewString("getMyClass1Type"), 0, nullptr);
  EXPECT_VALID(type1_obj);
 
  EXPECT_VALID(Dart_ObjectEquals(type1_obj, myclass1_type, &equal));
  EXPECT(equal);
 
  // MyClass0<double, int> type.
  type0_obj = Dart_Invoke(lib, NewString("getMyClass0_1"), 0, nullptr);
  EXPECT_VALID(type0_obj);
  EXPECT_VALID(Dart_ObjectIsType(type0_obj, myclass0_type, &instanceOf));
  EXPECT(!instanceOf);
  type0_obj = Dart_Invoke(lib, NewString("getMyClass0_1Type"), 0, nullptr);
  EXPECT_VALID(type0_obj);
  EXPECT_VALID(Dart_ObjectEquals(type0_obj, myclass0_type, &equal));
  EXPECT(!equal);
 
  // MyClass1<List<int>, List<double>> type.
  type1_obj = Dart_Invoke(lib, NewString("getMyClass1_1"), 0, nullptr);
  EXPECT_VALID(type1_obj);
  EXPECT_VALID(Dart_ObjectIsType(type1_obj, myclass1_type, &instanceOf));
  EXPECT(instanceOf);
  type1_obj = Dart_Invoke(lib, NewString("getMyClass1_1Type"), 0, nullptr);
  EXPECT_VALID(type1_obj);
  EXPECT_VALID(Dart_ObjectEquals(type1_obj, myclass1_type, &equal));
  EXPECT(!equal);
}

TEST_CASE() [217/600]

dart::TEST_CASE

(

DartAPI_TypeNever

)

Definition at line 960 of file dart_api_impl_test.cc.

                             {
  Dart_Handle type = Dart_TypeNever();
  EXPECT_VALID(type);
  EXPECT(Dart_IsType(type));
 
  Dart_Handle str = Dart_ToString(type);
  EXPECT_VALID(str);
  const char* cstr = nullptr;
  EXPECT_VALID(Dart_StringToCString(str, &cstr));
  EXPECT_STREQ("Never", cstr);
}

TEST_CASE() [218/600]

dart::TEST_CASE

(

DartAPI_TypeToNullability

)

Definition at line 7292 of file dart_api_impl_test.cc.

                                     {
  const char* kScriptChars =
      "library testlib;\n"
      "class Class {\n"
      "  static var name = 'Class';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  const Dart_Handle name = NewString("Class");
  // Lookup the legacy type for Class.
  Dart_Handle type = Dart_GetType(lib, name, 0, nullptr);
  Dart_Handle nonNullableType;
  Dart_Handle nullableType;
  if (Dart_IsError(type)) {
    EXPECT_ERROR(
        type,
        "Cannot use legacy types with --sound-null-safety enabled. "
        "Use Dart_GetNullableType or Dart_GetNonNullableType instead.");
 
    nonNullableType = Dart_GetNonNullableType(lib, name, 0, nullptr);
    EXPECT_VALID(nonNullableType);
    nullableType = Dart_GetNullableType(lib, name, 0, nullptr);
  } else {
    EXPECT_VALID(type);
    bool result = false;
    EXPECT_VALID(Dart_IsLegacyType(type, &result));
    EXPECT(result);
 
    // Legacy -> Nullable
    nullableType = Dart_TypeToNullableType(type);
    EXPECT_VALID(nullableType);
    result = false;
    EXPECT_VALID(Dart_IsNullableType(nullableType, &result));
    EXPECT(result);
    EXPECT(Dart_IdentityEquals(nullableType,
                               Dart_GetNullableType(lib, name, 0, nullptr)));
 
    // Legacy -> Non-Nullable
    nonNullableType = Dart_TypeToNonNullableType(type);
    EXPECT_VALID(nonNullableType);
    result = false;
    EXPECT_VALID(Dart_IsNonNullableType(nonNullableType, &result));
    EXPECT(result);
    EXPECT(Dart_IdentityEquals(nonNullableType,
                               Dart_GetNonNullableType(lib, name, 0, nullptr)));
  }
 
  // Nullable -> Non-Nullable
  EXPECT(Dart_IdentityEquals(
      nonNullableType,
      Dart_TypeToNonNullableType(Dart_GetNullableType(lib, name, 0, nullptr))));
 
  // Non-Nullable -> Nullable
  EXPECT(Dart_IdentityEquals(

TEST_CASE() [219/600]

dart::TEST_CASE

(

DartAPI_TypeVoid

)

Definition at line 948 of file dart_api_impl_test.cc.

                            {
  Dart_Handle type = Dart_TypeVoid();
  EXPECT_VALID(type);
  EXPECT(Dart_IsType(type));
 
  Dart_Handle str = Dart_ToString(type);
  EXPECT_VALID(str);
  const char* cstr = nullptr;
  EXPECT_VALID(Dart_StringToCString(str, &cstr));
  EXPECT_STREQ("void", cstr);
}

TEST_CASE() [220/600]

dart::TEST_CASE

(

DartAPI_UnhandleExceptionError

)

Definition at line 662 of file dart_api_impl_test.cc.

                                          {
  const char* exception_cstr = "";
 
  // Test with an API Error.
  const char* kApiError = "Api Error Exception Test.";
  Dart_Handle api_error = Dart_NewApiError(kApiError);
  Dart_Handle exception_error = Dart_NewUnhandledExceptionError(api_error);
  EXPECT(!Dart_IsApiError(exception_error));
  EXPECT(Dart_IsUnhandledExceptionError(exception_error));
  EXPECT(Dart_IsString(Dart_ErrorGetException(exception_error)));
  EXPECT_VALID(Dart_StringToCString(Dart_ErrorGetException(exception_error),
                                    &exception_cstr));
  EXPECT_STREQ(kApiError, exception_cstr);
 
  // Test with a Compilation Error.
  const char* kCompileError = "CompileError Exception Test.";
  Dart_Handle compile_error = Dart_NewCompilationError(kCompileError);
  exception_error = Dart_NewUnhandledExceptionError(compile_error);
  EXPECT(!Dart_IsApiError(exception_error));
  EXPECT(Dart_IsUnhandledExceptionError(exception_error));
  EXPECT(Dart_IsString(Dart_ErrorGetException(exception_error)));
  EXPECT_VALID(Dart_StringToCString(Dart_ErrorGetException(exception_error),
                                    &exception_cstr));
  EXPECT_STREQ(kCompileError, exception_cstr);
 
  // Test with a Fatal Error.
  Dart_Handle fatal_error;
  {
    TransitionNativeToVM transition(thread);
    const String& fatal_message =
        String::Handle(String::New("FatalError Exception Test."));
    fatal_error = Api::NewHandle(thread, UnwindError::New(fatal_message));
  }
  exception_error = Dart_NewUnhandledExceptionError(fatal_error);
  EXPECT(Dart_IsError(exception_error));
  EXPECT(!Dart_IsUnhandledExceptionError(exception_error));
 
  // Test with a Regular object.
  const char* kRegularString = "Regular String Exception Test.";
  exception_error = Dart_NewUnhandledExceptionError(NewString(kRegularString));
  EXPECT(!Dart_IsApiError(exception_error));
  EXPECT(Dart_IsUnhandledExceptionError(exception_error));
  EXPECT(Dart_IsString(Dart_ErrorGetException(exception_error)));
  EXPECT_VALID(Dart_StringToCString(Dart_ErrorGetException(exception_error),
                                    &exception_cstr));
  EXPECT_STREQ(kRegularString, exception_cstr);
}

TEST_CASE() [221/600]

dart::TEST_CASE

(

DartAPI_UnmodifiableTypedData_PassByReference

)

Definition at line 2982 of file dart_api_impl_test.cc.

                                                         {
  const char* kScriptChars = R"(
import 'dart:isolate';
test(original) {
  var port = new RawReceivePort();
  port.handler = (msg) {
    port.close();
    if (!identical(original, msg)) throw "got a copy";
  };
  port.sendPort.send(original);
})";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  uint8_t data[] = {0, 1, 2, 3};
  Dart_Handle typed_data = Dart_NewUnmodifiableExternalTypedDataWithFinalizer(
      Dart_TypedData_kUint8, &data[0], ARRAY_SIZE(data), nullptr, 0, nullptr);
  EXPECT_VALID(typed_data);
  EXPECT_EQ(Dart_TypedData_kUint8, Dart_GetTypeOfTypedData(typed_data));
  Dart_Handle args[1];
  args[0] = typed_data;
  Dart_Handle result =
      Dart_Invoke(lib, NewString("test"), ARRAY_SIZE(args), args);
  EXPECT_VALID(result);
  result = Dart_RunLoop();
  EXPECT_VALID(result);
}

TEST_CASE() [222/600]

dart::TEST_CASE

(

DartAPI_UnmodifiableTypedDataViewDirectAccessUnverified

)

Definition at line 2747 of file dart_api_impl_test.cc.

                                                                   {
  FLAG_verify_acquired_data = false;
  TestUnmodifiableTypedDataViewDirectAccess();
}

TEST_CASE() [223/600]

dart::TEST_CASE

(

DartAPI_UnmodifiableTypedDataViewDirectAccessVerified

)

Definition at line 2752 of file dart_api_impl_test.cc.

                                                                 {
  FLAG_verify_acquired_data = true;
  TestUnmodifiableTypedDataViewDirectAccess();
}

TEST_CASE() [224/600]

dart::TEST_CASE

(

DartAPI_UnmodifiableTypedDataViewListIsTypedData

)

Definition at line 2060 of file dart_api_impl_test.cc.

                                                            {
  const int kSize = 1000;
 
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "List testMain(int size) {\n"
      "  var a = new Int8List(size);\n"
      "  var view = new UnmodifiableInt8ListView(a);\n"
      "  return view;\n"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Create a typed data view object.
  Dart_Handle dart_args[1];
  dart_args[0] = Dart_NewInteger(kSize);
  Dart_Handle view_obj = Dart_Invoke(lib, NewString("testMain"), 1, dart_args);
  EXPECT_VALID(view_obj);
  // Test that the API considers it a TypedData object.
  EXPECT(Dart_IsTypedData(view_obj));
  EXPECT_EQ(Dart_TypedData_kInt8, Dart_GetTypeOfTypedData(view_obj));
}

TEST_CASE() [225/600]

dart::TEST_CASE

(

DartAPI_UserTags

)

Definition at line 10186 of file dart_api_impl_test.cc.

                                                {
  // We do not check the contents of the JSON output here because we have
  // pkg/vm_service/test/get_perfetto_vm_timeline_rpc_test.dart and
  // runtime/observatory/tests/get_vm_timeline_rpc_test.dart for that. This test
  // is used to ensure that assertions in timeline code are checked by debug
  // tryjobs, and that the sanitizers run on the timeline code.
 
  // Grab embedder stream.
  TimelineStream* stream = Timeline::GetEmbedderStream();
  // Make sure it is enabled.
  stream->set_enabled(true);
 
  ReportTimelineEvents();
  TimelineEventRecorder* recorder = Timeline::recorder();
  JSONStream js_chrome_timeline;
  JSONStream js_perfetto_timeline;
  TimelineEventFilter filter;
  recorder->PrintJSON(&js_chrome_timeline, &filter);
#if defined(SUPPORT_PERFETTO)
  recorder->PrintPerfettoTimeline(&js_perfetto_timeline, filter);
#endif  // defined(SUPPORT_PERFETTO)
}
 
static void CreateTimelineEvents(uword param) {
  {
    MonitorLocker ml(loop_test_lock);
    loop_test_exit = true;
    ml.Notify();
  }
  do {
    ReportTimelineEvents();
  } while (true);

TEST_CASE() [226/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandle

)

Definition at line 3468 of file dart_api_impl_test.cc.

                                        {
  Dart_WeakPersistentHandle weak_new_ref = nullptr;
  Dart_WeakPersistentHandle weak_old_ref = nullptr;
 
  {
    Dart_EnterScope();
 
    Dart_Handle new_ref, old_ref;
    {
      // GCs due to allocations or weak handle creation can cause early
      // promotion and interfere with the scenario this test is verifying.
      ForceGrowthScope force_growth(thread);
 
      // Create an object in new space.
      new_ref = AllocateNewString("new string");
      EXPECT_VALID(new_ref);
 
      // Create an object in old space.
      old_ref = AllocateOldString("old string");
      EXPECT_VALID(old_ref);
 
      // Create a weak ref to the new space object.
      weak_new_ref =
          Dart_NewWeakPersistentHandle(new_ref, nullptr, 0, NopCallback);
      EXPECT_VALID(AsHandle(weak_new_ref));
      EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
 
      // Create a weak ref to the old space object.
      weak_old_ref =
          Dart_NewWeakPersistentHandle(old_ref, nullptr, 0, NopCallback);
 
      EXPECT_VALID(AsHandle(weak_old_ref));
      EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
    }
 
    {
      TransitionNativeToVM transition(thread);
      // Garbage collect new space.
      GCTestHelper::CollectNewSpace();
    }
 
    // Nothing should be invalidated or cleared.
    EXPECT_VALID(new_ref);
    EXPECT(!Dart_IsNull(new_ref));
    EXPECT_VALID(old_ref);
    EXPECT(!Dart_IsNull(old_ref));
 
    EXPECT_VALID(AsHandle(weak_new_ref));
    EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
    EXPECT(Dart_IdentityEquals(new_ref, AsHandle(weak_new_ref)));
 
    EXPECT_VALID(AsHandle(weak_old_ref));
    EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
    EXPECT(Dart_IdentityEquals(old_ref, AsHandle(weak_old_ref)));
 
    {
      TransitionNativeToVM transition(thread);
      // Garbage collect old space.
      GCTestHelper::CollectOldSpace();
    }
 
    // Nothing should be invalidated or cleared.
    EXPECT_VALID(new_ref);
    EXPECT(!Dart_IsNull(new_ref));
    EXPECT_VALID(old_ref);
    EXPECT(!Dart_IsNull(old_ref));
 
    EXPECT_VALID(AsHandle(weak_new_ref));
    EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
    EXPECT(Dart_IdentityEquals(new_ref, AsHandle(weak_new_ref)));
 
    EXPECT_VALID(AsHandle(weak_old_ref));
    EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
    EXPECT(Dart_IdentityEquals(old_ref, AsHandle(weak_old_ref)));
 
    // Delete local (strong) references.
    Dart_ExitScope();
  }
 
  {
    TransitionNativeToVM transition(thread);
    // Garbage collect new space again.
    GCTestHelper::CollectNewSpace();
  }
 
  {
    Dart_EnterScope();
    // Weak ref to new space object should now be cleared.
    EXPECT_VALID(AsHandle(weak_new_ref));
    EXPECT(Dart_IsNull(AsHandle(weak_new_ref)));
    EXPECT_VALID(AsHandle(weak_old_ref));
    EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
    Dart_ExitScope();
  }
 
  {
    TransitionNativeToVM transition(thread);
    // Garbage collect old space again.
    GCTestHelper::CollectOldSpace();
  }
 
  {
    Dart_EnterScope();
    // Weak ref to old space object should now be cleared.
    EXPECT_VALID(AsHandle(weak_new_ref));
    EXPECT(Dart_IsNull(AsHandle(weak_new_ref)));
    EXPECT_VALID(AsHandle(weak_old_ref));
    EXPECT(Dart_IsNull(AsHandle(weak_old_ref)));
    Dart_ExitScope();
  }
 
  {
    TransitionNativeToVM transition(thread);
    // Garbage collect one last time to revisit deleted handles.
    GCTestHelper::CollectAllGarbage();
  }
 
  Dart_DeleteWeakPersistentHandle(weak_new_ref);
  Dart_DeleteWeakPersistentHandle(weak_old_ref);
}

TEST_CASE() [227/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleCallback

)

Definition at line 3931 of file dart_api_impl_test.cc.

                                                {
  Dart_WeakPersistentHandle weak_ref = nullptr;
  int peer = 0;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("new string");
    EXPECT_VALID(obj);
    weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                            WeakPersistentHandlePeerFinalizer);
    EXPECT_VALID(AsHandle(weak_ref));
    EXPECT(peer == 0);
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
    EXPECT(peer == 42);
  }
  Dart_DeleteWeakPersistentHandle(weak_ref);
}

TEST_CASE() [228/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleCallbackSelfDelete

)

Definition at line 4042 of file dart_api_impl_test.cc.

                                                          {
  int peer = 0;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("new string");
    EXPECT_VALID(obj);
    delete_on_finalization = Dart_NewWeakPersistentHandle(
        obj, &peer, 0, DeleteWeakHandleOnFinalization);
    EXPECT_VALID(AsHandle(delete_on_finalization));
    EXPECT(peer == 0);
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectNewSpace();
    EXPECT(peer == 42);
    ASSERT(delete_on_finalization == nullptr);
  }
}

TEST_CASE() [229/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleCleanupFinalizer

)

Definition at line 3857 of file dart_api_impl_test.cc.

                                                        {
  Heap* heap = IsolateGroup::Current()->heap();
 
  const char* kTestString1 = "Test String1";
  Dart_EnterScope();
  CHECK_API_SCOPE(thread);
  Dart_Handle ref1 = Dart_NewStringFromCString(kTestString1);
  persistent_handle1 = Dart_NewPersistentHandle(ref1);
  Dart_Handle ref2 = Dart_NewStringFromCString(kTestString1);
  int peer2 = 0;
  weak_persistent_handle2 =
      Dart_NewWeakPersistentHandle(ref2, &peer2, 0, NopCallback);
  int peer3 = 0;
  {
    Dart_EnterScope();
    Dart_Handle ref3 = Dart_NewStringFromCString(kTestString1);
    weak_persistent_handle3 = Dart_NewWeakPersistentHandle(
        ref3, &peer3, 0, WeakPersistentHandlePeerCleanupFinalizer);
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectAllGarbage();
    EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
    EXPECT(peer3 == 42);
  }
  Dart_ExitScope();
 
  Dart_DeleteWeakPersistentHandle(weak_persistent_handle3);
}

TEST_CASE() [230/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleCleanupFinalizerAtShutdown

)

Definition at line 3838 of file dart_api_impl_test.cc.

                                                                  {
  const char* kTestString1 = "Test String1";
  int peer3 = 0;
  Dart_EnterScope();
  CHECK_API_SCOPE(thread);
  Dart_Handle ref3 = Dart_NewStringFromCString(kTestString1);
  weak_persistent_handle3 = Dart_NewWeakPersistentHandle(
      ref3, &peer3, 0, WeakPersistentHandlePeerCleanupEnsuresIGFinalizer);
  Dart_ExitScope();
}

TEST_CASE() [231/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleErrors

)

Definition at line 3708 of file dart_api_impl_test.cc.

                                              {
  Dart_EnterScope();
 
  // nullptr callback.
  Dart_Handle obj1 = NewString("new string");
  EXPECT_VALID(obj1);
  Dart_WeakPersistentHandle ref1 =
      Dart_NewWeakPersistentHandle(obj1, nullptr, 0, nullptr);
  EXPECT_EQ(ref1, static_cast<void*>(nullptr));
 
  // Immediate object.
  Dart_Handle obj2 = Dart_NewInteger(0);
  EXPECT_VALID(obj2);
  Dart_WeakPersistentHandle ref2 =
      Dart_NewWeakPersistentHandle(obj2, nullptr, 0, NopCallback);
  EXPECT_EQ(ref2, static_cast<void*>(nullptr));
 
  // Pointer object.
  Dart_Handle ffi_lib = Dart_LookupLibrary(NewString("dart:ffi"));
  Dart_Handle pointer_type =
      Dart_GetNonNullableType(ffi_lib, NewString("Pointer"), 0, nullptr);
  Dart_Handle obj3 = Dart_Allocate(pointer_type);
  EXPECT_VALID(obj3);
  Dart_WeakPersistentHandle ref3 =
      Dart_NewWeakPersistentHandle(obj3, nullptr, 0, FinalizableHandleCallback);
  EXPECT_EQ(ref3, static_cast<void*>(nullptr));
 
  // Subtype of Struct or Union object.
  const char* kScriptChars = R"(
      import 'dart:ffi';
 
      final class MyStruct extends Struct {
        external Pointer notEmpty;
      }
 
      final class MyUnion extends Union {
        external Pointer notEmpty;
      }
  )";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Dart_Handle my_struct_type =
      Dart_GetNonNullableType(lib, NewString("MyStruct"), 0, nullptr);
  Dart_Handle obj4 = Dart_Allocate(my_struct_type);
  EXPECT_VALID(obj4);
  Dart_WeakPersistentHandle ref4 =
      Dart_NewWeakPersistentHandle(obj4, nullptr, 0, FinalizableHandleCallback);
  EXPECT_EQ(ref4, static_cast<void*>(nullptr));
 
  Dart_Handle my_union_type =
      Dart_GetNonNullableType(lib, NewString("MyUnion"), 0, nullptr);
  Dart_Handle obj5 = Dart_Allocate(my_union_type);
  EXPECT_VALID(obj5);
  Dart_WeakPersistentHandle ref5 =
      Dart_NewWeakPersistentHandle(obj4, nullptr, 0, FinalizableHandleCallback);
  EXPECT_EQ(ref5, static_cast<void*>(nullptr));
 
  Dart_ExitScope();
}

TEST_CASE() [232/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleExternalAllocationSize

)

Definition at line 4088 of file dart_api_impl_test.cc.

                                                              {
  Heap* heap = IsolateGroup::Current()->heap();
  EXPECT_EQ(heap->ExternalInWords(Heap::kNew), 0);
  EXPECT_EQ(heap->ExternalInWords(Heap::kOld), 0);
  Dart_WeakPersistentHandle weak1 = nullptr;
  const intptr_t kWeak1ExternalSize = 1 * KB;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("weakly referenced string");
    EXPECT_VALID(obj);
    weak1 = Dart_NewWeakPersistentHandle(obj, nullptr, kWeak1ExternalSize,
                                         NopCallback);
    EXPECT_VALID(AsHandle(weak1));
    Dart_ExitScope();
  }
  Dart_PersistentHandle strong_ref = nullptr;
  Dart_WeakPersistentHandle weak2 = nullptr;
  const intptr_t kWeak2ExternalSize = 2 * KB;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("strongly referenced string");
    EXPECT_VALID(obj);
    strong_ref = Dart_NewPersistentHandle(obj);
    weak2 = Dart_NewWeakPersistentHandle(obj, nullptr, kWeak2ExternalSize,
                                         NopCallback);
    EXPECT_VALID(AsHandle(strong_ref));
    EXPECT_VALID(AsHandle(weak2));
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    EXPECT_EQ(heap->ExternalInWords(Heap::kNew),
              (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
    EXPECT_EQ(heap->ExternalInWords(Heap::kOld), 0);
    // Collect weakly referenced string.
    GCTestHelper::CollectNewSpace();
    EXPECT_EQ(heap->ExternalInWords(Heap::kNew),
              kWeak2ExternalSize / kWordSize);
    EXPECT_EQ(heap->ExternalInWords(Heap::kOld), 0);
    // Promote strongly referenced string.
    GCTestHelper::CollectNewSpace();
    EXPECT_EQ(heap->ExternalInWords(Heap::kNew), 0);
    EXPECT_EQ(heap->ExternalInWords(Heap::kOld),
              kWeak2ExternalSize / kWordSize);
  }
  Dart_DeletePersistentHandle(strong_ref);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(heap->ExternalInWords(Heap::kNew), 0);
    EXPECT_EQ(heap->ExternalInWords(Heap::kOld), 0);
  }
  Dart_DeleteWeakPersistentHandle(weak1);
  Dart_DeleteWeakPersistentHandle(weak2);
}

TEST_CASE() [233/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleExternalAllocationSizeNewspaceGC

)

Definition at line 4192 of file dart_api_impl_test.cc.

                                                                        {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_WeakPersistentHandle weak1 = nullptr;
  // Large enough to exceed any new space limit. Not actually allocated.
  const intptr_t kWeak1ExternalSize = 500 * MB;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("weakly referenced string");
    EXPECT_VALID(obj);
    // Triggers a scavenge immediately, since kWeak1ExternalSize is above limit.
    weak1 = Dart_NewWeakPersistentHandle(obj, nullptr, kWeak1ExternalSize,
                                         NopCallback);
    EXPECT_VALID(AsHandle(weak1));
    // ... but the object is still alive and not yet promoted, so external size
    // in new space is still above the limit. Thus, even the following tiny
    // external allocation will trigger another scavenge.
    Dart_WeakPersistentHandle trigger =
        Dart_NewWeakPersistentHandle(obj, nullptr, 1, NopCallback);
    EXPECT_VALID(AsHandle(trigger));
    Dart_DeleteWeakPersistentHandle(trigger);
    // After the two scavenges above, 'obj' should now be promoted, hence its
    // external size charged to old space.
    {
      CHECK_API_SCOPE(thread);
      TransitionNativeToVM transition(thread);
      HANDLESCOPE(thread);
      String& handle = String::Handle(thread->zone());
      handle ^= Api::UnwrapHandle(obj);
      EXPECT(handle.IsOld());
    }
    EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
    EXPECT(heap->ExternalInWords(Heap::kOld) == kWeak1ExternalSize / kWordSize);
    Dart_ExitScope();
  }
  Dart_DeleteWeakPersistentHandle(weak1);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  }
}

TEST_CASE() [234/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleExternalAllocationSizeOddReferents

)

Definition at line 4357 of file dart_api_impl_test.cc.

                                                                          {
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_WeakPersistentHandle weak1 = nullptr;
  const intptr_t kWeak1ExternalSize = 1 * KB;
  Dart_WeakPersistentHandle weak2 = nullptr;
  const intptr_t kWeak2ExternalSize = 2 * KB;
  EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  {
    Dart_EnterScope();
    Dart_Handle dart_true = Dart_True();  // VM heap object.
    EXPECT_VALID(dart_true);
    weak1 = Dart_NewWeakPersistentHandle(dart_true, nullptr, kWeak1ExternalSize,
                                         UnreachedCallback);
    EXPECT_VALID(AsHandle(weak1));
    Dart_Handle zero = Dart_False();  // VM heap object.
    EXPECT_VALID(zero);
    weak2 = Dart_NewWeakPersistentHandle(zero, nullptr, kWeak2ExternalSize,
                                         UnreachedCallback);
    EXPECT_VALID(AsHandle(weak2));
    // Both should be charged to old space.
    EXPECT(heap->ExternalInWords(Heap::kOld) ==
           (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
    Dart_ExitScope();
  }
  Dart_DeleteWeakPersistentHandle(weak1);
  Dart_DeleteWeakPersistentHandle(weak2);
  EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  }
}

TEST_CASE() [235/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleExternalAllocationSizeOldspaceGC

)

Definition at line 4277 of file dart_api_impl_test.cc.

                                                                        {
  // Check that external allocation in old space can trigger GC.
  Heap* heap = IsolateGroup::Current()->heap();
  Dart_EnterScope();
  Dart_Handle live = AllocateOldString("live");
  EXPECT_VALID(live);
  Dart_WeakPersistentHandle weak = nullptr;
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::WaitForGCTasks();  // Finalize GC for accurate live size.
    EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
  }
  const intptr_t kSmallExternalSize = 1 * KB;
  {
    Dart_EnterScope();
    Dart_Handle dead = AllocateOldString("dead");
    EXPECT_VALID(dead);
    weak = Dart_NewWeakPersistentHandle(dead, nullptr, kSmallExternalSize,
                                        NopCallback);
    EXPECT_VALID(AsHandle(weak));
    Dart_ExitScope();
  }
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::WaitForGCTasks();  // Finalize GC for accurate live size.
    EXPECT_EQ(kSmallExternalSize,
              heap->ExternalInWords(Heap::kOld) * kWordSize);
  }
  // Large enough to trigger GC in old space. Not actually allocated.
  const intptr_t kHugeExternalSize = (kWordSize == 4) ? 513 * MB : 1025 * MB;
  Dart_WeakPersistentHandle weak2 = Dart_NewWeakPersistentHandle(
      live, nullptr, kHugeExternalSize, NopCallback);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::WaitForGCTasks();  // Finalize GC for accurate live size.
    // Expect small garbage to be collected.
    EXPECT_EQ(kHugeExternalSize, heap->ExternalInWords(Heap::kOld) * kWordSize);
  }
  Dart_ExitScope();
  Dart_DeleteWeakPersistentHandle(weak);
  Dart_DeleteWeakPersistentHandle(weak2);
}

TEST_CASE() [236/600]

dart::TEST_CASE

(

DartAPI_WeakPersistentHandleNoCallback

)

Definition at line 3974 of file dart_api_impl_test.cc.

                                                  {
  Dart_WeakPersistentHandle weak_ref = nullptr;
  int peer = 0;
  {
    Dart_EnterScope();
    Dart_Handle obj = NewString("new string");
    EXPECT_VALID(obj);
    weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                            WeakPersistentHandlePeerFinalizer);
    Dart_ExitScope();
  }
  // A finalizer is not invoked on a deleted handle.  Therefore, the
  // peer value should not change after the referent is collected.
  Dart_DeleteWeakPersistentHandle(weak_ref);
  EXPECT(peer == 0);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
    EXPECT(peer == 0);
    GCTestHelper::CollectNewSpace();
    EXPECT(peer == 0);
  }
}

TEST_CASE() [237/600]

dart::TEST_CASE

(

DeoptimizeFramesWhenSettingBreakpoint

)

Definition at line 5662 of file object_test.cc.

                                                 {
  const char* kOriginalScript = "test() {}";
 
  Dart_Handle lib = TestCase::LoadTestScript(kOriginalScript, nullptr);
  EXPECT_VALID(lib);
  Dart_SetNativeResolver(lib, &SetBreakpointResolver, nullptr);
 
  // Get unoptimized code for functions so they can be optimized.
  Dart_Handle result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(result);
 
  // Launch second isolate so that running with stopped mutators during
  // deoptimizattion requests a safepoint.
  Dart_Isolate parent = Dart_CurrentIsolate();
  Dart_ExitIsolate();
  char* error = nullptr;
  Dart_Isolate child = Dart_CreateIsolateInGroup(parent, "child",
                                                 /*shutdown_callback=*/nullptr,
                                                 /*cleanup_callback=*/nullptr,
                                                 /*peer=*/nullptr, &error);
  EXPECT_NE(nullptr, child);
  EXPECT_EQ(nullptr, error);
  Dart_ExitIsolate();
  Dart_EnterIsolate(parent);
 
  const char* kReloadScript =
      R"(
      @pragma("vm:external-name", "setBreakpoint")
      external setBreakpoint();
      baz() {}
      test() {
        if (true) {
          setBreakpoint();
        } else {
          baz();   // this line gets a breakpoint
        }
      }
      )";
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
 
  {
    TransitionNativeToVM transition(thread);
    const String& name = String::Handle(String::New(TestCase::url()));
    const Library& vmlib =
        Library::Handle(Library::LookupLibrary(thread, name));
    EXPECT(!vmlib.IsNull());
    Function& func_test = Function::Handle(GetFunction(vmlib, "test"));
    Compiler::EnsureUnoptimizedCode(thread, func_test);
    Compiler::CompileOptimizedFunction(thread, func_test);
    func_test.set_unoptimized_code(Code::Handle(Code::null()));
  }
 
  result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(result);
 
  // Make sure child isolate finishes.

TEST_CASE() [238/600]

dart::TEST_CASE

(

DirectChainedHashMap

)

Definition at line 23 of file hash_map_test.cc.

                                {
  DirectChainedHashMap<PointerSetKeyValueTrait<TestValue>> map;
  EXPECT(map.IsEmpty());
  TestValue v1(0);
  TestValue v2(1);
  TestValue v3(0);
  map.Insert(&v1);
  EXPECT(map.LookupValue(&v1) == &v1);
  map.Insert(&v2);
  EXPECT(map.LookupValue(&v1) == &v1);
  EXPECT(map.LookupValue(&v2) == &v2);
  EXPECT(map.LookupValue(&v3) == &v1);
  EXPECT(map.Remove(&v1));
  EXPECT(map.Lookup(&v1) == nullptr);
  map.Insert(&v1);
  DirectChainedHashMap<PointerSetKeyValueTrait<TestValue>> map2(map);
  EXPECT(map2.LookupValue(&v1) == &v1);
  EXPECT(map2.LookupValue(&v2) == &v2);
  EXPECT(map2.LookupValue(&v3) == &v1);
}

TEST_CASE() [239/600]

dart::TEST_CASE

(

DirectChainedHashMapInsertRemove

)

Definition at line 44 of file hash_map_test.cc.

                                            {
  DirectChainedHashMap<PointerSetKeyValueTrait<TestValue>> map;
  EXPECT(map.IsEmpty());
  TestValue v1(1);
  TestValue v2(3);  // Note: v1, v2, v3 should have the same hash.
  TestValue v3(5);
 
  // Start with adding and removing the same element.
  map.Insert(&v1);
  EXPECT(map.LookupValue(&v1) == &v1);
  EXPECT(map.Remove(&v1));
  EXPECT(map.Lookup(&v1) == nullptr);
 
  // Inserting v2 first should put it at the head of the list.
  map.Insert(&v2);
  map.Insert(&v1);
  EXPECT(map.LookupValue(&v2) == &v2);
  EXPECT(map.LookupValue(&v1) == &v1);
 
  // Check to see if removing the head of the list causes issues.
  EXPECT(map.Remove(&v2));
  EXPECT(map.Lookup(&v2) == nullptr);
  EXPECT(map.LookupValue(&v1) == &v1);
 
  // Reinsert v2, which will place it at the back of the hash map list.
  map.Insert(&v2);
  EXPECT(map.LookupValue(&v2) == &v2);
 
  // Remove from the back of the hash map list.
  EXPECT(map.Remove(&v2));
  EXPECT(map.Lookup(&v2) == nullptr);
  EXPECT(map.Remove(&v1));
  EXPECT(map.Lookup(&v1) == nullptr);
 
  // Check to see that removing an invalid element returns false.
  EXPECT(!map.Remove(&v1));
 
  // One last case: remove from the middle of a hash map list.
  map.Insert(&v1);
  map.Insert(&v2);
  map.Insert(&v3);
 
  EXPECT(map.LookupValue(&v1) == &v1);
  EXPECT(map.LookupValue(&v2) == &v2);
  EXPECT(map.LookupValue(&v3) == &v3);
 
  EXPECT(map.Remove(&v2));
  EXPECT(map.LookupValue(&v1) == &v1);
  EXPECT(map.Lookup(&v2) == nullptr);
  EXPECT(map.LookupValue(&v3) == &v3);
 
  EXPECT(map.Remove(&v1));
  EXPECT(map.Remove(&v3));
 
  EXPECT(map.IsEmpty());
}

TEST_CASE() [240/600]

dart::TEST_CASE

(

DirectChainedHashMapIterator

)

Definition at line 157 of file hash_map_test.cc.

                                        {
  IntptrPair p1(1, 1);
  IntptrPair p2(2, 2);
  IntptrPair p3(3, 3);
  IntptrPair p4(4, 4);
  IntptrPair p5(5, 5);
  DirectChainedHashMap<NumbersKeyValueTrait<IntptrPair>> map;
  EXPECT(map.IsEmpty());
  DirectChainedHashMap<NumbersKeyValueTrait<IntptrPair>>::Iterator it =
      map.GetIterator();
  EXPECT(it.Next() == nullptr);
  it.Reset();
 
  map.Insert(p1);
  EXPECT(*it.Next() == p1);
  it.Reset();
 
  map.Insert(p2);
  map.Insert(p3);
  map.Insert(p4);
  map.Insert(p5);
  intptr_t count = 0;
  intptr_t sum = 0;
  while (true) {
    IntptrPair* p = it.Next();
    if (p == nullptr) {
      break;
    }
    count++;
    sum += p->second();
  }
 
  EXPECT(count == 5);
  EXPECT(sum == 15);
}

TEST_CASE() [241/600]

dart::TEST_CASE

(

DirectChainedHashMapIteratorWithCollisionInLastBucket

)

Definition at line 193 of file hash_map_test.cc.

                                                                 {
  intptr_t values[] = {65,  325, 329, 73,  396, 207, 215, 93,  227, 39,
                       431, 112, 176, 313, 188, 317, 61,  127, 447};
  IntMap<intptr_t> map;
 
  for (intptr_t value : values) {
    map.Insert(value, value);
  }
 
  bool visited[ARRAY_SIZE(values)] = {};
  intptr_t count = 0;
  auto it = map.GetIterator();
  for (auto* p = it.Next(); p != nullptr; p = it.Next()) {
    ++count;
    bool found = false;
    intptr_t i = 0;
    for (intptr_t v : values) {
      if (v == p->key) {
        EXPECT(v == p->value);
        EXPECT(!visited[i]);
        visited[i] = true;
        found = true;
        break;
      }
      ++i;
    }
    EXPECT(found);
  }
  EXPECT(count == ARRAY_SIZE(values));
  for (bool is_visited : visited) {
    EXPECT(is_visited);
  }
}

TEST_CASE() [242/600]

dart::TEST_CASE

(

DirectoryCreateDelete

)

Definition at line 78 of file directory_test.cc.

                                 {
  const char* kTempDirName = "create_delete_test_name";
 
  const char* system_temp = dart::bin::Directory::SystemTemp(nullptr);
  EXPECT_NOTNULL(system_temp);
 
  const intptr_t name_len =
      snprintf(nullptr, 0, "%s/%s", system_temp, kTempDirName);
  ASSERT(name_len > 0);
  char* name = new char[name_len + 1];
  snprintf(name, name_len + 1, "%s/%s", system_temp, kTempDirName);
 
  // Make a directory.
  EXPECT(dart::bin::Directory::Create(nullptr, name));
 
  // Make sure it exists.
  dart::bin::Directory::ExistsResult r =
      dart::bin::Directory::Exists(nullptr, name);
  EXPECT_EQ(dart::bin::Directory::EXISTS, r);
 
  // Cleanup.
  EXPECT(dart::bin::Directory::Delete(nullptr, name, false));
  delete[] name;
}

TEST_CASE() [243/600]

dart::TEST_CASE

(

DirectoryCreateTemp

)

Definition at line 46 of file directory_test.cc.

                               {
  const char* kTempPrefix = "test_prefix";
  const char* system_temp = dart::bin::Directory::SystemTemp(nullptr);
  EXPECT_NOTNULL(system_temp);
 
  const char* temp_dir = dart::bin::Directory::CreateTemp(nullptr, kTempPrefix);
  EXPECT_NOTNULL(temp_dir);
 
  // Make sure temp_dir contains test_prefix.
  EXPECT_NOTNULL(strstr(temp_dir, kTempPrefix));
 
  // Cleanup.
  EXPECT(dart::bin::Directory::Delete(nullptr, temp_dir, false));
}

TEST_CASE() [244/600]

dart::TEST_CASE

(

DirectoryCurrent

)

Definition at line 18 of file directory_test.cc.

                            {
  const char* current = dart::bin::Directory::Current(nullptr);
  EXPECT_NOTNULL(current);
}

TEST_CASE() [245/600]

dart::TEST_CASE

(

DirectoryExists

)

Definition at line 23 of file directory_test.cc.

                           {
  const char* current = dart::bin::Directory::Current(nullptr);
  EXPECT_NOTNULL(current);
 
  dart::bin::Directory::ExistsResult r =
      dart::bin::Directory::Exists(nullptr, current);
  EXPECT_EQ(dart::bin::Directory::EXISTS, r);
}

TEST_CASE() [246/600]

dart::TEST_CASE

(

DirectoryRename

)

Definition at line 103 of file directory_test.cc.

                           {
  const char* kTempDirName = "rename_test_name";
 
  const char* system_temp = dart::bin::Directory::SystemTemp(nullptr);
  EXPECT_NOTNULL(system_temp);
 
  const intptr_t name_len =
      snprintf(nullptr, 0, "%s/%s", system_temp, kTempDirName);
  ASSERT(name_len > 0);
  char* name = new char[name_len + 1];
  snprintf(name, name_len + 1, "%s/%s", system_temp, kTempDirName);
 
  // Make a directory.
  EXPECT(dart::bin::Directory::Create(nullptr, name));
 
  // Make sure it exists.
  dart::bin::Directory::ExistsResult r =
      dart::bin::Directory::Exists(nullptr, name);
  EXPECT_EQ(dart::bin::Directory::EXISTS, r);
 
  const intptr_t new_name_len =
      snprintf(nullptr, 0, "%s/%snewname", system_temp, kTempDirName);
  ASSERT(new_name_len > 0);
  char* new_name = new char[new_name_len + 1];
  snprintf(new_name, new_name_len + 1, "%s/%snewname", system_temp,
           kTempDirName);
 
  EXPECT(dart::bin::Directory::Rename(nullptr, name, new_name));
 
  r = dart::bin::Directory::Exists(nullptr, new_name);
  EXPECT_EQ(dart::bin::Directory::EXISTS, r);
 
  r = dart::bin::Directory::Exists(nullptr, name);
  EXPECT_EQ(dart::bin::Directory::DOES_NOT_EXIST, r);
 
  EXPECT(dart::bin::Directory::Delete(nullptr, new_name, false));
  delete[] name;
  delete[] new_name;
}

TEST_CASE() [247/600]

dart::TEST_CASE

(

DirectorySetCurrent

)

Definition at line 61 of file directory_test.cc.

                               {
  const char* current = dart::bin::Directory::Current(nullptr);
  EXPECT_NOTNULL(current);
 
  const char* system_temp = dart::bin::Directory::SystemTemp(nullptr);
  EXPECT_NOTNULL(system_temp);
 
  EXPECT(dart::bin::Directory::SetCurrent(nullptr, system_temp));
 
  const char* new_current = dart::bin::Directory::Current(nullptr);
  EXPECT_NOTNULL(new_current);
 
  EXPECT_NOTNULL(strstr(new_current, system_temp));
 
  EXPECT(dart::bin::Directory::SetCurrent(nullptr, current));
}

TEST_CASE() [248/600]

dart::TEST_CASE

(

DirectorySystemTemp

)

Definition at line 32 of file directory_test.cc.

                               {
  const char* system_temp = dart::bin::Directory::SystemTemp(nullptr);
  EXPECT_NOTNULL(system_temp);
}

TEST_CASE() [249/600]

dart::TEST_CASE

(

DirectorySystemTempExists

)

Definition at line 37 of file directory_test.cc.

                                     {
  const char* system_temp = dart::bin::Directory::SystemTemp(nullptr);
  EXPECT_NOTNULL(system_temp);
 
  dart::bin::Directory::ExistsResult r =
      dart::bin::Directory::Exists(nullptr, system_temp);
  EXPECT_EQ(dart::bin::Directory::EXISTS, r);
}

TEST_CASE() [250/600]

dart::TEST_CASE

(

EvalExpression

)

Definition at line 177 of file compiler_test.cc.

                          {
  const char* kScriptChars =
      "int ten = 2 * 5;              \n"
      "get dot => '.';               \n"
      "class A {                     \n"
      "  var apa = 'Herr Nilsson';   \n"
      "  calc(x) => '${x*ten}';      \n"
      "}                             \n"
      "makeObj() => new A();         \n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle obj_handle =
      Dart_Invoke(lib, Dart_NewStringFromCString("makeObj"), 0, nullptr);
  EXPECT_VALID(obj_handle);
  TransitionNativeToVM transition(thread);
  const Object& obj = Object::Handle(Api::UnwrapHandle(obj_handle));
  EXPECT(!obj.IsNull());
  EXPECT(obj.IsInstance());
 
  String& expr_text = String::Handle();
  expr_text = String::New("apa + ' ${calc(10)}' + dot");
  Object& val = Object::Handle();
  const Class& receiver_cls = Class::Handle(obj.clazz());
 
  if (!KernelIsolate::IsRunning()) {
    UNREACHABLE();
  } else {
    LibraryPtr raw_library = Library::RawCast(Api::UnwrapHandle(lib));
    Library& lib_handle = Library::ZoneHandle(raw_library);
 
    Dart_KernelCompilationResult compilation_result =
        KernelIsolate::CompileExpressionToKernel(
            /*platform_kernel=*/nullptr, /*platform_kernel_size=*/0,
            expr_text.ToCString(), Array::empty_array(), Array::empty_array(),
            Array::empty_array(), Array::empty_array(), Array::empty_array(),
            String::Handle(lib_handle.url()).ToCString(), "A",
            /* method= */ nullptr,
            /* token_pos= */ TokenPosition::kNoSource,
            /* script_uri= */ String::Handle(lib_handle.url()).ToCString(),
            /* is_static= */ false);
    EXPECT_EQ(Dart_KernelCompilationStatus_Ok, compilation_result.status);
 
    const ExternalTypedData& kernel_buffer =
        ExternalTypedData::Handle(ExternalTypedData::NewFinalizeWithFree(
            const_cast<uint8_t*>(compilation_result.kernel),
            compilation_result.kernel_size));
 
    val = Instance::Cast(obj).EvaluateCompiledExpression(
        receiver_cls, kernel_buffer, Array::empty_array(), Array::empty_array(),
        TypeArguments::null_type_arguments());
  }
  EXPECT(!val.IsNull());
  EXPECT(!val.IsError());
  EXPECT(val.IsString());
  EXPECT_STREQ("Herr Nilsson 100.", val.ToCString());
}

TEST_CASE() [251/600]

dart::TEST_CASE

(

FailSerializeLargeArray

)

Definition at line 472 of file snapshot_test.cc.

                                   {
  Dart_CObject root;
  root.type = Dart_CObject_kArray;
  root.value.as_array.length = Array::kMaxElements + 1;
  root.value.as_array.values = nullptr;
  ApiNativeScope scope;
  ExpectEncodeFail(scope.zone(), &root);
}

TEST_CASE() [252/600]

dart::TEST_CASE

(

FailSerializeLargeExternalTypedData

)

Definition at line 515 of file snapshot_test.cc.

                                               {
  Dart_CObject root;
  root.type = Dart_CObject_kExternalTypedData;
  root.value.as_external_typed_data.type = Dart_TypedData_kUint8;
  root.value.as_external_typed_data.length =
      ExternalTypedData::MaxElements(kExternalTypedDataUint8ArrayCid) + 1;
  ApiNativeScope scope;
  ExpectEncodeFail(scope.zone(), &root);
}

TEST_CASE() [253/600]

dart::TEST_CASE

(

FailSerializeLargeNestedArray

)

Definition at line 481 of file snapshot_test.cc.

                                         {
  Dart_CObject parent;
  Dart_CObject child;
  Dart_CObject* values[1] = {&child};
 
  parent.type = Dart_CObject_kArray;
  parent.value.as_array.length = 1;
  parent.value.as_array.values = values;
  child.type = Dart_CObject_kArray;
  child.value.as_array.length = Array::kMaxElements + 1;
  ApiNativeScope scope;
  ExpectEncodeFail(scope.zone(), &parent);
}

TEST_CASE() [254/600]

dart::TEST_CASE

(

FailSerializeLargeTypedDataInt8

)

Definition at line 495 of file snapshot_test.cc.

                                           {
  Dart_CObject root;
  root.type = Dart_CObject_kTypedData;
  root.value.as_typed_data.type = Dart_TypedData_kInt8;
  root.value.as_typed_data.length =
      TypedData::MaxElements(kTypedDataInt8ArrayCid) + 1;
  ApiNativeScope scope;
  ExpectEncodeFail(scope.zone(), &root);
}

TEST_CASE() [255/600]

dart::TEST_CASE

(

FailSerializeLargeTypedDataUint8

)

Definition at line 505 of file snapshot_test.cc.

                                            {
  Dart_CObject root;
  root.type = Dart_CObject_kTypedData;
  root.value.as_typed_data.type = Dart_TypedData_kUint8;
  root.value.as_typed_data.length =
      TypedData::MaxElements(kTypedDataUint8ArrayCid) + 1;
  ApiNativeScope scope;
  ExpectEncodeFail(scope.zone(), &root);
}

TEST_CASE() [256/600]

dart::TEST_CASE

(

FailSerializeLargeUnmodifiableExternalTypedData

)

Definition at line 525 of file snapshot_test.cc.

                                                           {
  Dart_CObject root;
  root.type = Dart_CObject_kUnmodifiableExternalTypedData;
  root.value.as_external_typed_data.type = Dart_TypedData_kUint8;
  root.value.as_external_typed_data.length =
      ExternalTypedData::MaxElements(kExternalTypedDataUint8ArrayCid) + 1;
  ApiNativeScope scope;
  ExpectEncodeFail(scope.zone(), &root);
}

TEST_CASE() [257/600]

dart::TEST_CASE

(

FileLength

)

Definition at line 211 of file file_test.cc.

                      {
  const char* kFilename =
      bin::test::GetFileName("runtime/tests/vm/data/fixed_length_file");
  bin::File* file = bin::File::Open(nullptr, kFilename, bin::File::kRead);
  EXPECT(file != nullptr);
  EXPECT_EQ(42, file->Length());
  file->Release();
}

TEST_CASE() [258/600]

dart::TEST_CASE

(

FilePosition

)

Definition at line 220 of file file_test.cc.

                        {
  char buf[42];
  const char* kFilename =
      bin::test::GetFileName("runtime/tests/vm/data/fixed_length_file");
  bin::File* file = bin::File::Open(nullptr, kFilename, bin::File::kRead);
  EXPECT(file != nullptr);
  EXPECT(file->ReadFully(buf, 12));
  EXPECT_EQ(12, file->Position());
  EXPECT(file->ReadFully(buf, 6));
  EXPECT_EQ(18, file->Position());
  file->Release();
}

TEST_CASE() [259/600]

dart::TEST_CASE

(

FreeList

)

Definition at line 84 of file freelist_test.cc.

                    {
  FreeList* free_list = new FreeList();
  const intptr_t kBlobSize = 1 * MB;
  VirtualMemory* region = VirtualMemory::Allocate(
      kBlobSize, /* is_executable */ false, /* is_compressed */ false, "test");
 
  TestFreeList(region, free_list, false);
 
  // Delete the memory associated with the test.
  delete region;
  delete free_list;
}

TEST_CASE() [260/600]

dart::TEST_CASE

(

FreeListProtected

)

Definition at line 97 of file freelist_test.cc.

                             {
  FreeList* free_list = new FreeList();
  const intptr_t kBlobSize = 1 * MB;
  VirtualMemory* region = VirtualMemory::Allocate(
      kBlobSize, /*is_executable*/ false, /*is_compressed*/ false, "test");
 
  TestFreeList(region, free_list, true);
 
  // Delete the memory associated with the test.
  delete region;
  delete free_list;
}

TEST_CASE() [261/600]

dart::TEST_CASE

(

FreeListProtectedTinyObjects

)

Definition at line 110 of file freelist_test.cc.

                                        {
  FreeList* free_list = new FreeList();
  const intptr_t kBlobSize = 1 * MB;
  const intptr_t kObjectSize = 2 * kWordSize;
  uword* objects = new uword[kBlobSize / kObjectSize];
 
  VirtualMemory* blob = VirtualMemory::Allocate(
      kBlobSize, /*is_executable*/ false, /*is_compressed*/ false, "test");
  ASSERT(Utils::IsAligned(blob->start(), 4096));
  blob->Protect(VirtualMemory::kReadWrite);
 
  // Enqueue the large blob as one free block.
  free_list->Free(blob->start(), blob->size());
 
  // Write protect the whole region.
  blob->Protect(VirtualMemory::kReadExecute);
 
  // Allocate small objects.
  for (intptr_t i = 0; i < blob->size() / kObjectSize; i++) {
    objects[i] = Allocate(free_list, kObjectSize, true);  // is_protected
  }
 
  // All space is occupied. Expect failed allocation.
  ASSERT(Allocate(free_list, kObjectSize, true) == 0);
 
  // Free all objects again. Make the whole region writable for this.
  blob->Protect(VirtualMemory::kReadWrite);
  for (intptr_t i = 0; i < blob->size() / kObjectSize; i++) {
    free_list->Free(objects[i], kObjectSize);
  }
 
  // Delete the memory associated with the test.
  delete blob;
  delete free_list;
  delete[] objects;
}

TEST_CASE() [262/600]

dart::TEST_CASE

(

FreeListProtectedVariableSizeObjects

)

Definition at line 147 of file freelist_test.cc.

                                                {
  FreeList* free_list = new FreeList();
  const intptr_t kBlobSize = 16 * KB;
  ASSERT(kBlobSize >= VirtualMemory::PageSize());
  const intptr_t kMinSize = 2 * kWordSize;
  uword* objects = new uword[kBlobSize / kMinSize];
  for (intptr_t i = 0; i < kBlobSize / kMinSize; ++i) {
    objects[i] = 0;
  }
 
  VirtualMemory* blob = VirtualMemory::Allocate(
      kBlobSize, /*is_executable*/ false, /*is_compressed*/ false, "test");
  blob->Protect(VirtualMemory::kReadWrite);
 
  // Enqueue the large blob as one free block.
  free_list->Free(blob->start(), blob->size());
 
  // Write protect the whole region.
  blob->Protect(VirtualMemory::kReadOnly);
 
  // Allocate and free objects so that free list has > 1 elements.
  uword e0 = Allocate(free_list, 2 * KB, true);
  ASSERT(e0);
  uword e1 = Allocate(free_list, 6 * KB, true);
  ASSERT(e1);
  uword e2 = Allocate(free_list, 4 * KB, true);
  ASSERT(e2);
  uword e3 = Allocate(free_list, 4 * KB, true);
  ASSERT(e3);
 
  Free(free_list, e1, 6 * KB, true);
  Free(free_list, e2, 4 * KB, true);
  e0 = Allocate(free_list, 6 * KB - 2 * kWordSize, true);
  ASSERT(e0);
 
  // Delete the memory associated with the test.
  delete blob;
  delete free_list;
  delete[] objects;
}

TEST_CASE() [263/600]

dart::TEST_CASE

(

FunctionSourceFingerprint

)

Definition at line 5507 of file object_test.cc.

                                     {
  const char* kScriptChars =
      "class A {\n"
      "  static test1(int a) {\n"
      "    return a > 1 ? a + 1 : a;\n"
      "  }\n"
      "  static test2(a) {\n"
      "    return a > 1 ? a + 1 : a;\n"
      "  }\n"
      "  static test3(b) {\n"
      "    return b > 1 ? b + 1 : b;\n"
      "  }\n"
      "  static test4(b) {\n"
      "    return b > 1 ? b - 1 : b;\n"
      "  }\n"
      "  static test5(b) {\n"
      "    return b > 1 ? b - 2 : b;\n"
      "  }\n"
      "  test6(int a) {\n"
      "    return a > 1 ? a + 1 : a;\n"
      "  }\n"
      "}\n"
      "class B {\n"
      "  static /* Different declaration style. */\n"
      "  test1(int a) {\n"
      "    /* Returns a + 1 for a > 1, a otherwise. */\n"
      "    return a > 1 ?\n"
      "        a + 1 :\n"
      "        a;\n"
      "  }\n"
      "  static test5(b) {\n"
      "    return b > 1 ?\n"
      "        b - 2 : b;\n"
      "  }\n"
      "  test6(int a) {\n"
      "    return a > 1 ? a + 1 : a;\n"
      "  }\n"
      "}";
  TestCase::LoadTestScript(kScriptChars, nullptr);
  TransitionNativeToVM transition(thread);
  EXPECT(ClassFinalizer::ProcessPendingClasses());
  const String& name = String::Handle(String::New(TestCase::url()));
  const Library& lib = Library::Handle(Library::LookupLibrary(thread, name));
  EXPECT(!lib.IsNull());
 
  const Class& class_a =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
  const Class& class_b =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "B"))));
  const Function& a_test1 =
      Function::Handle(GetStaticFunction(class_a, "test1"));
  const Function& b_test1 =
      Function::Handle(GetStaticFunction(class_b, "test1"));
  const Function& a_test2 =
      Function::Handle(GetStaticFunction(class_a, "test2"));
  const Function& a_test3 =
      Function::Handle(GetStaticFunction(class_a, "test3"));
  const Function& a_test4 =
      Function::Handle(GetStaticFunction(class_a, "test4"));
  const Function& a_test5 =
      Function::Handle(GetStaticFunction(class_a, "test5"));
  const Function& b_test5 =
      Function::Handle(GetStaticFunction(class_b, "test5"));
  const Function& a_test6 = Function::Handle(GetFunction(class_a, "test6"));
  const Function& b_test6 = Function::Handle(GetFunction(class_b, "test6"));
 
  EXPECT_EQ(a_test1.SourceFingerprint(), b_test1.SourceFingerprint());
  EXPECT_NE(a_test1.SourceFingerprint(), a_test2.SourceFingerprint());
  EXPECT_NE(a_test2.SourceFingerprint(), a_test3.SourceFingerprint());
  EXPECT_NE(a_test3.SourceFingerprint(), a_test4.SourceFingerprint());
  EXPECT_NE(a_test4.SourceFingerprint(), a_test5.SourceFingerprint());
  EXPECT_EQ(a_test5.SourceFingerprint(), b_test5.SourceFingerprint());
  // Although a_test6's receiver type is different than b_test6's receiver type,
  // the fingerprints are identical. The token stream does not reflect the
  // receiver's type. This is not a problem, since we recognize functions
  // of a given class and of a given name.
  EXPECT_EQ(a_test6.SourceFingerprint(), b_test6.SourceFingerprint());
}

TEST_CASE() [264/600]

dart::TEST_CASE

(

FunctionWithBreakpointNotInlined

)

Definition at line 5588 of file object_test.cc.

                                            {
  const char* kScriptChars =
      "class A {\n"
      "  a() {\n"
      "  }\n"
      "  b() {\n"
      "    a();\n"  // This is line 5.
      "  }\n"
      "}\n"
      "test() {\n"
      "  new A().b();\n"
      "}";
  const int kBreakpointLine = 5;
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  // Run function A.b one time.
  Dart_Handle result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(result);
 
  // With no breakpoint, function A.b is inlineable.
  {
    TransitionNativeToVM transition(thread);
    const String& name = String::Handle(String::New(TestCase::url()));
    const Library& vmlib =
        Library::Handle(Library::LookupLibrary(thread, name));
    EXPECT(!vmlib.IsNull());
    const Class& class_a = Class::Handle(
        vmlib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
    Function& func_b = Function::Handle(GetFunction(class_a, "b"));
    EXPECT(func_b.CanBeInlined());
  }
 
  result = Dart_SetBreakpoint(NewString(TestCase::url()), kBreakpointLine);
  EXPECT_VALID(result);
 
  // After setting a breakpoint in a function A.b, it is no longer inlineable.
  {
    TransitionNativeToVM transition(thread);
    const String& name = String::Handle(String::New(TestCase::url()));
    const Library& vmlib =
        Library::Handle(Library::LookupLibrary(thread, name));
    EXPECT(!vmlib.IsNull());
    const Class& class_a = Class::Handle(
        vmlib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
    Function& func_b = Function::Handle(GetFunction(class_a, "b"));
    EXPECT(!func_b.CanBeInlined());
  }
}

TEST_CASE() [265/600]

dart::TEST_CASE

(

GrowableArray

)

Definition at line 68 of file growable_array_test.cc.

                         {
  TestGrowableArray<GrowableArray<int>, GrowableArray<int64_t> >();
}

TEST_CASE() [266/600]

dart::TEST_CASE

(

GrowableArrayMoveAssign

)

Definition at line 126 of file growable_array_test.cc.

                                   {
  GrowableArray<int> a, b;
  a.Add(1);
  a.Add(2);
  a.Add(3);
  b.Add(7);
  int* a_data = a.data();
  int* b_data = b.data();
 
  a = std::move(b);
 
  EXPECT_EQ(1, a.length());
  EXPECT_EQ(b_data, a.data());
  EXPECT_EQ(3, b.length());
  EXPECT_EQ(a_data, b.data());
}

TEST_CASE() [267/600]

dart::TEST_CASE

(

GrowableArrayMoveCtor

)

Definition at line 112 of file growable_array_test.cc.

                                 {
  GrowableArray<int> a;
  a.Add(4);
  a.Add(5);
  int* a_data = a.data();
 
  GrowableArray<int> b(std::move(a));
 
  EXPECT_EQ(0, a.length());
  EXPECT_EQ((int*)nullptr, a.data());
  EXPECT_EQ(2, b.length());
  EXPECT_EQ(a_data, b.data());
}

TEST_CASE() [268/600]

dart::TEST_CASE

(

GrowableArraySort

)

Definition at line 86 of file growable_array_test.cc.

                             {
  GrowableArray<int> g;
  g.Add(12);
  g.Add(4);
  g.Add(64);
  g.Add(8);
  g.Sort(greatestFirst);
  EXPECT_EQ(64, g[0]);
  EXPECT_EQ(4, g.Last());
}

TEST_CASE() [269/600]

dart::TEST_CASE

(

GuardFieldConstructor2Test

)

Definition at line 245 of file guard_field_test.cc.

                                      {
  const char* script_chars =
      "import 'dart:typed_data';\n"
      "class A {\n"
      "  final f3;\n"
      "  A(x) : f3 = x;\n"
      "  foo() {\n"
      "  }\n"
      "  bar() {\n"
      "  }\n"
      "}\n"
      "\n"
      "runFoo() {\n"
      "  var l = new Float32List(5);\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    var a = new A(l);\n"
      "  }\n"
      "}\n"
      "\n"
      "runBar() {\n"
      "  var l = new Float32List(99);\n"
      "  var a = new A(l);\n"
      "}\n"
      "main() {\n"
      "  for (int i = 0; i < 100; i++) {\n"
      "    runFoo();\n"
      "    runBar();\n"
      "  }\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(script_chars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  TransitionNativeToVM transition(thread);
  Field& f3 = Field::ZoneHandle(LookupField(lib, "A", "f3"));
  const intptr_t no_length = Field::kNoFixedLength;
  EXPECT_EQ(no_length, f3.guarded_list_length());
  EXPECT_EQ(kTypedDataFloat32ArrayCid, f3.guarded_cid());
  EXPECT_EQ(false, f3.is_nullable());
}

TEST_CASE() [270/600]

dart::TEST_CASE

(

GuardFieldConstructorTest

)

Definition at line 187 of file guard_field_test.cc.

                                     {
  const char* script_chars =
      "import 'dart:typed_data';\n"
      "class A {\n"
      "  var f1 = 3.0;\n"
      "  dynamic f2 = 3;\n"
      "  final f3;\n"
      "  A(x) : f3 = x;\n"
      "  foo() {\n"
      "    f1 = f1 + f1;\n"
      "  }\n"
      "  bar() {\n"
      "    f2 = null;\n"
      "    f2 = 3.0;\n"
      "  }\n"
      "}\n"
      "\n"
      "runFoo() {\n"
      "  var l = new Float32List(5);\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    var a = new A(l);\n"
      "    a.foo();\n"
      "  }\n"
      "}\n"
      "\n"
      "runBar() {\n"
      "  var l = new Float32List(5);\n"
      "  var a = new A(l);\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    a.bar();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  for (int i = 0; i < 100; i++) {\n"
      "    runFoo();\n"
      "    runBar();\n"
      "  }\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(script_chars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  TransitionNativeToVM transition(thread);
  Field& f1 = Field::ZoneHandle(LookupField(lib, "A", "f1"));
  Field& f2 = Field::ZoneHandle(LookupField(lib, "A", "f2"));
  Field& f3 = Field::ZoneHandle(LookupField(lib, "A", "f3"));
  const intptr_t no_length = Field::kNoFixedLength;
  EXPECT_EQ(no_length, f1.guarded_list_length());
  EXPECT_EQ(kDoubleCid, f1.guarded_cid());
  EXPECT_EQ(false, f1.is_nullable());
  EXPECT_EQ(no_length, f2.guarded_list_length());
  EXPECT_EQ(kDynamicCid, f2.guarded_cid());
  EXPECT_EQ(true, f2.is_nullable());
  const intptr_t length = 5;
  EXPECT_EQ(length, f3.guarded_list_length());
  EXPECT_EQ(kTypedDataFloat32ArrayCid, f3.guarded_cid());
  EXPECT_EQ(false, f3.is_nullable());
}

TEST_CASE() [271/600]

dart::TEST_CASE

(

GuardFieldFinalListTest

)

Definition at line 81 of file guard_field_test.cc.

                                   {
  const char* script_chars =
      "class A {\n"
      "  var f1 = 3.0;\n"
      "  dynamic f2 = 3;\n"
      "  final f3 = List<dynamic>.filled(4, null);\n"
      "  foo() {\n"
      "    f1 = f1 + f1;\n"
      "  }\n"
      "  bar() {\n"
      "    f2 = null;\n"
      "    f2 = 3.0;\n"
      "  }\n"
      "}\n"
      "\n"
      "runFoo() {\n"
      "  var a = A();\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    a.foo();\n"
      "  }\n"
      "}\n"
      "\n"
      "runBar() {\n"
      "  var a = A();\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    a.bar();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  for (int i = 0; i < 100; i++) {\n"
      "    runFoo();\n"
      "    runBar();\n"
      "  }\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(script_chars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  TransitionNativeToVM transition(thread);
  Field& f1 = Field::ZoneHandle(LookupField(lib, "A", "f1"));
  Field& f2 = Field::ZoneHandle(LookupField(lib, "A", "f2"));
  Field& f3 = Field::ZoneHandle(LookupField(lib, "A", "f3"));
  const intptr_t no_length = Field::kNoFixedLength;
  EXPECT_EQ(no_length, f1.guarded_list_length());
  EXPECT_EQ(kDoubleCid, f1.guarded_cid());
  EXPECT_EQ(false, f1.is_nullable());
  EXPECT_EQ(no_length, f2.guarded_list_length());
  EXPECT_EQ(kDynamicCid, f2.guarded_cid());
  EXPECT_EQ(true, f2.is_nullable());
  EXPECT_EQ(4, f3.guarded_list_length());
  EXPECT_EQ(kArrayCid, f3.guarded_cid());
  EXPECT_EQ(false, f3.is_nullable());
}

TEST_CASE() [272/600]

dart::TEST_CASE

(

GuardFieldFinalVariableLengthListTest

)

Definition at line 134 of file guard_field_test.cc.

                                                 {
  const char* script_chars =
      "class A {\n"
      "  var f1 = 3.0;\n"
      "  dynamic f2 = 3;\n"
      "  final f3 = List.empty(growable: true);\n"
      "  foo() {\n"
      "    f1 = f1 + f1;\n"
      "  }\n"
      "  bar() {\n"
      "    f2 = null;\n"
      "    f2 = 3.0;\n"
      "  }\n"
      "}\n"
      "\n"
      "runFoo() {\n"
      "  var a = A();\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    a.foo();\n"
      "  }\n"
      "}\n"
      "\n"
      "runBar() {\n"
      "  var a = A();\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    a.bar();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  for (int i = 0; i < 100; i++) {\n"
      "    runFoo();\n"
      "    runBar();\n"
      "  }\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(script_chars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  TransitionNativeToVM transition(thread);
  Field& f1 = Field::ZoneHandle(LookupField(lib, "A", "f1"));
  Field& f2 = Field::ZoneHandle(LookupField(lib, "A", "f2"));
  Field& f3 = Field::ZoneHandle(LookupField(lib, "A", "f3"));
  const intptr_t no_length = Field::kNoFixedLength;
  EXPECT_EQ(no_length, f1.guarded_list_length());
  EXPECT_EQ(kDoubleCid, f1.guarded_cid());
  EXPECT_EQ(false, f1.is_nullable());
  EXPECT_EQ(no_length, f2.guarded_list_length());
  EXPECT_EQ(kDynamicCid, f2.guarded_cid());
  EXPECT_EQ(true, f2.is_nullable());
  EXPECT_EQ(no_length, f3.guarded_list_length());
  EXPECT_EQ(kGrowableObjectArrayCid, f3.guarded_cid());
  EXPECT_EQ(false, f3.is_nullable());
}

TEST_CASE() [273/600]

dart::TEST_CASE

(

GuardFieldSimpleTest

)

Definition at line 30 of file guard_field_test.cc.

                                {
  const char* script_chars =
      "class A {\n"
      "  var f1 = 3.0;\n"
      "  dynamic f2 = 3;\n"
      "  var f3 = List<dynamic>.filled(4, null);\n"
      "  foo() {\n"
      "    f1 = f1 + f1;\n"
      "  }\n"
      "  bar() {\n"
      "    f2 = null;\n"
      "    f2 = 3.0;\n"
      "  }\n"
      "}\n"
      "\n"
      "runFoo() {\n"
      "  var a = A();\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    a.foo();\n"
      "  }\n"
      "}\n"
      "\n"
      "runBar() {\n"
      "  var a = A();\n"
      "  for (int i = 0; i < 2000; i++) {\n"
      "    a.bar();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  for (int i = 0; i < 100; i++) {\n"
      "    runFoo();\n"
      "    runBar();\n"
      "  }\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(script_chars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  TransitionNativeToVM transition(thread);
  Field& f1 = Field::ZoneHandle(LookupField(lib, "A", "f1"));
  Field& f2 = Field::ZoneHandle(LookupField(lib, "A", "f2"));
  Field& f3 = Field::ZoneHandle(LookupField(lib, "A", "f3"));
  const intptr_t no_length = Field::kNoFixedLength;
  EXPECT_EQ(no_length, f1.guarded_list_length());
  EXPECT_EQ(kDoubleCid, f1.guarded_cid());
  EXPECT_EQ(false, f1.is_nullable());
  EXPECT_EQ(no_length, f2.guarded_list_length());
  EXPECT_EQ(kDynamicCid, f2.guarded_cid());
  EXPECT_EQ(true, f2.is_nullable());
  EXPECT_EQ(no_length, f3.guarded_list_length());
}

TEST_CASE() [274/600]

dart::TEST_CASE

(

HashCode

)

Definition at line 6423 of file object_test.cc.

                    {
  // Ensure C++ overrides of Instance::HashCode match the Dart implementations.
  const char* kScript =
      "foo() {\n"
      "  return \"foo\".hashCode;\n"
      "}";
 
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);

TEST_CASE() [275/600]

dart::TEST_CASE

(

HashCode_Double

)

Definition at line 6528 of file object_test.cc.

                           {
  const char* kScript =
      "value() {\n"
      "  return 1.0;\n"
      "}\n";

TEST_CASE() [276/600]

dart::TEST_CASE

(

HashCode_Mint

)

Definition at line 6545 of file object_test.cc.

  {
    TransitionNativeToVM transition(thread);
    kInt1HashCode = Integer::Handle(Integer::New(1)).CanonicalizeHash();

TEST_CASE() [277/600]

dart::TEST_CASE

(

HashCode_Null

)

Definition at line 6553 of file object_test.cc.

                         {
  const char* kScript =
      "value() {\n"
      "  return 0x8000000;\n"

TEST_CASE() [278/600]

dart::TEST_CASE

(

HashCode_Smi

)

Definition at line 6561 of file object_test.cc.

                         {
  const char* kScript =
      "value() {\n"
      "  return null;\n"

TEST_CASE() [279/600]

dart::TEST_CASE

(

HashCode_String

)

Definition at line 6569 of file object_test.cc.

                        {
  const char* kScript =
      "value() {\n"
      "  return 123;\n"

TEST_CASE() [280/600]

dart::TEST_CASE

(

HashCode_Symbol

)

Definition at line 6577 of file object_test.cc.

                           {
  const char* kScript =
      "value() {\n"
      "  return 'asdf';\n"
      "}\n";

TEST_CASE() [281/600]

dart::TEST_CASE

(

HashCode_True

)

Definition at line 6586 of file object_test.cc.

                           {
  const char* kScript =
      "value() {\n"
      "  return #A;\n"
      "}\n";

TEST_CASE() [282/600]

dart::TEST_CASE

(

HashCode_Type_Dynamic

)

Definition at line 6594 of file object_test.cc.

                         {
  const char* kScript =
      "value() {\n"
      "  return true;\n"
      "}\n";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript));
}

TEST_CASE() [283/600]

dart::TEST_CASE

(

HashCode_Type_Int

)

Definition at line 6605 of file object_test.cc.

                                 {
  const char* kScript =
      "const type = dynamic;\n"
      "\n"
      "value() {\n"
      "  return type;\n"
      "}\n";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript, kCalculateCanonicalizeHash,
                                        /*check_identity=*/false));
}

TEST_CASE() [284/600]

dart::TEST_CASE

(

ImplementorCid

)

Definition at line 5181 of file object_test.cc.

                          {
  const char* kScriptChars = R"(
abstract class AInterface {}
 
abstract class BInterface {}
class BImplementation implements BInterface {}
 
abstract class CInterface {}
class CImplementation1 implements CInterface {}
class CImplementation2 implements CInterface {}
 
abstract class DInterface {}
abstract class DSubinterface implements DInterface {}
 
abstract class EInterface {}
abstract class ESubinterface implements EInterface {}
class EImplementation implements ESubinterface {}
 
abstract class FInterface {}
abstract class FSubinterface implements FInterface {}
class FImplementation1 implements FSubinterface {}
class FImplementation2 implements FSubinterface {}
 
main() {
  new BImplementation();
  new CImplementation1();
  new CImplementation2();
  new EImplementation();
  new FImplementation1();
  new FImplementation2();
}
)";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
 
  TransitionNativeToVM transition(thread);
  const Library& lib =
      Library::CheckedHandle(thread->zone(), Api::UnwrapHandle(h_lib));
  EXPECT(!lib.IsNull());
 
  const Class& AInterface = Class::Handle(GetClass(lib, "AInterface"));
  EXPECT_EQ(AInterface.implementor_cid(), kIllegalCid);
 
  const Class& BInterface = Class::Handle(GetClass(lib, "BInterface"));
  const Class& BImplementation =
      Class::Handle(GetClass(lib, "BImplementation"));
  EXPECT_EQ(BInterface.implementor_cid(), BImplementation.id());
  EXPECT_EQ(BImplementation.implementor_cid(), BImplementation.id());
 
  const Class& CInterface = Class::Handle(GetClass(lib, "CInterface"));
  const Class& CImplementation1 =
      Class::Handle(GetClass(lib, "CImplementation1"));
  const Class& CImplementation2 =
      Class::Handle(GetClass(lib, "CImplementation2"));
  EXPECT_EQ(CInterface.implementor_cid(), kDynamicCid);
  EXPECT_EQ(CImplementation1.implementor_cid(), CImplementation1.id());
  EXPECT_EQ(CImplementation2.implementor_cid(), CImplementation2.id());
 
  const Class& DInterface = Class::Handle(GetClass(lib, "DInterface"));
  const Class& DSubinterface = Class::Handle(GetClass(lib, "DSubinterface"));
  EXPECT_EQ(DInterface.implementor_cid(), kIllegalCid);
  EXPECT_EQ(DSubinterface.implementor_cid(), kIllegalCid);
 
  const Class& EInterface = Class::Handle(GetClass(lib, "EInterface"));
  const Class& ESubinterface = Class::Handle(GetClass(lib, "ESubinterface"));
  const Class& EImplementation =
      Class::Handle(GetClass(lib, "EImplementation"));
  EXPECT_EQ(EInterface.implementor_cid(), EImplementation.id());
  EXPECT_EQ(ESubinterface.implementor_cid(), EImplementation.id());
  EXPECT_EQ(EImplementation.implementor_cid(), EImplementation.id());
 
  const Class& FInterface = Class::Handle(GetClass(lib, "FInterface"));
  const Class& FSubinterface = Class::Handle(GetClass(lib, "FSubinterface"));
  const Class& FImplementation1 =
      Class::Handle(GetClass(lib, "FImplementation1"));
  const Class& FImplementation2 =
      Class::Handle(GetClass(lib, "FImplementation2"));
  EXPECT_EQ(FInterface.implementor_cid(), kDynamicCid);
  EXPECT_EQ(FSubinterface.implementor_cid(), kDynamicCid);
  EXPECT_EQ(FImplementation1.implementor_cid(), FImplementation1.id());
  EXPECT_EQ(FImplementation2.implementor_cid(), FImplementation2.id());
}

TEST_CASE() [285/600]

dart::TEST_CASE

(

Inliner_InlineAndRunForceOptimized

)

Definition at line 548 of file inliner_test.cc.

                                              {
  auto check_handle = [](Dart_Handle handle) {
    if (Dart_IsError(handle)) {
      OS::PrintErr("Encountered unexpected error: %s\n", Dart_GetError(handle));
      FATAL("Aborting");
    }
    return handle;
  };
 
  auto get_integer = [&](Dart_Handle lib, const char* name) {
    Dart_Handle handle = Dart_GetField(lib, check_handle(NewString(name)));
    check_handle(handle);
 
    int64_t value = 0;
    handle = Dart_IntegerToInt64(handle, &value);
    check_handle(handle);
    OS::Print("Field '%s': %" Pd64 "\n", name, value);
    return value;
  };
 
  const char* kScriptChars = R"(
import 'dart:ffi';
import 'dart:_internal';
 
int _add(int a, int b) => a + b;
 
@pragma('vm:external-name', "testPrint")
external void print(String s);
 
@pragma("vm:external-name", "InspectStack")
external InspectStack();
 
@pragma('vm:never-inline')
void nop() {}
 
int prologueCount = 0;
int epilogueCount = 0;
 
@pragma('vm:never-inline')
void countPrologue() {
  prologueCount++;
  print('countPrologue: $prologueCount');
}
 
@pragma('vm:never-inline')
void countEpilogue() {
  epilogueCount++;
  print('countEpilogue: $epilogueCount');
}
 
@pragma('vm:force-optimize')
@pragma('vm:idempotent')
@pragma('vm:prefer-inline')
int idempotentForceOptimizedFunction(int x) {
  countPrologue();
  print('deoptimizing');
 
  InspectStack();
  VMInternalsForTesting.deoptimizeFunctionsOnStack();
  InspectStack();
  print('deoptimizing after');
  countEpilogue();
  return _add(x, 1);
}
 
@pragma('vm:never-inline')
int foo(int x, {bool onlyOptimizeFunction = false}) {
  if (onlyOptimizeFunction) {
    print('Optimizing `foo`');
    for (int i = 0; i < 100000; i++) nop();
  }
  print('Running `foo`');
  return x + idempotentForceOptimizedFunction(x+1) + 1;
}
 
void main() {
  for (int i = 0; i < 100; i++) {
    print('\n\nround=$i');
 
    // Get the `foo` function optimized while leaving prologue/epilogue counters
    // untouched.
    final (a, b) = (prologueCount, epilogueCount);
    foo(i, onlyOptimizeFunction: true);
    prologueCount = a;
    epilogueCount = b;
 
    // Execute the optimized function `foo` function (which has the
    // `idempotentForceOptimizedFunction` inlined).
    final result = foo(i);
    if (result != (2 * i + 3)) throw 'Expected ${2 * i + 3} but got $result!';
  }
}
    )";
  DisableBackgroundCompilationScope scope;
 
  Dart_Handle lib =
      check_handle(TestCase::LoadTestScript(kScriptChars, nullptr));
  Dart_SetNativeResolver(lib, &PrintAndInspectResolver, nullptr);
 
  // We disable OSR to ensure we control when the function gets optimized,
  // namely afer a call to `foo(..., onlyOptimizeFunction:true)` it will be
  // optimized and during a call to `foo(...)` it will get deoptimized.
  IsolateGroup::Current()->set_use_osr(false);
 
  // Run the test.
  check_handle(Dart_Invoke(lib, NewString("main"), 0, nullptr));
 
  // Examine the result.
  const int64_t prologue_count = get_integer(lib, "prologueCount");
  const int64_t epilogue_count = get_integer(lib, "epilogueCount");
 
  // We always call the "foo" function when its optimized (and it's optimized
  // code has the call to `idempotentForceOptimizedFunction` inlined).
  //
  // The `idempotentForceOptimizedFunction` will always execute prologue,
  // lazy-deoptimize the `foo` frame, that will make the `foo` re-try the call
  // to `idempotentForceOptimizedFunction`.
  // = > We should see the prologue of the force-optimized function to be
  // executed twice as many times as epilogue.
  EXPECT_EQ(epilogue_count * 2, prologue_count);
}

TEST_CASE() [286/600]

dart::TEST_CASE

(

InstanceEquality

)

Definition at line 6394 of file object_test.cc.

         {\"type\":\"Sentinel\","
        "\"kind\":\"BeingInitialized\","
        "\"valueAsString\":\"<being initialized>\"}",
        js.ToCString());
  }
}
 
#endif  // !PRODUCT
 
TEST_CASE(InstanceEquality) {
  // Test that Instance::OperatorEquals can call a user-defined operator==.
  const char* kScript =
      "class A {\n"
      "  bool operator==(covariant A other) { return true; }\n"
      "}\n"
      "main() {\n"
      "  A a = new A();\n"
      "}";
 
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
 
  TransitionNativeToVM transition(thread);
  Library& lib = Library::Handle();

TEST_CASE() [287/600]

dart::TEST_CASE

(

Int8ListLengthMaxElements

)

Definition at line 1971 of file object_test.cc.

                                     {
  const intptr_t max_elements = TypedData::MaxElements(kTypedDataInt8ArrayCid);
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "import 'dart:typed_data';\n"
                 "main() {\n"
                 "  return new Int8List(%" Pd
                 ");\n"
                 "}\n",
                 max_elements);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  if (Dart_IsError(result)) {
    EXPECT_ERROR(result, "Out of Memory");
  } else {
    intptr_t actual = 0;
    EXPECT_VALID(Dart_ListLength(result, &actual));
    EXPECT_EQ(max_elements, actual);
  }
}

TEST_CASE() [288/600]

dart::TEST_CASE

(

Int8ListLengthNegativeOne

)

Definition at line 1946 of file object_test.cc.

                                     {
  TestIllegalTypedDataLength("Int8List", -1);
}

TEST_CASE() [289/600]

dart::TEST_CASE

(

Int8ListLengthOneTooMany

)

Definition at line 1952 of file object_test.cc.

                                    {
  const intptr_t kOneTooMany =
      TypedData::MaxElements(kTypedDataInt8ArrayCid) + 1;
  ASSERT(kOneTooMany >= 0);
 
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "import 'dart:typed_data';\n"
                 "main() {\n"
                 "  return new Int8List(%" Pd
                 ");\n"
                 "}\n",
                 kOneTooMany);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_ERROR(result, "Out of Memory");
}

TEST_CASE() [290/600]

dart::TEST_CASE

(

Int8ListLengthSmiMin

)

Definition at line 1949 of file object_test.cc.

                                {
  TestIllegalTypedDataLength("Int8List", kSmiMin);
}

TEST_CASE() [291/600]

dart::TEST_CASE

(

IsIsolateUnsendable

)

Definition at line 5145 of file object_test.cc.

                               {
  Zone* const zone = Thread::Current()->zone();
 
  const char* kScript = R"(
import 'dart:ffi';
 
class AImpl implements A {}
class ASub extends A {}
// Wonky class order and non-alphabetic naming on purpose.
class C extends Z {}
class E extends D {}
class A implements Finalizable {}
class Z implements A {}
class D implements C {}
class X extends E {}
)";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
 
  TransitionNativeToVM transition(thread);
  const Library& lib = Library::CheckedHandle(zone, Api::UnwrapHandle(h_lib));
  EXPECT(!lib.IsNull());
 
  const auto& class_x = Class::Handle(zone, GetClass(lib, "X"));
  class_x.EnsureIsFinalized(thread);
  EXPECT(class_x.is_isolate_unsendable());
 
  const auto& class_a_impl = Class::Handle(zone, GetClass(lib, "AImpl"));
  class_a_impl.EnsureIsFinalized(thread);
  EXPECT(class_a_impl.is_isolate_unsendable());
 
  const auto& class_a_sub = Class::Handle(zone, GetClass(lib, "ASub"));
  class_a_sub.EnsureIsFinalized(thread);
  EXPECT(class_a_sub.is_isolate_unsendable());
}

TEST_CASE() [292/600]

dart::TEST_CASE

(

IsKernelNegative

)

Definition at line 2042 of file snapshot_test.cc.

                            {
  EXPECT(!Dart_IsKernel(nullptr, 0));
 
  uint8_t buffer[4] = {0, 0, 0, 0};
  EXPECT(!Dart_IsKernel(buffer, ARRAY_SIZE(buffer)));
}

TEST_CASE() [293/600]

dart::TEST_CASE

(

IsolateReload_AddNewStaticField

)

Definition at line 5341 of file isolate_reload_test.cc.

                                              {\n"
                                "  T%s x;\n"
                                "}\n"
                                "%s Foo value1;\n"
                                "%s Foo value2;\n"
                                "main() {\n"
                                "  value1 = Foo<String>();\n"
                                "  value2 = Foo<int>();\n"
                                "  return 'Okay';\n"
                                "}\n",
                                nullable_tag, late_tag, late_tag),
                              std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main"));
 
  // clang-format off
  auto kReloadScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "class Foo<T> {\n"

TEST_CASE() [294/600]

dart::TEST_CASE

(

IsolateReload_BadClass

)

Definition at line 364 of file isolate_reload_test.cc.

                                  {
  const char* kScript =
      "class Foo {\n"
      "  final a;\n"
      "  Foo(this.a);\n"
      "}\n"
      "main() {\n"
      "  new Foo(5);\n"
      "  return 4;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "var _unused;"
      "class Foo {\n"
      "  final a kjsdf ksjdf ;\n"
      "  Foo(this.a);\n"
      "}\n"
      "main() {\n"
      "  new Foo(5);\n"
      "  return 10;\n"
      "}\n";
 
  Dart_Handle result = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(result, "Expected ';' after this");
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
}

TEST_CASE() [295/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassFactoryConstructor

)

Definition at line 3082 of file isolate_reload_test.cc.

                                                             {
  const char* kScript =
      "class C { factory C.deleted() => new C(); C(); }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted().toString();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of \'C\'", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {}\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [296/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassFactoryConstructorArityChange

)

Definition at line 3113 of file isolate_reload_test.cc.

                                                                        {
  const char* kScript =
      "class C { factory C.deleted() => new C(); C(); }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted().toString();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of \'C\'", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C { factory C.deleted(newParameter) => new C(); C(); }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [297/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassFactoryConstructorClassDeleted

)

Definition at line 3144 of file isolate_reload_test.cc.

                                                                         {
  const char* kScript =
      "class C { factory C.deleted() => new C(); C(); }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted().toString();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of \'C\'", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [298/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassFunction

)

Definition at line 2806 of file isolate_reload_test.cc.

                                                   {
  const char* kScript =
      "class C { static deleted() { return 'hello'; } }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [299/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassFunctionArityChange

)

Definition at line 2836 of file isolate_reload_test.cc.

                                                              {
  const char* kScript =
      "class C { static deleted() { return 'hello'; } }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C { static deleted(newParameter) { return 'hello'; } }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [300/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassFunctionEvaluationOrder

)

Definition at line 2867 of file isolate_reload_test.cc.

                                                                  {
  const char* kScript =
      "first(flag) { if (flag) throw 'first!'; }\n"
      "class C { static deleted(_) { return 'hello'; } }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = (bool flag) => C.deleted(first(flag));\n"
      "  return retained(false);\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "first(flag) { if (flag) throw 'first!'; }\n"
      "class C { }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained(true);\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_STREQ("first!", result);  // Not NoSuchMethodError
}

TEST_CASE() [301/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassGenerativeConstructor

)

Definition at line 2990 of file isolate_reload_test.cc.

                                                                {
  const char* kScript =
      "class C { C.deleted(); }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted().toString();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of \'C\'", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {}\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [302/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassGenerativeConstructorArityChange

)

Definition at line 3021 of file isolate_reload_test.cc.

                                                                           {
  const char* kScript =
      "class C { C.deleted(); }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted().toString();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of \'C\'", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C { C.deleted(newParameter); }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [303/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassGenerativeConstructorClassDeleted

)

Definition at line 3052 of file isolate_reload_test.cc.

                                                                            {
  const char* kScript =
      "class C { C.deleted(); }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted().toString();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of \'C\'", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [304/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassGetter

)

Definition at line 2899 of file isolate_reload_test.cc.

                                                 {
  const char* kScript =
      "class C { static get deleted { return 'hello'; } }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted;\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [305/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassSetter

)

Definition at line 2929 of file isolate_reload_test.cc.

                                                 {
  const char* kScript =
      "class C { static set deleted(x) {}}\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => C.deleted = 'hello';\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [306/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_ClassSetterEvaluationOrder

)

Definition at line 2959 of file isolate_reload_test.cc.

                                                                {
  const char* kScript =
      "first(flag) { if (flag) throw 'first!'; return 'hello'; }\n"
      "class C { static set deleted(x) {}}\n"
      "var retained;\n"
      "main() {\n"
      "  retained = (bool flag) => C.deleted = first(flag);\n"
      "  return retained(false);\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "first(flag) { if (flag) throw 'first!'; return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained(true);\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_STREQ("first!", result);
}

TEST_CASE() [307/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_SuperFieldGetter

)

Definition at line 3306 of file isolate_reload_test.cc.

                                                      {
  const char* kScript =
      "class C { var deleted = 'hello'; }\n"
      "class D extends C { curry() => () => super.deleted; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = new D().curry();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {}\n"
      "class D extends C {}\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [308/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_SuperFieldSetter

)

Definition at line 3339 of file isolate_reload_test.cc.

                                                      {
  const char* kScript =
      "class C { var deleted; }\n"
      "class D extends C { curry() => () => super.deleted = 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = new D().curry();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {}\n"
      "class D extends C {}\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [309/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_SuperFunction

)

Definition at line 3174 of file isolate_reload_test.cc.

                                                   {
  const char* kScript =
      "class C { deleted() { return 'hello'; } }\n"
      "class D extends C { curry() => () => super.deleted(); }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = new D().curry();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {}\n"
      "class D extends C {}\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [310/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_SuperFunctionArityChange

)

Definition at line 3207 of file isolate_reload_test.cc.

                                                              {
  const char* kScript =
      "class C { deleted() { return 'hello'; } }\n"
      "class D extends C { curry() => () => super.deleted(); }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = new D().curry();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C { deleted(newParameter) { return 'hello'; } }\n"
      "class D extends C {}\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [311/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_SuperGetter

)

Definition at line 3240 of file isolate_reload_test.cc.

                                                 {
  const char* kScript =
      "class C { get deleted { return 'hello'; } }\n"
      "class D extends C { curry() => () => super.deleted; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = new D().curry();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {}\n"
      "class D extends C {}\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [312/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_SuperSetter

)

Definition at line 3273 of file isolate_reload_test.cc.

                                                 {
  const char* kScript =
      "class C { set deleted(x) {} }\n"
      "class D extends C { curry() => () => super.deleted = 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = new D().curry();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {}\n"
      "class D extends C {}\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [313/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelAddTypeArguments

)

Definition at line 2530 of file isolate_reload_test.cc.

                                                              {
  const char* kScript =
      "deleted() { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => deleted();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "deleted<A, B, C>() { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [314/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelFunction

)

Definition at line 2469 of file isolate_reload_test.cc.

                                                      {
  const char* kScript =
      "deleted() { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => deleted();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [315/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelFunctionArityChange

)

Definition at line 2499 of file isolate_reload_test.cc.

                                                                 {
  const char* kScript =
      "deleted() { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => deleted();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "deleted(newParameter) { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [316/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelFunctionEvaluationOrder

)

Definition at line 2620 of file isolate_reload_test.cc.

                                                                     {
  const char* kScript =
      "first(flag) { if (flag) throw 'first!'; }\n"
      "deleted(_) { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = (bool flag) => deleted(first(flag));\n"
      "  return retained(false);\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "first(flag) { if (flag) throw 'first!'; }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained(true);\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_STREQ("first!", result);  // Not NoSuchMethodError
}

TEST_CASE() [317/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelFunctionLibraryDeleted

)

Definition at line 2651 of file isolate_reload_test.cc.

                                                                    {
  // clang-format off
  Dart_SourceFile sourcefiles[] = {
    {
      "file:///test-app.dart",
 
      "import 'test-lib.dart';\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => deleted();\n"
      "  return retained();\n"
      "}\n",
    },
    {
      "file:///test-lib.dart",
 
      "deleted() { return 'hello'; }\n",
    },
  };
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      NULL /* resolver */, true /* finalize */, true /* incrementally */);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  // clang-format off
  Dart_SourceFile updated_sourcefiles[] = {
    {
      "file:///test-app.dart",
 
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n",
    },
  };
  // clang-format on
 
  const uint8_t* kernel_buffer = NULL;
  intptr_t kernel_buffer_size = 0;
  char* error = TestCase::CompileTestScriptWithDFE(
      "file:///test-app.dart",
      sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
      updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
      true /* incrementally */);
  EXPECT(error == NULL);
  EXPECT_NOTNULL(kernel_buffer);
  lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  // What actually happens because we don't re-search imported libraries.
  EXPECT_STREQ(result, "hello");
 
  // What should happen and what did happen with the old VM frontend:
  // EXPECT_SUBSTRING("NoSuchMethodError", result);
  // EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [318/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelGetter

)

Definition at line 2715 of file isolate_reload_test.cc.

                                                    {
  const char* kScript =
      "get deleted { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => deleted;\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [319/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelMissingPassingTypeArguments

)

Definition at line 2590 of file isolate_reload_test.cc.

                                                                         {
  const char* kScript =
      "deleted<A, B, C>() { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => deleted<int, int, int>();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [320/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelRemoveTypeArguments

)

Definition at line 2559 of file isolate_reload_test.cc.

                                                                 {
  const char* kScript =
      "deleted<A, B, C>() { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => deleted<int, int, int>();\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "deleted() { return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [321/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelSetter

)

Definition at line 2745 of file isolate_reload_test.cc.

                                                    {
  const char* kScript =
      "set deleted(x) {}\n"
      "var retained;\n"
      "main() {\n"
      "  retained = () => deleted = 'hello';\n"
      "  return retained();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained();\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_SUBSTRING("NoSuchMethodError", result);
  EXPECT_SUBSTRING("deleted", result);
}

TEST_CASE() [322/600]

dart::TEST_CASE

(

IsolateReload_CallDeleted_TopLevelSetterEvaluationOrder

)

Definition at line 2775 of file isolate_reload_test.cc.

                                                                   {
  const char* kScript =
      "first(flag) { if (flag) throw 'first!'; return 'hello'; }\n"
      "set deleted(x) {}\n"
      "var retained;\n"
      "main() {\n"
      "  retained = (bool flag) => deleted = first(flag);\n"
      "  return retained(false);\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "first(flag) { if (flag) throw 'first!'; return 'hello'; }\n"
      "var retained;\n"
      "main() {\n"
      "  try {\n"
      "    return retained(true);\n"
      "  } catch (e) {\n"
      "    return e.toString();\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_STREQ("first!", result);  // Not NoSuchMethodError
}

TEST_CASE() [323/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat0

)

Definition at line 3632 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Foo {\n"
      "  var a;\n"
      "  var b;\n"
      "  var c;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  f = new Foo();\n"
      "  f.c = 42;\n"
      "  return f.c;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(42, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo {\n"
      "  var c;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  return f.c;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(42, SimpleInvoke(lib, "main"));
}

TEST_CASE() [324/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat1

)

Definition at line 3667 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Foo {\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  f = new Foo();\n"
      "  return 42;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(42, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo {\n"
      "  var c;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  return (f.c == null) ? 42: 21;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(42, SimpleInvoke(lib, "main"));
}

TEST_CASE() [325/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat2

)

Definition at line 3698 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Foo {\n"
      "  var c;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  f = new Foo();\n"
      "  f.c = 42;\n"
      "  return f.c;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(42, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo {\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  try {\n"
      "    return f.c;\n"
      "  } catch (e) {\n"
      "    return 24;\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(24, SimpleInvoke(lib, "main"));
}

TEST_CASE() [326/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat3

)

Definition at line 3734 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Foo<A,B> {\n"
      "  var a;\n"
      "  var b;\n"
      "  var c;\n"
      "  var d;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  f = new Foo();\n"
      "  f.a = 1;\n"
      "  f.b = 2;\n"
      "  f.c = 3;\n"
      "  f.d = 4;\n"
      "  return f.c;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(3, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo<A,B> {\n"
      "  var c;\n"
      "  var g;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  return f.c;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(3, SimpleInvoke(lib, "main"));
}

TEST_CASE() [327/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat4

)

Definition at line 3774 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Bar{\n"
      "  var c;\n"
      "}\n"
      "class Foo extends Bar{\n"
      "  var d;\n"
      "  var e;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  f = new Foo();\n"
      "  f.c = 44;\n"
      "  return f.c;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo {\n"
      "  var c;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  return f.c;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
}

TEST_CASE() [328/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat5

)

Definition at line 3811 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Bar{\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      "class Foo extends Bar{\n"
      "  var c;\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  f = new Foo();\n"
      "  f.c = 44;\n"
      "  return f.c;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Bar{\n"
      "  var c;\n"
      "}\n"
      "class Foo extends Bar {\n"
      "}\n"
      "var f;\n"
      "main() {\n"
      "  return f.c;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
}

TEST_CASE() [329/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat6

)

Definition at line 3850 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Foo<A, B> {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n"
      "main() {\n"
      "  new Foo();\n"
      "  return 43;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(43, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo<A> {\n"
      "  var a;\n"
      "}\n";
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib, "type parameters have changed");
}

TEST_CASE() [330/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat7

)

Definition at line 3877 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Foo<A, B> {\n"
      "  var a;\n"
      "  var b;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "class Foo<A> {\n"
      "  var a;\n"
      "}\n";
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
}

TEST_CASE() [331/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat8

)

Definition at line 3897 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class A{\n"
      "  var x;\n"
      "}\n"
      "class B {\n"
      "  var x, y, z, w;\n"
      "}\n"
      "var a, b;\n"
      "main() {\n"
      "  a = new A();\n"
      "  b = new B();\n"
      "  return '$a $b';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of 'A' Instance of 'B'", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class A{\n"
      "  var x, y;\n"
      "}\n"
      "class B {\n"
      "  var x, y, z, w, v;\n"
      "}\n"
      "var a, b;\n"
      "main() {\n"
      "  return '$a $b';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of 'A' Instance of 'B'", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [332/600]

dart::TEST_CASE

(

IsolateReload_ChangeInstanceFormat9

)

Definition at line 3936 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "class Foo<A> {\n"
      "  var a;\n"
      "}\n"
      "class Bar<B, C> extends Foo<B> {}\n"
      "class Baz extends Foo<String> {}"
      "main() {\n"
      "  new Baz();\n"
      "  return 43;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(43, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo<A> {\n"
      "  var a;\n"
      "}\n"
      "class Bar<B, C> extends Foo<B> {}\n"
      "class Baz extends Bar<String, double> {}"
      "main() {\n"
      "  new Baz();\n"
      "  return 43;\n"
      "}\n";
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib, "type parameters have changed");
}

TEST_CASE() [333/600]

dart::TEST_CASE

(

IsolateReload_ClassAdded

)

Definition at line 568 of file isolate_reload_test.cc.

                                    {
  const char* kScript =
      "main() {\n"
      "  return 'hello';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var _unused;"
      "class A {\n"
      "  toString() => 'hello from A';\n"
      "}\n"
      "main() {\n"
      "  return new A().toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello from A", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [334/600]

dart::TEST_CASE

(

IsolateReload_ClassFieldAdded

)

Definition at line 479 of file isolate_reload_test.cc.

                                         {
  const char* kScript =
      "class Foo {\n"
      "  var x;\n"
      "}\n"
      "main() {\n"
      "  new Foo();\n"
      "  return 44;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo {\n"
      "  var x;\n"
      "  var y;\n"
      "}\n"
      "main() {\n"
      "  new Foo();\n"
      "  return 44;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
}

TEST_CASE() [335/600]

dart::TEST_CASE

(

IsolateReload_ClassFieldAdded2

)

Definition at line 508 of file isolate_reload_test.cc.

                                          {
  const char* kScript =
      "class Foo {\n"
      "  var x;\n"
      "  var y;\n"
      "}\n"
      "main() {\n"
      "  new Foo();\n"
      "  return 44;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo {\n"
      "  var x;\n"
      "  var y;\n"
      "  var z;\n"
      "}\n"
      "main() {\n"
      "  new Foo();\n"
      "  return 44;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
}

TEST_CASE() [336/600]

dart::TEST_CASE

(

IsolateReload_ClassFieldRemoved

)

Definition at line 539 of file isolate_reload_test.cc.

                                           {
  const char* kScript =
      "class Foo {\n"
      "  var x;\n"
      "  var y;\n"
      "}\n"
      "main() {\n"
      "  new Foo();\n"
      "  return 44;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "class Foo {\n"
      "  var x;\n"
      "}\n"
      "main() {\n"
      "  new Foo();\n"
      "  return 44;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(44, SimpleInvoke(lib, "main"));
}

TEST_CASE() [337/600]

dart::TEST_CASE

(

IsolateReload_ClassRemoved

)

Definition at line 592 of file isolate_reload_test.cc.

                                      {
  const char* kScript =
      "class A {\n"
      "  toString() => 'hello from A';\n"
      "}\n"
      "List<dynamic> list = <dynamic>[];"
      "main() {\n"
      "  list.add(new A());\n"
      "  return list[0].toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello from A", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "List<dynamic> list = <dynamic>[];\n"
      "main() {\n"
      "  return list[0].toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("hello from A", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [338/600]

dart::TEST_CASE

(

IsolateReload_ComplexInheritanceChange

)

Definition at line 973 of file isolate_reload_test.cc.

                                                  {
  const char* kScript =
      "class A {\n"
      "  String name;\n"
      "  A(this.name);\n"
      "}\n"
      "class B extends A {\n"
      "  B(name) : super(name);\n"
      "}\n"
      "class C extends B {\n"
      "  C(name) : super(name);\n"
      "}\n"
      "var list = <dynamic>[ new A('a'), new B('b'), new C('c') ];\n"
      "main() {\n"
      "  return (list.map((x) {\n"
      "    return '${x.name} is A(${x is A})/ B(${x is B})/ C(${x is C})';\n"
      "  })).toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      "(a is A(true)/ B(false)/ C(false),"
      " b is A(true)/ B(true)/ C(false),"
      " c is A(true)/ B(true)/ C(true))",
      SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {\n"
      "  String name;\n"
      "  C(this.name);\n"
      "}\n"
      "class X extends C {\n"
      "  X(name) : super(name);\n"
      "}\n"
      "class A extends X {\n"
      "  A(name) : super(name);\n"
      "}\n"
      "var list;\n"
      "main() {\n"
      "  list.add(new X('x'));\n"
      "  return (list.map((x) {\n"
      "    return '${x.name} is A(${x is A})/ C(${x is C})/ X(${x is X})';\n"
      "  })).toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      "(a is A(true)/ C(true)/ X(true),"
      " b is A(true)/ C(true)/ X(true),"  // still extends A...
      " c is A(false)/ C(true)/ X(false),"
      " x is A(false)/ C(true)/ X(true))",
      SimpleInvokeStr(lib, "main"));
 
  // Revive the class B and make sure all allocated instances take
  // their place in the inheritance hierarchy.
  const char* kReloadScript2 =
      "class X {\n"
      "  String name;\n"
      "  X(this.name);\n"
      "}\n"
      "class A extends X{\n"
      "  A(name) : super(name);\n"
      "}\n"
      "class B extends X {\n"
      "  B(name) : super(name);\n"
      "}\n"
      "class C extends A {\n"
      "  C(name) : super(name);\n"
      "}\n"
      "var list;\n"
      "main() {\n"
      "  return (list.map((x) {\n"
      "    return '${x.name} is '\n"
      "           'A(${x is A})/ B(${x is B})/ C(${x is C})/ X(${x is X})';\n"
      "  })).toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript2);
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      "(a is A(true)/ B(false)/ C(false)/ X(true),"
      " b is A(false)/ B(true)/ C(false)/ X(true),"
      " c is A(true)/ B(false)/ C(true)/ X(true),"
      " x is A(false)/ B(false)/ C(false)/ X(true))",
      SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [339/600]

dart::TEST_CASE

(

IsolateReload_ConstantIdentical

)

Definition at line 2432 of file isolate_reload_test.cc.

                                           {
  const char* kScript =
      "class Fruit {\n"
      "  final String name;\n"
      "  const Fruit(this.name);\n"
      "  String toString() => name;\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  x = const Fruit('Pear');\n"
      "  return x.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Pear", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class Fruit {\n"
      "  final String name;\n"
      "  const Fruit(this.name);\n"
      "  String toString() => name;\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  if (identical(x, const Fruit('Pear'))) {\n"
      "    return 'yes';\n"
      "  } else {\n"
      "    return 'no';\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [340/600]

dart::TEST_CASE

(

IsolateReload_ConstFieldUpdate

)

Definition at line 4656 of file isolate_reload_test.cc.

                          :exportlib", kReloadExportScript);
 
  const char* kReloadScript =
      "import 'test:importlib';\n"
      "main() {\n"
      "  return exportedFunc() + ' pants';\n"
      "}\n";
 
  Dart_SetFileModifiedCallback(&ExportModifiedCallback);
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  Dart_SetFileModifiedCallback(nullptr);
 
  // Modification of an exported library propagates.

TEST_CASE() [341/600]

dart::TEST_CASE

(

IsolateReload_ConstructorChanged

)

Definition at line 730 of file isolate_reload_test.cc.

                                            {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "class A {\n"
                  "  %s int field;\n"
                  "  A() { field = 20; }\n"
                  "}\n"
                  "var savedA = A();\n"
                  "main() {\n"
                  "  var newA = A();\n"
                  "  return 'saved:${savedA.field} new:${newA.field}';\n"
                  "}\n",
                  late_tag),
      std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("saved:20 new:20", SimpleInvokeStr(lib, "main"));
 
  // clang-format off
  auto kReloadScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "var _unused;"
                  "class A {\n"
                  "  %s int field;\n"
                  "  A() { field = 10; }\n"
                  "}\n"
                  "var savedA = A();\n"
                  "main() {\n"
                  "  var newA = A();\n"
                  "  return 'saved:${savedA.field} new:${newA.field}';\n"
                  "}\n",
                  late_tag),
      std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  EXPECT_STREQ("saved:20 new:10", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [342/600]

dart::TEST_CASE

(

IsolateReload_ConstToNonConstClass

)

Definition at line 4351 of file isolate_reload_test.cc.

                   :deeply-immutable')
        final class B {
          final int x;
          B(this.x);
        }
      )"
    }};
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      nullptr /* resolver */, true /* finalize */, true /* incrementally */);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(42, value);
 
  // clang-format off
  Dart_SourceFile updated_sourcefiles[] = {
    {
      "file:///test-lib.dart",
      R"(
        final class B {
          final int x;
          B(this.x);
        }
      )"
    }};
  // clang-format on
 
  {

TEST_CASE() [343/600]

dart::TEST_CASE

(

IsolateReload_ConstToNonConstClass_Empty

)

Definition at line 4385 of file isolate_reload_test.cc.

             :///test-app.dart",
        sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
        updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
        true /* incrementally */);
    // This is rejected by class A being recompiled and the validator failing.
    EXPECT(error != nullptr);
    EXPECT_NULLPTR(kernel_buffer);
  }
}
 
TEST_CASE(IsolateReload_ConstToNonConstClass) {
  const char* kScript = R"(
    class A {
      final dynamic x;
      const A(this.x);
    }
    dynamic a;
    main() {
      a = const A(1);
      return 'okay';
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript = R"(
    class A {
      dynamic x;

TEST_CASE() [344/600]

dart::TEST_CASE

(

IsolateReload_DeeplyImmutableChange

)

Definition at line 4193 of file isolate_reload_test.cc.

                                               {
  const char* kScript = R"(
    @pragma('vm:deeply-immutable')
    final class A {
      final int x;
      A(this.x);
    }
    String main () {
      A(123);
      return 'okay';
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript = R"(
    final class A {
      final int x;
      A(this.x);
    }
    String main () {
      A(123);
      return 'okay';
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib,
               "Classes cannot change their @pragma('vm:deeply-immutable'): "
               "Library:'file:///test-lib' Class: A");
}

TEST_CASE() [345/600]

dart::TEST_CASE

(

IsolateReload_DeeplyImmutableChange_2

)

Definition at line 4227 of file isolate_reload_test.cc.

                                                 {
  const char* kScript = R"(
    final class A {
      final int x;
      A(this.x);
    }
    String main () {
      A(123);
      return 'okay';
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript = R"(
    @pragma('vm:deeply-immutable')
    final class A {
      final int x;
      A(this.x);
    }
    String main () {
      A(123);
      return 'okay';
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib,
               "Classes cannot change their @pragma('vm:deeply-immutable'): "
               "Library:'file:///test-lib' Class: A");
}

TEST_CASE() [346/600]

dart::TEST_CASE

(

IsolateReload_DeeplyImmutableChange_MultiLib

)

Definition at line 4261 of file isolate_reload_test.cc.

                                                        {
  // clang-format off
  Dart_SourceFile sourcefiles[] = {
    {
      "file:///test-app.dart",
      R"(
        import 'test-lib.dart';
 
        @pragma('vm:deeply-immutable')
        final class A {
          final B b;
          A(this.b);
        }
        int main () {
          A(B(123));
          return 42;
        }
      )",
    },
    {
      "file:///test-lib.dart",
      R"(
        @pragma('vm:deeply-immutable')
        final class B {
          final int x;
          B(this.x);
        }
      )"
    }};
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      nullptr /* resolver */, true /* finalize */, true /* incrementally */);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(42, value);
 
  // clang-format off
  Dart_SourceFile updated_sourcefiles[] = {
    {

TEST_CASE() [347/600]

dart::TEST_CASE

(

IsolateReload_DeeplyImmutableChange_TypeBound

)

Definition at line 4306 of file isolate_reload_test.cc.

                      {
          final int x;
          B(this.x);
        }
      )"
    }};
  // clang-format on
 
  {
    const uint8_t* kernel_buffer = nullptr;
    intptr_t kernel_buffer_size = 0;
    char* error = TestCase::CompileTestScriptWithDFE(
        "file:///test-app.dart",
        sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
        updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
        true /* incrementally */);
    // This is rejected by class A being recompiled and the validator failing.
    EXPECT(error != nullptr);
    EXPECT_NULLPTR(kernel_buffer);
  }
}
 
TEST_CASE(IsolateReload_DeeplyImmutableChange_TypeBound) {
  // clang-format off
  Dart_SourceFile sourcefiles[] = {
    {
      "file:///test-app.dart",
      R"(
        import 'test-lib.dart';
 
        @pragma('vm:deeply-immutable')
        final class A<T extends B> {
          final T b;
          A(this.b);
        }
        int main () {
          A(B(123));
          return 42;
        }
      )",
    },
    {
      "file:///test-lib.dart",

TEST_CASE() [348/600]

dart::TEST_CASE

(

IsolateReload_DeleteStaticField

)

Definition at line 5411 of file isolate_reload_test.cc.

                                                              {
  const char* kScript =
      "class C {\n"
      "  static var x = 42;\n"
      "}\n"
      "main() {\n"
      "  return '${C.x}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("42", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class C {\n"
      "  static var x = 13;\n"
      "}\n"
      "main() {\n"
      "  return '${C.x}';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  // Newly loaded field maintained old static value
  EXPECT_STREQ("42", SimpleInvokeStr(lib, "main"));
}
 
class CidCountingVisitor : public ObjectVisitor {
 public:
  explicit CidCountingVisitor(intptr_t cid) : cid_(cid) {}
  virtual ~CidCountingVisitor() {}
 
  virtual void VisitObject(ObjectPtr obj) {
    if (obj->GetClassId() == cid_) {
      count_++;
    }
  }
 
  intptr_t count() const { return count_; }
 
 private:
  intptr_t cid_;
  intptr_t count_ = 0;
};
 
TEST_CASE(IsolateReload_DeleteStaticField) {
  const char* kScript =
      "class C {\n"
      "}\n"
      "class Foo {\n"
      "static var x = C();\n"
      "}\n"

TEST_CASE() [349/600]

dart::TEST_CASE

(

IsolateReload_EnumAddition

)

Definition at line 2096 of file isolate_reload_test.cc.

                                      {
  const char* kScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  return Fruit.Apple.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Cantaloupe,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  String r = '${Fruit.Apple.index}/${Fruit.Apple} ';\n"
      "  r += '${Fruit.Cantaloupe.index}/${Fruit.Cantaloupe} ';\n"
      "  r += '${Fruit.Banana.index}/${Fruit.Banana}';\n"
      "  return r;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("0/Fruit.Apple 1/Fruit.Cantaloupe 2/Fruit.Banana",
               SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [350/600]

dart::TEST_CASE

(

IsolateReload_EnumDelete

)

Definition at line 2181 of file isolate_reload_test.cc.

                                    {
  const char* kScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "  Cantaloupe,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  x = Fruit.Cantaloupe;\n"
      "  return Fruit.Apple.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  // Delete 'Cantaloupe' but make sure that we can still invoke toString,
  // and access the hashCode and index properties.
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  String r = '$x ${x.hashCode is int} ${x.index}';\n"
      "  return r;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Deleted enum value from Fruit true -1",
               SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [351/600]

dart::TEST_CASE

(

IsolateReload_EnumEquality

)

Definition at line 1990 of file isolate_reload_test.cc.

                                      {
  const char* kScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  x = Fruit.Banana;\n"
      "  return Fruit.Apple.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  if (x == Fruit.Banana) {\n"
      "    return 'yes';\n"
      "  } else {\n"
      "    return 'no';\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [352/600]

dart::TEST_CASE

(

IsolateReload_EnumIdentical

)

Definition at line 2026 of file isolate_reload_test.cc.

                                       {
  const char* kScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  x = Fruit.Banana;\n"
      "  return Fruit.Apple.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  if (identical(x, Fruit.Banana)) {\n"
      "    return 'yes';\n"
      "  } else {\n"
      "    return 'no';\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [353/600]

dart::TEST_CASE

(

IsolateReload_EnumIdentityReload

)

Definition at line 2218 of file isolate_reload_test.cc.

                                            {
  const char* kScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "  Cantaloupe,\n"
      "}\n"
      "var x;\n"
      "var y;\n"
      "var z;\n"
      "var w;\n"
      "main() {\n"
      "  x = { Fruit.Apple: Fruit.Apple.index,\n"
      "        Fruit.Banana: Fruit.Banana.index,\n"
      "        Fruit.Cantaloupe: Fruit.Cantaloupe.index};\n"
      "  y = Fruit.Apple;\n"
      "  z = Fruit.Banana;\n"
      "  w = Fruit.Cantaloupe;\n"
      "  return Fruit.Apple.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "  Cantaloupe,\n"
      "}\n"
      "var x;\n"
      "var y;\n"
      "var z;\n"
      "var w;\n"
      "bool identityCheck(Fruit f, int index) {\n"
      "  return identical(Fruit.values[index], f);\n"
      "}\n"
      "main() {\n"
      "  String r = '';\n"
      "  x.forEach((key, value) {\n"
      "    r += '${identityCheck(key, value)} ';\n"
      "  });\n"
      "  r += '${x[Fruit.Apple] == Fruit.Apple.index} ';\n"
      "  r += '${x[Fruit.Banana] == Fruit.Banana.index} ';\n"
      "  r += '${x[Fruit.Cantaloupe] == Fruit.Cantaloupe.index} ';\n"
      "  r += '${identical(y, Fruit.values[x[Fruit.Apple]])} ';\n"
      "  r += '${identical(z, Fruit.values[x[Fruit.Banana]])} ';\n"
      "  r += '${identical(w, Fruit.values[x[Fruit.Cantaloupe]])} ';\n"
      "  return r;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("true true true true true true true true true ",
               SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [354/600]

dart::TEST_CASE

(

IsolateReload_EnumInMainLibraryModified

)

Definition at line 6303 of file isolate_reload_test.cc.

           {
      f.fn();
      return "okay";
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  lib = TestCase::ReloadTestScript(kScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
}
 
// Regression test for https://github.com/dart-lang/sdk/issues/51215.
TEST_CASE(IsolateReload_ImplicitGetterWithLoadGuard) {
  const char* kLibScript = R"(
    import 'file:///test:isolate_reload_helper';
 
    class A {
      int x;
      A(this.x);
      A.withUinitializedObject(int Function() callback) : x = callback();

TEST_CASE() [355/600]

dart::TEST_CASE

(

IsolateReload_EnumReferentShapeChangeAdd

)

Definition at line 2370 of file isolate_reload_test.cc.

                                                    {
  const char* kScript =
      "class Box {\n"
      "  final x;\n"
      "  const Box(this.x);\n"
      "}\n"
      "enum Fruit {\n"
      "  Apple('Apple', const Box('A')),\n"
      "  Banana('Banana', const Box('B')),\n"
      "  Cherry('Cherry', const Box('C')),\n"
      "  Durian('Durian', const Box('D')),\n"
      "  Elderberry('Elderberry', const Box('E')),\n"
      "  Fig('Fig', const Box('F')),\n"
      "  Grape('Grape', const Box('G')),\n"
      "  Huckleberry('Huckleberry', const Box('H')),\n"
      "  Jackfruit('Jackfruit', const Box('J'));\n"
      "  const Fruit(this.name, this.initial);\n"
      "  final String name;\n"
      "  final Box initial;\n"
      "}\n"
      "var retained;\n"
      "main() {\n"
      "  retained = Fruit.Apple;\n"
      "  return retained.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class Box {\n"
      "  final x;\n"
      "  final y;\n"
      "  final z;\n"
      "  const Box(this.x, this.y, this.z);\n"
      "}\n"
      "enum Fruit {\n"
      "  Apple('Apple', const Box('A', 0, 0)),\n"
      "  Banana('Banana', const Box('B', 0, 0)),\n"
      "  Cherry('Cherry', const Box('C', 0, 0)),\n"
      "  Durian('Durian', const Box('D', 0, 0)),\n"
      "  Elderberry('Elderberry', const Box('E', 0, 0)),\n"
      "  Fig('Fig', const Box('F', 0, 0)),\n"
      "  Grape('Grape', const Box('G', 0, 0)),\n"
      "  Huckleberry('Huckleberry', const Box('H', 0, 0)),\n"
      "  Jackfruit('Jackfruit', const Box('J', 0, 0)),\n"
      "  Lemon('Lemon', const Box('L', 0, 0));\n"
      "  const Fruit(this.name, this.initial);\n"
      "  final String name;\n"
      "  final Box initial;\n"
      "}\n"
      "var retained;\n"
      "main() {\n"
      "  return retained.toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [356/600]

dart::TEST_CASE

(

IsolateReload_EnumReorderIdentical

)

Definition at line 2061 of file isolate_reload_test.cc.

                                              {
  const char* kScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  x = Fruit.Banana;\n"
      "  return Fruit.Apple.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Banana,\n"
      "  Apple,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  if (identical(x, Fruit.Banana)) {\n"
      "    return 'yes';\n"
      "  } else {\n"
      "    return 'no';\n"
      "  }\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [357/600]

dart::TEST_CASE

(

IsolateReload_EnumShapeChange

)

Definition at line 2276 of file isolate_reload_test.cc.

                                         {
  const char* kScript =
      "enum Fruit { Apple, Banana }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = Fruit.Apple;\n"
      "  return retained.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple('Apple', 'A'),\n"
      "  Banana('Banana', 'B');\n"
      "  const Fruit(this.name, this.initial);\n"
      "  final String name;\n"
      "  final String initial;\n"
      "}\n"
      "var retained;\n"
      "main() {\n"
      "  return retained.initial;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("A", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [358/600]

dart::TEST_CASE

(

IsolateReload_EnumShapeChangeAdd

)

Definition at line 2307 of file isolate_reload_test.cc.

                                            {
  const char* kScript =
      "enum Fruit { Apple, Banana }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = Fruit.Apple;\n"
      "  return retained.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple('Apple', 'A'),\n"
      "  Banana('Banana', 'B'),\n"
      "  Cherry('Cherry', 'C');\n"
      "  const Fruit(this.name, this.initial);\n"
      "  final String name;\n"
      "  final String initial;\n"
      "}\n"
      "var retained;\n"
      "main() {\n"
      "  return Fruit.Cherry.initial;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("C", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [359/600]

dart::TEST_CASE

(

IsolateReload_EnumShapeChangeRemove

)

Definition at line 2339 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "enum Fruit { Apple, Banana }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = Fruit.Banana;\n"
      "  return retained.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Banana", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple('Apple', 'A');\n"
      "  const Fruit(this.name, this.initial);\n"
      "  final String name;\n"
      "  final String initial;\n"
      "}\n"
      "var retained;\n"
      "main() {\n"
      "  return retained.toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Deleted enum value from Fruit",
               SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [360/600]

dart::TEST_CASE

(

IsolateReload_EnumToNotEnum

)

Definition at line 2131 of file isolate_reload_test.cc.

                                       {
  const char* kScript =
      "enum Fruit {\n"
      "  Apple\n"
      "}\n"
      "main() {\n"
      "  return Fruit.Apple.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class Fruit {\n"
      "  final int zero = 0;\n"
      "}\n"
      "main() {\n"
      "  return new Fruit().zero.toString();\n"
      "}\n";
 
  Dart_Handle result = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(result, "Enum class cannot be redefined to be a non-enum class");
}

TEST_CASE() [361/600]

dart::TEST_CASE

(

IsolateReload_EnumValuesToString

)

Definition at line 3372 of file isolate_reload_test.cc.

                                            {
  const char* kScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Banana,\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  String r = '';\n"
      "  r += Fruit.Apple.toString();\n"
      "  r += ' ';\n"
      "  r += Fruit.Banana.toString();\n"
      "  return r;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple Fruit.Banana", SimpleInvokeStr(lib, "main"));
 
  // Insert 'Cantaloupe'.
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple,\n"
      "  Cantaloupe,\n"
      "  Banana\n"
      "}\n"
      "var x;\n"
      "main() {\n"
      "  String r = '';\n"
      "  r += Fruit.Apple.toString();\n"
      "  r += ' ';\n"
      "  r += Fruit.Cantaloupe.toString();\n"
      "  r += ' ';\n"
      "  r += Fruit.Banana.toString();\n"
      "  return r;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Fruit.Apple Fruit.Cantaloupe Fruit.Banana",
               SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [362/600]

dart::TEST_CASE

(

IsolateReload_EnumWithSet

)

Definition at line 6382 of file isolate_reload_test.cc.

              {\n"
      "  return Foo().toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_VALID(Dart_FinalizeAllClasses());
  EXPECT_STREQ("foo", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Bar { bar }\n"
      "class Foo { int? a; String? b; toString() => 'foo'; }"
      "main() {\n"
      "  return Foo().toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
 
  // Modification of an imported library propagates to the importing library.
  EXPECT_STREQ("foo", SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_KeepPragma1) {
  // Old version of closure function bar() has a pragma.
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "foo() {\n"
      "  @pragma('vm:prefer-inline')\n"
      "  void bar() {}\n"
      "  return bar;\n"
      "}"
      "main() {\n"
      "  reloadTest();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  // New version of closure function bar() doesn't have a pragma.
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "foo() {\n"
      "  void bar() {}\n"
      "  return bar;\n"
      "}"
      "main() {\n"
      "  reloadTest();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  Dart_Handle foo1_result = Dart_Invoke(lib, NewString("foo"), 0, nullptr);
  EXPECT_VALID(foo1_result);
 
  EXPECT_VALID(Dart_Invoke(lib, NewString("main"), 0, nullptr));
 
  Dart_Handle foo2_result = Dart_Invoke(lib, NewString("foo"), 0, nullptr);
  EXPECT_VALID(foo2_result);
 
  TransitionNativeToVM transition(thread);
  const auto& bar1 = Function::Handle(
      Closure::Handle(Closure::RawCast(Api::UnwrapHandle(foo1_result)))
          .function());
  const auto& bar2 = Function::Handle(
      Closure::Handle(Closure::RawCast(Api::UnwrapHandle(foo2_result)))
          .function());
  // Pragma should be retained on the old function,
  // and should not appear on the new function.
  EXPECT(Library::FindPragma(thread, /*only_core=*/false, bar1,
                             Symbols::vm_prefer_inline()));
  EXPECT(!Library::FindPragma(thread, /*only_core=*/false, bar2,

TEST_CASE() [363/600]

dart::TEST_CASE

(

IsolateReload_ExistingFieldBoxedToUnboxed

)

Definition at line 5554 of file isolate_reload_test.cc.

                :typed_data';
 
    void doubleEq(double got, double expected) {
      if (got != expected) throw 'expected $expected got $got';
    }
 

TEST_CASE() [364/600]

dart::TEST_CASE

(

IsolateReload_ExistingFieldChangesType

)

Definition at line 5528 of file isolate_reload_test.cc.

                                                        {
      if (got.equal(expected).signMask != 0xf) throw 'expected $expected got $got';
    }
 
    class Foo {

TEST_CASE() [365/600]

dart::TEST_CASE

(

IsolateReload_ExistingFieldChangesTypeIndirect

)

Definition at line 5608 of file isolate_reload_test.cc.

                                                     {
  TestReloadWithFieldChange(
      /*prefix=*/"double a = 1.5;",
      /*suffix=*/"Float32x4 b = Float32x4(1.0, 2.0, 3.0, 4.0);", /*verify=*/
      "doubleEq(value.a, 1.5); float32x4Eq(value.b, Float32x4(1.0, 2.0, 3.0, "
      "4.0));",
      /*from_type=*/"double", /*from_init=*/"42.0", /*to_type=*/"String",
      /*to_init=*/"'42'");
}
 
TEST_CASE(IsolateReload_ExistingFieldBoxedToUnboxed) {
  // Note: underlying field will not actually be unboxed.
  TestReloadWithFieldChange(
      /*prefix=*/"double a = 1.5;",
      /*suffix=*/"Float32x4 b = Float32x4(1.0, 2.0, 3.0, 4.0);", /*verify=*/
      "doubleEq(value.a, 1.5); float32x4Eq(value.b, Float32x4(1.0, 2.0, 3.0, "
      "4.0));",
      /*from_type=*/"String", /*from_init=*/"'42.0'", /*to_type=*/"double",
      /*to_init=*/"42.0");
}
 
TEST_CASE(IsolateReload_ExistingFieldUnboxedToUnboxed) {
  // Note: underlying field will not actually be unboxed.
  TestReloadWithFieldChange(
      /*prefix=*/"double a = 1.5;",
      /*suffix=*/"Float32x4 b = Float32x4(1.0, 2.0, 3.0, 4.0);", /*verify=*/
      "doubleEq(value.a, 1.5); float32x4Eq(value.b, Float32x4(1.0, 2.0, 3.0, "
      "4.0));",
      /*from_type=*/"double", /*from_init=*/"42.0", /*to_type=*/"Float32x4",
      /*to_init=*/"Float32x4(1.0, 2.0, 3.0, 4.0)");
}
 
TEST_CASE(IsolateReload_ExistingStaticFieldChangesType) {
  const char* kScript = R"(
    int value = init();
    init() => 42;
    main() {
      return value.toString();
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);

TEST_CASE() [366/600]

dart::TEST_CASE

(

IsolateReload_ExistingFieldChangesTypeIndirectFunction

)

Definition at line 5778 of file isolate_reload_test.cc.

            {}
    class B {}
    class Foo {
      List<A> x;
      Foo(this.x);
    }
    %s Foo value;
    main() {
      try {
        return value.x.toString();
      } catch (e) {
        return e.toString();
      }
    }
  )", late_tag), std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      "type 'List<B>' is not a subtype of type 'List<A>' of 'function result'",
      SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_ExistingStaticFieldChangesTypeIndirectGeneric) {
  const char* kScript = R"(
    class A {}
    class B extends A {}
    List<A> value = init();
    init() => List<B>.empty();
    main() {
      return value.toString();
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("[]", SimpleInvokeStr(lib, "main"));
 
  // B is no longer a subtype of A.
  const char* kReloadScript = R"(
    class A {}
    class B {}
    List<A> value = init();

TEST_CASE() [367/600]

dart::TEST_CASE

(

IsolateReload_ExistingFieldChangesTypeIndirectGeneric

)

Definition at line 5692 of file isolate_reload_test.cc.

            {}
    class B {}
    class Foo {
      A x;
      Foo(this.x);
    }
    %s Foo value;
    main() {
      try {
        return value.x.toString();
      } catch (e) {
        return e.toString();
      }
    }
  )", late_tag), std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  EXPECT_STREQ("type 'B' is not a subtype of type 'A' of 'function result'",
               SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_ExistingStaticFieldChangesTypeIndirect) {
  const char* kScript = R"(
    class A {}
    class B extends A {}
    A value = init();
    init() => new B();
    main() {
      return value.toString();
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of 'B'", SimpleInvokeStr(lib, "main"));
 
  // B is no longer a subtype of A.

TEST_CASE() [368/600]

dart::TEST_CASE

(

IsolateReload_ExistingFieldChangesTypeWithOtherUnboxedFields

)

Definition at line 5534 of file isolate_reload_test.cc.

           {
      value = Foo();
      %s
      return 'Okay';
    }

TEST_CASE() [369/600]

dart::TEST_CASE

(

IsolateReload_ExistingFieldUnboxedToBoxed

)

Definition at line 5544 of file isolate_reload_test.cc.

TEST_CASE() [370/600]

dart::TEST_CASE

(

IsolateReload_ExistingFieldUnboxedToUnboxed

)

Definition at line 5565 of file isolate_reload_test.cc.

              {
      %s
      %s x = %s;
      %s
    }
    %s Foo value;
    main() {

TEST_CASE() [371/600]

dart::TEST_CASE

(

IsolateReload_ExistingStaticFieldChangesType

)

Definition at line 5576 of file isolate_reload_test.cc.

                  {
        return e.toString();
      }
    }
  )", prefix, to_type, to_init, suffix,
  late_tag, verify), std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      OS::SCreate(
          Thread::Current()->zone(),
          "type '%s' is not a subtype of type '%s' of 'function result'",
          from_type, to_type),
      SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_ExistingFieldChangesType) {
  TestReloadWithFieldChange(/*prefix=*/"", /*suffix=*/"", /*verify=*/"",
                            /*from_type=*/"int", /*from_init=*/"42",
                            /*to_type=*/"double", /*to_init=*/"42.0");
}
 
TEST_CASE(IsolateReload_ExistingFieldChangesTypeWithOtherUnboxedFields) {
  TestReloadWithFieldChange(
      /*prefix=*/"double a = 1.5;",
      /*suffix=*/"Float32x4 b = Float32x4(1.0, 2.0, 3.0, 4.0);", /*verify=*/
      "doubleEq(value.a, 1.5); float32x4Eq(value.b, Float32x4(1.0, 2.0, 3.0, "

TEST_CASE() [372/600]

dart::TEST_CASE

(

IsolateReload_ExistingStaticFieldChangesTypeIndirect

)

Definition at line 5656 of file isolate_reload_test.cc.

           {
      try {
        return value.toString();
      } catch (e) {
        return e.toString();
      }
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      "type 'int' is not a subtype of type 'double' of 'function result'",
      SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_ExistingFieldChangesTypeIndirect) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
    class A {}
    class B extends A {}
    class Foo {
      A x;
      Foo(this.x);
    }
    %s Foo value;
    main() {
      value = Foo(B());
      return 'Okay';
    }

TEST_CASE() [373/600]

dart::TEST_CASE

(

IsolateReload_ExistingStaticFieldChangesTypeIndirectFunction

)

Definition at line 5830 of file isolate_reload_test.cc.

           {
      try {
        return value.toString();
      } catch (e) {
        return e.toString();
      }
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      "type 'List<B>' is not a subtype of type 'List<A>' of 'function result'",
      SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_ExistingFieldChangesTypeIndirectFunction) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
    class A {}
    class B extends A {}
    typedef bool Predicate(B b);
    class Foo {
      Predicate x;
      Foo(this.x);
    }
    %s Foo value;
    main() {
      value = Foo((A a) => true);
      return 'Okay';
    }
  )", late_tag), std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main"));
 

TEST_CASE() [374/600]

dart::TEST_CASE

(

IsolateReload_ExistingStaticFieldChangesTypeIndirectGeneric

)

Definition at line 5741 of file isolate_reload_test.cc.

            {}
    class B {}
    A value = init();
    init() => new A();
    main() {
      try {
        return value.toString();
      } catch (e) {
        return e.toString();
      }
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("type 'B' is not a subtype of type 'A' of 'function result'",
               SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_ExistingFieldChangesTypeIndirectGeneric) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
    class A {}
    class B extends A {}
    class Foo {
      List<A> x;
      Foo(this.x);
    }
    %s Foo value;
    main() {
      value = Foo(List<B>.empty());
      return 'Okay';
    }
  )", late_tag), std::free);
  // clang-format on

TEST_CASE() [375/600]

dart::TEST_CASE

(

IsolateReload_ExportedLibModified

)

Definition at line 4599 of file isolate_reload_test.cc.

                                                   {
  const char* kImportScript = "importedFunc() => 'fancy';";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  const char* kScript =
      "import 'test:lib1' as cobra;\n"
      "main() {\n"
      "  return cobra.importedFunc() + ' feast';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadImportScript = "importedFunc() => 'bossy';";
  TestCase::AddTestLib("test:lib1", kReloadImportScript);
 
  const char* kReloadScript =
      "import 'test:lib1' as cobra;\n"
      "main() {\n"
      "  return cobra.importedFunc() + ' pants';\n"
      "}\n";
 
  Dart_SetFileModifiedCallback(&ImportModifiedCallback);
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  Dart_SetFileModifiedCallback(nullptr);
 

TEST_CASE() [376/600]

dart::TEST_CASE

(

IsolateReload_FunctionReplacement

)

Definition at line 47 of file isolate_reload_test.cc.

                                             {
  const char* kScript =
      "main() {\n"
      "  return 4;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "var _unused;"
      "main() {\n"
      "  return 10;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(10, SimpleInvoke(lib, "main"));
}

TEST_CASE() [377/600]

dart::TEST_CASE

(

IsolateReload_GenericConstructorTearOff

)

Definition at line 6212 of file isolate_reload_test.cc.

                                           {
  struct Component {
    Dart_SourceFile source;
    const uint8_t* kernel_buffer;
    intptr_t kernel_buffer_size;
  };
 
  // clang-format off
  std::array<Component, 2> components = {{
    {{
      "file:///test-app",
      R"(
        class A {}
        void main() {
          A();
        }
      )"
    }, nullptr, 0},
    {{
      "file:///library",
      R"(
        class B {}
      )"
    }, nullptr, 0}
  }};
  // clang-format on
 
  for (auto& component : components) {
    CompileToKernel(component.source, &component.kernel_buffer,
                    &component.kernel_buffer_size);
    TestCaseBase::AddToKernelBuffers(component.kernel_buffer);

TEST_CASE() [378/600]

dart::TEST_CASE

(

IsolateReload_Generics

)

Definition at line 805 of file isolate_reload_test.cc.

                                  {
  // Reload a program with generics without changing the source.  We
  // do this to produce duplication TypeArguments and make sure that
  // the system doesn't die.
  const char* kScript =
      "class A {\n"
      "}\n"
      "class B<T extends A> {\n"
      "}\n"
      "main() {\n"
      "  return new B<A>().toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of 'B<A>'", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class A {\n"
      "}\n"
      "class B<T extends A> {\n"
      "}\n"
      "main() {\n"
      "  return new B<A>().toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Instance of 'B<A>'", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [379/600]

dart::TEST_CASE

(

IsolateReload_ImplicitConstructorChanged

)

Definition at line 697 of file isolate_reload_test.cc.

                                                    {
  // Note that we are checking that the value 20 gets cleared from the
  // compile-time constants cache.  To make this test work, "20" and
  // "10" need to be at the same token position.
  const char* kScript =
      "class A {\n"
      "  int field = 20;\n"
      "}\n"
      "var savedA = new A();\n"
      "main() {\n"
      "  var newA = new A();\n"
      "  return 'saved:${savedA.field} new:${newA.field}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("saved:20 new:20", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class A {\n"
      "  int field = 10;\n"
      "}\n"
      "var savedA = new A();\n"
      "main() {\n"
      "  var newA = new A();\n"
      "  return 'saved:${savedA.field} new:${newA.field}';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("saved:20 new:10", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [380/600]

dart::TEST_CASE

(

IsolateReload_ImplicitGetterWithLoadGuard

)

Definition at line 6246 of file isolate_reload_test.cc.

                      : components) {
    kernel_buffer_size += component.kernel_buffer_size;
  }
  uint8_t* kernel_buffer = static_cast<uint8_t*>(malloc(kernel_buffer_size));
  TestCaseBase::AddToKernelBuffers(kernel_buffer);
  intptr_t pos = 0;
  for (auto component : components) {
    memcpy(kernel_buffer + pos, component.kernel_buffer,  // NOLINT
           component.kernel_buffer_size);
    pos += component.kernel_buffer_size;
  }
 
  // Load the first component into the isolate (to have something set as
  // root library).
  Dart_Handle lib = Dart_LoadLibraryFromKernel(
      components[0].kernel_buffer, components[0].kernel_buffer_size);
  EXPECT_VALID(lib);
  EXPECT_VALID(Dart_SetRootLibrary(lib));
 
  {
    KernelTagHandler handler(kernel_buffer, kernel_buffer_size);
    {
      // Additional API scope to prevent handles leaking into outer scope.
      Dart_EnterScope();
      // root_script_url does not really matter.
      TestCase::TriggerReload(/*root_script_url=*/"something.dill");
      Dart_ExitScope();
    }
    EXPECT(handler.was_called());
 
    // Check that triggering GC does not cause finalizer registered by
    // tag handler to fire - meaning that kernel binary continues to live.
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectAllGarbage();
    EXPECT(!handler.was_finalized());
  }
}
 
// Regression test for https://github.com/dart-lang/sdk/issues/50148.
TEST_CASE(IsolateReload_GenericConstructorTearOff) {
  const char* kScript = R"(
    typedef Create<T, R> = T Function(R ref);
 
    class Base<Input> {
      Base(void Function(Create<void, Input> create) factory) : _factory = factory;
 
      final void Function(Create<void, Input> create) _factory;
 
      void fn() => _factory((ref) {});
    }
 
    class Check<T> {
      Check(Create<Object?, List<T>> create);

TEST_CASE() [381/600]

dart::TEST_CASE

(

IsolateReload_ImportedLibModified

)

Definition at line 4527 of file isolate_reload_test.cc.

                        :///test-lib") == 0)) {
    return true;
  }
  return false;
}
 
TEST_CASE(IsolateReload_MainLibModified) {
  const char* kImportScript = "importedFunc() => 'fancy';";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  const char* kScript =
      "import 'test:lib1';\n"
      "main() {\n"
      "  return importedFunc() + ' feast';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadImportScript = "importedFunc() => 'bossy';";
  TestCase::AddTestLib("test:lib1", kReloadImportScript);
 
  const char* kReloadScript =
      "import 'test:lib1';\n"
      "main() {\n"
      "  return importedFunc() + ' pants';\n"
      "}\n";
 
  Dart_SetFileModifiedCallback(&MainModifiedCallback);

TEST_CASE() [382/600]

dart::TEST_CASE

(

IsolateReload_ImportedMixinFunction

)

Definition at line 1233 of file isolate_reload_test.cc.

                                               {
  const char* kImportScript =
      "mixin ImportedMixin {\n"
      "  mixinFunc() => 'mixin';\n"
      "}\n";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  const char* kScript =
      "import 'test:lib1' show ImportedMixin;\n"
      "class A extends Object with ImportedMixin {\n"
      "}"
      "var func = new A().mixinFunc;\n"
      "main() {\n"
      "  return func();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  EXPECT_STREQ("mixin", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "import 'test:lib1' show ImportedMixin;\n"
      "class A extends Object with ImportedMixin {\n"
      "}"
      "var func;\n"
      "main() {\n"
      "  return func();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("mixin", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [383/600]

dart::TEST_CASE

(

IsolateReload_IncrementalCompile

)

Definition at line 69 of file isolate_reload_test.cc.

                                            {
  const char* kScriptChars =
      "main() {\n"
      "  return 42;\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(42, value);
 
  const char* kUpdatedScriptChars =
      "main() {\n"
      "  return 24;\n"
      "}\n"
      "";
  lib = TestCase::ReloadTestScript(kUpdatedScriptChars);
  EXPECT_VALID(lib);
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(24, value);
}

TEST_CASE() [384/600]

dart::TEST_CASE

(

IsolateReload_KeepPragma1

)

Definition at line 6330 of file isolate_reload_test.cc.

           {
      int sum = 0;
      // Trigger OSR and optimize this function.
      for (int i = 0; i < 30000; ++i) {
        sum += i;
      }
      // Make sure A.get:x is compiled.
      int y = a.x;
      // Reload while having an uninitialized
      // object A on the stack. This should result in
      // a load guard for A.x.
      A.withUinitializedObject(() {
         reloadTest();
         return 4;
      });
      // Trigger OSR and optimize this function once again.
      for (int i = 0; i < 30000; ++i) {
        sum += i;
      }
      // Trigger deoptimization in A.get:x.
      // It should correctly deoptimize into an implicit
      // getter with a load guard.
      a.x = 0x8070605040302010;
      int z = a.x & 0xffff;
      return "y: $y, z: $z";
    }
  )";
 
  Dart_Handle lib1 =
      TestCase::LoadTestLibrary("test_lib1.dart", kLibScript, nullptr);
  EXPECT_VALID(lib1);
 
  const char* kMainScript = R"(
    main() {}
  )";
 
  // Trigger hot reload during execution of 'main' from test_lib1
  // without reloading test_lib1, so its unoptimized code is retained.
  EXPECT_VALID(TestCase::LoadTestScript(kMainScript, nullptr));
  EXPECT_VALID(TestCase::SetReloadTestScript(kMainScript));
 
  EXPECT_STREQ("y: 3, z: 8208", SimpleInvokeStr(lib1, "main"));
}
 
// Regression test for https://github.com/dart-lang/sdk/issues/51835
TEST_CASE(IsolateReload_EnumInMainLibraryModified) {
  const char* kScript =
      "enum Bar { bar }\n"

TEST_CASE() [385/600]

dart::TEST_CASE

(

IsolateReload_KeepPragma2

)

Definition at line 6455 of file isolate_reload_test.cc.

                                     {
  const char* kScript =
      "enum Enum1 {\n"
      "  member1({Enum2.member1, Enum2.member2}),\n"
      "  member2({Enum2.member2}),\n"
      "  member3({Enum2.member1}),\n"
      "  member4({Enum2.member2, Enum2.member1}),\n"
      "  member5({Enum2.member1}),\n"
      "  member6({Enum2.member1});\n"
      "  const Enum1(this.set);\n"
      "  final Set<Enum2> set;\n"
      "}\n"
      "enum Enum2 { member1, member2; }\n"
      "var retained;\n"
      "main() {\n"
      "  retained = Enum1.member4;\n"
      "  return 'ok';\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("ok", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Enum2 { member1, member2; }\n"
      "enum Enum1 {\n"
      "  member1({Enum2.member1, Enum2.member2}),\n"
      "  member2({Enum2.member2}),\n"
      "  member3({Enum2.member1}),\n"
      "  member4({Enum2.member2, Enum2.member1}),\n"
      "  member5({Enum2.member1}),\n"
      "  member6({Enum2.member1});\n"
      "  const Enum1(this.set);\n"
      "  final Set<Enum2> set;\n"
      "}\n"
      "var retained;\n"
      "foo(e) {\n"
      "  return switch (e as Enum1) {\n"
      "    Enum1.member1 => \"a\",\n"
      "    Enum1.member2 => \"b\",\n"
      "    Enum1.member3 => \"c\",\n"
      "    Enum1.member4 => \"d\",\n"
      "    Enum1.member5 => \"e\",\n"
      "    Enum1.member6 => \"f\",\n"
      "  };\n"
      "}\n"
      "main() {\n"
      "  return foo(retained);\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
 

TEST_CASE() [386/600]

dart::TEST_CASE

(

IsolateReload_KeepPragma3

)

Definition at line 6510 of file isolate_reload_test.cc.

                                                      {
      constants.SetAt(i, Object::sentinel());
    }
  }
 
  EXPECT_STREQ("d", SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_KeepPragma2) {
  // Old version of closure function bar() has a pragma.
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "foo() {\n"
      "  @pragma('vm:prefer-inline')\n"
      "  void bar() {}\n"
      "  return bar;\n"
      "}"
      "main() {\n"
      "  reloadTest();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  // New version of closure function bar() has a different pragma.
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "foo() {\n"
      "  @pragma('vm:never-inline')\n"
      "  void bar() {}\n"
      "  return bar;\n"
      "}"
      "main() {\n"
      "  reloadTest();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 

TEST_CASE() [387/600]

dart::TEST_CASE

(

IsolateReload_KernelIncrementalCompile

)

Definition at line 95 of file isolate_reload_test.cc.

                                                  {
  // clang-format off
  Dart_SourceFile sourcefiles[] = {
    {
      "file:///test-app",
      "main() {\n"
      "  return 42;\n"
      "}\n",
    }};
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      nullptr /* resolver */, true /* finalize */, true /* incrementally */);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(42, value);
 
  // clang-format off
  Dart_SourceFile updated_sourcefiles[] = {
    {
      "file:///test-app",
      "main() {\n"
      "  return 24;\n"
      "}\n"
      ""
    }};
  // clang-format on
  {
    const uint8_t* kernel_buffer = nullptr;
    intptr_t kernel_buffer_size = 0;
    char* error = TestCase::CompileTestScriptWithDFE(
        "file:///test-app",
        sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
        updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
        true /* incrementally */);
    EXPECT(error == nullptr);
    EXPECT_NOTNULL(kernel_buffer);
 
    lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size);
    EXPECT_VALID(lib);
  }
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(24, value);
}

TEST_CASE() [388/600]

dart::TEST_CASE

(

IsolateReload_KernelIncrementalCompileAppAndLib

)

Definition at line 145 of file isolate_reload_test.cc.

                                                           {
  // clang-format off
  Dart_SourceFile sourcefiles[] = {
    {
      "file:///test-app.dart",
      "import 'test-lib.dart';\n"
      "main() {\n"
      "  return WhatsTheMeaningOfAllThis();\n"
      "}\n",
    },
    {
      "file:///test-lib.dart",
      "WhatsTheMeaningOfAllThis() {\n"
      "  return 42;\n"
      "}\n",
    }};
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      nullptr /* resolver */, true /* finalize */, true /* incrementally */);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(42, value);
 
  // clang-format off
  Dart_SourceFile updated_sourcefiles[] = {
    {
      "file:///test-lib.dart",
      "WhatsTheMeaningOfAllThis() {\n"
      "  return 24;\n"
      "}\n"
      ""
    }};
  // clang-format on
 
  {
    const uint8_t* kernel_buffer = nullptr;
    intptr_t kernel_buffer_size = 0;
    char* error = TestCase::CompileTestScriptWithDFE(
        "file:///test-app.dart",
        sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
        updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
        true /* incrementally */);
    EXPECT(error == nullptr);
    EXPECT_NOTNULL(kernel_buffer);
 
    lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size);
    EXPECT_VALID(lib);
  }
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(24, value);
}

TEST_CASE() [389/600]

dart::TEST_CASE

(

IsolateReload_KernelIncrementalCompileBaseClass

)

Definition at line 278 of file isolate_reload_test.cc.

                                                           {
  const char* nullable_tag = TestCase::NullableTag();
  // clang-format off
  auto kSourceFile1 =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                "class State<T, U> {\n"
                                "  T%s t;\n"
                                "  U%s u;\n"
                                "  State(List l) {\n"
                                "    t = l[0] is T ? l[0] : null;\n"
                                "    u = l[1] is U ? l[1] : null;\n"
                                "  }\n"
                                "}\n",
                                nullable_tag, nullable_tag),
                              std::free);
  Dart_SourceFile sourcefiles[3] = {
      {
          "file:///test-app.dart",
          "import 'test-util.dart';\n"
          "main() {\n"
          "  var v = doWork();"
          "  return v == 42 ? 1 : v == null ? -1 : 0;\n"
          "}\n",
      },
      {
          "file:///test-lib.dart",
          kSourceFile1.get()
      },
      {
        "file:///test-util.dart",
        "import 'test-lib.dart';\n"
        "class MyAccountState extends State<int, String> {\n"
        "  MyAccountState(List l): super(l) {}\n"
        "  first() => t;\n"
        "}\n"
        "doWork() => new MyAccountState(<dynamic>[42, 'abc']).first();\n"
      }
  };
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      nullptr /* resolver */, true /* finalize */, true /* incrementally */);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(1, value);
 
  auto kUpdatedSourceFile =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                          "class State<U, T> {\n"
                                          "  T%s t;\n"
                                          "  U%s u;\n"
                                          "  State(List l) {\n"
                                          "    t = l[0] is T ? l[0] : null;\n"
                                          "    u = l[1] is U ? l[1] : null;\n"
                                          "  }\n"
                                          "}\n",
                                          nullable_tag, nullable_tag),
                              std::free);
  Dart_SourceFile updated_sourcefiles[1] = {{
      "file:///test-lib.dart",
      kUpdatedSourceFile.get(),
  }};
  {
    const uint8_t* kernel_buffer = nullptr;
    intptr_t kernel_buffer_size = 0;
    char* error = TestCase::CompileTestScriptWithDFE(
        "file:///test-app.dart",
        sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
        updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
        true /* incrementally */);
    EXPECT(error == nullptr);
    EXPECT_NOTNULL(kernel_buffer);
 
    lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size);
    EXPECT_VALID(lib);
  }
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(-1, value);
}

TEST_CASE() [390/600]

dart::TEST_CASE

(

IsolateReload_KernelIncrementalCompileGenerics

)

Definition at line 204 of file isolate_reload_test.cc.

                                                          {
  // clang-format off
  Dart_SourceFile sourcefiles[] = {
    {
      "file:///test-app.dart",
      "import 'test-lib.dart';\n"
      "class Account {\n"
      "  int balance() => 42;\n"
      "}\n"
      "class MyAccountState extends State<Account> {\n"
      "  MyAccountState(Account a): super(a) {}\n"
      "}\n"
      "main() {\n"
      "  return (new MyAccountState(new Account()))\n"
      "      .howAreTheThings().balance();\n"
      "}\n",
    },
    {
      "file:///test-lib.dart",
      "class State<T> {\n"
      "  T t;"
      "  State(this.t);\n"
      "  T howAreTheThings() => t;\n"
      "}\n",
    }};
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      nullptr /* resolver */, true /* finalize */, true /* incrementally */);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(42, value);
 
  // clang-format off
  Dart_SourceFile updated_sourcefiles[] = {
    {
      "file:///test-app.dart",
      "import 'test-lib.dart';\n"
      "class Account {\n"
      "  int balance() => 24;\n"
      "}\n"
      "class MyAccountState extends State<Account> {\n"
      "  MyAccountState(Account a): super(a) {}\n"
      "}\n"
      "main() {\n"
      "  return (new MyAccountState(new Account()))\n"
      "      .howAreTheThings().balance();\n"
      "}\n",
    }};
  // clang-format on
  {
    const uint8_t* kernel_buffer = nullptr;
    intptr_t kernel_buffer_size = 0;
    char* error = TestCase::CompileTestScriptWithDFE(
        "file:///test-app.dart",
        sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
        updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
        true /* incrementally */);
    EXPECT(error == nullptr);
    EXPECT_NOTNULL(kernel_buffer);
 
    lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size);
    EXPECT_VALID(lib);
  }
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(24, value);
}

TEST_CASE() [391/600]

dart::TEST_CASE

(

IsolateReload_LibraryDebuggable

)

Definition at line 659 of file isolate_reload_test.cc.

                                           {
  const char* kScript =
      "main() {\n"
      "  return 1;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  // The library is by default debuggable.  Make it not debuggable.
  intptr_t lib_id = -1;
  bool debuggable = false;
  EXPECT_VALID(Dart_LibraryId(lib, &lib_id));
  EXPECT_VALID(Dart_GetLibraryDebuggable(lib_id, &debuggable));
  EXPECT_EQ(true, debuggable);
  EXPECT_VALID(Dart_SetLibraryDebuggable(lib_id, false));
  EXPECT_VALID(Dart_GetLibraryDebuggable(lib_id, &debuggable));
  EXPECT_EQ(false, debuggable);
 
  EXPECT_EQ(1, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "main() {\n"
      "  return 2;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
 
  EXPECT_EQ(2, SimpleInvoke(lib, "main"));
 
  // Library debuggability is preserved.
  intptr_t new_lib_id = -1;
  EXPECT_VALID(Dart_LibraryId(lib, &new_lib_id));
  EXPECT_VALID(Dart_GetLibraryDebuggable(new_lib_id, &debuggable));
  EXPECT_EQ(false, debuggable);
}

TEST_CASE() [392/600]

dart::TEST_CASE

(

IsolateReload_LibraryHide

)

Definition at line 1136 of file isolate_reload_test.cc.

                                     {
  const char* kImportScript = "importedFunc() => 'a';\n";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  // Import 'test:lib1' with importedFunc hidden. Will result in an
  // error.
  const char* kScript =
      "import 'test:lib1' hide importedFunc;\n"
      "main() {\n"
      "  return importedFunc();\n"
      "}\n";
 
  // Dart_Handle result;
 
  Dart_Handle lib = TestCase::LoadTestScriptWithErrors(kScript);
  EXPECT_VALID(lib);
  EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc");
 
  // Import 'test:lib1'.
  const char* kReloadScript =
      "import 'test:lib1';\n"
      "main() {\n"
      "  return importedFunc();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("a", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [393/600]

dart::TEST_CASE

(

IsolateReload_LibraryImportAdded

)

Definition at line 618 of file isolate_reload_test.cc.

                                            {
  const char* kScript =
      "main() {\n"
      "  return max(3, 4);\n"
      "}\n";
 
  const char* kReloadScript =
      "import 'dart:math';\n"
      "main() {\n"
      "  return max(3, 4);\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScriptWithErrors(kScript);
  EXPECT_VALID(lib);
  EXPECT_ERROR(SimpleInvokeError(lib, "main"), "max");
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
}

TEST_CASE() [394/600]

dart::TEST_CASE

(

IsolateReload_LibraryImportRemoved

)

Definition at line 639 of file isolate_reload_test.cc.

                                              {
  const char* kScript =
      "import 'dart:math';\n"
      "main() {\n"
      "  return max(3, 4);\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "main() {\n"
      "  return max(3, 4);\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(SimpleInvokeError(lib, "main"), "max");
}

TEST_CASE() [395/600]

dart::TEST_CASE

(

IsolateReload_LibraryLookup

)

Definition at line 1095 of file isolate_reload_test.cc.

                                       {
  const char* kImportScript = "importedFunc() => 'a';\n";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  const char* kScript =
      "main() {\n"
      "  return 'b';\n"
      "}\n";
  Dart_Handle result;
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("b", SimpleInvokeStr(lib, "main"));
 
  // Fail to find 'test:lib1' in the isolate.
  result = Dart_LookupLibrary(NewString("test:lib1"));
  EXPECT(Dart_IsError(result));
 
  const char* kReloadScript =
      "import 'test:lib1';\n"
      "main() {\n"
      "  return importedFunc();\n"
      "}\n";
 
  // Reload and add 'test:lib1' to isolate.
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("a", SimpleInvokeStr(lib, "main"));
 
  // Find 'test:lib1' in the isolate.
  result = Dart_LookupLibrary(NewString("test:lib1"));
  EXPECT(Dart_IsLibrary(result));
 
  // Reload and remove 'test:lib1' from isolate.
  lib = TestCase::ReloadTestScript(kScript);
  EXPECT_VALID(lib);
 
  // Fail to find 'test:lib1' in the isolate.
  result = Dart_LookupLibrary(NewString("test:lib1"));
  EXPECT(Dart_IsError(result));
}

TEST_CASE() [396/600]

dart::TEST_CASE

(

IsolateReload_LibraryShow

)

Definition at line 1166 of file isolate_reload_test.cc.

                                     {
  const char* kImportScript =
      "importedFunc() => 'a';\n"
      "importedIntFunc() => 4;\n";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  // Import 'test:lib1' with importedIntFunc visible. Will result in
  // an error when 'main' is invoked.
  const char* kScript =
      "import 'test:lib1' show importedIntFunc;\n"
      "main() {\n"
      "  return importedFunc();\n"
      "}\n"
      "mainInt() {\n"
      "  return importedIntFunc();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScriptWithErrors(kScript);
  EXPECT_VALID(lib);
 
  // Works.
  EXPECT_EQ(4, SimpleInvoke(lib, "mainInt"));
  // Results in an error.
  EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc");
 
  // Import 'test:lib1' with importedFunc visible. Will result in
  // an error when 'mainInt' is invoked.
  const char* kReloadScript =
      "import 'test:lib1' show importedFunc;\n"
      "main() {\n"
      "  return importedFunc();\n"
      "}\n"
      "mainInt() {\n"
      "  return importedIntFunc();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib, "importedIntFunc");
}

TEST_CASE() [397/600]

dart::TEST_CASE

(

IsolateReload_LiveStack

)

Definition at line 1062 of file isolate_reload_test.cc.

                                   {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "helper() => 7;\n"
      "alpha() { var x = helper(); reloadTest(); return x + helper(); }\n"
      "foo() => alpha();\n"
      "bar() => foo();\n"
      "main() {\n"
      "  return bar();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "helper() => 100;\n"
      "alpha() => 5 + helper();\n"
      "foo() => alpha();\n"
      "bar() => foo();\n"
      "main() {\n"
      "  return bar();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_EQ(107, SimpleInvoke(lib, "main"));
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
  EXPECT_EQ(105, SimpleInvoke(lib, "main"));
}

TEST_CASE() [398/600]

dart::TEST_CASE

(

IsolateReload_MainLibModified

)

Definition at line 4488 of file isolate_reload_test.cc.

                                                                    {
  return false;
}
 
TEST_CASE(IsolateReload_NoLibsModified) {
  const char* kImportScript = "importedFunc() => 'fancy';";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  const char* kScript =
      "import 'test:lib1';\n"
      "main() {\n"
      "  return importedFunc() + ' feast';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadImportScript = "importedFunc() => 'bossy';";
  TestCase::AddTestLib("test:lib1", kReloadImportScript);
 
  const char* kReloadScript =
      "import 'test:lib1';\n"
      "main() {\n"
      "  return importedFunc() + ' pants';\n"
      "}\n";
 
  Dart_SetFileModifiedCallback(&NothingModifiedCallback);
  lib = TestCase::ReloadTestScript(kReloadScript);

TEST_CASE() [399/600]

dart::TEST_CASE

(

IsolateReload_MixinChanged

)

Definition at line 931 of file isolate_reload_test.cc.

                                      {
  const char* kScript =
      "mixin Mixin1 {\n"
      "  var field = 'mixin1';\n"
      "  func() => 'mixin1';\n"
      "}\n"
      "class B extends Object with Mixin1 {\n"
      "}\n"
      "var saved = new B();\n"
      "main() {\n"
      "  return 'saved:field=${saved.field},func=${saved.func()}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("saved:field=mixin1,func=mixin1", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "mixin Mixin2 {\n"
      "  var field = 'mixin2';\n"
      "  func() => 'mixin2';\n"
      "}\n"
      "class B extends Object with Mixin2 {\n"
      "}\n"
      "var saved = new B();\n"
      "main() {\n"
      "  var newer = new B();\n"
      "  return 'saved:field=${saved.field},func=${saved.func()} '\n"
      "         'newer:field=${newer.field},func=${newer.func()}';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
 
  // The saved instance of B retains its old field value from mixin1,
  // but it gets the new implementation of func from mixin2.
  EXPECT_STREQ(
      "saved:field=mixin1,func=mixin2 "
      "newer:field=mixin2,func=mixin2",
      SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [400/600]

dart::TEST_CASE

(

IsolateReload_NoLibsModified

)

Definition at line 4448 of file isolate_reload_test.cc.

            {
      dynamic x;
      A(this.x);
    }
    dynamic a;
    main() {
      a.x = 10;
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib,
               "Const class cannot become non-const: "
               "Library:'file:///test-lib' Class: A");
}
 
TEST_CASE(IsolateReload_StaticTearOffRetainsHash) {
  const char* kScript =
      "foo() {}\n"
      "var hash1, hash2;\n"
      "main() {\n"
      "  hash1 = foo.hashCode;\n"
      "  return 'okay';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "foo() {}\n"

TEST_CASE() [401/600]

dart::TEST_CASE

(

IsolateReload_NotEnumToEnum

)

Definition at line 2156 of file isolate_reload_test.cc.

                                       {
  const char* kScript =
      "class Fruit {\n"
      "  final int zero = 0;\n"
      "}\n"
      "main() {\n"
      "  return new Fruit().zero.toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("0", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "enum Fruit {\n"
      "  Apple\n"
      "}\n"
      "main() {\n"
      "  return Fruit.Apple.toString();\n"
      "}\n";
 
  Dart_Handle result = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(result, "Class cannot be redefined to be a enum class");
}

TEST_CASE() [402/600]

dart::TEST_CASE

(

IsolateReload_NotTypedefToTypedef

)

Definition at line 5896 of file isolate_reload_test.cc.

                                                                        {
  const char* kScript = R"(
    class A {}
    class B extends A {}
    typedef bool Predicate(B b);
    Predicate value = init();
    init() => (A a) => true;
    main() {
      return value.toString();
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Closure: (A) => bool", SimpleInvokeStr(lib, "main"));
 
  // B is no longer a subtype of A.
  const char* kReloadScript = R"(
    class A {}
    class B {}
    typedef bool Predicate(B b);
    Predicate value = init();
    init() => (B a) => true;

TEST_CASE() [403/600]

dart::TEST_CASE

(

IsolateReload_PatchStaticInitializerWithClosure

)

Definition at line 5946 of file isolate_reload_test.cc.

                       {\n"
      "  bool call(dynamic x) { return false; }\n"
      "}\n"
      "main() {\n"
      "  return (42 is Predicate).toString();\n"
      "}\n";
 
  Dart_Handle result = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(result);
}
 
TEST_CASE(IsolateReload_NotTypedefToTypedef) {
  const char* kScript =
      "class Predicate {\n"
      "  bool call(dynamic x) { return false; }\n"
      "}\n"
      "main() {\n"

TEST_CASE() [404/600]

dart::TEST_CASE

(

IsolateReload_PendingConstructorCall_AbstractToConcrete

)

Definition at line 1381 of file isolate_reload_test.cc.

                                                                   {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "abstract class Foo {}\n"
      "class C {\n"
      "  test() {\n"
      "    reloadTest();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    new C().test();\n"
      "    return 'okay';\n"
      "  } catch (e) {\n"
      "    return 'exception';\n"
      "  }\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class Foo {}\n"
      "class C {\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return new Foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    new C().test();\n"
      "    return 'okay';\n"
      "  } catch (e) {\n"
      "    return 'exception';\n"
      "  }\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  const char* expected = "okay";
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_STREQ(expected, result);
 
  // Bail out if we've already failed so we don't crash in the tag handler.
  if ((result == nullptr) || (strcmp(expected, result) != 0)) {
    return;
  }
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
  EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [405/600]

dart::TEST_CASE

(

IsolateReload_PendingConstructorCall_ConcreteToAbstract

)

Definition at line 1436 of file isolate_reload_test.cc.

                                                                   {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class Foo {}\n"
      "class C {\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return new Foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    new C().test();\n"
      "    return 'okay';\n"
      "  } catch (e) {\n"
      "    return 'exception';\n"
      "  }\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "abstract class Foo {}\n"
      "class C {\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return new Foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    new C().test();\n"
      "    return 'okay';\n"
      "  } catch (e) {\n"
      "    return 'exception';\n"
      "  }\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
  EXPECT_ERROR(SimpleInvokeError(lib, "main"), "is abstract");
}

TEST_CASE() [406/600]

dart::TEST_CASE

(

IsolateReload_PendingStaticCall_DefinedToNSM

)

Definition at line 1480 of file isolate_reload_test.cc.

                                                        {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo() => 'static';\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return C.foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    return new C().test();\n"
      "  } catch (e) {\n"
      "    return 'exception';\n"
      "  }\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return C.foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    return new C().test();\n"
      "  } catch (e) {\n"
      "    return 'exception';\n"
      "  }\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
  const char* expected = "exception";
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_NOTNULL(result);
 
  // Bail out if we've already failed so we don't crash in StringEquals.
  if (result == nullptr) {
    return;
  }
  EXPECT_STREQ(expected, result);
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
  EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [407/600]

dart::TEST_CASE

(

IsolateReload_PendingStaticCall_NSMToDefined

)

Definition at line 1533 of file isolate_reload_test.cc.

                                                        {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return C.foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    return new C().test();\n"
      "  } catch (e) {\n"
      "    return 'exception';\n"
      "  }\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo() => 'static';\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return C.foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    return new C().test();\n"
      "  } catch (e) {\n"
      "    return 'exception';\n"
      "  }\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  const char* expected = "static";
  const char* result = SimpleInvokeStr(lib, "main");
 
  // Bail out if we've already failed so we don't crash in the tag handler.
  if (result == nullptr) {
    return;
  }
  EXPECT_STREQ(expected, result);
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
  EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [408/600]

dart::TEST_CASE

(

IsolateReload_PendingSuperCall

)

Definition at line 1586 of file isolate_reload_test.cc.

                                          {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class S {\n"
      "  foo() => 1;\n"
      "}\n"
      "class C extends S {\n"
      "  foo() => 100;\n"
      "  test() {\n"
      "    var n = super.foo();\n"
      "    reloadTest();\n"
      "    return n + super.foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return new C().test();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class S {\n"
      "  foo() => 10;\n"
      "}\n"
      "class C extends S {\n"
      "  foo() => 100;\n"
      "  test() {\n"
      "    var n = super.foo();\n"
      "    reloadTest();\n"
      "    return n + super.foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return new C().test();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_EQ(11, SimpleInvoke(lib, "main"));
}

TEST_CASE() [409/600]

dart::TEST_CASE

(

IsolateReload_PendingUnqualifiedCall_InstanceToStatic

)

Definition at line 1336 of file isolate_reload_test.cc.

                                                                 {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  foo() => 'instance';\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return new C().test();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo() => 'static';\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return new C().test();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
  const char* expected = "static";
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_NOTNULL(result);
  // Bail out if we've already failed so we don't crash in StringEquals.
  if (result == nullptr) {
    return;
  }
  EXPECT_STREQ(expected, result);
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
  EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [410/600]

dart::TEST_CASE

(

IsolateReload_PendingUnqualifiedCall_StaticToInstance

)

Definition at line 1290 of file isolate_reload_test.cc.

                                                                 {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo() => 'static';\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return new C().test();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  foo() => 'instance';\n"
      "  test() {\n"
      "    reloadTest();\n"
      "    return foo();\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  return new C().test();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  const char* expected = "instance";
  const char* result = SimpleInvokeStr(lib, "main");
  EXPECT_STREQ(expected, result);
 
  // Bail out if we've already failed so we don't crash in the tag handler.
  if ((result == nullptr) || (strcmp(expected, result) != 0)) {
    return;
  }
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
  EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [411/600]

dart::TEST_CASE

(

IsolateReload_PrefixImportedLibModified

)

Definition at line 4559 of file isolate_reload_test.cc.

                                                                   {
  if (strcmp(url, "test:lib1") == 0) {
    return true;
  }
  return false;
}
 
TEST_CASE(IsolateReload_ImportedLibModified) {
  const char* kImportScript = "importedFunc() => 'fancy';";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  const char* kScript =
      "import 'test:lib1';\n"
      "main() {\n"
      "  return importedFunc() + ' feast';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadImportScript = "importedFunc() => 'bossy';";
  TestCase::AddTestLib("test:lib1", kReloadImportScript);
 
  const char* kReloadScript =

TEST_CASE() [412/600]

dart::TEST_CASE

(

IsolateReload_RegressB179030011

)

Definition at line 6145 of file isolate_reload_test.cc.

                                                          {
  Dart_SourceFile sources[] = {source};
  char* error = TestCase::CompileTestScriptWithDFE(
      sources[0].uri, ARRAY_SIZE(sources), sources, kernel_buffer,
      kernel_buffer_size,
      /*incrementally=*/false);
  EXPECT(error == nullptr);
  EXPECT_NOTNULL(kernel_buffer);
}
 
// LibraryTagHandler which returns a fixed Kernel binary back every time it
// receives a Dart_kKernelTag request. The binary is wrapped in an external
// typed data with a finalizer attached to it. If this finalizer is called
// it will set |was_finalized_| to true.
class KernelTagHandler {
 public:
  KernelTagHandler(uint8_t* kernel_buffer, intptr_t kernel_buffer_size)
      : kernel_buffer_(kernel_buffer), kernel_buffer_size_(kernel_buffer_size) {
    Dart_SetLibraryTagHandler(&LibraryTagHandler);
    instance_ = this;
  }
 
  ~KernelTagHandler() {
    Dart_SetLibraryTagHandler(nullptr);
    instance_ = nullptr;
  }
 
  static KernelTagHandler* Current() { return instance_; }
 
  bool was_called() const { return was_called_; }
  bool was_finalized() const { return was_finalized_; }
 
 private:
  static void Finalizer(void* isolate_callback_data, void* peer) {
    if (auto handler = KernelTagHandler::Current()) {
      handler->was_finalized_ = true;
    }
  }
 
  static Dart_Handle LibraryTagHandler(Dart_LibraryTag tag,
                                       Dart_Handle library,
                                       Dart_Handle url) {
    if (tag == Dart_kKernelTag) {
      auto handler = KernelTagHandler::Current();
      handler->was_called_ = true;
 
      Dart_Handle result = Dart_NewExternalTypedData(
          Dart_TypedData_kUint8, handler->kernel_buffer_,
          handler->kernel_buffer_size_);
      Dart_NewFinalizableHandle(result, handler->kernel_buffer_,
                                handler->kernel_buffer_size_, &Finalizer);
      return result;
    }
    UNREACHABLE();
    return Dart_Null();
  }
 
  static KernelTagHandler* instance_;
  uint8_t* kernel_buffer_;
  intptr_t kernel_buffer_size_;
  bool was_finalized_ = false;
  bool was_called_ = false;
};
 

TEST_CASE() [413/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializers

)

Definition at line 4678 of file isolate_reload_test.cc.

                                                {
  const char* kScript =
      "const value = 'a';\n"
      "main() {\n"
      "  return 'value=${value}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("value=a", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "const value = 'b';\n"
      "main() {\n"
      "  return 'value=${value}';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("value=b", SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_ConstFieldUpdate) {
  const char* kScript =
      "const value = const Duration(seconds: 1);\n"
      "main() {\n"
      "  return 'value=${value}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("value=0:00:01.000000", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "const value = const Duration(seconds: 2);\n"
      "main() {\n"
      "  return 'value=${value}';\n"
      "}\n";

TEST_CASE() [414/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersCyclicInitialization

)

Definition at line 4992 of file isolate_reload_test.cc.

                                                       {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                            "class Foo {\n"
                                            "  int x = 4;\n"
                                            "}\n"
                                            "%s Foo value;\n"
                                            "main() {\n"
                                            "  value = Foo();\n"
                                            "  return value.x;\n"
                                            "}\n",
                                            late_tag),
                                         std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y.
  // clang-format off
  auto kReloadScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                "class Foo {\n"
                                "  int x = 4;\n"
                                "  int y = throw 'exception';\n"
                                "}\n"
                                "%s Foo value;\n"
                                "main() {\n"
                                "  try {\n"
                                "    return value.y.toString();\n"
                                "  } catch (e) {\n"
                                "    return e.toString();\n"
                                "  }\n"
                                "}\n",
                                late_tag),
                              std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  // Verify that we ran field initializers on existing instances.

TEST_CASE() [415/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersLazy

)

Definition at line 4764 of file isolate_reload_test.cc.

                                                                     {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                          "int myInitialValue = 8 * 7;\n"
                                          "class Foo {\n"
                                          "  int x = 4;\n"
                                          "}\n"
                                          "%s Foo value;\n"
                                          "main() {\n"
                                          "  value = Foo();\n"
                                          "  return value.x;\n"
                                          "}\n",
                                          late_tag),
                              std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y.
  // clang-format off
  auto kReloadScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                          "int myInitialValue = 8 * 7;\n"
                                          "class Foo {\n"
                                          "  int x = 4;\n"
                                          "  int y = myInitialValue;\n"
                                          "}\n"
                                          "%s Foo value;\n"
                                          "main() {\n"
                                          "  return value.y;\n"
                                          "}\n",
                                          late_tag),
                              std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  // Verify that we ran field initializers on existing instances.
  EXPECT_EQ(56, SimpleInvoke(lib, "main"));
}
 
TEST_CASE(IsolateReload_RunNewFieldInitializersLazy) {
  const char* late_tag = TestCase::LateTag();

TEST_CASE() [416/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersLazyConst

)

Definition at line 4813 of file isolate_reload_test.cc.

                                           {\n"
                                "  int x = 4;\n"
                                "}\n"
                                "%s Foo value;\n"
                                "%s Foo value1;\n"
                                "main() {\n"
                                "  value = Foo();\n"
                                "  value1 = Foo();\n"
                                "  return value.x;\n"
                                "}\n",
                                late_tag, late_tag),
                              std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y.
  // clang-format off
  auto kReloadScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "int myInitialValue = 8 * 7;\n"
                  "class Foo {\n"
                  "  int x = 4;\n"
                  "  int y = myInitialValue++;\n"
                  "}\n"
                  "%s Foo value;\n"
                  "%s Foo value1;\n"
                  "main() {\n"
                  "  return '${myInitialValue} ${value.y} ${value1.y} "
                  "${myInitialValue}';\n"
                  "}\n",
                  late_tag, late_tag),
      std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  // Verify that field initializers ran lazily.
  EXPECT_STREQ("56 56 57 58", SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_RunNewFieldInitializersLazyConst) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                            "class Foo {\n"
                                            "  int x = 4;\n"
                                            "}\n"
                                            "%s Foo value;\n"
                                            "main() {\n"
                                            "  value = Foo();\n"
                                            "  return value.x;\n"
                                            "}\n",
                                            late_tag),
                                         std::free);

TEST_CASE() [417/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersLazyTransitive

)

Definition at line 4874 of file isolate_reload_test.cc.

                                                             {\n"
                                                  "  int x = 4;\n"
                                                  "  int y = 5;\n"
                                                  "}\n"
                                                  "%s Foo value;\n"
                                                  "main() {\n"
                                                  "  return 0;\n"
                                                  "}\n",
                                                  late_tag),
                                               std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  EXPECT_EQ(0, SimpleInvoke(lib, "main"));
 
  // Change y's initializer and check this new initializer is used.
  auto kReloadScript2 =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                          "class Foo {\n"
                                          "  int x = 4;\n"
                                          "  int y = 6;\n"
                                          "}\n"
                                          "%s Foo value;\n"
                                          "main() {\n"
                                          "  return value.y;\n"
                                          "}\n",
                                          late_tag),
                              std::free);
 
  lib = TestCase::ReloadTestScript(kReloadScript2.get());
  EXPECT_VALID(lib);
  EXPECT_EQ(6, SimpleInvoke(lib, "main"));
}
 
TEST_CASE(IsolateReload_RunNewFieldInitializersLazyTransitive) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                "int myInitialValue = 8 * 7;\n"
                                "class Foo {\n"
                                "  int x = 4;\n"
                                "}\n"
                                "%s Foo value;\n"
                                "%s Foo value1;\n"
                                "main() {\n"
                                "  value = Foo();\n"
                                "  value1 = Foo();\n"
                                "  return value.x;\n"
                                "}\n",
                                late_tag, late_tag),
                              std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y. Do not touch y.

TEST_CASE() [418/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersReferenceStaticField

)

Definition at line 4719 of file isolate_reload_test.cc.

                       :00:02.000000", SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_RunNewFieldInitializers) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                            "class Foo {\n"
                                            "  int x = 4;\n"
                                            "}\n"
                                            "%s Foo value;\n"
                                            "main() {\n"
                                            "  value = Foo();\n"
                                            "  return value.x;\n"
                                            "}\n",
                                            late_tag),
                                         std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y.
  // clang-format off
  auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                                  "class Foo {\n"
                                                  "  int x = 4;\n"
                                                  "  int y = 7;\n"
                                                  "}\n"
                                                  "%s Foo value;\n"
                                                  "main() {\n"
                                                  "  return value.y;\n"
                                                  "}\n",
                                                  late_tag),
                                               std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  // Verify that we ran field initializers on existing instances.
  EXPECT_EQ(7, SimpleInvoke(lib, "main"));

TEST_CASE() [419/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersSuperClass

)

Definition at line 5174 of file isolate_reload_test.cc.

                                                             {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "class Foo {\n"
                  "  Foo() { /* default constructor */ }\n"
                  "  int x = 4;\n"
                  "}\n"
                  "%s Foo value;\n"
                  "main() {\n"
                  "  value = Foo();\n"
                  "  return value.x;\n"
                  "}\n",
                  late_tag),
      std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y with a syntax error in the initializing expression.
  // clang-format off
  auto kReloadScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "class Foo {\n"
                  "  Foo() { /* default constructor */ }\n"
                  "  int x = 4;\n"
                  "  int y = ......\n"
                  "}\n"
                  "%s Foo value;\n"
                  "main() {\n"
                  "  return '${value.y == null}';"
                  "}\n",
                  late_tag),
      std::free);
  // clang-format on
 
  // The reload fails because the initializing expression is parsed at
  // class finalization time.
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_ERROR(lib, "......");
}
 
TEST_CASE(IsolateReload_RunNewFieldInitializersSuperClass) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                "class Super {\n"
                                "  static var foo = 'right';\n"
                                "}\n"

TEST_CASE() [420/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersSyntaxError

)

Definition at line 5038 of file isolate_reload_test.cc.

                                                                     {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                          "class Foo {\n"
                                            "  int x = 4;\n"
                                            "}\n"
                                            "%s Foo value;\n"
                                            "main() {\n"
                                            "  value = Foo();\n"
                                            "  return value.x;\n"
                                            "}\n",
                                            late_tag),
                                         std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y.
  // clang-format off
  auto kReloadScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                "class Foo {\n"
                                "  int x = 4;\n"
                                "  int y = value.y;\n"
                                "}\n"
                                "%s Foo value;\n"
                                "main() {\n"
                                "  try {\n"
                                "    return value.y.toString();\n"
                                "  } catch (e) {\n"
                                "    return e.toString();\n"
                                "  }\n"
                                "}\n",
                                late_tag),
                              std::free);
  // clang-format on
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);

TEST_CASE() [421/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersSyntaxError2

)

Definition at line 5082 of file isolate_reload_test.cc.

                                                            {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                            "class Foo {\n"
                                            "  int x = 4;\n"
                                            "}\n"
                                            "%s Foo value;\n"
                                            "main() {\n"
                                            "  value = Foo();\n"
                                            "  return value.x;\n"
                                            "}\n",
                                            late_tag),
                                         std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y with a syntax error in the initializing expression.
  // clang-format off
  auto kReloadScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                "class Foo {\n"
                                "  int x = 4;\n"
                                "  int y = ......;\n"
                                "}\n"
                                "%s Foo value;\n"
                                "main() {\n"
                                "  return '${value.y == null}';"
                                "}\n",
                                late_tag),
                              std::free);
  // clang-format on
 
  // The reload fails because the initializing expression is parsed at
  // class finalization time.
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_ERROR(lib, "...");
}
 

TEST_CASE() [422/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersSyntaxError3

)

Definition at line 5129 of file isolate_reload_test.cc.

                             {\n"
                  "  Foo() { /* default constructor */ }\n"
                  "  int x = 4;\n"
                  "}\n"
                  "%s Foo value;\n"
                  "main() {\n"
                  "  value = Foo();\n"
                  "  return value.x;\n"
                  "}\n",
                  late_tag),
      std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  // Add the field y with a syntax error in the initializing expression.
  // clang-format off
  auto kReloadScript = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "class Foo {\n"
                  "  Foo() { /* default constructor */ }\n"
                  "  int x = 4;\n"
                  "  int y = ......;\n"
                  "}\n"
                  "%s Foo value;\n"
                  "main() {\n"
                  "  return '${value.y == null}';"
                  "}\n",
                  late_tag),
      std::free);
  // clang-format on
 
  // The reload fails because the initializing expression is parsed at
  // class finalization time.
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_ERROR(lib, "...");
}
 

TEST_CASE() [423/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersThrows

)

Definition at line 4946 of file isolate_reload_test.cc.

                                           {\n"
                                "  int x = 4;\n"
                                "  int y = myInitialValue++;\n"
                                "}\n"
                                "%s Foo value;\n"
                                "%s Foo value1;\n"
                                "main() {\n"
                                "  return '${myInitialValue}';\n"
                                "}\n",
                                late_tag, late_tag),
                              std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  EXPECT_STREQ("56", SimpleInvokeStr(lib, "main"));
 
  // Reload again. Field y's getter still needs to keep for initialization even
  // though it is no longer new.
  // clang-format off
  auto kReloadScript2 = Utils::CStringUniquePtr(
      OS::SCreate(nullptr,
                  "int myInitialValue = 8 * 7;\n"
                  "class Foo {\n"
                  "  int x = 4;\n"
                  "  int y = myInitialValue++;\n"
                  "}\n"
                  "%s Foo value;\n"
                  "%s Foo value1;\n"
                  "main() {\n"
                  "  return '${myInitialValue} ${value.y} ${value1.y} "
                  "${myInitialValue}';\n"
                  "}\n",
                  late_tag, late_tag),
      std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript2.get());
  EXPECT_VALID(lib);
  // Verify that field initializers ran lazily.
  EXPECT_STREQ("56 56 57 58", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [424/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersWithConsts

)

Definition at line 5229 of file isolate_reload_test.cc.

                                        {\n"
                                "  Super.foo;\n"
                                "  Foo.foo;\n"
                                "  value = Foo();\n"
                                "  return 0;\n"
                                "}\n",
                                late_tag),
                              std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(0, SimpleInvoke(lib, "main"));
 
  // clang-format on
  auto kReloadScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                          "class Super {\n"
                                          "  static var foo = 'right';\n"
                                          "  var newField = foo;\n"
                                          "}\n"
                                          "class Foo extends Super {\n"
                                          "  static var foo = 'wrong';\n"
                                          "}\n"
                                          "%s Foo value;\n"
                                          "main() {\n"
                                          "  return value.newField;\n"
                                          "}\n",
                                          late_tag),
                              std::free);
  // clang-format off
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  // Verify that we ran field initializers on existing instances in the
  // correct scope.
  const char* actual = SimpleInvokeStr(lib, "main");
  EXPECT(actual != nullptr);
  if (actual != nullptr) {
    EXPECT_STREQ("right", actual);
  }
}
 
TEST_CASE(IsolateReload_RunNewFieldInitializersWithConsts) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                "class C {\n"
                                "  final x;\n"
                                "  const C(this.x);\n"
                                "}\n"
                                "var a = const C(const C(1));\n"
                                "var b = const C(const C(2));\n"
                                "var c = const C(const C(3));\n"
                                "var d = const C(const C(4));\n"
                                "class Foo {\n"
                                "}\n"

TEST_CASE() [425/600]

dart::TEST_CASE

(

IsolateReload_RunNewFieldInitializersWithGenerics

)

Definition at line 5291 of file isolate_reload_test.cc.

                                        {\n"
                                "  value = Foo();\n"
                                "  a; b; c; d;\n"
                                "  return 'Okay';\n"
                                "}\n",
                                late_tag),
                              std::free);
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main"));
 
  // clang-format off
  auto kReloadScript = Utils::CStringUniquePtr(
      OS::SCreate(
          nullptr,
          "class C {\n"
          "  final x;\n"
          "  const C(this.x);\n"
          "}\n"
          "var a = const C(const C(1));\n"
          "var b = const C(const C(2));\n"
          "var c = const C(const C(3));\n"
          "var d = const C(const C(4));\n"
          "class Foo {\n"
          "  var d = const C(const C(4));\n"
          "  var c = const C(const C(3));\n"
          "  var b = const C(const C(2));\n"
          "  var a = const C(const C(1));\n"
          "}\n"
          "%s Foo value;\n"
          "main() {\n"
          "  return '${identical(a, value.a)} ${identical(b, value.b)}'"
          "      ' ${identical(c, value.c)} ${identical(d, value.d)}';\n"
          "}\n",
          late_tag),
      std::free);
  // clang-format on
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  // Verify that we ran field initializers on existing instances and the const
  // expressions were properly canonicalized.
  EXPECT_STREQ("true true true true", SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_RunNewFieldInitializersWithGenerics) {
  const char* nullable_tag = TestCase::NullableTag();
  const char* late_tag = TestCase::LateTag();

TEST_CASE() [426/600]

dart::TEST_CASE

(

IsolateReload_SavedClosure

)

Definition at line 422 of file isolate_reload_test.cc.

                                      {
  // Create a closure in main which only exists in the original source.
  const char* kScript =
      "magic() {\n"
      "  var x = 'ante';\n"
      "  return x + 'diluvian';\n"
      "}\n"
      "var closure;\n"
      "main() {\n"
      "  closure = () { return magic().toString() + '!'; };\n"
      "  return closure();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("antediluvian!", SimpleInvokeStr(lib, "main"));
 
  // Remove the original closure from the source code.  The closure is
  // able to be recompiled because its source is preserved in a
  // special patch class.
  const char* kReloadScript =
      "magic() {\n"
      "  return 'postapocalyptic';\n"
      "}\n"
      "var closure;\n"
      "main() {\n"
      "  return closure();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("postapocalyptic!", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [427/600]

dart::TEST_CASE

(

IsolateReload_ShapeChange_Const_AddSlot

)

Definition at line 4071 of file isolate_reload_test.cc.

                                                   {
  // On IA32, instructions can contain direct pointers to const objects. We need
  // to be careful that if the const objects are reallocated because of a shape
  // change, they are allocated old. Because instructions normally contain
  // pointers only to old objects, the scavenger does not bother to ensure code
  // pages are writable when visiting the remembered set. Visiting the
  // remembered involves writing to update the pointer for any target that gets
  // promoted.
  const char* kScript = R"(
    import 'file:///test:isolate_reload_helper';
    class A {
      final x;
      const A(this.x);
    }
    var a;
    main() {
      a = const A(1);
      collectNewSpace();
      return 'okay';
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript = R"(
    import 'file:///test:isolate_reload_helper';
    class A {
      final x, y, z;
      const A(this.x, this.y, this.z);
    }
    var a;
    main() {
      a = const A(1, null, null);
      collectNewSpace();
      return 'okay';
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript2 = R"(
    import 'file:///test:isolate_reload_helper';
    class A {
      final x, y, z, w, u;
      const A(this.x, this.y, this.z, this.w, this.u);
    }
    var a;
    main() {
      a = const A(1, null, null, null, null);
      collectNewSpace();
      return 'okay';
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript2);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [428/600]

dart::TEST_CASE

(

IsolateReload_ShapeChange_Const_RemoveSlot

)

Definition at line 4134 of file isolate_reload_test.cc.

                                                      {
  const char* kScript = R"(
    import 'file:///test:isolate_reload_helper';
    class A {
      final x, y, z;
      const A(this.x, this.y, this.z);
    }
    var a;
    main() {
      a = const A(1, 2, 3);
      collectNewSpace();
      return 'okay';
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript = R"(
    import 'file:///test:isolate_reload_helper';
    class A {
      final x, y;
      const A(this.x, this.y);
    }
    var a;
    main() {
      a = const A(1, null);
      collectNewSpace();
      return 'okay';
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib,
               "Const class cannot remove fields: "
               "Library:'file:///test-lib' Class: A");
 
  // Rename is seen by the VM is unrelated add and remove.
  const char* kReloadScript2 = R"(
    import 'file:///test:isolate_reload_helper';
    class A {
      final x, y, w;
      const A(this.x, this.y, this.w);
    }
    var a;
    main() {
      a = const A(1, null, null);
      collectNewSpace();
      return 'okay';
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript2);
  EXPECT_ERROR(lib,
               "Const class cannot remove fields: "
               "Library:'file:///test-lib' Class: A");
}

TEST_CASE() [429/600]

dart::TEST_CASE

(

IsolateReload_ShapeChangeMutualReference

)

Definition at line 3966 of file isolate_reload_test.cc.

                                                    {
  const char* kScript =
      "class A{\n"
      "  var x;\n"
      "  get yourself => this;\n"
      "}\n"
      "var retained1;\n"
      "var retained2;\n"
      "main() {\n"
      "  retained1 = new A();\n"
      "  retained2 = new A();\n"
      "  retained1.x = retained2;\n"
      "  retained2.x = retained1;\n"
      "  return '${identical(retained1.x.yourself, retained2)}'\n"
      "         '${identical(retained2.x.yourself, retained1)}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("truetrue", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class A{\n"
      "  var x;\n"
      "  var y;\n"
      "  var z;\n"
      "  var w;\n"
      "  get yourself => this;\n"
      "}\n"
      "var retained1;\n"
      "var retained2;\n"
      "main() {\n"
      "  return '${identical(retained1.x.yourself, retained2)}'\n"
      "         '${identical(retained2.x.yourself, retained1)}';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("truetrue", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [430/600]

dart::TEST_CASE

(

IsolateReload_ShapeChangeRetainsHash

)

Definition at line 4007 of file isolate_reload_test.cc.

                                                {
  const char* kScript =
      "class A{\n"
      "  var x;\n"
      "}\n"
      "var a, hash1, hash2;\n"
      "main() {\n"
      "  a = new A();\n"
      "  hash1 = a.hashCode;\n"
      "  return 'okay';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class A{\n"
      "  var x, y, z;\n"
      "}\n"
      "var a, hash1, hash2;\n"
      "main() {\n"
      "  hash2 = a.hashCode;\n"
      "  return (hash1 == hash2).toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("true", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [431/600]

dart::TEST_CASE

(

IsolateReload_ShapeChangeRetainsHash_Const

)

Definition at line 4038 of file isolate_reload_test.cc.

                                                      {
  const char* kScript =
      "class A {\n"
      "  final x;\n"
      "  const A(this.x);\n"
      "}\n"
      "var a, hash1, hash2;\n"
      "main() {\n"
      "  a = const A(1);\n"
      "  hash1 = a.hashCode;\n"
      "  return 'okay';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "class A {\n"
      "  final x, y, z;\n"
      "  const A(this.x, this.y, this.z);\n"
      "}\n"
      "var a, hash1, hash2;\n"
      "main() {\n"
      "  hash2 = a.hashCode;\n"
      "  return (hash1 == hash2).toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("true", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [432/600]

dart::TEST_CASE

(

IsolateReload_SimpleConstFieldUpdate

)

Definition at line 4634 of file isolate_reload_test.cc.

                                                                   {
  if (strcmp(url, "test:exportlib") == 0) {
    return true;
  }
  return false;
}
 
TEST_CASE(IsolateReload_ExportedLibModified) {
  const char* kImportScript = "export 'test:exportlib';";
  TestCase::AddTestLib("test:importlib", kImportScript);
 
  const char* kExportScript = "exportedFunc() => 'fancy';";
  TestCase::AddTestLib("test:exportlib", kExportScript);
 
  const char* kScript =
      "import 'test:importlib';\n"
      "main() {\n"

TEST_CASE() [433/600]

dart::TEST_CASE

(

IsolateReload_SmiFastPathStubs

)

Definition at line 1208 of file isolate_reload_test.cc.

                                          {
  const char* kImportScript = "importedIntFunc() => 4;\n";
  TestCase::AddTestLib("test:lib1", kImportScript);
 
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "import 'test:lib1' show importedIntFunc;\n"
      "main() {\n"
      "  var x = importedIntFunc();\n"
      "  var y = importedIntFunc();\n"
      "  reloadTest();\n"
      "  return x + y;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  // Identity reload.
  EXPECT_VALID(TestCase::SetReloadTestScript(kScript));
 
  EXPECT_EQ(8, SimpleInvoke(lib, "main"));
}

TEST_CASE() [434/600]

dart::TEST_CASE

(

IsolateReload_StaticFieldInitialValueDoesnotChange

)

Definition at line 5366 of file isolate_reload_test.cc.

                                      {};"
                  "}\n"
                  "%s Foo value1;\n"
                  "%s Foo value2;\n"
                  "main() {\n"
                  "  return '${value1.y.runtimeType} ${value1.z.runtimeType}'"
                  "      ' ${value2.y.runtimeType} ${value2.z.runtimeType}';\n"
                  "}\n",
                  nullable_tag, late_tag, late_tag),
      std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  // Verify that we ran field initializers on existing instances and
  // correct type arguments were used.
  EXPECT_STREQ("List<String> _Map<String, String> List<int> _Map<int, int>",
               SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_AddNewStaticField) {
  const char* kScript =
      "class C {\n"
      "}\n"
      "main() {\n"

TEST_CASE() [435/600]

dart::TEST_CASE

(

IsolateReload_StaticTargetArityChange

)

Definition at line 5971 of file isolate_reload_test.cc.

              {\n"
      "  return (42 is Predicate).toString();\n"
      "}\n";
 
  Dart_Handle result = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(result);
}
 
TEST_CASE(IsolateReload_TypedefAddParameter) {
  const char* kScript =
      "typedef bool Predicate(dynamic x);\n"
      "main() {\n"
      "  bool foo(x) => true;\n"
      "  return (foo is Predicate).toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("true", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "typedef bool Predicate(dynamic x, dynamic y);\n"
      "main() {\n"
      "  bool foo(x) => true;\n"
      "  return (foo is Predicate).toString();\n"
      "}\n";
 
  Dart_Handle result = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(result);
  EXPECT_STREQ("false", SimpleInvokeStr(lib, "main"));
}
 

TEST_CASE() [436/600]

dart::TEST_CASE

(

IsolateReload_StaticTearOffRetainsHash

)

Definition at line 4418 of file isolate_reload_test.cc.

           {
      a.x = 10;
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib,
               "Const class cannot become non-const: "
               "Library:'file:///test-lib' Class: A");
}
 
TEST_CASE(IsolateReload_ConstToNonConstClass_Empty) {
  const char* kScript = R"(
    class A {
      const A();
    }
    dynamic a;
    main() {
      a = const A();
      return 'okay';
    }
  )";
 

TEST_CASE() [437/600]

dart::TEST_CASE

(

IsolateReload_StaticValuePreserved

)

Definition at line 395 of file isolate_reload_test.cc.

                                              {
  const char* kScript =
      "init() => 'old value';\n"
      "var value = init();\n"
      "main() {\n"
      "  return 'init()=${init()},value=${value}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("init()=old value,value=old value",
               SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var _unused;"
      "init() => 'new value';\n"
      "var value = init();\n"
      "main() {\n"
      "  return 'init()=${init()},value=${value}';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("init()=new value,value=old value",
               SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [438/600]

dart::TEST_CASE

(

IsolateReload_SuperClassChanged

)

Definition at line 774 of file isolate_reload_test.cc.

                                           {
  const char* kScript =
      "class A {\n"
      "}\n"
      "class B extends A {\n"
      "}\n"
      "var list = [ new A(), new B() ];\n"
      "main() {\n"
      "  return (list.map((x) => '${x is A}/${x is B}')).toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("(true/false, true/true)", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var _unused;"
      "class B{\n"
      "}\n"
      "class A extends B {\n"
      "}\n"
      "var list = [ new A(), new B() ];\n"
      "main() {\n"
      "  return (list.map((x) => '${x is A}/${x is B}')).toString();\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("(true/true, false/true)", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [439/600]

dart::TEST_CASE

(

IsolateReload_SuperGetterReboundToMethod

)

Definition at line 6015 of file isolate_reload_test.cc.

              {\n"
      "  dynamic f = field;\n"
      "  return f('b');\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("ab", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "extraFunction() => 'Just here to change kernel offsets';\n"
      "dynamic field = (_, __) => 'Not executed';\n"
      "main() {\n"
      "  dynamic f = field;\n"
      "  return f('c');\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("ac", SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_StaticTargetArityChange) {
  const char* kScript = R"(
    class A {
      final x;
      final y;
      const A(this.x, this.y);
    }
 
    dynamic closure;
 
    main() {
      closure = () => A(1, 2);
      return "okay";
    }
  )";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript = R"(
    class A {
      final x;
      const A(this.x);
    }
 
    dynamic closure;

TEST_CASE() [440/600]

dart::TEST_CASE

(

IsolateReload_TearOff_AddArguments

)

Definition at line 1878 of file isolate_reload_test.cc.

                                              {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  foo(x) => x;\n"
      "}\n"
      "invoke(f, a) {\n"
      "  try {\n"
      "    return f(a);\n"
      "  } catch (e) {\n"
      "    return e.toString().split('\\n').first;\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  var c = new C();\n"
      "  var f = c.foo;\n"
      "  var r1 = invoke(f, 1);\n"
      "  reloadTest();\n"
      "  var r2 = invoke(f, 1);\n"
      "  return '$r1 $r2';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  foo(x, y, z) => x + y + z;\n"
      "}\n"
      "invoke(f, a) {\n"
      "  try {\n"
      "    return f(a);\n"
      "  } catch (e) {\n"
      "    return e.toString().split('\\n').first;\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  var c = new C();\n"
      "  var f = c.foo;\n"
      "  var r1 = invoke(f, 1);\n"
      "  reloadTest();\n"
      "  var r2 = invoke(f, 1);\n"
      "  return '$r1 $r2';\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ(
      "1 NoSuchMethodError: Class 'C' has no instance method "
      "'foo' with matching arguments.",
      SimpleInvokeStr(lib, "main"));
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
}

TEST_CASE() [441/600]

dart::TEST_CASE

(

IsolateReload_TearOff_AddArguments2

)

Definition at line 1935 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo(x) => x;\n"
      "}\n"
      "invoke(f, a) {\n"
      "  try {\n"
      "    return f(a);\n"
      "  } catch (e) {\n"
      "    return e.toString().split('\\n').first;\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  var f = C.foo;\n"
      "  var r1 = invoke(f, 1);\n"
      "  reloadTest();\n"
      "  var r2 = invoke(f, 1);\n"
      "  return '$r1 $r2';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo(x, y, z) => x + y + z;\n"
      "}\n"
      "invoke(f, a) {\n"
      "  try {\n"
      "    return f(a);\n"
      "  } catch (e) {\n"
      "    return e.toString().split('\\n').first;\n"
      "  }\n"
      "}\n"
      "main() {\n"
      "  var f = C.foo;\n"
      "  var r1 = invoke(f, 1);\n"
      "  reloadTest();\n"
      "  var r2 = invoke(f, 1);\n"
      "  return '$r1 $r2';\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ(
      "1 NoSuchMethodError: Closure call with mismatched arguments: "
      "function 'C.foo'",
      SimpleInvokeStr(lib, "main"));
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
}

TEST_CASE() [442/600]

dart::TEST_CASE

(

IsolateReload_TearOff_Class_Identity

)

Definition at line 1743 of file isolate_reload_test.cc.

                                                {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo() => 'old';\n"
      "}\n"
      "getFoo() => C.foo;\n"
      "main() {\n"
      "  var f1 = getFoo();\n"
      "  reloadTest();\n"
      "  var f2 = getFoo();\n"
      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo() => 'new';\n"
      "}\n"
      "getFoo() => C.foo;\n"
      "main() {\n"
      "  var f1 = getFoo();\n"
      "  reloadTest();\n"
      "  var f2 = getFoo();\n"
      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ("new new true true", SimpleInvokeStr(lib, "main"));
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
}

TEST_CASE() [443/600]

dart::TEST_CASE

(

IsolateReload_TearOff_Instance_Equality

)

Definition at line 1629 of file isolate_reload_test.cc.

                                                   {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  foo() => 'old';\n"
      "}\n"
      "main() {\n"
      "  var c = new C();\n"
      "  var f1 = c.foo;\n"
      "  reloadTest();\n"
      "  var f2 = c.foo;\n"
      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  foo() => 'new';\n"
      "}\n"
      "main() {\n"
      "  var c = new C();\n"
      "  var f1 = c.foo;\n"
      "  reloadTest();\n"
      "  var f2 = c.foo;\n"
      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ("new new true false", SimpleInvokeStr(lib, "main"));
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
}

TEST_CASE() [444/600]

dart::TEST_CASE

(

IsolateReload_TearOff_Library_Identity

)

Definition at line 1781 of file isolate_reload_test.cc.

                                                  {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "foo() => 'old';\n"
      "getFoo() => foo;\n"
      "main() {\n"
      "  var f1 = getFoo();\n"
      "  reloadTest();\n"
      "  var f2 = getFoo();\n"
      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "foo() => 'new';\n"
      "getFoo() => foo;\n"
      "main() {\n"
      "  var f1 = getFoo();\n"
      "  reloadTest();\n"
      "  var f2 = getFoo();\n"
      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ("new new true true", SimpleInvokeStr(lib, "main"));
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
}

TEST_CASE() [445/600]

dart::TEST_CASE

(

IsolateReload_TearOff_List_Set

)

Definition at line 1815 of file isolate_reload_test.cc.

                                          {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  foo() => 'old';\n"
      "}\n"
      "List list = List<dynamic>.filled(2, null);\n"
      "Set set = Set();\n"
      "main() {\n"
      "  var c = C();\n"
      "  list[0] = c.foo;\n"
      "  list[1] = c.foo;\n"
      "  set.add(c.foo);\n"
      "  set.add(c.foo);\n"
      "  int countBefore = set.length;\n"
      "  reloadTest();\n"
      "  list[1] = c.foo;\n"
      "  set.add(c.foo);\n"
      "  set.add(c.foo);\n"
      "  int countAfter = set.length;\n"
      "  return '${list[0]()} ${list[1]()} ${list[0] == list[1]} '\n"
      "         '${countBefore == 1} ${countAfter == 1} ${(set.first)()} '\n"
      "         '${set.first == c.foo} ${set.first == c.foo} '\n"
      "         '${set.remove(c.foo)}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  foo() => 'new';\n"
      "}\n"
      "List list = List<dynamic>.filled(2, null);\n"
      "Set set = Set();\n"
      "main() {\n"
      "  var c = C();\n"
      "  list[0] = c.foo;\n"
      "  list[1] = c.foo;\n"
      "  set.add(c.foo);\n"
      "  set.add(c.foo);\n"
      "  int countBefore = set.length;\n"
      "  reloadTest();\n"
      "  list[1] = c.foo;\n"
      "  set.add(c.foo);\n"
      "  set.add(c.foo);\n"
      "  int countAfter = set.length;\n"
      "  return '${list[0]()} ${list[1]()} ${list[0] == list[1]} '\n"
      "         '${countBefore == 1} ${countAfter == 1} ${(set.first)()} '\n"
      "         '${set.first == c.foo} ${set.first == c.foo} '\n"
      "         '${set.remove(c.foo)}';\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ("new new true true true new true true true",
               SimpleInvokeStr(lib, "main"));
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
}

TEST_CASE() [446/600]

dart::TEST_CASE

(

IsolateReload_TearOff_Parameter_Count_Mismatch

)

Definition at line 1667 of file isolate_reload_test.cc.

                                                          {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo() => 'old';\n"
      "}\n"
      "main() {\n"
      "  var f1 = C.foo;\n"
      "  reloadTest();\n"
      "  return f1();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo(i) => 'new:$i';\n"
      "}\n"
      "main() {\n"
      "  var f1 = C.foo;\n"
      "  reloadTest();\n"
      "  return f1();\n"
      "}\n";
 
  TestCase::SetReloadTestScript(kReloadScript);
  Dart_Handle error_handle = SimpleInvokeError(lib, "main");
 
  const char* error;
  error =
      "/test-lib:8:12: Error: Too few positional"
      " arguments: 1 required, 0 given.\n"
      "  return f1();";
  EXPECT_ERROR(error_handle, error);
}

TEST_CASE() [447/600]

dart::TEST_CASE

(

IsolateReload_TearOff_Remove

)

Definition at line 1704 of file isolate_reload_test.cc.

                                        {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "  static foo({String bar = 'bar'}) => 'old';\n"
      "}\n"
      "main() {\n"
      "  var f1 = C.foo;\n"
      "  reloadTest();\n"
      "  try {\n"
      "    return f1();\n"
      "  } catch(e) { return '$e'; }\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class C {\n"
      "}\n"
      "main() {\n"
      "  var f1;\n"
      "  reloadTest();\n"
      "  try {\n"
      "    return f1();\n"
      "  } catch(e) { return '$e'; }\n"
      "}\n";
 
  TestCase::SetReloadTestScript(kReloadScript);
 
  EXPECT_SUBSTRING(
      "NoSuchMethodError: No static method 'foo' declared in class 'C'.",
      SimpleInvokeStr(lib, "main"));
 
  lib = Dart_RootLibrary();
  EXPECT_NON_NULL(lib);
}

TEST_CASE() [448/600]

dart::TEST_CASE

(

IsolateReload_TopLevelFieldAdded

)

Definition at line 456 of file isolate_reload_test.cc.

                                            {
  const char* kScript =
      "var value1 = 10;\n"
      "main() {\n"
      "  return 'value1=${value1}';\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_STREQ("value1=10", SimpleInvokeStr(lib, "main"));
 
  const char* kReloadScript =
      "var value1 = 10;\n"
      "var value2 = 20;\n"
      "main() {\n"
      "  return 'value1=${value1},value2=${value2}';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ("value1=10,value2=20", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [449/600]

dart::TEST_CASE

(

IsolateReload_TopLevelParseError

)

Definition at line 1268 of file isolate_reload_test.cc.

                                            {
  const char* kScript =
      "main() {\n"
      "  return 4;\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  EXPECT_EQ(4, SimpleInvoke(lib, "main"));
 
  const char* kReloadScript =
      "kjsadkfjaksldfjklsadf;\n"
      "main() {\n"
      "  return 4;\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_ERROR(lib,
               "Variables must be declared using the keywords"
               " 'const', 'final', 'var' or a type name.");
}

TEST_CASE() [450/600]

dart::TEST_CASE

(

IsolateReload_TypedefAddParameter

)

Definition at line 5922 of file isolate_reload_test.cc.

          {
        return value.toString();
      } catch (e) {
        return e.toString();
      }
    }
  )";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      "type '(A) => bool' is not a subtype of type '(B) => bool' of 'function "
      "result'",
      SimpleInvokeStr(lib, "main"));
}
 
TEST_CASE(IsolateReload_TypedefToNotTypedef) {
  // The CFE lowers typedefs to function types and as such the VM will not see
  // any name collision between a class and a typedef class (which doesn't exist
  // anymore).
  const char* kScript =
      "typedef bool Predicate(dynamic x);\n"
      "main() {\n"

TEST_CASE() [451/600]

dart::TEST_CASE

(

IsolateReload_TypedefToNotTypedef

)

Definition at line 5870 of file isolate_reload_test.cc.

            {}
    class B {}
    typedef bool Predicate(B b);
    class Foo {
      Predicate x;
      Foo(this.x);
    }
    %s Foo value;
    main() {
      try {
        return value.x.toString();
      } catch (e) {
        return e.toString();
      }
    }
  )", late_tag), std::free);
  // clang-format on
 
  lib = TestCase::ReloadTestScript(kReloadScript.get());
  EXPECT_VALID(lib);
  EXPECT_STREQ(
      "type '(A) => bool' is not a subtype of type '(B) => bool' of 'function "
      "result'",

TEST_CASE() [452/600]

dart::TEST_CASE

(

IsolateReload_TypeIdentity

)

Definition at line 836 of file isolate_reload_test.cc.

                                      {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class T { }\n"
      "getType() => T;\n"
      "main() {\n"
      "  var oldType = getType();\n"
      "  reloadTest();\n"
      "  var newType = getType();\n"
      "  return identical(oldType, newType).toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class T extends Stopwatch { }\n"
      "getType() => T;\n"
      "main() {\n"
      "  var oldType = getType();\n"
      "  reloadTest();\n"
      "  var newType = getType();\n"
      "  return identical(oldType, newType).toString();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ("true", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [453/600]

dart::TEST_CASE

(

IsolateReload_TypeIdentityGeneric

)

Definition at line 867 of file isolate_reload_test.cc.

                                             {
  const char* kScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class T<G> { }\n"
      "getType() => new T<int>().runtimeType;\n"
      "main() {\n"
      "  var oldType = getType();\n"
      "  reloadTest();\n"
      "  var newType = getType();\n"
      "  return identical(oldType, newType).toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'file:///test:isolate_reload_helper';\n"
      "class T<G> extends Stopwatch { }\n"
      "getType() => new T<int>().runtimeType;\n"
      "main() {\n"
      "  var oldType = getType();\n"
      "  reloadTest();\n"
      "  var newType = getType();\n"
      "  return identical(oldType, newType).toString();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ("true", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [454/600]

dart::TEST_CASE

(

IsolateReload_TypeIdentityParameter

)

Definition at line 898 of file isolate_reload_test.cc.

                                               {
  const char* kScript =
      "import 'dart:mirrors';\n"
      "import 'file:///test:isolate_reload_helper';\n"
      "class T<G> { }\n"
      "getTypeVar() => reflectType(T).typeVariables[0];\n"
      "main() {\n"
      "  var oldType = getTypeVar();\n"
      "  reloadTest();\n"
      "  var newType = getTypeVar();\n"
      "  return (oldType == newType).toString();\n"
      "}\n";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
 
  const char* kReloadScript =
      "import 'dart:mirrors';\n"
      "import 'file:///test:isolate_reload_helper';\n"
      "class T<G> extends Stopwatch { }\n"
      "getTypeVar() => reflectType(T).typeVariables[0];\n"
      "main() {\n"
      "  var oldType = getTypeVar();\n"
      "  reloadTest();\n"
      "  var newType = getTypeVar();\n"
      "  return (oldType == newType).toString();\n"
      "}\n";
 
  EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript));
 
  EXPECT_STREQ("true", SimpleInvokeStr(lib, "main"));
}

TEST_CASE() [455/600]

dart::TEST_CASE

(

IsolateSpawn_FileUri

)

Definition at line 102 of file isolate_test.cc.

                                {
  IsolateSpawn("file:/a.dart");
}

TEST_CASE() [456/600]

dart::TEST_CASE

(

IsolateSpawn_PackageUri

)

Definition at line 106 of file isolate_test.cc.

                                   {
  IsolateSpawn("package:/a.dart");
}

TEST_CASE() [457/600]

dart::TEST_CASE

(

JSON_JSONStream_Array

)

Definition at line 84 of file json_test.cc.

                                 {
  JSONStream js;
  {
    JSONArray jsarr(&js);
    jsarr.AddValue(true);
    jsarr.AddValue(false);
  }
  EXPECT_STREQ("[true,false]", js.ToCString());
}

TEST_CASE() [458/600]

dart::TEST_CASE

(

JSON_JSONStream_ArrayArray

)

Definition at line 141 of file json_test.cc.

                                      {
  JSONStream js;
  {
    JSONArray jsarr(&js);
    {
      JSONArray jsarr1(&jsarr);
      jsarr1.AddValue(static_cast<intptr_t>(4));
    }
    {
      JSONArray jsarr1(&jsarr);
      jsarr1.AddValue(false);
    }
  }
  EXPECT_STREQ("[[4],[false]]", js.ToCString());
}

TEST_CASE() [459/600]

dart::TEST_CASE

(

JSON_JSONStream_Base64String

)

Definition at line 94 of file json_test.cc.

                                        {
  JSONStream js;
  {
    JSONBase64String jsonBase64String(&js);
    jsonBase64String.AppendBytes(reinterpret_cast<const uint8_t*>("Hello"), 5);
    jsonBase64String.AppendBytes(reinterpret_cast<const uint8_t*>(", "), 2);
    jsonBase64String.AppendBytes(reinterpret_cast<const uint8_t*>("world!"), 6);
  }
  EXPECT_STREQ("\"SGVsbG8sIHdvcmxkIQ==\"", js.ToCString());
}

TEST_CASE() [460/600]

dart::TEST_CASE

(

JSON_JSONStream_DartString

)

Definition at line 224 of file json_test.cc.

                                      {
  const char* kScriptChars =
      "var ascii = 'Hello, World!';\n"
      "var unicode = '\\u00CE\\u00F1\\u0163\\u00E9r\\u00F1\\u00E5\\u0163"
      "\\u00EE\\u00F6\\u00F1\\u00E5\\u013C\\u00EE\\u017E\\u00E5\\u0163"
      "\\u00EE\\u1EDD\\u00F1';\n"
      "var surrogates = '\\u{1D11E}\\u{1D11E}\\u{1D11E}"
      "\\u{1D11E}\\u{1D11E}';\n"
      "var wrongEncoding = '\\u{1D11E}' + surrogates[0] + '\\u{1D11E}';"
      "var nullInMiddle = 'This has\\u0000 four words.';";
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  Dart_Handle result;
  TransitionNativeToVM transition1(thread);
  String& obj = String::Handle();
 
  auto do_test = [&](const char* field_name, const char* expected) {
    {
      TransitionVMToNative to_native(thread);
      result = Dart_GetField(lib, NewString(field_name));
      EXPECT_VALID(result);
    }
 
    obj ^= Api::UnwrapHandle(result);
 
    {
      JSONStream js;
      {
        JSONObject jsobj(&js);
        EXPECT(!jsobj.AddPropertyStr(field_name, obj));
      }
      EXPECT_STREQ(expected, js.ToCString());
    }
  };
 
  {
    TransitionVMToNative to_native(thread);
    result = Dart_GetField(lib, NewString("ascii"));
    EXPECT_VALID(result);
  }
 
  obj ^= Api::UnwrapHandle(result);
 
  {
    JSONStream js;
    {
      JSONObject jsobj(&js);
      EXPECT(jsobj.AddPropertyStr("subrange", obj, 1, 4));
    }
    EXPECT_STREQ("{\"subrange\":\"ello\"}", js.ToCString());
  }
 
  do_test("ascii", "{\"ascii\":\"Hello, World!\"}");
  do_test("unicode", "{\"unicode\":\"Îñţérñåţîöñåļîžåţîờñ\"}");
  do_test("surrogates", "{\"surrogates\":\"𝄞𝄞𝄞𝄞𝄞\"}");
  do_test("wrongEncoding", "{\"wrongEncoding\":\"𝄞\\uD834𝄞\"}");
  do_test("nullInMiddle", "{\"nullInMiddle\":\"This has\\u0000 four words.\"}");
}

TEST_CASE() [461/600]

dart::TEST_CASE

(

JSON_JSONStream_EscapedString

)

Definition at line 215 of file json_test.cc.

                                         {
  JSONStream js;
  {
    JSONArray jsarr(&js);
    jsarr.AddValue("Hel\"\"lo\r\n\t");
  }
  EXPECT_STREQ("[\"Hel\\\"\\\"lo\\r\\n\\t\"]", js.ToCString());
}

TEST_CASE() [462/600]

dart::TEST_CASE

(

JSON_JSONStream_NestedObject

)

Definition at line 115 of file json_test.cc.

                                        {
  JSONStream js;
  {
    JSONObject jsobj(&js);
    JSONObject jsobj1(&jsobj, "key");
    jsobj1.AddProperty("key1", "d");
  }
  EXPECT_STREQ("{\"key\":{\"key1\":\"d\"}}", js.ToCString());
}

TEST_CASE() [463/600]

dart::TEST_CASE

(

JSON_JSONStream_Object

)

Definition at line 105 of file json_test.cc.

                                  {
  JSONStream js;
  {
    JSONObject jsobj(&js);
    jsobj.AddProperty("key1", "a");
    jsobj.AddProperty("key2", "b");
  }
  EXPECT_STREQ("{\"key1\":\"a\",\"key2\":\"b\"}", js.ToCString());
}

TEST_CASE() [464/600]

dart::TEST_CASE

(

JSON_JSONStream_ObjectArray

)

Definition at line 125 of file json_test.cc.

                                       {
  JSONStream js;
  {
    JSONArray jsarr(&js);
    {
      JSONObject jsobj(&jsarr);
      jsobj.AddProperty("key", "e");
    }
    {
      JSONObject jsobj(&jsarr);
      jsobj.AddProperty("yek", "f");
    }
  }
  EXPECT_STREQ("[{\"key\":\"e\"},{\"yek\":\"f\"}]", js.ToCString());
}

TEST_CASE() [465/600]

dart::TEST_CASE

(

JSON_JSONStream_ObjectPrintf

)

Definition at line 166 of file json_test.cc.

                                        {
  JSONStream js;
  {
    JSONObject jsobj(&js);
    jsobj.AddPropertyF("key", "%d %s", 2, "hello");
  }
  EXPECT_STREQ("{\"key\":\"2 hello\"}", js.ToCString());
}

TEST_CASE() [466/600]

dart::TEST_CASE

(

JSON_JSONStream_Params

)

Definition at line 285 of file json_test.cc.

                                  {
  const char* param_keys[] = {"dog", "cat"};
  const char* param_values[] = {"apple", "banana"};
 
  JSONStream js;
  EXPECT(js.num_params() == 0);
  js.SetParams(&param_keys[0], &param_values[0], 2);
  EXPECT(js.num_params() == 2);
  EXPECT(!js.HasParam("lizard"));
  EXPECT(js.HasParam("dog"));
  EXPECT(js.HasParam("cat"));
  EXPECT(js.ParamIs("cat", "banana"));
  EXPECT(!js.ParamIs("dog", "banana"));
}

TEST_CASE() [467/600]

dart::TEST_CASE

(

JSON_JSONStream_Primitives

)

Definition at line 23 of file json_test.cc.

                                      {
  {
    JSONStream js;
    { JSONObject jsobj(&js); }
    EXPECT_STREQ("{}", js.ToCString());
  }
  {
    JSONStream js;
    { JSONArray jsarr(&js); }
    EXPECT_STREQ("[]", js.ToCString());
  }
  {
    JSONStream js;
    {
      JSONArray jsarr(&js);
      jsarr.AddValue(true);
    }
    EXPECT_STREQ("[true]", js.ToCString());
  }
  {
    JSONStream js;
    {
      JSONArray jsarr(&js);
      jsarr.AddValue(false);
    }
    EXPECT_STREQ("[false]", js.ToCString());
  }
  {
    JSONStream js;
    {
      JSONArray jsarr(&js);
      jsarr.AddValue(static_cast<intptr_t>(4));
    }
    EXPECT_STREQ("[4]", js.ToCString());
  }
  {
    JSONStream js;
    {
      JSONArray jsarr(&js);
      jsarr.AddValue(1.0);
    }
    EXPECT_STREQ("[1.0]", js.ToCString());
  }
  {
    JSONStream js;
    {
      JSONArray jsarr(&js);
      jsarr.AddValue("hello");
    }
    EXPECT_STREQ("[\"hello\"]", js.ToCString());
  }
  {
    JSONStream js;
    {
      JSONArray jsarr(&js);
      jsarr.AddValueF("h%s", "elo");
    }
    EXPECT_STREQ("[\"helo\"]", js.ToCString());
  }
}

TEST_CASE() [468/600]

dart::TEST_CASE

(

JSON_JSONStream_Printf

)

Definition at line 157 of file json_test.cc.

                                  {
  JSONStream js;
  {
    JSONArray jsarr(&js);
    jsarr.AddValueF("%d %s", 2, "hello");
  }
  EXPECT_STREQ("[\"2 hello\"]", js.ToCString());
}

TEST_CASE() [469/600]

dart::TEST_CASE

(

JSON_TextBuffer

)

Definition at line 15 of file json_test.cc.

                           {
  TextBuffer w(5);  // Small enough to make buffer grow at least once.
  w.Printf("{ \"%s\" : %d", "length", 175);
  EXPECT_STREQ("{ \"length\" : 175", w.buffer());
  w.Printf(", \"%s\" : \"%s\" }", "command", "stopIt");
  EXPECT_STREQ("{ \"length\" : 175, \"command\" : \"stopIt\" }", w.buffer());
}

TEST_CASE() [470/600]

dart::TEST_CASE

(

LargeSweep

)

Definition at line 71 of file heap_test.cc.

                      {
  const char* kScriptChars =
      "main() {\n"
      "  return List.filled(8 * 1024 * 1024, null);\n"
      "}\n";
  NOT_IN_PRODUCT(FLAG_verbose_gc = true);
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
 
  EXPECT_VALID(result);
  EXPECT(!Dart_IsNull(result));
  EXPECT(Dart_IsList(result));
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
  }
  Dart_ExitScope();
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectOldSpace();
  }
}

TEST_CASE() [471/600]

dart::TEST_CASE

(

Log_Basic

)

Definition at line 61 of file log_test.cc.

                     {
  test_output_ = nullptr;
  Log* log = new Log(TestPrinter);
 
  EXPECT_EQ(static_cast<const char*>(nullptr), test_output_);
  log->Print("Hello %s", "World");
  EXPECT_STREQ("Hello World", test_output_);
 
  delete log;
  LogTestHelper::FreeTestOutput();
}

TEST_CASE() [472/600]

dart::TEST_CASE

(

Log_Block

)

Definition at line 73 of file log_test.cc.

                     {
  test_output_ = nullptr;
  Log* log = new Log(TestPrinter);
 
  EXPECT_EQ(static_cast<const char*>(nullptr), test_output_);
  {
    LogBlock ba(thread, log);
    log->Print("APPLE");
    EXPECT_EQ(static_cast<const char*>(nullptr), test_output_);
    {
      LogBlock ba(thread, log);
      log->Print("BANANA");
      EXPECT_EQ(static_cast<const char*>(nullptr), test_output_);
    }
    EXPECT_EQ(static_cast<const char*>(nullptr), test_output_);
    {
      LogBlock ba(thread, log);
      log->Print("PEAR");
      EXPECT_EQ(static_cast<const char*>(nullptr), test_output_);
    }
    EXPECT_EQ(static_cast<const char*>(nullptr), test_output_);
  }
  EXPECT_STREQ("APPLEBANANAPEAR", test_output_);
  delete log;
  LogTestHelper::FreeTestOutput();
}

TEST_CASE() [473/600]

dart::TEST_CASE

(

Log_Macro

)

Definition at line 49 of file log_test.cc.

                     {
  test_output_ = nullptr;
  Log* log = Log::Current();
  LogTestHelper::SetPrinter(log, TestPrinter);
 
  THR_Print("Hello %s", "World");
  EXPECT_STREQ("Hello World", test_output_);
  THR_Print("SingleArgument");
  EXPECT_STREQ("SingleArgument", test_output_);
  LogTestHelper::FreeTestOutput();
}

TEST_CASE() [474/600]

dart::TEST_CASE

(

MallocDirectChainedHashMap

)

Definition at line 101 of file hash_map_test.cc.

                                      {
  MallocDirectChainedHashMap<PointerSetKeyValueTrait<TestValue>> map;
  EXPECT(map.IsEmpty());
  TestValue v1(0);
  TestValue v2(1);
  TestValue v3(0);
  map.Insert(&v1);
  EXPECT(map.LookupValue(&v1) == &v1);
  map.Insert(&v2);
  EXPECT(map.LookupValue(&v1) == &v1);
  EXPECT(map.LookupValue(&v2) == &v2);
  EXPECT(map.LookupValue(&v3) == &v1);
  MallocDirectChainedHashMap<PointerSetKeyValueTrait<TestValue>> map2(map);
  EXPECT(map2.LookupValue(&v1) == &v1);
  EXPECT(map2.LookupValue(&v2) == &v2);
  EXPECT(map2.LookupValue(&v3) == &v1);
}

TEST_CASE() [475/600]

dart::TEST_CASE

(

MallocGrowableArray

)

Definition at line 72 of file growable_array_test.cc.

                               {
  TestGrowableArray<MallocGrowableArray<int>, MallocGrowableArray<int64_t> >();
}

TEST_CASE() [476/600]

dart::TEST_CASE

(

ManyClasses

)

Definition at line 292 of file compiler_test.cc.

                       {
  // Limit is 20 bits. Check only more than 16 bits so test completes in
  // reasonable time.
  const intptr_t kNumClasses = (1 << 16) + 1;
 
  TextBuffer buffer(MB);
  for (intptr_t i = 0; i < kNumClasses; i++) {
    buffer.Printf("class C%" Pd " { String toString() => 'C%" Pd "'; }\n", i,
                  i);
  }
  buffer.Printf("main() {\n");
  for (intptr_t i = 0; i < kNumClasses; i++) {
    buffer.Printf("  new C%" Pd "().toString();\n", i);
  }
  buffer.Printf("}\n");
 
  Dart_Handle lib = TestCase::LoadTestScript(buffer.buffer(), nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
 
  EXPECT(IsolateGroup::Current()->class_table()->NumCids() >= kNumClasses);
}

TEST_CASE() [477/600]

dart::TEST_CASE

(

Map_iteration

)

Definition at line 6616 of file object_test.cc.

                             {
  const char* kScript =
      "const type = int;\n"
      "\n"
      "value() {\n"
      "  return type;\n"
      "}\n";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript, kCalculateCanonicalizeHash,
                                        /*check_identity=*/false));
}
 
TEST_CASE(Map_iteration) {
  const char* kScript =
      "makeMap() {\n"
      "  var map = {'x': 3, 'y': 4, 'z': 5, 'w': 6};\n"
      "  map.remove('y');\n"
      "  map.remove('w');\n"
      "  return map;\n"
      "}";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle h_result = Dart_Invoke(h_lib, NewString("makeMap"), 0, nullptr);
  EXPECT_VALID(h_result);
 
  TransitionNativeToVM transition(thread);
  Instance& dart_map = Instance::Handle();
  dart_map ^= Api::UnwrapHandle(h_result);
  ASSERT(dart_map.IsMap());
  const Map& cc_map = Map::Cast(dart_map);
 
  EXPECT_EQ(2, cc_map.Length());
 
  Map::Iterator iterator(cc_map);
  Object& object = Object::Handle();
 
  EXPECT(iterator.MoveNext());
  object = iterator.CurrentKey();
  EXPECT_STREQ("x", object.ToCString());

TEST_CASE() [478/600]

dart::TEST_CASE

(

MessageQueue_BasicOperations

)

Definition at line 15 of file message_test.cc.

                                        {
  MessageQueue queue;
  EXPECT(queue.IsEmpty());
  MessageQueue::Iterator it(&queue);
  // Queue is empty.
  EXPECT(!it.HasNext());
 
  Dart_Port port = 1;
 
  const char* str1 = "msg1";
  const char* str2 = "msg2";
  const char* str3 = "msg3";
  const char* str4 = "msg4";
  const char* str5 = "msg5";
  const char* str6 = "msg6";
 
  // Add two messages.
  std::unique_ptr<Message> msg =
      Message::New(port, AllocMsg(str1), strlen(str1) + 1, nullptr,
                   Message::kNormalPriority);
  Message* msg1 = msg.get();
  queue.Enqueue(std::move(msg), false);
  EXPECT(queue.Length() == 1);
  EXPECT(!queue.IsEmpty());
  it.Reset(&queue);
  EXPECT(it.HasNext());
  EXPECT(it.Next() == msg1);
  EXPECT(!it.HasNext());
 
  msg = Message::New(port, AllocMsg(str2), strlen(str2) + 1, nullptr,
                     Message::kNormalPriority);
  Message* msg2 = msg.get();
  queue.Enqueue(std::move(msg), false);
  EXPECT(queue.Length() == 2);
  EXPECT(!queue.IsEmpty());
  it.Reset(&queue);
  EXPECT(it.HasNext());
  EXPECT(it.Next() == msg1);
  EXPECT(it.HasNext());
  EXPECT(it.Next() == msg2);
  EXPECT(!it.HasNext());
 
  // Lookup messages by id.
  EXPECT(queue.FindMessageById(reinterpret_cast<intptr_t>(msg1)) == msg1);
  EXPECT(queue.FindMessageById(reinterpret_cast<intptr_t>(msg2)) == msg2);
 
  // Lookup bad id.
  EXPECT(queue.FindMessageById(0x1) == nullptr);
 
  // Remove message 1
  msg = queue.Dequeue();
  EXPECT(msg != nullptr);
  EXPECT_STREQ(str1, reinterpret_cast<char*>(msg->snapshot()));
  EXPECT(!queue.IsEmpty());
 
  it.Reset(&queue);
  EXPECT(it.HasNext());
  EXPECT(it.Next() == msg2);
 
  // Remove message 2
  msg = queue.Dequeue();
  EXPECT(msg != nullptr);
  EXPECT_STREQ(str2, reinterpret_cast<char*>(msg->snapshot()));
  EXPECT(queue.IsEmpty());
 
  msg = Message::New(Message::kIllegalPort, AllocMsg(str3), strlen(str3) + 1,
                     nullptr, Message::kNormalPriority);
  queue.Enqueue(std::move(msg), true);
  EXPECT(!queue.IsEmpty());
 
  msg = Message::New(Message::kIllegalPort, AllocMsg(str4), strlen(str4) + 1,
                     nullptr, Message::kNormalPriority);
  queue.Enqueue(std::move(msg), true);
  EXPECT(!queue.IsEmpty());
 
  msg = Message::New(port, AllocMsg(str5), strlen(str5) + 1, nullptr,
                     Message::kNormalPriority);
  queue.Enqueue(std::move(msg), false);
  EXPECT(!queue.IsEmpty());
 
  msg = Message::New(Message::kIllegalPort, AllocMsg(str6), strlen(str6) + 1,
                     nullptr, Message::kNormalPriority);
  queue.Enqueue(std::move(msg), true);
  EXPECT(!queue.IsEmpty());
 
  msg = queue.Dequeue();
  EXPECT(msg != nullptr);
  EXPECT_STREQ(str3, reinterpret_cast<char*>(msg->snapshot()));
  EXPECT(!queue.IsEmpty());
 
  msg = queue.Dequeue();
  EXPECT(msg != nullptr);
  EXPECT_STREQ(str4, reinterpret_cast<char*>(msg->snapshot()));
  EXPECT(!queue.IsEmpty());
 
  msg = queue.Dequeue();
  EXPECT(msg != nullptr);
  EXPECT_STREQ(str6, reinterpret_cast<char*>(msg->snapshot()));
  EXPECT(!queue.IsEmpty());
 
  msg = queue.Dequeue();
  EXPECT(msg != nullptr);
  EXPECT_STREQ(str5, reinterpret_cast<char*>(msg->snapshot()));
  EXPECT(queue.IsEmpty());
}

TEST_CASE() [479/600]

dart::TEST_CASE

(

MessageQueue_Clear

)

Definition at line 121 of file message_test.cc.

                              {
  MessageQueue queue;
  Dart_Port port1 = 1;
  Dart_Port port2 = 2;
 
  const char* str1 = "msg1";
  const char* str2 = "msg2";
 
  // Add two messages.
  std::unique_ptr<Message> msg;
  msg = Message::New(port1, AllocMsg(str1), strlen(str1) + 1, nullptr,
                     Message::kNormalPriority);
  queue.Enqueue(std::move(msg), false);
  msg = Message::New(port2, AllocMsg(str2), strlen(str2) + 1, nullptr,
                     Message::kNormalPriority);
  queue.Enqueue(std::move(msg), false);
 
  EXPECT(!queue.IsEmpty());
  queue.Clear();
  EXPECT(queue.IsEmpty());
}

TEST_CASE() [480/600]

dart::TEST_CASE

(

Metadata

)

Definition at line 5427 of file object_test.cc.

                    {
  // clang-format off
  auto kScriptChars =
      Utils::CStringUniquePtr(OS::SCreate(nullptr,
        "@metafoo                       \n"
        "class Meta {                   \n"
        "  final m;                     \n"
        "  const Meta(this.m);          \n"
        "}                              \n"
        "                               \n"
        "const metafoo = 'metafoo';     \n"
        "const metabar = 'meta' 'bar';  \n"
        "                               \n"
        "@metafoo                       \n"
        "@Meta(0) String%s gVar;        \n"
        "                               \n"
        "@metafoo                       \n"
        "get tlGetter => gVar;          \n"
        "                               \n"
        "@metabar                       \n"
        "class A {                      \n"
        "  @metafoo                     \n"
        "  @metabar                     \n"
        "  @Meta('baz')                 \n"
        "  var aField;                  \n"
        "                               \n"
        "  @metabar @Meta('baa')        \n"
        "  int aFunc(a,b) => a + b;     \n"
        "}                              \n"
        "                               \n"
        "@Meta('main')                  \n"
        "A main() {                     \n"
        "  return A();                  \n"
        "}                              \n",
        TestCase::NullableTag()), std::free);
  // clang-format on
 
  Dart_Handle h_lib = TestCase::LoadTestScript(kScriptChars.get(), nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  TransitionNativeToVM transition(thread);
  Library& lib = Library::Handle();
  lib ^= Api::UnwrapHandle(h_lib);
  EXPECT(!lib.IsNull());
  const Class& class_a = Class::Handle(GetClass(lib, "A"));
  Object& res = Object::Handle(lib.GetMetadata(class_a));
  PrintMetadata("A", res);
 
  const Class& class_meta = Class::Handle(GetClass(lib, "Meta"));
  res = lib.GetMetadata(class_meta);
  PrintMetadata("Meta", res);
 
  Field& field = Field::Handle(GetField(class_a, "aField"));
  res = lib.GetMetadata(field);
  PrintMetadata("A.aField", res);
 
  Function& func = Function::Handle(GetFunction(class_a, "aFunc"));
  res = lib.GetMetadata(func);
  PrintMetadata("A.aFunc", res);
 
  func = lib.LookupFunctionAllowPrivate(
      String::Handle(Symbols::New(thread, "main")));
  EXPECT(!func.IsNull());
  res = lib.GetMetadata(func);
  PrintMetadata("main", res);
 
  func = lib.LookupFunctionAllowPrivate(
      String::Handle(Symbols::New(thread, "get:tlGetter")));
  EXPECT(!func.IsNull());
  res = lib.GetMetadata(func);
  PrintMetadata("tlGetter", res);
 
  field =
      lib.LookupFieldAllowPrivate(String::Handle(Symbols::New(thread, "gVar")));
  EXPECT(!field.IsNull());
  res = lib.GetMetadata(field);
  PrintMetadata("gVar", res);
}

TEST_CASE() [481/600]

dart::TEST_CASE

(

Mixin_PrivateSuperResolution

)

Definition at line 12 of file mixin_test.cc.

                                        {
  // clang-format off
  Dart_SourceFile sourcefiles[] = {
    {
      "file:///test-app.dart",
      "class A {\n"
      "  _bar() => 42;\n"
      "}\n"
      "mixin M on A {\n"
      "  bar() => -1;\n"
      "}\n"
      "class B extends A {\n"
      "  foo() => 6;\n"
      "}\n"
      "class C extends B with M {\n"
      "  bar() => super._bar();\n"
      "}\n"
      "main() {\n"
      "  return new C().bar();\n"
      "}\n",
    }};
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      /* resolver= */ nullptr, /* finalize= */ true, /* incrementally= */ true);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_VALID(result);
  EXPECT_EQ(42, value);
}

TEST_CASE() [482/600]

dart::TEST_CASE

(

Mixin_PrivateSuperResolutionCrossLibraryShouldFail

)

Definition at line 46 of file mixin_test.cc.

                                                              {
  // clang-format off
  Dart_SourceFile sourcefiles[] = {
    {
      "file:///test-app.dart",
      "import 'test-lib.dart';\n"
      "class D extends B with M {\n"
      "  bar() => super._bar();\n"
      "}\n"
      "main() {\n"
      "  try {\n"
      "    return new D().bar();\n"
      "  } catch (e) {\n"
      "    return e.toString().split('\\n').first;\n"
      "  }\n"
      "}\n",
    },
    {
      "file:///test-lib.dart",
      "class A {\n"
      "  foo() => 4;\n"
      "  _bar() => 42;\n"
      "}\n"
      "mixin M on A {\n"
      "  bar() => -1;\n"
      "}\n"
      "class B extends A {\n"
      "  foo() => 6;\n"
      "}\n"
      "class C extends B with M {\n"
      "  bar() => super._bar();\n"
      "}\n"
    },
    {
      "file:///.packages", "untitled:/"
    }};
  // clang-format on
 
  Dart_Handle lib = TestCase::LoadTestScriptWithDFE(
      sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
      /* resolver= */ nullptr, /* finalize= */ true, /* incrementally= */ true);
  EXPECT_ERROR(lib, "Error: Superclass has no method named '_bar'.");
}

TEST_CASE() [483/600]

dart::TEST_CASE

(

ObjectIdRingScavengeMoveTest

)

Definition at line 124 of file object_id_ring_test.cc.

                                        {
  const char* kScriptChars =
      "main() {\n"
      "  return [1, 2, 3];\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  Dart_Handle moved_handle;
  intptr_t list_length = 0;
  EXPECT_VALID(result);
  EXPECT(!Dart_IsNull(result));
  EXPECT(Dart_IsList(result));
  EXPECT_VALID(Dart_ListLength(result, &list_length));
  EXPECT_EQ(3, list_length);
 
  Isolate* isolate = thread->isolate();
  ObjectIdRing* ring = isolate->EnsureObjectIdRing();
  ObjectIdRing::LookupResult kind = ObjectIdRing::kInvalid;
 
  {
    TransitionNativeToVM to_vm(thread);
    ObjectPtr raw_obj = Api::UnwrapHandle(result);
    // Located in new heap.
    EXPECT(raw_obj->IsNewObject());
    EXPECT_NE(Object::null(), raw_obj);
    intptr_t raw_obj_id1 = ring->GetIdForObject(raw_obj);
    EXPECT_EQ(0, raw_obj_id1);
    // Get id 0 again.
    EXPECT_EQ(raw_obj_id1,
              ring->GetIdForObject(raw_obj, ObjectIdRing::kReuseId));
    // Add to ring a second time.
    intptr_t raw_obj_id2 = ring->GetIdForObject(raw_obj);
    EXPECT_EQ(1, raw_obj_id2);
    // Get id 0 again.
    EXPECT_EQ(raw_obj_id1,
              ring->GetIdForObject(raw_obj, ObjectIdRing::kReuseId));
    ObjectPtr raw_obj1 = ring->GetObjectForId(raw_obj_id1, &kind);
    EXPECT_EQ(ObjectIdRing::kValid, kind);
    ObjectPtr raw_obj2 = ring->GetObjectForId(raw_obj_id2, &kind);
    EXPECT_EQ(ObjectIdRing::kValid, kind);
    EXPECT_NE(Object::null(), raw_obj1);
    EXPECT_NE(Object::null(), raw_obj2);
    EXPECT_EQ(UntaggedObject::ToAddr(raw_obj),
              UntaggedObject::ToAddr(raw_obj1));
    EXPECT_EQ(UntaggedObject::ToAddr(raw_obj),
              UntaggedObject::ToAddr(raw_obj2));
    // Force a scavenge.
    GCTestHelper::CollectNewSpace();
    ObjectPtr raw_object_moved1 = ring->GetObjectForId(raw_obj_id1, &kind);
    EXPECT_EQ(ObjectIdRing::kValid, kind);
    ObjectPtr raw_object_moved2 = ring->GetObjectForId(raw_obj_id2, &kind);
    EXPECT_EQ(ObjectIdRing::kValid, kind);
    EXPECT_NE(Object::null(), raw_object_moved1);
    EXPECT_NE(Object::null(), raw_object_moved2);
    EXPECT_EQ(UntaggedObject::ToAddr(raw_object_moved1),
              UntaggedObject::ToAddr(raw_object_moved2));
    // Test that objects have moved.
    EXPECT_NE(UntaggedObject::ToAddr(raw_obj1),
              UntaggedObject::ToAddr(raw_object_moved1));
    EXPECT_NE(UntaggedObject::ToAddr(raw_obj2),
              UntaggedObject::ToAddr(raw_object_moved2));
    // Test that we still point at the same list.
    moved_handle = Api::NewHandle(thread, raw_object_moved1);
    // Test id reuse.
    EXPECT_EQ(raw_obj_id1,
              ring->GetIdForObject(raw_object_moved1, ObjectIdRing::kReuseId));
  }
  EXPECT_VALID(moved_handle);
  EXPECT(!Dart_IsNull(moved_handle));
  EXPECT(Dart_IsList(moved_handle));
  EXPECT_VALID(Dart_ListLength(moved_handle, &list_length));
  EXPECT_EQ(3, list_length);
}

TEST_CASE() [484/600]

dart::TEST_CASE

(

OldGC

)

Definition at line 29 of file heap_test.cc.

                 {
  const char* kScriptChars =
      "main() {\n"
      "  return [1, 2, 3];\n"
      "}\n";
  NOT_IN_PRODUCT(FLAG_verbose_gc = true);
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
 
  EXPECT_VALID(result);
  EXPECT(!Dart_IsNull(result));
  EXPECT(Dart_IsList(result));
  TransitionNativeToVM transition(thread);
  GCTestHelper::CollectOldSpace();
}

TEST_CASE() [485/600]

dart::TEST_CASE

(

OldGC_Unsync

)

Definition at line 46 of file heap_test.cc.

                        {
  // Finalize any GC in progress as it is unsafe to change FLAG_marker_tasks
  // when incremental marking is in progress.
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectAllGarbage();
  }
  FLAG_marker_tasks = 0;
 
  const char* kScriptChars =
      "main() {\n"
      "  return [1, 2, 3];\n"
      "}\n";
  FLAG_verbose_gc = true;
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
 
  EXPECT_VALID(result);
  EXPECT(!Dart_IsNull(result));
  EXPECT(Dart_IsList(result));
  TransitionNativeToVM transition(thread);
  GCTestHelper::CollectOldSpace();
}

TEST_CASE() [486/600]

dart::TEST_CASE

(

OpenUri_AbsoluteFilename

)

Definition at line 55 of file file_test.cc.

                                    {
  const char* kRelativeFilename =
      bin::test::GetFileName("runtime/bin/file_test.cc");
  const char* kFilename =
      bin::File::GetCanonicalPath(nullptr, kRelativeFilename);
  EXPECT_NOTNULL(kFilename);
  char* encoded = reinterpret_cast<char*>(
      bin::DartUtils::ScopedCString(strlen(kFilename) * 3 + 1));
  char* t = encoded;
  // percent-encode all characters 'c'
  for (const char* p = kFilename; *p != '\0'; p++) {
    if (*p == 'c') {
      *t++ = '%';
      *t++ = '6';
      *t++ = '3';
    } else {
      *t++ = *p;
    }
  }
  *t = 0;
  bin::File* file = bin::File::OpenUri(nullptr, encoded, bin::File::kRead);
  EXPECT(file != nullptr);
  char buffer[16];
  buffer[0] = '\0';
  EXPECT(file->ReadFully(buffer, 13));  // ReadFully returns true.
  buffer[13] = '\0';
  EXPECT_STREQ("// Copyright ", buffer);
  EXPECT(!file->WriteByte(1));  // Cannot write to a read-only file.
  file->Release();
}

TEST_CASE() [487/600]

dart::TEST_CASE

(

OpenUri_InvalidUriPercentEncoding

)

Definition at line 171 of file file_test.cc.

                                             {
  const char* kFilename = bin::test::GetFileName("runtime/bin/file_test.cc");
  char* encoded = reinterpret_cast<char*>(
      bin::DartUtils::ScopedCString(strlen(kFilename) * 3 + 1));
  char* t = encoded;
  // percent-encode all characters 'c'
  for (const char* p = kFilename; *p != '\0'; p++) {
    if (*p == 'c') {
      *t++ = '%';
      *t++ = 'f';
      *t++ = 'o';
    } else {
      *t++ = *p;
    }
  }
  *t = 0;
  bin::File* file = bin::File::OpenUri(nullptr, encoded, bin::File::kRead);
  EXPECT(file == nullptr);
}

TEST_CASE() [488/600]

dart::TEST_CASE

(

OpenUri_RelativeFilename

)

Definition at line 28 of file file_test.cc.

                                    {
  const char* kFilename = bin::test::GetFileName("runtime/bin/file_test.cc");
  char* encoded = reinterpret_cast<char*>(
      bin::DartUtils::ScopedCString(strlen(kFilename) * 3 + 1));
  char* t = encoded;
  // percent-encode all characters 'c'
  for (const char* p = kFilename; *p != '\0'; p++) {
    if (*p == 'c') {
      *t++ = '%';
      *t++ = '6';
      *t++ = '3';
    } else {
      *t++ = *p;
    }
  }
  *t = 0;
  bin::File* file = bin::File::OpenUri(nullptr, encoded, bin::File::kRead);
  EXPECT(file != nullptr);
  char buffer[16];
  buffer[0] = '\0';
  EXPECT(file->ReadFully(buffer, 13));  // ReadFully returns true.
  buffer[13] = '\0';
  EXPECT_STREQ("// Copyright ", buffer);
  EXPECT(!file->WriteByte(1));  // Cannot write to a read-only file.
  file->Release();
}

TEST_CASE() [489/600]

dart::TEST_CASE

(

OpenUri_TruncatedUriPercentEncoding

)

Definition at line 191 of file file_test.cc.

                                               {
  const char* kFilename = bin::test::GetFileName("runtime/bin/file_test.cc");
  char* encoded = reinterpret_cast<char*>(
      bin::DartUtils::ScopedCString(strlen(kFilename) * 3 + 1));
  char* t = encoded;
  // percent-encode all characters 'c'
  for (const char* p = kFilename; *p != '\0'; p++) {
    if (*p == 'c') {
      *t++ = '%';
      *t++ = 'f';
      *t++ = 'o';
    } else {
      *t++ = *p;
    }
  }
  *(t - 1) = 0;  // truncate last uri encoding
  bin::File* file = bin::File::OpenUri(nullptr, encoded, bin::File::kRead);
  EXPECT(file == nullptr);
}

TEST_CASE() [490/600]

dart::TEST_CASE

(

OpenUri_UriWithSpaces

)

Definition at line 127 of file file_test.cc.

                                 {
  const char* kRelativeFilename =
      bin::test::GetFileName("runtime/bin/file_test.cc");
  const char* strSystemTemp = bin::Directory::SystemTemp(nullptr);
  EXPECT_NOTNULL(strSystemTemp);
  const char* kTempDir = Concat(strSystemTemp, "/foo bar");
  const char* strTempDir = bin::Directory::CreateTemp(nullptr, kTempDir);
  EXPECT_NOTNULL(strTempDir);
  const char* kTargetFilename = Concat(strTempDir, "/file test.cc");
  bool result = bin::File::Copy(nullptr, kRelativeFilename, kTargetFilename);
  EXPECT(result);
 
  const char* kAbsoluteFilename =
      bin::File::GetCanonicalPath(nullptr, kTargetFilename);
  EXPECT_NOTNULL(kAbsoluteFilename);
  const char* kFilename = Concat("file:///", kAbsoluteFilename);
 
  char* encoded = reinterpret_cast<char*>(
      bin::DartUtils::ScopedCString(strlen(kFilename) * 3 + 1));
  char* t = encoded;
  // percent-encode all spaces
  for (const char* p = kFilename; *p != '\0'; p++) {
    if (*p == ' ') {
      *t++ = '%';
      *t++ = '2';
      *t++ = '0';
    } else {
      *t++ = *p;
    }
  }
  *t = 0;
  printf("encoded: %s\n", encoded);
  bin::File* file = bin::File::OpenUri(nullptr, encoded, bin::File::kRead);
  EXPECT(file != nullptr);
  char buffer[16];
  buffer[0] = '\0';
  EXPECT(file->ReadFully(buffer, 13));  // ReadFully returns true.
  buffer[13] = '\0';
  EXPECT_STREQ("// Copyright ", buffer);
  EXPECT(!file->WriteByte(1));  // Cannot write to a read-only file.
  file->Release();
  bin::Directory::Delete(nullptr, strTempDir, /* recursive= */ true);
}

TEST_CASE() [491/600]

dart::TEST_CASE

(

OpenUri_ValidUri

)

Definition at line 94 of file file_test.cc.

                            {
  const char* kRelativeFilename =
      bin::test::GetFileName("runtime/bin/file_test.cc");
  const char* kAbsoluteFilename =
      bin::File::GetCanonicalPath(nullptr, kRelativeFilename);
  EXPECT_NOTNULL(kAbsoluteFilename);
  const char* kFilename = Concat("file:///", kAbsoluteFilename);
 
  char* encoded = reinterpret_cast<char*>(
      bin::DartUtils::ScopedCString(strlen(kFilename) * 3 + 1));
  char* t = encoded;
  // percent-encode all characters 'c'
  for (const char* p = kFilename; *p != '\0'; p++) {
    if (*p == 'c') {
      *t++ = '%';
      *t++ = '6';
      *t++ = '3';
    } else {
      *t++ = *p;
    }
  }
  *t = 0;
  bin::File* file = bin::File::OpenUri(nullptr, encoded, bin::File::kRead);
  EXPECT(file != nullptr);
  char buffer[16];
  buffer[0] = '\0';
  EXPECT(file->ReadFully(buffer, 13));  // ReadFully returns true.
  buffer[13] = '\0';
  EXPECT_STREQ("// Copyright ", buffer);
  EXPECT(!file->WriteByte(1));  // Cannot write to a read-only file.
  file->Release();
}

TEST_CASE() [492/600]

dart::TEST_CASE

(

ParseUri_BrokenEscapeSequence

)

Definition at line 276 of file uri_test.cc.

                                         {
  ParsedUri uri;
  EXPECT(ParseUri("scheme:/%1g", &uri));
  EXPECT_STREQ("scheme", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("/%1g", uri.path);  // Broken sequence is unchanged.
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [493/600]

dart::TEST_CASE

(

ParseUri_LowerCaseScheme

)

Definition at line 215 of file uri_test.cc.

                                    {
  ParsedUri uri;
  EXPECT(ParseUri("ScHeMe:path", &uri));
  EXPECT_STREQ("scheme", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("path", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [494/600]

dart::TEST_CASE

(

ParseUri_NormalizeEscapes_Authority

)

Definition at line 252 of file uri_test.cc.

                                               {
  ParsedUri uri;
  EXPECT(ParseUri("scheme://UsEr N%61%4de@h%4FsT.c%6fm:80/", &uri));
  EXPECT_STREQ("scheme", uri.scheme);
  EXPECT_STREQ("UsEr%20NaMe", uri.userinfo);  // Normalized, case preserved.
  EXPECT_STREQ("host.com", uri.host);         // Normalized, lower-cased.
  EXPECT_STREQ("80", uri.port);
  EXPECT_STREQ("/", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [495/600]

dart::TEST_CASE

(

ParseUri_NormalizeEscapes_PathQueryFragment

)

Definition at line 227 of file uri_test.cc.

                                                       {
  ParsedUri uri;
  EXPECT(ParseUri("scheme:/This%09Is A P%61th?This%09Is A Qu%65ry#A Fr%61gment",
                  &uri));
  EXPECT_STREQ("scheme", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("/This%09Is%20A%20Path", uri.path);
  EXPECT_STREQ("This%09Is%20A%20Query", uri.query);
  EXPECT_STREQ("A%20Fragment", uri.fragment);
}

TEST_CASE() [496/600]

dart::TEST_CASE

(

ParseUri_NormalizeEscapes_UppercaseEscapeInHost

)

Definition at line 264 of file uri_test.cc.

                                                           {
  ParsedUri uri;
  EXPECT(ParseUri("scheme://tEst%1b/", &uri));
  EXPECT_STREQ("scheme", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT_STREQ("test%1B", uri.host);  // Notice that %1B is upper-cased.
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("/", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [497/600]

dart::TEST_CASE

(

ParseUri_NormalizeEscapes_UppercaseEscapesPreferred

)

Definition at line 240 of file uri_test.cc.

                                                               {
  ParsedUri uri;
  EXPECT(ParseUri("scheme:/%1b%1B", &uri));
  EXPECT_STREQ("scheme", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("/%1B%1B", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [498/600]

dart::TEST_CASE

(

ParseUri_NoScheme_AbsPath_NoAuthority

)

Definition at line 131 of file uri_test.cc.

                                                 {
  ParsedUri uri;
  EXPECT(ParseUri("/over/there", &uri));
  EXPECT(uri.scheme == nullptr);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("/over/there", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [499/600]

dart::TEST_CASE

(

ParseUri_NoScheme_AbsPath_StrayColon

)

Definition at line 144 of file uri_test.cc.

                                                {
  ParsedUri uri;
  EXPECT(ParseUri("/ov:er/there", &uri));
  EXPECT(uri.scheme == nullptr);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("/ov:er/there", uri.path);
  EXPECT(uri.query == nullptr);
}

TEST_CASE() [500/600]

dart::TEST_CASE

(

ParseUri_NoScheme_AbsPath_WithAuthority

)

Definition at line 119 of file uri_test.cc.

                                                   {
  ParsedUri uri;
  EXPECT(ParseUri("//example.com:8042/over/there", &uri));
  EXPECT(uri.scheme == nullptr);
  EXPECT(uri.userinfo == nullptr);
  EXPECT_STREQ("example.com", uri.host);
  EXPECT_STREQ("8042", uri.port);
  EXPECT_STREQ("/over/there", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [501/600]

dart::TEST_CASE

(

ParseUri_NoScheme_Empty

)

Definition at line 179 of file uri_test.cc.

                                   {
  ParsedUri uri;
  EXPECT(ParseUri("", &uri));
  EXPECT(uri.scheme == nullptr);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [502/600]

dart::TEST_CASE

(

ParseUri_NoScheme_FragmentOnly

)

Definition at line 203 of file uri_test.cc.

                                          {
  ParsedUri uri;
  EXPECT(ParseUri("#fragment", &uri));
  EXPECT(uri.scheme == nullptr);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT_STREQ("fragment", uri.fragment);
}

TEST_CASE() [503/600]

dart::TEST_CASE

(

ParseUri_NoScheme_QueryOnly

)

Definition at line 191 of file uri_test.cc.

                                       {
  ParsedUri uri;
  EXPECT(ParseUri("?name=ferret", &uri));
  EXPECT(uri.scheme == nullptr);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("", uri.path);
  EXPECT_STREQ("name=ferret", uri.query);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [504/600]

dart::TEST_CASE

(

ParseUri_NoScheme_Rootless1

)

Definition at line 155 of file uri_test.cc.

                                       {
  ParsedUri uri;
  EXPECT(ParseUri("here", &uri));
  EXPECT(uri.scheme == nullptr);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("here", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [505/600]

dart::TEST_CASE

(

ParseUri_NoScheme_Rootless2

)

Definition at line 167 of file uri_test.cc.

                                       {
  ParsedUri uri;
  EXPECT(ParseUri("or/here", &uri));
  EXPECT(uri.scheme == nullptr);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("or/here", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [506/600]

dart::TEST_CASE

(

ParseUri_WithScheme_EmptyPath

)

Definition at line 83 of file uri_test.cc.

                                         {
  ParsedUri uri;
  EXPECT(ParseUri("foo://example.com:8042", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT_STREQ("example.com", uri.host);
  EXPECT_STREQ("8042", uri.port);
  EXPECT_STREQ("", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [507/600]

dart::TEST_CASE

(

ParseUri_WithScheme_NoQueryNoUser

)

Definition at line 10 of file uri_test.cc.

                                             {
  ParsedUri uri;
  EXPECT(ParseUri("foo://example.com:8042/over/there", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT_STREQ("example.com", uri.host);
  EXPECT_STREQ("8042", uri.port);
  EXPECT_STREQ("/over/there", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [508/600]

dart::TEST_CASE

(

ParseUri_WithScheme_Rootless1

)

Definition at line 95 of file uri_test.cc.

                                         {
  ParsedUri uri;
  EXPECT(ParseUri("foo:here", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("here", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [509/600]

dart::TEST_CASE

(

ParseUri_WithScheme_Rootless2

)

Definition at line 107 of file uri_test.cc.

                                         {
  ParsedUri uri;
  EXPECT(ParseUri("foo:or/here", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT(uri.host == nullptr);
  EXPECT(uri.port == nullptr);
  EXPECT_STREQ("or/here", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [510/600]

dart::TEST_CASE

(

ParseUri_WithScheme_ShortPath

)

Definition at line 71 of file uri_test.cc.

                                         {
  ParsedUri uri;
  EXPECT(ParseUri("foo://example.com:8042/", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT_STREQ("example.com", uri.host);
  EXPECT_STREQ("8042", uri.port);
  EXPECT_STREQ("/", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [511/600]

dart::TEST_CASE

(

ParseUri_WithScheme_WithFragment

)

Definition at line 34 of file uri_test.cc.

                                            {
  ParsedUri uri;
  EXPECT(ParseUri("foo://example.com:8042/over/there#fragment", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT_STREQ("example.com", uri.host);
  EXPECT_STREQ("8042", uri.port);
  EXPECT_STREQ("/over/there", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT_STREQ("fragment", uri.fragment);
}

TEST_CASE() [512/600]

dart::TEST_CASE

(

ParseUri_WithScheme_WithQuery

)

Definition at line 22 of file uri_test.cc.

                                         {
  ParsedUri uri;
  EXPECT(ParseUri("foo://example.com:8042/over/there?name=ferret", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT_STREQ("example.com", uri.host);
  EXPECT_STREQ("8042", uri.port);
  EXPECT_STREQ("/over/there", uri.path);
  EXPECT_STREQ("name=ferret", uri.query);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [513/600]

dart::TEST_CASE

(

ParseUri_WithScheme_WithQueryWithFragment

)

Definition at line 46 of file uri_test.cc.

                                                     {
  ParsedUri uri;
  EXPECT(
      ParseUri("foo://example.com:8042/over/there?name=ferret#fragment", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT(uri.userinfo == nullptr);
  EXPECT_STREQ("example.com", uri.host);
  EXPECT_STREQ("8042", uri.port);
  EXPECT_STREQ("/over/there", uri.path);
  EXPECT_STREQ("name=ferret", uri.query);
  EXPECT_STREQ("fragment", uri.fragment);
}

TEST_CASE() [514/600]

dart::TEST_CASE

(

ParseUri_WithScheme_WithUser

)

Definition at line 59 of file uri_test.cc.

                                        {
  ParsedUri uri;
  EXPECT(ParseUri("foo://user@example.com:8042/over/there", &uri));
  EXPECT_STREQ("foo", uri.scheme);
  EXPECT_STREQ("user", uri.userinfo);
  EXPECT_STREQ("example.com", uri.host);
  EXPECT_STREQ("8042", uri.port);
  EXPECT_STREQ("/over/there", uri.path);
  EXPECT(uri.query == nullptr);
  EXPECT(uri.fragment == nullptr);
}

TEST_CASE() [515/600]

dart::TEST_CASE

(

PortMap_ClosePorts

)

Definition at line 54 of file port_test.cc.

                              {
  PortTestMessageHandler handler;
  Dart_Port port1 = PortMap::CreatePort(&handler);
  Dart_Port port2 = PortMap::CreatePort(&handler);
  EXPECT(PortMap::PortExists(port1));
  EXPECT(PortMap::PortExists(port2));
 
  // Close all ports at once.
  PortMap::ClosePorts(&handler);
  EXPECT(!PortMap::PortExists(port1));
  EXPECT(!PortMap::PortExists(port2));
}

TEST_CASE() [516/600]

dart::TEST_CASE

(

PortMap_CreateAndCloseOnePort

)

Definition at line 25 of file port_test.cc.

                                         {
  PortTestMessageHandler handler;
  Dart_Port port = PortMap::CreatePort(&handler);
  EXPECT_NE(0, port);
  EXPECT(PortMap::PortExists(port));
 
  PortMap::ClosePort(port);
  EXPECT(!PortMap::PortExists(port));
}

TEST_CASE() [517/600]

dart::TEST_CASE

(

PortMap_CreateAndCloseTwoPorts

)

Definition at line 35 of file port_test.cc.

                                          {
  PortTestMessageHandler handler;
  Dart_Port port1 = PortMap::CreatePort(&handler);
  Dart_Port port2 = PortMap::CreatePort(&handler);
  EXPECT(PortMap::PortExists(port1));
  EXPECT(PortMap::PortExists(port2));
 
  // Uniqueness.
  EXPECT_NE(port1, port2);
 
  PortMap::ClosePort(port1);
  EXPECT(!PortMap::PortExists(port1));
  EXPECT(PortMap::PortExists(port2));
 
  PortMap::ClosePort(port2);
  EXPECT(!PortMap::PortExists(port1));
  EXPECT(!PortMap::PortExists(port2));
}

TEST_CASE() [518/600]

dart::TEST_CASE

(

PortMap_CreateManyPorts

)

Definition at line 67 of file port_test.cc.

                                   {
  PortTestMessageHandler handler;
  for (int i = 0; i < 32; i++) {
    Dart_Port port = PortMap::CreatePort(&handler);
    EXPECT(PortMap::PortExists(port));
    PortMap::ClosePort(port);
    EXPECT(!PortMap::PortExists(port));
  }
}

TEST_CASE() [519/600]

dart::TEST_CASE

(

PortMap_PostIntegerMessage

)

Definition at line 94 of file port_test.cc.

                                      {
  PortTestMessageHandler handler;
  Dart_Port port = PortMap::CreatePort(&handler);
  EXPECT_EQ(0, handler.notify_count);
 
  EXPECT(PortMap::PostMessage(
      Message::New(port, Smi::New(42), Message::kNormalPriority)));
 
  // Check that the message notify callback was called.
  EXPECT_EQ(1, handler.notify_count);
  PortMap::ClosePorts(&handler);
}

TEST_CASE() [520/600]

dart::TEST_CASE

(

PortMap_PostMessage

)

Definition at line 77 of file port_test.cc.

                               {
  PortTestMessageHandler handler;
  Dart_Port port = PortMap::CreatePort(&handler);
  EXPECT_EQ(0, handler.notify_count);
 
  const char* message = "msg";
  intptr_t message_len = strlen(message) + 1;
 
  EXPECT(PortMap::PostMessage(
      Message::New(port, reinterpret_cast<uint8_t*>(Utils::StrDup(message)),
                   message_len, nullptr, Message::kNormalPriority)));
 
  // Check that the message notify callback was called.
  EXPECT_EQ(1, handler.notify_count);
  PortMap::ClosePorts(&handler);
}

TEST_CASE() [521/600]

dart::TEST_CASE

(

PortMap_PostMessageClosedPort

)

Definition at line 120 of file port_test.cc.

                                         {
  // Create a port id and make it invalid.
  PortTestMessageHandler handler;
  Dart_Port port = PortMap::CreatePort(&handler);
  PortMap::ClosePort(port);
 
  const char* message = "msg";
  intptr_t message_len = strlen(message) + 1;
 
  EXPECT(!PortMap::PostMessage(
      Message::New(port, reinterpret_cast<uint8_t*>(Utils::StrDup(message)),
                   message_len, nullptr, Message::kNormalPriority)));
}

TEST_CASE() [522/600]

dart::TEST_CASE

(

PortMap_PostNullMessage

)

Definition at line 107 of file port_test.cc.

                                   {
  PortTestMessageHandler handler;
  Dart_Port port = PortMap::CreatePort(&handler);
  EXPECT_EQ(0, handler.notify_count);
 
  EXPECT(PortMap::PostMessage(
      Message::New(port, Object::null(), Message::kNormalPriority)));
 
  // Check that the message notify callback was called.
  EXPECT_EQ(1, handler.notify_count);
  PortMap::ClosePorts(&handler);
}

TEST_CASE() [523/600]

dart::TEST_CASE

(

PrintToString

)

Definition at line 185 of file zone_test.cc.

                         {
  TransitionNativeToVM transition(Thread::Current());
  StackZone zone(Thread::Current());
  const char* result = zone.GetZone()->PrintToString("Hello %s!", "World");
  EXPECT_STREQ("Hello World!", result);
}

TEST_CASE() [524/600]

dart::TEST_CASE

(

Profiler_AllocationSampleTest

)

Definition at line 198 of file profiler_test.cc.

                                         {
  Isolate* isolate = Isolate::Current();
  SampleBlockBuffer* sample_buffer = new SampleBlockBuffer(1, 1);
  Sample* sample = sample_buffer->ReserveAllocationSample(isolate);
  sample->Init(isolate->main_port(), 0, 0);
  sample->set_metadata(99);
  sample->set_is_allocation_sample(true);
  EXPECT_EQ(99, sample->allocation_cid());
  isolate->set_current_allocation_sample_block(nullptr);
  delete sample_buffer;
}

TEST_CASE() [525/600]

dart::TEST_CASE

(

Profiler_SampleBufferIterateTest

)

Definition at line 154 of file profiler_test.cc.

                                            {
  Isolate* isolate = Isolate::Current();
 
  SampleBlockBufferOverrideScope sbbos(new SampleBlockBuffer(3, 1));
  SampleBlockBuffer* sample_buffer = Profiler::sample_block_buffer();
 
  Dart_Port i = 123;
  ProfileSampleBufferTestHelper visitor(i);
 
  sample_buffer->VisitSamples(&visitor);
  EXPECT_EQ(0, visitor.visited());
  Sample* s;
  s = sample_buffer->ReserveCPUSample(isolate);
  EXPECT_NOTNULL(s);
  s->Init(i, kValidTimeStamp, 0);
  s->SetAt(0, kValidPc);
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(1, visitor.visited());
 
  s = sample_buffer->ReserveCPUSample(isolate);
  EXPECT_NOTNULL(s);
  s->Init(i, kValidTimeStamp, 0);
  s->SetAt(0, kValidPc);
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(2, visitor.visited());
 
  s = sample_buffer->ReserveCPUSample(isolate);
  EXPECT_NOTNULL(s);
  s->Init(i, kValidTimeStamp, 0);
  s->SetAt(0, kValidPc);
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(3, visitor.visited());
 
  s = sample_buffer->ReserveCPUSample(isolate);
  EXPECT_NOTNULL(s);
  s->Init(i, kValidTimeStamp, 0);
  s->SetAt(0, kValidPc);
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(3, visitor.visited());
 
  // The overridden sample buffer will be freed before isolate shutdown.
  isolate->set_current_sample_block(nullptr);
}

TEST_CASE() [526/600]

dart::TEST_CASE

(

Profiler_SampleBufferWrapTest

)

Definition at line 106 of file profiler_test.cc.

                                         {
  Isolate* isolate = Isolate::Current();
 
  SampleBlockBufferOverrideScope sbbos(new SampleBlockBuffer(3, 1));
  SampleBlockBuffer* sample_buffer = Profiler::sample_block_buffer();
 
  Dart_Port i = 123;
  ProfileSampleBufferTestHelper visitor(i);
 
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(0, visitor.sum());
  Sample* s;
 
  s = sample_buffer->ReserveCPUSample(isolate);
  EXPECT_NOTNULL(s);
  s->Init(i, kValidTimeStamp, 0);
  s->SetAt(0, 2);
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(2, visitor.sum());
 
  s = sample_buffer->ReserveCPUSample(isolate);
  EXPECT_NOTNULL(s);
  s->Init(i, kValidTimeStamp, 0);
  s->SetAt(0, 4);
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(6, visitor.sum());
 
  s = sample_buffer->ReserveCPUSample(isolate);
  EXPECT_NOTNULL(s);
  s->Init(i, kValidTimeStamp, 0);
  s->SetAt(0, 6);
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(12, visitor.sum());
 
  // Mark the completed blocks as free so they can be re-used.
  sample_buffer->FreeCompletedBlocks();
 
  s = sample_buffer->ReserveCPUSample(isolate);
  EXPECT_NOTNULL(s);
  s->Init(i, kValidTimeStamp, 0);
  s->SetAt(0, 8);
  VisitSamples(sample_buffer, &visitor);
  EXPECT_EQ(18, visitor.sum());
 
  // The overridden sample buffer will be freed before isolate shutdown.
  isolate->set_current_sample_block(nullptr);
}

TEST_CASE() [527/600]

dart::TEST_CASE

(

RangeAdd

)

Definition at line 263 of file range_analysis_test.cc.

                    {
#define TEST_RANGE_ADD(l_min, l_max, r_min, r_max, result_min, result_max)     \
  {                                                                            \
    RangeBoundary min, max;                                                    \
    Range* left_range = new Range(RangeBoundary::FromConstant(l_min),          \
                                  RangeBoundary::FromConstant(l_max));         \
    Range* right_range = new Range(RangeBoundary::FromConstant(r_min),         \
                                   RangeBoundary::FromConstant(r_max));        \
    EXPECT(left_range->min().ConstantValue() == l_min);                        \
    EXPECT(left_range->max().ConstantValue() == l_max);                        \
    EXPECT(right_range->min().ConstantValue() == r_min);                       \
    EXPECT(right_range->max().ConstantValue() == r_max);                       \
    Range::Add(left_range, right_range, &min, &max, nullptr);                  \
    EXPECT(min.Equals(result_min));                                            \
    if (FLAG_support_il_printer && !min.Equals(result_min)) {                  \
      OS::PrintErr("%s != %s\n", min.ToCString(), result_min.ToCString());     \
    }                                                                          \
    EXPECT(max.Equals(result_max));                                            \
    if (FLAG_support_il_printer && !max.Equals(result_max)) {                  \
      OS::PrintErr("%s != %s\n", max.ToCString(), result_max.ToCString());     \
    }                                                                          \
  }
 
  // [kMaxInt32, kMaxInt32 + 15] + [10, 20] = [kMaxInt32 + 10, kMaxInt32 + 35].
  TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt32),
                 static_cast<int64_t>(kMaxInt32) + 15, static_cast<int64_t>(10),
                 static_cast<int64_t>(20),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32) + 10),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32) + 35));
 
  // [kMaxInt32 - 15, kMaxInt32 + 15] + [15, -15] = [kMaxInt32, kMaxInt32].
  TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt32) - 15,
                 static_cast<int64_t>(kMaxInt32) + 15, static_cast<int64_t>(15),
                 static_cast<int64_t>(-15),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32)),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32)));
 
  // [kMaxInt32, kMaxInt32 + 15] + [10, kMaxInt64] = [kMinInt64, kMaxInt64].
  TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt32),
                 static_cast<int64_t>(kMaxInt32) + 15, static_cast<int64_t>(10),
                 static_cast<int64_t>(kMaxInt64), RangeBoundary(kMinInt64),
                 RangeBoundary(kMaxInt64));
 
  // [kMinInt64, kMaxInt32 + 15] + [10, 20] = [kMinInt64 + 10, kMaxInt32 + 35].
  TEST_RANGE_ADD(static_cast<int64_t>(kMinInt64),
                 static_cast<int64_t>(kMaxInt32) + 15, static_cast<int64_t>(10),
                 static_cast<int64_t>(20),
                 RangeBoundary(static_cast<int64_t>(kMinInt64) + 10),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32) + 35));
 
  // [0, 0] + [kMinInt64, kMaxInt64] = [kMinInt64, kMaxInt64].
  TEST_RANGE_ADD(static_cast<int64_t>(0), static_cast<int64_t>(0),
                 static_cast<int64_t>(kMinInt64),
                 static_cast<int64_t>(kMaxInt64), RangeBoundary(kMinInt64),
                 RangeBoundary(kMaxInt64));
 
  // Overflows.
 
  // [-1, 1] + [kMinInt64, kMaxInt64] = [kMinInt64, kMaxInt64].
  TEST_RANGE_ADD(static_cast<int64_t>(-1), static_cast<int64_t>(1),
                 static_cast<int64_t>(kMinInt64),
                 static_cast<int64_t>(kMaxInt64), RangeBoundary(kMinInt64),
                 RangeBoundary(kMaxInt64));
 
  // [kMaxInt64, kMaxInt64] + [kMaxInt64, kMaxInt64] = [kMinInt64, kMaxInt64].
  TEST_RANGE_ADD(
      static_cast<int64_t>(kMaxInt64), static_cast<int64_t>(kMaxInt64),
      static_cast<int64_t>(kMaxInt64), static_cast<int64_t>(kMaxInt64),
      RangeBoundary(kMinInt64), RangeBoundary(kMaxInt64));
 
  // [kMaxInt64, kMaxInt64] + [1, 1] = [kMinInt64, kMaxInt64].
  TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt64),
                 static_cast<int64_t>(kMaxInt64), static_cast<int64_t>(1),
                 static_cast<int64_t>(1), RangeBoundary(kMinInt64),
                 RangeBoundary(kMaxInt64));
 
#undef TEST_RANGE_ADD
}

TEST_CASE() [528/600]

dart::TEST_CASE

(

RangeAnd

)

Definition at line 395 of file range_analysis_test.cc.

                    {
#define TEST_RANGE_AND(l_min, l_max, r_min, r_max, result_min, result_max)     \
  {                                                                            \
    RangeBoundary min, max;                                                    \
    Range* left_range = new Range(RangeBoundary::FromConstant(l_min),          \
                                  RangeBoundary::FromConstant(l_max));         \
    Range* right_range = new Range(RangeBoundary::FromConstant(r_min),         \
                                   RangeBoundary::FromConstant(r_max));        \
    EXPECT(left_range->min().ConstantValue() == l_min);                        \
    EXPECT(left_range->max().ConstantValue() == l_max);                        \
    EXPECT(right_range->min().ConstantValue() == r_min);                       \
    EXPECT(right_range->max().ConstantValue() == r_max);                       \
    Range::And(left_range, right_range, &min, &max);                           \
    EXPECT(min.Equals(result_min));                                            \
    if (FLAG_support_il_printer && !min.Equals(result_min)) {                  \
      OS::PrintErr("%s != %s\n", min.ToCString(), result_min.ToCString());     \
    }                                                                          \
    EXPECT(max.Equals(result_max));                                            \
    if (FLAG_support_il_printer && !max.Equals(result_max)) {                  \
      OS::PrintErr("%s != %s\n", max.ToCString(), result_max.ToCString());     \
    }                                                                          \
  }
 
  // [0xff, 0xfff] & [0xf, 0xf] = [0x0, 0xf].
  TEST_RANGE_AND(static_cast<int64_t>(0xff), static_cast<int64_t>(0xfff),
                 static_cast<int64_t>(0xf), static_cast<int64_t>(0xf),
                 RangeBoundary::FromConstant(0), RangeBoundary(0xf));
 
  // [0xffffffff, 0xffffffff] & [0xfffffffff, 0xfffffffff] = [0x0, 0xfffffffff].
  TEST_RANGE_AND(
      static_cast<int64_t>(0xffffffff), static_cast<int64_t>(0xffffffff),
      static_cast<int64_t>(0xfffffffff), static_cast<int64_t>(0xfffffffff),
      RangeBoundary::FromConstant(0),
      RangeBoundary(static_cast<int64_t>(0xfffffffff)));
 
  // [0xffffffff, 0xffffffff] & [-20, 20] = [0x0, 0xffffffff].
  TEST_RANGE_AND(static_cast<int64_t>(0xffffffff),
                 static_cast<int64_t>(0xffffffff), static_cast<int64_t>(-20),
                 static_cast<int64_t>(20), RangeBoundary::FromConstant(0),
                 RangeBoundary(static_cast<int64_t>(0xffffffff)));
 
  // [-20, 20] & [0xffffffff, 0xffffffff] = [0x0, 0xffffffff].
  TEST_RANGE_AND(static_cast<int64_t>(-20), static_cast<int64_t>(20),
                 static_cast<int64_t>(0xffffffff),
                 static_cast<int64_t>(0xffffffff),
                 RangeBoundary::FromConstant(0),
                 RangeBoundary(static_cast<int64_t>(0xffffffff)));
 
  // Test that [-20, 20] & [-20, 20] = [-32, 31].
  TEST_RANGE_AND(static_cast<int64_t>(-20), static_cast<int64_t>(20),
                 static_cast<int64_t>(-20), static_cast<int64_t>(20),
                 RangeBoundary(-32), RangeBoundary(31));
 
#undef TEST_RANGE_AND
}

TEST_CASE() [529/600]

dart::TEST_CASE

(

RangeBinaryOp

)

Definition at line 210 of file range_analysis_test.cc.

                         {
  Range* range_a = new Range(RangeBoundary::FromConstant(-1),
                             RangeBoundary::FromConstant(RangeBoundary::kMax));
  range_a->Clamp(RangeBoundary::kRangeBoundaryInt32);
  EXPECT(range_a->min().ConstantValue() == -1);
  EXPECT(range_a->max().ConstantValue() == kMaxInt32);
  range_a->set_max(RangeBoundary::FromConstant(RangeBoundary::kMax));
 
  Range* range_b = new Range(RangeBoundary::FromConstant(RangeBoundary::kMin),
                             RangeBoundary::FromConstant(1));
  range_b->Clamp(RangeBoundary::kRangeBoundaryInt32);
  EXPECT(range_b->min().ConstantValue() == kMinInt32);
  EXPECT(range_b->max().ConstantValue() == 1);
  range_b->set_min(RangeBoundary::FromConstant(RangeBoundary::kMin));
 
  {
    Range result;
    Range::BinaryOp(Token::kADD, range_a, range_b, nullptr, &result);
    ASSERT(!Range::IsUnknown(&result));
    EXPECT(result.min().Equals(
        RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64)));
    EXPECT(result.max().Equals(
        RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64)));
  }
 
  // Test that [5, 10] + [0, 5] = [5, 15].
  Range* range_c = new Range(RangeBoundary::FromConstant(5),
                             RangeBoundary::FromConstant(10));
  Range* range_d =
      new Range(RangeBoundary::FromConstant(0), RangeBoundary::FromConstant(5));
 
  {
    Range result;
    Range::BinaryOp(Token::kADD, range_c, range_d, nullptr, &result);
    ASSERT(!Range::IsUnknown(&result));
    EXPECT(result.min().ConstantValue() == 5);
    EXPECT(result.max().ConstantValue() == 15);
  }
 
  // Test that [0xff, 0xfff] & [0xf, 0xf] = [0x0, 0xf].
  Range* range_e = new Range(RangeBoundary::FromConstant(0xff),
                             RangeBoundary::FromConstant(0xfff));
  Range* range_f = new Range(RangeBoundary::FromConstant(0xf),
                             RangeBoundary::FromConstant(0xf));
  {
    Range result;
    Range::BinaryOp(Token::kBIT_AND, range_e, range_f, nullptr, &result);
    ASSERT(!Range::IsUnknown(&result));
    EXPECT(result.min().ConstantValue() == 0x0);
    EXPECT(result.max().ConstantValue() == 0xf);
  }
}

TEST_CASE() [530/600]

dart::TEST_CASE

(

RangeIntersectionMinMax

)

Definition at line 451 of file range_analysis_test.cc.

                                   {
  // Test IntersectionMin and IntersectionMax methods which for constants are
  // simply defined as Max/Min respectively.
 
  // Constants.
  // MIN(0, 1) == 0
  EXPECT(RangeBoundary::IntersectionMax(RangeBoundary::FromConstant(0),
                                        RangeBoundary::FromConstant(1))
             .ConstantValue() == 0);
  // MIN(0, -1) == -1
  EXPECT(RangeBoundary::IntersectionMax(RangeBoundary::FromConstant(0),
                                        RangeBoundary::FromConstant(-1))
             .ConstantValue() == -1);
 
  // MIN(1, 0) == 0
  EXPECT(RangeBoundary::IntersectionMax(RangeBoundary::FromConstant(1),
                                        RangeBoundary::FromConstant(0))
             .ConstantValue() == 0);
  // MIN(-1, 0) == -1
  EXPECT(RangeBoundary::IntersectionMax(RangeBoundary::FromConstant(-1),
                                        RangeBoundary::FromConstant(0))
             .ConstantValue() == -1);
 
  // MAX(0, 1) == 1
  EXPECT(RangeBoundary::IntersectionMin(RangeBoundary::FromConstant(0),
                                        RangeBoundary::FromConstant(1))
             .ConstantValue() == 1);
 
  // MAX(0, -1) == 0
  EXPECT(RangeBoundary::IntersectionMin(RangeBoundary::FromConstant(0),
                                        RangeBoundary::FromConstant(-1))
             .ConstantValue() == 0);
 
  // MAX(1, 0) == 1
  EXPECT(RangeBoundary::IntersectionMin(RangeBoundary::FromConstant(1),
                                        RangeBoundary::FromConstant(0))
             .ConstantValue() == 1);
  // MAX(-1, 0) == 0
  EXPECT(RangeBoundary::IntersectionMin(RangeBoundary::FromConstant(-1),
                                        RangeBoundary::FromConstant(0))
             .ConstantValue() == 0);
 
  // Constants vs. kMinInt64 / kMaxInt64.
  EXPECT(RangeBoundary::IntersectionMin(RangeBoundary(kMinInt64),
                                        RangeBoundary::FromConstant(-1))
             .ConstantValue() == -1);
 
  EXPECT(RangeBoundary::IntersectionMin(RangeBoundary::FromConstant(-1),
                                        RangeBoundary(kMinInt64))
             .ConstantValue() == -1);
 
  EXPECT(RangeBoundary::IntersectionMin(RangeBoundary::FromConstant(1),
                                        RangeBoundary(kMinInt64))
             .ConstantValue() == 1);
 
  EXPECT(RangeBoundary::IntersectionMin(RangeBoundary(kMinInt64),
                                        RangeBoundary::FromConstant(1))
             .ConstantValue() == 1);
 
  EXPECT(RangeBoundary::IntersectionMax(RangeBoundary(kMaxInt64),
                                        RangeBoundary::FromConstant(-1))
             .ConstantValue() == -1);
 
  EXPECT(RangeBoundary::IntersectionMax(RangeBoundary::FromConstant(-1),
                                        RangeBoundary(kMaxInt64))
             .ConstantValue() == -1);
 
  EXPECT(RangeBoundary::IntersectionMax(RangeBoundary::FromConstant(1),
                                        RangeBoundary(kMaxInt64))
             .ConstantValue() == 1);
 
  EXPECT(RangeBoundary::IntersectionMax(RangeBoundary(kMaxInt64),
                                        RangeBoundary::FromConstant(1))
             .ConstantValue() == 1);
}

TEST_CASE() [531/600]

dart::TEST_CASE

(

RangeJoinMinMax

)

Definition at line 527 of file range_analysis_test.cc.

                           {
  // Test IntersectionMin and IntersectionMax methods which for constants are
  // simply defined as Min/Max respectively.
  const RangeBoundary::RangeSize size = RangeBoundary::kRangeBoundarySmi;
 
  // Constants.
  EXPECT(RangeBoundary::JoinMax(RangeBoundary::FromConstant(0),
                                RangeBoundary::FromConstant(1), size)
             .ConstantValue() == 1);
  EXPECT(RangeBoundary::JoinMax(RangeBoundary::FromConstant(0),
                                RangeBoundary::FromConstant(-1), size)
             .ConstantValue() == 0);
  EXPECT(RangeBoundary::JoinMax(RangeBoundary::FromConstant(1),
                                RangeBoundary::FromConstant(0), size)
             .ConstantValue() == 1);
  EXPECT(RangeBoundary::JoinMax(RangeBoundary::FromConstant(-1),
                                RangeBoundary::FromConstant(0), size)
             .ConstantValue() == 0);
  EXPECT(RangeBoundary::JoinMin(RangeBoundary::FromConstant(0),
                                RangeBoundary::FromConstant(1), size)
             .ConstantValue() == 0);
  EXPECT(RangeBoundary::JoinMin(RangeBoundary::FromConstant(0),
                                RangeBoundary::FromConstant(-1), size)
             .ConstantValue() == -1);
  EXPECT(RangeBoundary::JoinMin(RangeBoundary::FromConstant(1),
                                RangeBoundary::FromConstant(0), size)
             .ConstantValue() == 0);
  EXPECT(RangeBoundary::JoinMin(RangeBoundary::FromConstant(-1),
                                RangeBoundary::FromConstant(0), size)
             .ConstantValue() == -1);
 
  // Constants vs. kMinInt64 / kMaxInt64.
  EXPECT(RangeBoundary::JoinMin(RangeBoundary(kMinInt64),
                                RangeBoundary::FromConstant(-1), size)
             .IsMinimumOrBelow(size));
 
  EXPECT(RangeBoundary::JoinMin(RangeBoundary::FromConstant(-1),
                                RangeBoundary(kMinInt64), size)
             .IsMinimumOrBelow(size));
 
  EXPECT(RangeBoundary::JoinMin(RangeBoundary::FromConstant(1),
                                RangeBoundary(kMinInt64), size)
             .IsMinimumOrBelow(size));
 
  EXPECT(RangeBoundary::JoinMin(RangeBoundary(kMinInt64),
                                RangeBoundary::FromConstant(1), size)
             .IsMinimumOrBelow(size));
 
  EXPECT(RangeBoundary::JoinMax(RangeBoundary(kMaxInt64),
                                RangeBoundary::FromConstant(-1), size)
             .IsMaximumOrAbove(size));
 
  EXPECT(RangeBoundary::JoinMax(RangeBoundary::FromConstant(-1),
                                RangeBoundary(kMaxInt64), size)
             .IsMaximumOrAbove(size));
 
  EXPECT(RangeBoundary::JoinMax(RangeBoundary::FromConstant(1),
                                RangeBoundary(kMaxInt64), size)
             .IsMaximumOrAbove(size));
 
  EXPECT(RangeBoundary::JoinMax(RangeBoundary(kMaxInt64),
                                RangeBoundary::FromConstant(1), size)
             .IsMaximumOrAbove(size));
}

TEST_CASE() [532/600]

dart::TEST_CASE

(

RangeSub

)

Definition at line 342 of file range_analysis_test.cc.

                    {
#define TEST_RANGE_SUB(l_min, l_max, r_min, r_max, result_min, result_max)     \
  {                                                                            \
    RangeBoundary min, max;                                                    \
    Range* left_range = new Range(RangeBoundary::FromConstant(l_min),          \
                                  RangeBoundary::FromConstant(l_max));         \
    Range* right_range = new Range(RangeBoundary::FromConstant(r_min),         \
                                   RangeBoundary::FromConstant(r_max));        \
    EXPECT(left_range->min().ConstantValue() == l_min);                        \
    EXPECT(left_range->max().ConstantValue() == l_max);                        \
    EXPECT(right_range->min().ConstantValue() == r_min);                       \
    EXPECT(right_range->max().ConstantValue() == r_max);                       \
    Range::Sub(left_range, right_range, &min, &max, nullptr);                  \
    EXPECT(min.Equals(result_min));                                            \
    if (FLAG_support_il_printer && !min.Equals(result_min)) {                  \
      OS::PrintErr("%s != %s\n", min.ToCString(), result_min.ToCString());     \
    }                                                                          \
    EXPECT(max.Equals(result_max));                                            \
    if (FLAG_support_il_printer && !max.Equals(result_max)) {                  \
      OS::PrintErr("%s != %s\n", max.ToCString(), result_max.ToCString());     \
    }                                                                          \
  }
 
  // [kMaxInt32, kMaxInt32 + 15] - [10, 20] = [kMaxInt32 - 20, kMaxInt32 + 5].
  TEST_RANGE_SUB(static_cast<int64_t>(kMaxInt32),
                 static_cast<int64_t>(kMaxInt32) + 15, static_cast<int64_t>(10),
                 static_cast<int64_t>(20),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32) - 20),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32) + 5));
 
  // [kMintInt64, kMintInt64] - [1, 1] = [kMinInt64, kMaxInt64].
  TEST_RANGE_SUB(static_cast<int64_t>(kMinInt64),
                 static_cast<int64_t>(kMinInt64), static_cast<int64_t>(1),
                 static_cast<int64_t>(1), RangeBoundary(kMinInt64),
                 RangeBoundary(kMaxInt64));
 
  // [1, 1] - [kMintInt64, kMintInt64] = [kMinInt64, kMaxInt64].
  TEST_RANGE_SUB(static_cast<int64_t>(1), static_cast<int64_t>(1),
                 static_cast<int64_t>(kMinInt64),
                 static_cast<int64_t>(kMinInt64), RangeBoundary(kMinInt64),
                 RangeBoundary(kMaxInt64));
 
  // [kMaxInt32 + 10, kMaxInt32 + 20] - [-20, -20] =
  //     [kMaxInt32 + 30, kMaxInt32 + 40].
  TEST_RANGE_SUB(static_cast<int64_t>(kMaxInt32) + 10,
                 static_cast<int64_t>(kMaxInt32) + 20,
                 static_cast<int64_t>(-20), static_cast<int64_t>(-20),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32) + 30),
                 RangeBoundary(static_cast<int64_t>(kMaxInt32) + 40));
 
#undef TEST_RANGE_SUB
}

TEST_CASE() [533/600]

dart::TEST_CASE

(

RangeTests

)

Definition at line 11 of file range_analysis_test.cc.

                      {
  Range* zero =
      new Range(RangeBoundary::FromConstant(0), RangeBoundary::FromConstant(0));
  Range* positive = new Range(RangeBoundary::FromConstant(0),
                              RangeBoundary::FromConstant(100));
  Range* negative = new Range(RangeBoundary::FromConstant(-1),
                              RangeBoundary::FromConstant(-100));
  Range* range_x = new Range(RangeBoundary::FromConstant(-15),
                             RangeBoundary::FromConstant(100));
  EXPECT(positive->IsPositive());
  EXPECT(zero->Overlaps(0, 0));
  EXPECT(positive->Overlaps(0, 0));
  EXPECT(!negative->Overlaps(0, 0));
  EXPECT(range_x->Overlaps(0, 0));
  EXPECT(range_x->IsWithin(-15, 100));
  EXPECT(!range_x->IsWithin(-15, 99));
  EXPECT(!range_x->IsWithin(-14, 100));
 
#define TEST_RANGE_OP_(Op, l_min, l_max, r_min, r_max, Clamp, res_min,         \
                       res_max)                                                \
  {                                                                            \
    RangeBoundary min, max;                                                    \
    Range* left_range = new Range(RangeBoundary::FromConstant(l_min),          \
                                  RangeBoundary::FromConstant(l_max));         \
    Range* shift_range = new Range(RangeBoundary::FromConstant(r_min),         \
                                   RangeBoundary::FromConstant(r_max));        \
    Op(left_range, shift_range, &min, &max);                                   \
    min = Clamp(min);                                                          \
    max = Clamp(max);                                                          \
    EXPECT(min.Equals(res_min));                                               \
    if (FLAG_support_il_printer && !min.Equals(res_min)) {                     \
      OS::PrintErr("%s\n", min.ToCString());                                   \
    }                                                                          \
    EXPECT(max.Equals(res_max));                                               \
    if (FLAG_support_il_printer && !max.Equals(res_max)) {                     \
      OS::PrintErr("%s\n", max.ToCString());                                   \
    }                                                                          \
  }
 
#define NO_CLAMP(b) (b)
#define TEST_RANGE_OP(Op, l_min, l_max, r_min, r_max, result_min, result_max)  \
  TEST_RANGE_OP_(Op, l_min, l_max, r_min, r_max, NO_CLAMP, result_min,         \
                 result_max)
 
#define CLAMP_TO_SMI(b) (b.Clamp(RangeBoundary::kRangeBoundarySmi))
#define TEST_RANGE_OP_SMI(Op, l_min, l_max, r_min, r_max, res_min, res_max)    \
  TEST_RANGE_OP_(Op, l_min, l_max, r_min, r_max, CLAMP_TO_SMI, res_min, res_max)
 
  TEST_RANGE_OP(Range::Shl, -15, 100, 0, 2, RangeBoundary(-60),
                RangeBoundary(400));
  TEST_RANGE_OP(Range::Shl, -15, 100, -2, 2, RangeBoundary(-60),
                RangeBoundary(400));
  TEST_RANGE_OP(Range::Shl, -15, -10, 1, 2, RangeBoundary(-60),
                RangeBoundary(-20));
  TEST_RANGE_OP(Range::Shl, 5, 10, -2, 2, RangeBoundary(5), RangeBoundary(40));
  TEST_RANGE_OP(Range::Shl, -15, 100, 0, 64, RangeBoundary(kMinInt64),
                RangeBoundary(kMaxInt64));
  TEST_RANGE_OP(Range::Shl, -1, 1, 63, 63, RangeBoundary(kMinInt64),
                RangeBoundary(kMaxInt64));
  if (compiler::target::kSmiBits == 62) {
    TEST_RANGE_OP_SMI(Range::Shl, -1, 1, 62, 62,
                      RangeBoundary(compiler::target::kSmiMin),
                      RangeBoundary(compiler::target::kSmiMax));
    TEST_RANGE_OP_SMI(Range::Shl, -1, 1, 30, 30, RangeBoundary(-(1 << 30)),
                      RangeBoundary(1 << 30));
  } else {
    ASSERT(compiler::target::kSmiBits == 30);
    TEST_RANGE_OP_SMI(Range::Shl, -1, 1, 30, 30,
                      RangeBoundary(compiler::target::kSmiMin),
                      RangeBoundary(compiler::target::kSmiMax));
    TEST_RANGE_OP_SMI(Range::Shl, -1, 1, 62, 62,
                      RangeBoundary(compiler::target::kSmiMin),
                      RangeBoundary(compiler::target::kSmiMax));
  }
  TEST_RANGE_OP(Range::Shl, 0, 100, 0, 64, RangeBoundary(kMinInt64),
                RangeBoundary(kMaxInt64));
  TEST_RANGE_OP(Range::Shl, -100, 0, 0, 64, RangeBoundary(kMinInt64),
                RangeBoundary(kMaxInt64));
 
  TEST_RANGE_OP(Range::Shr, -8, 8, 1, 2, RangeBoundary(-4), RangeBoundary(4));
  TEST_RANGE_OP(Range::Shr, 1, 8, 1, 2, RangeBoundary::FromConstant(0),
                RangeBoundary(4));
  TEST_RANGE_OP(Range::Shr, -16, -8, 1, 2, RangeBoundary(-8),
                RangeBoundary(-2));
  TEST_RANGE_OP(Range::Shr, 2, 4, -1, 1, RangeBoundary(1), RangeBoundary(4));
  TEST_RANGE_OP(Range::Shr, kMaxInt64, kMaxInt64, 0, 1,
                RangeBoundary(kMaxInt64 >> 1), RangeBoundary(kMaxInt64));
  TEST_RANGE_OP(Range::Shr, kMinInt64, kMinInt64, 0, 1,
                RangeBoundary(kMinInt64), RangeBoundary(kMinInt64 >> 1));
#undef TEST_RANGE_OP
}

TEST_CASE() [534/600]

dart::TEST_CASE

(

RangeTestsInt64Range

)

Definition at line 103 of file range_analysis_test.cc.

                                {
  const Range fullInt64Range = Range::Full(RangeBoundary::kRangeBoundaryInt64);
 
  Range* all = new Range(RangeBoundary(kMinInt64), RangeBoundary(kMaxInt64));
  EXPECT(all->Equals(&fullInt64Range));
  EXPECT(all->Overlaps(0, 0));
  EXPECT(all->Overlaps(-1, 1));
  EXPECT(!all->IsWithin(0, 100));
 
  Range* positive =
      new Range(RangeBoundary::FromConstant(0), RangeBoundary(kMaxInt64));
  EXPECT(positive->Overlaps(0, 1));
  EXPECT(positive->Overlaps(1, 100));
  EXPECT(positive->Overlaps(-1, 0));
 
  Range* negative =
      new Range(RangeBoundary(kMinInt64), RangeBoundary::FromConstant(-1));
  EXPECT(negative->Overlaps(-1, 0));
  EXPECT(negative->Overlaps(-2, -1));
 
  Range* negpos =
      new Range(RangeBoundary(kMinInt64), RangeBoundary::FromConstant(0));
  EXPECT(!negpos->IsPositive());
 
  Range* c =
      new Range(RangeBoundary(kMinInt64), RangeBoundary::FromConstant(32));
 
  EXPECT(!c->OnlyLessThanOrEqualTo(31));
}

TEST_CASE() [535/600]

dart::TEST_CASE

(

RangeUtils

)

Definition at line 133 of file range_analysis_test.cc.

                      {
  // Use kMin/kMax instead of +/-inf as any range with a +/-inf bound is
  // converted to the full int64 range due to wrap-around.
  const RangeBoundary negativeInfinity =
      RangeBoundary::FromConstant(RangeBoundary::kMin);
  const RangeBoundary positiveInfinity =
      RangeBoundary::FromConstant(RangeBoundary::kMax);
 
  // [-inf, +inf].
  const Range& range_0 = *(new Range(negativeInfinity, positiveInfinity));
  // [-inf, -1].
  const Range& range_a =
      *(new Range(negativeInfinity, RangeBoundary::FromConstant(-1)));
  // [-inf, 0].
  const Range& range_b =
      *(new Range(negativeInfinity, RangeBoundary::FromConstant(0)));
  // [-inf, 1].
  const Range& range_c =
      *(new Range(negativeInfinity, RangeBoundary::FromConstant(1)));
  // [-1, +inf]
  const Range& range_d =
      *(new Range(RangeBoundary::FromConstant(-1), positiveInfinity));
  // [0, +inf]
  const Range& range_e =
      *(new Range(RangeBoundary::FromConstant(0), positiveInfinity));
  // [1, +inf].
  const Range& range_f =
      *(new Range(RangeBoundary::FromConstant(1), positiveInfinity));
  // [1, 2].
  const Range& range_g = *(new Range(RangeBoundary::FromConstant(1),
                                     RangeBoundary::FromConstant(2)));
  // [-1, -2].
  const Range& range_h = *(new Range(RangeBoundary::FromConstant(-1),
                                     RangeBoundary::FromConstant(-2)));
  // [-1, 1].
  const Range& range_i = *(new Range(RangeBoundary::FromConstant(-1),
                                     RangeBoundary::FromConstant(1)));
 
  // OnlyPositiveOrZero.
  EXPECT(!Range::OnlyPositiveOrZero(range_a, range_b));
  EXPECT(!Range::OnlyPositiveOrZero(range_b, range_c));
  EXPECT(!Range::OnlyPositiveOrZero(range_c, range_d));
  EXPECT(!Range::OnlyPositiveOrZero(range_d, range_e));
  EXPECT(Range::OnlyPositiveOrZero(range_e, range_f));
  EXPECT(!Range::OnlyPositiveOrZero(range_d, range_d));
  EXPECT(Range::OnlyPositiveOrZero(range_e, range_e));
  EXPECT(Range::OnlyPositiveOrZero(range_f, range_g));
  EXPECT(!Range::OnlyPositiveOrZero(range_g, range_h));
  EXPECT(!Range::OnlyPositiveOrZero(range_i, range_i));
 
  // OnlyNegativeOrZero.
  EXPECT(Range::OnlyNegativeOrZero(range_a, range_b));
  EXPECT(!Range::OnlyNegativeOrZero(range_b, range_c));
  EXPECT(Range::OnlyNegativeOrZero(range_b, range_b));
  EXPECT(!Range::OnlyNegativeOrZero(range_c, range_c));
  EXPECT(!Range::OnlyNegativeOrZero(range_c, range_d));
  EXPECT(!Range::OnlyNegativeOrZero(range_d, range_e));
  EXPECT(!Range::OnlyNegativeOrZero(range_e, range_f));
  EXPECT(!Range::OnlyNegativeOrZero(range_f, range_g));
  EXPECT(!Range::OnlyNegativeOrZero(range_g, range_h));
  EXPECT(Range::OnlyNegativeOrZero(range_h, range_h));
  EXPECT(!Range::OnlyNegativeOrZero(range_i, range_i));
 
  // [-inf, +inf].
  EXPECT(!Range::OnlyNegativeOrZero(range_0, range_0));
  EXPECT(!Range::OnlyPositiveOrZero(range_0, range_0));
 
  EXPECT(Range::ConstantAbsMax(&range_0) == RangeBoundary::kMax);
  EXPECT(Range::ConstantAbsMax(&range_h) == 2);
  EXPECT(Range::ConstantAbsMax(&range_i) == 1);
 
  // RangeBoundary.Equals.
  EXPECT(RangeBoundary::FromConstant(1).Equals(RangeBoundary::FromConstant(1)));
  EXPECT(
      !RangeBoundary::FromConstant(2).Equals(RangeBoundary::FromConstant(1)));
}

TEST_CASE() [536/600]

dart::TEST_CASE

(

Read

)

Definition at line 15 of file file_test.cc.

                {
  const char* kFilename = bin::test::GetFileName("runtime/bin/file_test.cc");
  bin::File* file = bin::File::Open(nullptr, kFilename, bin::File::kRead);
  EXPECT(file != nullptr);
  char buffer[16];
  buffer[0] = '\0';
  EXPECT(file->ReadFully(buffer, 13));  // ReadFully returns true.
  buffer[13] = '\0';
  EXPECT_STREQ("// Copyright ", buffer);
  EXPECT(!file->WriteByte(1));  // Cannot write to a read-only file.
  file->Release();
}

TEST_CASE() [537/600]

dart::TEST_CASE

(

ReadStream_Read16

)

Definition at line 117 of file datastream_test.cc.

                             {
  TestRaw<int16_t>();
}

TEST_CASE() [538/600]

dart::TEST_CASE

(

ReadStream_Read32

)

Definition at line 121 of file datastream_test.cc.

                             {
  TestRaw<int32_t>();
}

TEST_CASE() [539/600]

dart::TEST_CASE

(

ReadStream_Read64

)

Definition at line 125 of file datastream_test.cc.

                             {
  TestRaw<int64_t>();
}

TEST_CASE() [540/600]

dart::TEST_CASE

(

Regress38528

)

Definition at line 231 of file freelist_test.cc.

                        {
  for (const intptr_t i : {-2, -1, 0, 1, 2}) {
    TestRegress38528(i);
  }
}

TEST_CASE() [541/600]

dart::TEST_CASE

(

ResolveUri_DataUri

)

Definition at line 452 of file uri_test.cc.

                              {
  const char* data_uri =
      "data:application/"
      "dart;charset=utf-8,%20%20%20%20%20%20%20%20import%20%22dart:isolate%22;%"
      "0A%0A%20%20%20%20%20%20%20%20import%20%22package:stream_channel/"
      "stream_channel.dart%22;%0A%0A%20%20%20%20%20%20%20%20import%20%"
      "22package:test/src/runner/plugin/"
      "remote_platform_helpers.dart%22;%0A%20%20%20%20%20%20%20%20import%20%"
      "22package:test/src/runner/vm/"
      "catch_isolate_errors.dart%22;%0A%0A%20%20%20%20%20%20%20%20import%20%"
      "22file:///home/sra/xxxx/dev_compiler/test/"
      "all_tests.dart%22%20as%20test;%0A%0A%20%20%20%20%20%20%20%20void%20main("
      "_,%20SendPort%20message)%20%7B%0A%20%20%20%20%20%20%20%20%20%20var%"
      "20channel%20=%20serializeSuite(()%20%7B%0A%20%20%20%20%20%20%20%20%20%"
      "20%20%20catchIsolateErrors();%0A%20%20%20%20%20%20%20%20%20%20%20%"
      "20return%20test.main;%0A%20%20%20%20%20%20%20%20%20%20%7D);%0A%20%20%20%"
      "20%20%20%20%20%20%20new%20IsolateChannel.connectSend(message).pipe("
      "channel);%0A%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%20%20";
 
  const char* target_uri;
  EXPECT(ResolveUri(data_uri,
                    "bscheme://buser@bhost:11/base/path?baseQuery#bfragment",
                    &target_uri));
  EXPECT_STREQ(data_uri, target_uri);
}

TEST_CASE() [542/600]

dart::TEST_CASE

(

ResolveUri_MoreDotSegmentTests

)

Definition at line 567 of file uri_test.cc.

                                          {
  const char* base = "/";
  EXPECT_STREQ("/a/g", TestResolve(base, "/a/b/c/./../../g"));
  EXPECT_STREQ("/a/g", TestResolve(base, "/a/b/c/./../../g"));
  EXPECT_STREQ("/mid/6", TestResolve(base, "mid/content=5/../6"));
  EXPECT_STREQ("/a/b/e", TestResolve(base, "a/b/c/d/../../e"));
  EXPECT_STREQ("/a/b/e", TestResolve(base, "../a/b/c/d/../../e"));
  EXPECT_STREQ("/a/b/e", TestResolve(base, "./a/b/c/d/../../e"));
  EXPECT_STREQ("/a/b/e", TestResolve(base, "../a/b/./c/d/../../e"));
  EXPECT_STREQ("/a/b/e", TestResolve(base, "./a/b/./c/d/../../e"));
  EXPECT_STREQ("/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/."));
  EXPECT_STREQ("/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/./."));
  EXPECT_STREQ("/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/././."));
 
#define LH "http://localhost"
  base = LH;
  EXPECT_STREQ(LH "/a/g", TestResolve(base, "/a/b/c/./../../g"));
  EXPECT_STREQ(LH "/a/g", TestResolve(base, "/a/b/c/./../../g"));
  EXPECT_STREQ(LH "/mid/6", TestResolve(base, "mid/content=5/../6"));
  EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "a/b/c/d/../../e"));
  EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "../a/b/c/d/../../e"));
  EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "./a/b/c/d/../../e"));
  EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "../a/b/./c/d/../../e"));
  EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "./a/b/./c/d/../../e"));
  EXPECT_STREQ(LH "/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/."));
  EXPECT_STREQ(LH "/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/./."));
  EXPECT_STREQ(LH "/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/././."));
#undef LH
}

TEST_CASE() [543/600]

dart::TEST_CASE

(

ResolveUri_NormalizeEscapes_Authority

)

Definition at line 436 of file uri_test.cc.

                                                 {
  const char* target_uri;
  EXPECT(
      ResolveUri("", "scheme://UsEr N%61%4de@h%4FsT.c%6fm:80/", &target_uri));
  // userinfo is normalized and case is preserved.  host is normalized
  // and lower-cased.
  EXPECT_STREQ("scheme://UsEr%20NaMe@host.com:80/", target_uri);
}

TEST_CASE() [544/600]

dart::TEST_CASE

(

ResolveUri_NormalizeEscapes_BrokenEscapeSequence

)

Definition at line 445 of file uri_test.cc.

                                                            {
  const char* target_uri;
  EXPECT(ResolveUri("", "scheme:/%1g", &target_uri));
  // We don't change broken escape sequences.
  EXPECT_STREQ("scheme:/%1g", target_uri);
}

TEST_CASE() [545/600]

dart::TEST_CASE

(

ResolveUri_NormalizeEscapes_PathQueryFragment

)

Definition at line 420 of file uri_test.cc.

                                                         {
  const char* target_uri;
  EXPECT(ResolveUri("#A Fr%61gment",
                    "scheme:/This%09Is A P%61th?This%09Is A Qu%65ry",
                    &target_uri));
  EXPECT_STREQ(
      "scheme:/This%09Is%20A%20Path?This%09Is%20A%20Query#A%20Fragment",
      target_uri);
}

TEST_CASE() [546/600]

dart::TEST_CASE

(

ResolveUri_NormalizeEscapes_UppercaseHexPreferred

)

Definition at line 430 of file uri_test.cc.

                                                             {
  const char* target_uri;
  EXPECT(ResolveUri("", "scheme:/%1b%1B", &target_uri));
  EXPECT_STREQ("scheme:/%1B%1B", target_uri);
}

TEST_CASE() [547/600]

dart::TEST_CASE

(

ResolveUri_NoScheme_WithAuthority

)

Definition at line 304 of file uri_test.cc.

                                             {
  const char* target_uri;
  EXPECT(ResolveUri("//ruser@rhost:22/ref/path",
                    "bscheme://buser@bhost:11/base/path?baseQuery",
                    &target_uri));
  EXPECT_STREQ("bscheme://ruser@rhost:22/ref/path", target_uri);
}

TEST_CASE() [548/600]

dart::TEST_CASE

(

ResolveUri_NoSchemeNoAuthority_AbsolutePath

)

Definition at line 312 of file uri_test.cc.

                                                       {
  const char* target_uri;
  EXPECT(ResolveUri("/ref/path", "bscheme://buser@bhost:11/base/path?baseQuery",
                    &target_uri));
  EXPECT_STREQ("bscheme://buser@bhost:11/ref/path", target_uri);
}

TEST_CASE() [549/600]

dart::TEST_CASE

(

ResolveUri_NoSchemeNoAuthority_EmptyPath

)

Definition at line 338 of file uri_test.cc.

                                                    {
  const char* target_uri;
  EXPECT(ResolveUri("",
                    "bscheme://buser@bhost:11/base/path?baseQuery#bfragment",
                    &target_uri));
  // Note that we drop the base fragment from the resolved uri.
  EXPECT_STREQ("bscheme://buser@bhost:11/base/path?baseQuery", target_uri);
}

TEST_CASE() [550/600]

dart::TEST_CASE

(

ResolveUri_NoSchemeNoAuthority_EmptyPathWithFragment

)

Definition at line 355 of file uri_test.cc.

                                                                {
  const char* target_uri;
  EXPECT(ResolveUri("#rfragment",
                    "bscheme://buser@bhost:11/base/path?baseQuery#bfragment",
                    &target_uri));
  EXPECT_STREQ("bscheme://buser@bhost:11/base/path?baseQuery#rfragment",
               target_uri);
}

TEST_CASE() [551/600]

dart::TEST_CASE

(

ResolveUri_NoSchemeNoAuthority_EmptyPathWithQuery

)

Definition at line 347 of file uri_test.cc.

                                                             {
  const char* target_uri;
  EXPECT(ResolveUri("?refQuery",
                    "bscheme://buser@bhost:11/base/path?baseQuery#bfragment",
                    &target_uri));
  EXPECT_STREQ("bscheme://buser@bhost:11/base/path?refQuery", target_uri);
}

TEST_CASE() [552/600]

dart::TEST_CASE

(

ResolveUri_NoSchemeNoAuthority_RelativePath

)

Definition at line 319 of file uri_test.cc.

                                                       {
  const char* target_uri;
  EXPECT(ResolveUri("ref/path", "bscheme://buser@bhost:11/base/path?baseQuery",
                    &target_uri));
  EXPECT_STREQ("bscheme://buser@bhost:11/base/ref/path", target_uri);
}

TEST_CASE() [553/600]

dart::TEST_CASE

(

ResolveUri_NoSchemeNoAuthority_RelativePathEmptyBasePath

)

Definition at line 326 of file uri_test.cc.

                                                                    {
  const char* target_uri;
  EXPECT(ResolveUri("ref/path", "bscheme://buser@bhost:11", &target_uri));
  EXPECT_STREQ("bscheme://buser@bhost:11/ref/path", target_uri);
}

TEST_CASE() [554/600]

dart::TEST_CASE

(

ResolveUri_NoSchemeNoAuthority_RelativePathWeirdBasePath

)

Definition at line 332 of file uri_test.cc.

                                                                    {
  const char* target_uri;
  EXPECT(ResolveUri("ref/path", "bscheme:base", &target_uri));
  EXPECT_STREQ("bscheme:ref/path", target_uri);
}

TEST_CASE() [555/600]

dart::TEST_CASE

(

ResolveUri_RelativeBase_NotImplemented

)

Definition at line 481 of file uri_test.cc.

                                                  {
  const char* target_uri;
  EXPECT(!ResolveUri("../r1", "b1/b2", &target_uri));
  EXPECT(target_uri == nullptr);
 
  EXPECT(!ResolveUri("..", "b1/b2", &target_uri));
  EXPECT(target_uri == nullptr);
 
  EXPECT(!ResolveUri("../..", "b1/b2", &target_uri));
  EXPECT(target_uri == nullptr);
 
  EXPECT(!ResolveUri("../../..", "b1/b2", &target_uri));
  EXPECT(target_uri == nullptr);
 
  EXPECT(!ResolveUri("../../../r1", "b1/b2", &target_uri));
  EXPECT(target_uri == nullptr);
 
  EXPECT(!ResolveUri("../r1", "../../b1/b2/b3", &target_uri));
  EXPECT(target_uri == nullptr);
 
  EXPECT(!ResolveUri("../../../r1", "../../b1/b2/b3", &target_uri));
  EXPECT(target_uri == nullptr);
}

TEST_CASE() [556/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveDotSegmentsInitialPrefix

)

Definition at line 407 of file uri_test.cc.

                                                                {
  const char* target_uri;
  EXPECT(ResolveUri("../../../../refpath", "scheme://auth", &target_uri));
  EXPECT_STREQ("scheme://auth/refpath", target_uri);
}

TEST_CASE() [557/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveDotSegmentsMixed

)

Definition at line 413 of file uri_test.cc.

                                                        {
  const char* target_uri;
  EXPECT(ResolveUri("../../1/./2/../3/4/../5/././6/../7",
                    "scheme://auth/a/b/c/d/e", &target_uri));
  EXPECT_STREQ("scheme://auth/a/b/1/3/5/7", target_uri);
}

TEST_CASE() [558/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveDotSegmentsNothingLeft1

)

Definition at line 395 of file uri_test.cc.

                                                               {
  const char* target_uri;
  EXPECT(ResolveUri("../../../../..", "scheme://auth/a/b/c/d", &target_uri));
  EXPECT_STREQ("scheme://auth/", target_uri);
}

TEST_CASE() [559/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveDotSegmentsNothingLeft2

)

Definition at line 401 of file uri_test.cc.

                                                               {
  const char* target_uri;
  EXPECT(ResolveUri(".", "scheme://auth/", &target_uri));
  EXPECT_STREQ("scheme://auth/", target_uri);
}

TEST_CASE() [560/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveOneDotDotSegment

)

Definition at line 376 of file uri_test.cc.

                                                        {
  const char* target_uri;
  EXPECT(ResolveUri("../refpath", "scheme://auth/a/b/c/d", &target_uri));
  EXPECT_STREQ("scheme://auth/a/b/refpath", target_uri);
}

TEST_CASE() [561/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveOneDotSegment

)

Definition at line 364 of file uri_test.cc.

                                                     {
  const char* target_uri;
  EXPECT(ResolveUri("./refpath", "scheme://auth/a/b/c/d", &target_uri));
  EXPECT_STREQ("scheme://auth/a/b/c/refpath", target_uri);
}

TEST_CASE() [562/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveTooManyDotDotSegments

)

Definition at line 388 of file uri_test.cc.

                                                             {
  const char* target_uri;
  EXPECT(ResolveUri("../../../../../../../../../refpath",
                    "scheme://auth/a/b/c/d", &target_uri));
  EXPECT_STREQ("scheme://auth/refpath", target_uri);
}

TEST_CASE() [563/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveTwoDotDotSegments

)

Definition at line 382 of file uri_test.cc.

                                                         {
  const char* target_uri;
  EXPECT(ResolveUri("../../refpath", "scheme://auth/a/b/c/d", &target_uri));
  EXPECT_STREQ("scheme://auth/a/refpath", target_uri);
}

TEST_CASE() [564/600]

dart::TEST_CASE

(

ResolveUri_RemoveDots_RemoveTwoDotSegments

)

Definition at line 370 of file uri_test.cc.

                                                      {
  const char* target_uri;
  EXPECT(ResolveUri("././refpath", "scheme://auth/a/b/c/d", &target_uri));
  EXPECT_STREQ("scheme://auth/a/b/c/refpath", target_uri);
}

TEST_CASE() [565/600]

dart::TEST_CASE

(

ResolveUri_TestUriPerRFCs

)

Definition at line 512 of file uri_test.cc.

                                     {
  const char* base = "http://a/b/c/d;p?q";
 
  // From RFC 3986
  EXPECT_STREQ("g:h", TestResolve(base, "g:h"));
  EXPECT_STREQ("http://a/b/c/g", TestResolve(base, "g"));
  EXPECT_STREQ("http://a/b/c/g", TestResolve(base, "./g"));
  EXPECT_STREQ("http://a/b/c/g/", TestResolve(base, "g/"));
  EXPECT_STREQ("http://a/g", TestResolve(base, "/g"));
  EXPECT_STREQ("http://g", TestResolve(base, "//g"));
  EXPECT_STREQ("http://a/b/c/d;p?y", TestResolve(base, "?y"));
  EXPECT_STREQ("http://a/b/c/g?y", TestResolve(base, "g?y"));
  EXPECT_STREQ("http://a/b/c/d;p?q#s", TestResolve(base, "#s"));
  EXPECT_STREQ("http://a/b/c/g#s", TestResolve(base, "g#s"));
  EXPECT_STREQ("http://a/b/c/g?y#s", TestResolve(base, "g?y#s"));
  EXPECT_STREQ("http://a/b/c/;x", TestResolve(base, ";x"));
  EXPECT_STREQ("http://a/b/c/g;x", TestResolve(base, "g;x"));
  EXPECT_STREQ("http://a/b/c/g;x?y#s", TestResolve(base, "g;x?y#s"));
  EXPECT_STREQ("http://a/b/c/d;p?q", TestResolve(base, ""));
  EXPECT_STREQ("http://a/b/c/", TestResolve(base, "."));
  EXPECT_STREQ("http://a/b/c/", TestResolve(base, "./"));
  EXPECT_STREQ("http://a/b/", TestResolve(base, ".."));
  EXPECT_STREQ("http://a/b/", TestResolve(base, "../"));
  EXPECT_STREQ("http://a/b/g", TestResolve(base, "../g"));
  EXPECT_STREQ("http://a/", TestResolve(base, "../.."));
  EXPECT_STREQ("http://a/", TestResolve(base, "../../"));
  EXPECT_STREQ("http://a/g", TestResolve(base, "../../g"));
  EXPECT_STREQ("http://a/g", TestResolve(base, "../../../g"));
  EXPECT_STREQ("http://a/g", TestResolve(base, "../../../../g"));
  EXPECT_STREQ("http://a/g", TestResolve(base, "/./g"));
  EXPECT_STREQ("http://a/g", TestResolve(base, "/../g"));
  EXPECT_STREQ("http://a/b/c/g.", TestResolve(base, "g."));
  EXPECT_STREQ("http://a/b/c/.g", TestResolve(base, ".g"));
  EXPECT_STREQ("http://a/b/c/g..", TestResolve(base, "g.."));
  EXPECT_STREQ("http://a/b/c/..g", TestResolve(base, "..g"));
  EXPECT_STREQ("http://a/b/g", TestResolve(base, "./../g"));
  EXPECT_STREQ("http://a/b/c/g/", TestResolve(base, "./g/."));
  EXPECT_STREQ("http://a/b/c/g/h", TestResolve(base, "g/./h"));
  EXPECT_STREQ("http://a/b/c/h", TestResolve(base, "g/../h"));
  EXPECT_STREQ("http://a/b/c/g;x=1/y", TestResolve(base, "g;x=1/./y"));
  EXPECT_STREQ("http://a/b/c/y", TestResolve(base, "g;x=1/../y"));
  EXPECT_STREQ("http://a/b/c/g?y/./x", TestResolve(base, "g?y/./x"));
  EXPECT_STREQ("http://a/b/c/g?y/../x", TestResolve(base, "g?y/../x"));
  EXPECT_STREQ("http://a/b/c/g#s/./x", TestResolve(base, "g#s/./x"));
  EXPECT_STREQ("http://a/b/c/g#s/../x", TestResolve(base, "g#s/../x"));
  EXPECT_STREQ("http:g", TestResolve(base, "http:g"));
 
  // Additional tests (not from RFC 3986).
  EXPECT_STREQ("http://a/b/g;p/h;s", TestResolve(base, "../g;p/h;s"));
 
  base = "s:a/b";
  EXPECT_STREQ("s:/c", TestResolve(base, "../c"));
}

TEST_CASE() [566/600]

dart::TEST_CASE

(

ResolveUri_WindowsPaths_Backslash

)

Definition at line 615 of file uri_test.cc.

                                             {
  EXPECT_STREQ(
      "file:///b.dll",
      TestResolve(
          "file:///C:\\Users\\USERNA~1\\AppData\\Local\\Temp\\a\\out.dill",
          "b.dll"));
}

TEST_CASE() [567/600]

dart::TEST_CASE

(

ResolveUri_WindowsPaths_Forwardslash_FileScheme

)

Definition at line 607 of file uri_test.cc.

                                                           {
  EXPECT_STREQ(
      "file:///"
      "C:/Users/USERNA~1/AppData/Local/Temp/a/b.dll",
      TestResolve("file:///C:/Users/USERNA~1/AppData/Local/Temp/a/out.dill",
                  "b.dll"));
}

TEST_CASE() [568/600]

dart::TEST_CASE

(

ResolveUri_WindowsPaths_Forwardslash_NoScheme

)

Definition at line 597 of file uri_test.cc.

                                                         {
  EXPECT_STREQ(
      "c:/Users/USERNA~1/AppData/Local/Temp/a/b.dll",
      TestResolve("C:/Users/USERNA~1/AppData/Local/Temp/a/out.dill", "b.dll"));
}

TEST_CASE() [569/600]

dart::TEST_CASE

(

ResolveUri_WithScheme_NoAuthorityNoQuery

)

Definition at line 288 of file uri_test.cc.

                                                    {
  const char* target_uri;
  EXPECT(ResolveUri("rscheme:/ref/path",
                    "bscheme://buser@bhost:11/base/path?baseQuery",
                    &target_uri));
  EXPECT_STREQ("rscheme:/ref/path", target_uri);
}

TEST_CASE() [570/600]

dart::TEST_CASE

(

ResolveUri_WithScheme_WithAuthorityWithQuery

)

Definition at line 296 of file uri_test.cc.

                                                        {
  const char* target_uri;
  EXPECT(ResolveUri("rscheme://ruser@rhost:22/ref/path?refQuery",
                    "bscheme://buser@bhost:11/base/path?baseQuery",
                    &target_uri));
  EXPECT_STREQ("rscheme://ruser@rhost:22/ref/path?refQuery", target_uri);
}

TEST_CASE() [571/600]

dart::TEST_CASE

(

RingBuffer

)

Definition at line 11 of file ring_buffer_test.cc.

                      {
  RingBuffer<int, 2> buf;
  EXPECT_EQ(0, buf.Size());
  buf.Add(42);
  EXPECT_EQ(1, buf.Size());
  EXPECT_EQ(42, buf.Get(0));
  buf.Add(87);
  EXPECT_EQ(2, buf.Size());
  EXPECT_EQ(87, buf.Get(0));
  EXPECT_EQ(42, buf.Get(1));
  buf.Add(-1);
  EXPECT_EQ(2, buf.Size());
  EXPECT_EQ(-1, buf.Get(0));
  EXPECT_EQ(87, buf.Get(1));
}

TEST_CASE() [572/600]

dart::TEST_CASE

(

SafepointTestDart

)

Definition at line 613 of file thread_test.cc.

                             {
  Isolate* isolate = Thread::Current()->isolate();
  Monitor monitor;
  intptr_t expected_count = 0;
  intptr_t total_done = 0;
  intptr_t exited = 0;
  for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
    Dart::thread_pool()->Run<SafepointTestTask>(
        isolate, &monitor, &expected_count, &total_done, &exited);
  }
// Run Dart code on the main thread long enough to allow all helpers
// to get their verification done and exit. Use a specific UserTag
// to enable the helpers to verify that the main thread is
// successfully interrupted in the pure Dart loop.
#if defined(USING_SIMULATOR)
  const intptr_t kLoopCount = 12345678;
#else
  const intptr_t kLoopCount = 1234567890;
#endif  // defined(USING_SIMULATOR)
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "import 'dart:developer';\n"
                 "int dummy = 0;\n"
                 "main() {\n"
                 "  new UserTag('foo').makeCurrent();\n"
                 "  for (dummy = 0; dummy < %" Pd
                 "; ++dummy) {\n"
                 "    dummy += (dummy & 1);\n"
                 "  }\n"
                 "}\n",
                 kLoopCount);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  // Ensure we looped long enough to allow all helpers to succeed and exit.
  {
    MonitorLocker ml(&monitor);
    while (exited != SafepointTestTask::kTaskCount) {
      ml.Wait();
    }
    EXPECT_EQ(SafepointTestTask::kTaskCount, total_done);
    EXPECT_EQ(SafepointTestTask::kTaskCount, exited);
  }
}

TEST_CASE() [573/600]

dart::TEST_CASE

(

Set_iteration

)

Definition at line 7101 of file object_test.cc.

            {
  constValue()[null];
}
)";
  HashMapNonConstEqualsConst(kScript, false);
}
 
TEST_CASE(Set_iteration) {
  const char* kScript = R"(
makeSet() {
  var set = {'x', 'y', 'z', 'w'};
  set.remove('y');
  set.remove('w');
  return set;
}
)";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle h_result = Dart_Invoke(h_lib, NewString("makeSet"), 0, nullptr);
  EXPECT_VALID(h_result);
 
  TransitionNativeToVM transition(thread);
  Instance& dart_set = Instance::Handle();
  dart_set ^= Api::UnwrapHandle(h_result);
  ASSERT(dart_set.IsSet());
  const Set& cc_set = Set::Cast(dart_set);
 
  EXPECT_EQ(2, cc_set.Length());
 
  Set::Iterator iterator(cc_set);
  Object& object = Object::Handle();

TEST_CASE() [574/600]

dart::TEST_CASE

(

SlotFromGuardedField

)

Definition at line 35 of file slot_test.cc.

                                {
  if (!FLAG_use_field_guards) {
    return;
  }
 
  TransitionNativeToVM transition(thread);
  Zone* zone = thread->zone();
 
  // Setup: create dummy class, function and a field.
  const Class& dummy_class = Class::Handle(Class::New(
      Library::Handle(), String::Handle(Symbols::New(thread, "DummyClass")),
      Script::Handle(), TokenPosition::kNoSource));
  dummy_class.set_is_synthesized_class_unsafe();
 
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  const Function& dummy_function = Function::ZoneHandle(
      Function::New(signature, String::Handle(Symbols::New(thread, "foo")),
                    UntaggedFunction::kRegularFunction, false, false, false,
                    false, false, dummy_class, TokenPosition::kMinSource));
 
  const Field& field = Field::Handle(
      Field::New(String::Handle(Symbols::New(thread, "field")),
                 /*is_static=*/false, /*is_final=*/false, /*is_const=*/false,
                 /*is_reflectable=*/true, /*is_late=*/false, dummy_class,
                 Object::dynamic_type(), TokenPosition::kMinSource,
                 TokenPosition::kMinSource));
 
  // Set non-trivial guarded state on the field.
  field.set_guarded_cid_unsafe(kSmiCid);
  field.set_is_nullable_unsafe(false);
 
  // Enter compiler state.
  CompilerState compiler_state(thread, /*is_aot=*/false,
                               /*is_optimizing=*/true);
 
  const Field& field_clone_1 = Field::ZoneHandle(field.CloneFromOriginal());
  const Field& field_clone_2 = Field::ZoneHandle(field.CloneFromOriginal());
 
  // Check that Slot::Get() returns correctly canonicalized and configured
  // slot that matches properties of the field.
  ParsedFunction* parsed_function =
      new (zone) ParsedFunction(thread, dummy_function);
  const Slot& slot1 = Slot::Get(field_clone_1, parsed_function);
  const Slot& slot2 = Slot::Get(field_clone_2, parsed_function);
  EXPECT_EQ(&slot1, &slot2);
  EXPECT(slot1.is_guarded_field());
  EXPECT(!slot1.type().is_nullable());
  EXPECT_EQ(kSmiCid, slot1.type().ToCid());
 
  // Check that the field was added (once) to the list of guarded fields.
  EXPECT_EQ(1, parsed_function->guarded_fields()->Length());
  EXPECT(parsed_function->guarded_fields()->HasKey(&field_clone_1));
 
  // Change the guarded state of the field to "unknown" - emulating concurrent
  // modification of the guarded state in mutator) and create a new clone of
  // the field.
  field.set_guarded_cid_unsafe(kDynamicCid);
  field.set_is_nullable_unsafe(true);
  const Field& field_clone_3 = Field::ZoneHandle(field.CloneFromOriginal());
 
  // Slot::Get must return the same slot and add the field from which it
  // was created to the guarded fields list.
  ParsedFunction* parsed_function2 =
      new (zone) ParsedFunction(thread, dummy_function);
  const Slot& slot3 = Slot::Get(field_clone_3, parsed_function2);
  EXPECT_EQ(&slot1, &slot3);
  EXPECT_EQ(1, parsed_function2->guarded_fields()->Length());
  EXPECT(parsed_function2->guarded_fields()->HasKey(&field_clone_1));
}

TEST_CASE() [575/600]

dart::TEST_CASE

(

StackLimitInterrupts

)

Definition at line 156 of file isolate_test.cc.

                                {
  ThreadBarrier* barrier = new ThreadBarrier(InterruptChecker::kTaskCount + 1,
                                             InterruptChecker::kTaskCount + 1);
  // Start all tasks. They will busy-wait until interrupted in the first round.
  for (intptr_t task = 0; task < InterruptChecker::kTaskCount; task++) {
    Dart::thread_pool()->Run<InterruptChecker>(thread, barrier);
  }
  // Wait for all tasks to get ready for the first round.
  barrier->Sync();
  for (intptr_t i = 0; i < InterruptChecker::kIterations; ++i) {
    thread->ScheduleInterrupts(Thread::kVMInterrupt);
    // Wait for all tasks to observe the interrupt.
    barrier->Sync();
    // Continue with next round.
    uword interrupts = thread->GetAndClearInterrupts();
    EXPECT((interrupts & Thread::kVMInterrupt) != 0);
  }
  barrier->Sync();
  barrier->Release();
}

TEST_CASE() [576/600]

dart::TEST_CASE

(

StackMapGC

)

Definition at line 42 of file code_descriptors_test.cc.

                      {
  const char* kScriptChars = R"(
class A {
  @pragma("vm:external-name", "NativeFunc")
  external static void func(var i, var k);
  static foo() {
    var i;
    var s1;
    var k;
    var s2;
    var s3;
    i = 10; s1 = 'abcd'; k = 20; s2 = 'B'; s3 = 'C';
    func(i, k);
    return i + k; }
  static void moo() {
    var i = A.foo();
    if (i != 30) throw '$i != 30';
  }
})";
  // First setup the script and compile the script.
  TestCase::LoadTestScript(kScriptChars, native_resolver);
  TransitionNativeToVM transition(thread);
 
  EXPECT(ClassFinalizer::ProcessPendingClasses());
  const String& name = String::Handle(String::New(TestCase::url()));
  const Library& lib = Library::Handle(Library::LookupLibrary(thread, name));
  EXPECT(!lib.IsNull());
  Class& cls =
      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
  EXPECT(!cls.IsNull());
 
  // Now compile the two functions 'A.foo' and 'A.moo'
  String& function_moo_name = String::Handle(String::New("moo"));
  const auto& error = cls.EnsureIsFinalized(thread);
  EXPECT(error == Error::null());
  Function& function_moo =
      Function::Handle(cls.LookupStaticFunction(function_moo_name));
  EXPECT(CompilerTest::TestCompileFunction(function_moo));
  EXPECT(function_moo.HasCode());
 
  String& function_foo_name = String::Handle(String::New("foo"));
  Function& function_foo =
      Function::Handle(cls.LookupStaticFunction(function_foo_name));
  EXPECT(CompilerTest::TestCompileFunction(function_foo));
  EXPECT(function_foo.HasCode());
 
  // Build and setup a stackmap for the call to 'func' in 'A.foo' in order
  // to test the traversal of stack maps when a GC happens.
  BitmapBuilder* stack_bitmap = new BitmapBuilder();
  EXPECT(stack_bitmap != nullptr);
  stack_bitmap->Set(0, false);  // var i.
  stack_bitmap->Set(1, true);   // var s1.
  stack_bitmap->Set(2, false);  // var k.
  stack_bitmap->Set(3, true);   // var s2.
  stack_bitmap->Set(4, true);   // var s3.
  const Code& code = Code::Handle(function_foo.unoptimized_code());
  // Search for the pc of the call to 'func'.
  const PcDescriptors& descriptors =
      PcDescriptors::Handle(code.pc_descriptors());
  int call_count = 0;
  PcDescriptors::Iterator iter(descriptors,
                               UntaggedPcDescriptors::kUnoptStaticCall);
  CompressedStackMapsBuilder compressed_maps_builder(thread->zone());
  while (iter.MoveNext()) {
    compressed_maps_builder.AddEntry(iter.PcOffset(), stack_bitmap, 0);
    ++call_count;
  }
  // We can't easily check that we put the stackmap at the correct pc, but
  // we did if there was exactly one call seen.
  EXPECT(call_count == 1);
  const auto& compressed_maps =
      CompressedStackMaps::Handle(compressed_maps_builder.Finalize());
  code.set_compressed_stackmaps(compressed_maps);
 
  // Now invoke 'A.moo' and it will trigger a GC when the native function
  // is called, this should then cause the stack map of function 'A.foo'
  // to be traversed and the appropriate objects visited.
  const Object& result = Object::Handle(
      DartEntry::InvokeFunction(function_foo, Object::empty_array()));
  EXPECT(!result.IsError());
}

TEST_CASE() [577/600]

dart::TEST_CASE

(

StackTraceFormat

)

Definition at line 3338 of file object_test.cc.

                            {
  const char* kScriptChars =
      "void baz() {\n"
      "  throw 'MyException';\n"
      "}\n"
      "\n"
      "class _OtherClass {\n"
      "  _OtherClass._named() {\n"
      "    baz();\n"
      "  }\n"
      "}\n"
      "\n"
      "set globalVar(var value) {\n"
      "  new _OtherClass._named();\n"
      "}\n"
      "\n"
      "void _bar() {\n"
      "  globalVar = null;\n"
      "}\n"
      "\n"
      "class MyClass {\n"
      "  MyClass() {\n"
      "    (() => foo())();\n"
      "  }\n"
      "\n"
      "  static get field {\n"
      "    _bar();\n"
      "  }\n"
      "\n"
      "  static foo() {\n"
      "    fooHelper() {\n"
      "      field;\n"
      "    }\n"
      "    fooHelper();\n"
      "  }\n"
      "}\n"
      "\n"
      "main() {\n"
      "  (() => new MyClass())();\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
 
  const char* lib_url = "file:///test-lib";
  const size_t kBufferSize = 1024;
  char expected[kBufferSize];
  snprintf(expected, kBufferSize,
           "Unhandled exception:\n"
           "MyException\n"
           "#0      baz (%1$s:2:3)\n"
           "#1      new _OtherClass._named (%1$s:7:5)\n"
           "#2      globalVar= (%1$s:12:7)\n"
           "#3      _bar (%1$s:16:3)\n"
           "#4      MyClass.field (%1$s:25:5)\n"
           "#5      MyClass.foo.fooHelper (%1$s:30:7)\n"
           "#6      MyClass.foo (%1$s:32:5)\n"
           "#7      new MyClass.<anonymous closure> (%1$s:21:12)\n"
           "#8      new MyClass (%1$s:21:18)\n"
           "#9      main.<anonymous closure> (%1$s:37:14)\n"
           "#10     main (%1$s:37:24)",
           lib_url);
 
  EXPECT_ERROR(result, expected);
}

TEST_CASE() [578/600]

dart::TEST_CASE

(

STC_HashLookup

)

Definition at line 8557 of file object_test.cc.

                                                            {
    SubtypeTestCacheCheckContents(zone, *stcs[i]);

TEST_CASE() [579/600]

dart::TEST_CASE

(

STC_LinearLookup

)

Definition at line 8552 of file object_test.cc.

TEST_CASE() [580/600]

dart::TEST_CASE

(

StressMallocDirectly

)

Definition at line 218 of file zone_test.cc.

                                {
#if defined(CHECK_RSS)
  int64_t start_rss = Service::CurrentRSS();
#endif
 
  void* allocations[ARRAY_SIZE(kSizes)];
  for (size_t i = 0; i < ((3u * GB) / (512u * KB)); i++) {
    for (size_t j = 0; j < ARRAY_SIZE(kSizes); j++) {
      allocations[j] = malloc(kSizes[j]);
    }
    for (size_t j = 0; j < ARRAY_SIZE(kSizes); j++) {
      free(allocations[j]);
    }
  }
 
#if defined(CHECK_RSS)
  int64_t stop_rss = Service::CurrentRSS();
  EXPECT_LT(stop_rss, start_rss + kRssSlack);
#endif
}

TEST_CASE() [581/600]

dart::TEST_CASE

(

ThreadIterator_AddFindRemove

)

Definition at line 755 of file thread_test.cc.

                                        {
  ThreadIteratorTestParams params;
  params.spawned_thread_id = OSThread::kInvalidThreadId;
  params.monitor = new Monitor();
 
  {
    MonitorLocker ml(params.monitor);
    EXPECT(params.spawned_thread_id == OSThread::kInvalidThreadId);
    // Spawn thread and wait to receive the thread id.
    OSThread::Start("ThreadIteratorTest", ThreadIteratorTestMain,
                    reinterpret_cast<uword>(&params));
    while (params.spawned_thread_id == OSThread::kInvalidThreadId) {
      ml.Wait();
    }
    EXPECT(params.spawned_thread_id != OSThread::kInvalidThreadId);
    EXPECT(params.spawned_thread_join_id != OSThread::kInvalidThreadJoinId);
    OSThread::Join(params.spawned_thread_join_id);
  }
 
  EXPECT(!OSThread::IsThreadInList(params.spawned_thread_id))
 
  delete params.monitor;
}

TEST_CASE() [582/600]

dart::TEST_CASE

(

ThreadRegistry

)

Definition at line 353 of file thread_test.cc.

                          {
  Isolate* orig = Thread::Current()->isolate();
  Zone* orig_zone = Thread::Current()->zone();
  char* orig_str = orig_zone->PrintToString("foo");
  Dart_ExitIsolate();
  // Create and enter a new isolate.
  TestCase::CreateTestIsolate();
  Zone* zone0 = Thread::Current()->zone();
  EXPECT(zone0 != orig_zone);
  Dart_ShutdownIsolate();
  // Create and enter yet another isolate.
  TestCase::CreateTestIsolate();
  {
    // Create a stack resource this time, and exercise it.
    TransitionNativeToVM transition(Thread::Current());
    StackZone stack_zone(Thread::Current());
    Zone* zone1 = Thread::Current()->zone();
    EXPECT(zone1 != zone0);
    EXPECT(zone1 != orig_zone);
  }
  Dart_ShutdownIsolate();
  Dart_EnterIsolate(reinterpret_cast<Dart_Isolate>(orig));
  // Original zone should be preserved.
  EXPECT_EQ(orig_zone, Thread::Current()->zone());
  EXPECT_STREQ("foo", orig_str);
}

TEST_CASE() [583/600]

dart::TEST_CASE

(

TimelineEventArguments

)

Definition at line 217 of file timeline_test.cc.

                                  {
  // Create a test stream.
  TimelineStream stream("testStream", "testStream", false, true);
 
  // Create a test event.
  TimelineEvent event;
  TimelineTestHelper::SetStream(&event, &stream);
 
  // Allocate room for four arguments.
  event.SetNumArguments(4);
  // Reset.
  event.Reset();
 
  event.DurationBegin("apple");
  event.SetNumArguments(2);
  event.CopyArgument(0, "arg1", "value1");
  event.CopyArgument(1, "arg2", "value2");
  event.SetTimeEnd();
}

TEST_CASE() [584/600]

dart::TEST_CASE

(

TimelineEventArgumentsPrintJSON

)

Definition at line 237 of file timeline_test.cc.

                                           {
  // Create a test stream.
  TimelineStream stream("testStream", "testStream", false, true);
 
  // Create a test event.
  TimelineEvent event;
  TimelineTestHelper::SetStream(&event, &stream);
 
  event.DurationBegin("apple");
  event.SetNumArguments(2);
  event.CopyArgument(0, "arg1", "value1");
  event.CopyArgument(1, "arg2", "value2");
  event.SetTimeEnd();
 
  {
    // Test printing to JSON.
    JSONStream js;
    event.PrintJSON(&js);
 
    // Check both arguments.
    EXPECT_SUBSTRING("\"arg1\":\"value1\"", js.ToCString());
    EXPECT_SUBSTRING("\"arg2\":\"value2\"", js.ToCString());
  }
}

TEST_CASE() [585/600]

dart::TEST_CASE

(

TimelineEventBufferPrintJSON

)

Definition at line 262 of file timeline_test.cc.

                                        {
  JSONStream js;
  TimelineEventFilter filter;
  Timeline::recorder()->PrintJSON(&js, &filter);
  // Check the type.
  EXPECT_SUBSTRING("\"type\":\"Timeline\"", js.ToCString());
  // Check that there is a traceEvents array.
  EXPECT_SUBSTRING("\"traceEvents\":[", js.ToCString());
}

TEST_CASE() [586/600]

dart::TEST_CASE

(

TimelineEventCallbackRecorderBasic

)

Definition at line 289 of file timeline_test.cc.

                                              {
  TimelineRecorderOverride<EventCounterRecorder> override;
 
  // Initial counts are all zero.
  for (intptr_t i = TimelineEvent::kNone + 1; i < TimelineEvent::kNumEventTypes;
       i++) {
    EXPECT_EQ(0, override.recorder()->CountFor(
                     static_cast<TimelineEvent::EventType>(i)));
  }
 
  // Create a test stream.
  TimelineStream stream("testStream", "testStream", false, true);
 
  TimelineEvent* event = nullptr;
 
  event = stream.StartEvent();
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kDuration));
  event->DurationBegin("cabbage");
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kDuration));
  event->SetTimeEnd();
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kDuration));
  event->Complete();
  EXPECT_EQ(1, override.recorder()->CountFor(TimelineEvent::kDuration));
 
  event = stream.StartEvent();
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kInstant));
  event->Instant("instantCabbage");
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kInstant));
  event->Complete();
  EXPECT_EQ(1, override.recorder()->CountFor(TimelineEvent::kInstant));
 
  event = stream.StartEvent();
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kAsyncBegin));
  int64_t async_id = thread->GetNextTaskId();
  EXPECT(async_id != 0);
  event->AsyncBegin("asyncBeginCabbage", async_id);
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kAsyncBegin));
  event->Complete();
  EXPECT_EQ(1, override.recorder()->CountFor(TimelineEvent::kAsyncBegin));
 
  event = stream.StartEvent();
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kAsyncInstant));
  event->AsyncInstant("asyncInstantCabbage", async_id);
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kAsyncInstant));
  event->Complete();
  EXPECT_EQ(1, override.recorder()->CountFor(TimelineEvent::kAsyncInstant));
 
  event = stream.StartEvent();
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kAsyncEnd));
  event->AsyncEnd("asyncEndCabbage", async_id);
  EXPECT_EQ(0, override.recorder()->CountFor(TimelineEvent::kAsyncEnd));
  event->Complete();
  EXPECT_EQ(1, override.recorder()->CountFor(TimelineEvent::kAsyncEnd));
}

TEST_CASE() [587/600]

dart::TEST_CASE

(

TimelineEventDuration

)

Definition at line 128 of file timeline_test.cc.

                                 {
  // Create a test stream.
  TimelineStream stream("testStream", "testStream", false, true);
 
  // Create a test event.
  TimelineEvent event;
  TimelineTestHelper::SetStream(&event, &stream);
  event.DurationBegin("apple");
  // Measure the duration.
  int64_t current_duration = event.TimeDuration();
  event.SetTimeEnd();
  // Verify that duration is larger.
  EXPECT_GE(event.TimeDuration(), current_duration);
}

TEST_CASE() [588/600]

dart::TEST_CASE

(

TimelineEventDurationPrintJSON

)

Definition at line 143 of file timeline_test.cc.

                                          {
  // Create a test stream.
  TimelineStream stream("testStream", "testStream", false, true);
 
  // Create a test event.
  TimelineEvent event;
  TimelineTestHelper::SetStream(&event, &stream);
  event.DurationBegin("apple");
  {
    // Test printing to JSON.
    JSONStream js;
    event.PrintJSON(&js);
    // Check category
    EXPECT_SUBSTRING("\"cat\":\"testStream\"", js.ToCString());
    // Check name.
    EXPECT_SUBSTRING("\"name\":\"apple\"", js.ToCString());
    // Check phase.
    EXPECT_SUBSTRING("\"ph\":\"X\"", js.ToCString());
    // Check that ts key is present.
    EXPECT_SUBSTRING("\"ts\":", js.ToCString());
    // Check that dur key is present.
    EXPECT_SUBSTRING("\"dur\":", js.ToCString());
  }
  event.SetTimeEnd();
}

TEST_CASE() [589/600]

dart::TEST_CASE

(

TimelineEventIsValid

)

Definition at line 109 of file timeline_test.cc.

                                {
  // Create a test stream.
  TimelineStream stream("testStream", "testStream", false, true);
 
  TimelineEvent event;
  TimelineTestHelper::SetStream(&event, &stream);
 
  // Starts invalid.
  EXPECT(!event.IsValid());
 
  // Becomes valid.
  event.Instant("hello");
  EXPECT(event.IsValid());
 
  // Becomes invalid.
  event.Reset();
  EXPECT(!event.IsValid());
}

TEST_CASE() [590/600]

dart::TEST_CASE

(

TimelineRingRecorderJSONOrder

)

Definition at line 344 of file timeline_test.cc.

                                         {
  TimelineStream stream("testStream", "testStream", false, true);
 
  TimelineEventRingRecorder* recorder =
      new TimelineEventRingRecorder(TimelineEventBlock::kBlockSize * 2);
  TimelineRecorderOverride<TimelineEventRingRecorder> override(recorder);
 
  {
    Mutex& recorder_lock = TimelineTestHelper::GetRecorderLock(*recorder);
    MutexLocker ml(&recorder_lock);
    TimelineEventBlock* block_0 = Timeline::recorder()->GetNewBlockLocked();
    EXPECT(block_0 != nullptr);
    TimelineEventBlock* block_1 = Timeline::recorder()->GetNewBlockLocked();
    EXPECT(block_1 != nullptr);
    // Test that we wrapped.
    EXPECT(block_0 == Timeline::recorder()->GetNewBlockLocked());
 
    // Emit the earlier event into block_1.
    TimelineTestHelper::FakeThreadEvent(block_1, 2, "Alpha", &stream);
    OS::Sleep(32);
    // Emit the later event into block_0.
    TimelineTestHelper::FakeThreadEvent(block_0, 2, "Beta", &stream);
 
    TimelineTestHelper::FinishBlock(block_0);
    TimelineTestHelper::FinishBlock(block_1);
  }
 
  JSONStream js;
  TimelineEventFilter filter;
  Timeline::recorder()->PrintJSON(&js, &filter);
  // trace-event has a requirement that events for a thread must have
  // monotonically increasing timestamps.
  // Verify that "Alpha" comes before "Beta" even though "Beta" is in the first
  // block.
  const char* alpha = strstr(js.ToCString(), "Alpha");
  const char* beta = strstr(js.ToCString(), "Beta");
  EXPECT(alpha < beta);
}

TEST_CASE() [591/600]

dart::TEST_CASE

(

TimelineRingRecorderRace

)

Definition at line 383 of file timeline_test.cc.

                                    {
  struct ReportEventsArguments {
    Monitor& synchronization_monitor;
    TimelineEventRecorder& recorder;
    ThreadJoinId join_id = OSThread::kInvalidThreadJoinId;
  };
 
  // Note that |recorder| will be freed by |TimelineRecorderOverride|'s
  // destructor.
  TimelineEventRingRecorder& recorder =
      *(new TimelineEventRingRecorder(2 * TimelineEventBlock::kBlockSize));
  TimelineRecorderOverride<TimelineEventRingRecorder> override(&recorder);
  Monitor synchronization_monitor;
  JSONStream js;
  TimelineEventFilter filter;
  ReportEventsArguments report_events_1_arguments{synchronization_monitor,
                                                  recorder};
  ReportEventsArguments report_events_2_arguments{synchronization_monitor,
                                                  recorder};
 
  // Try concurrently writing events, serializing them, and clearing the
  // timeline. It is not possible to assert anything about the outcome, because
  // of scheduling uncertainty. This test is just used to ensure that TSAN
  // checks the ring recorder code.
  OSThread::Start(
      "ReportEvents1",
      [](uword arguments_ptr) {
        ReportEventsArguments& arguments =
            *reinterpret_cast<ReportEventsArguments*>(arguments_ptr);
        for (intptr_t i = 0; i < 2 * TimelineEventBlock::kBlockSize; ++i) {
          TimelineTestHelper::FakeDuration(&arguments.recorder, "testEvent",
                                           /*start=*/0, /*end=*/1);
        }
        MonitorLocker ml(&arguments.synchronization_monitor);
        arguments.join_id =
            OSThread::GetCurrentThreadJoinId(OSThread::Current());
        ml.Notify();
      },
      reinterpret_cast<uword>(&report_events_1_arguments));
  OSThread::Start(
      "ReportEvents2",
      [](uword arguments_ptr) {
        ReportEventsArguments& arguments =
            *reinterpret_cast<ReportEventsArguments*>(arguments_ptr);
        for (intptr_t i = 0; i < 2 * TimelineEventBlock::kBlockSize; ++i) {
          TimelineTestHelper::FakeDuration(&arguments.recorder, "testEvent",
                                           /*start=*/0, /*end=*/1);
        }
        MonitorLocker ml(&arguments.synchronization_monitor);
        arguments.join_id =
            OSThread::GetCurrentThreadJoinId(OSThread::Current());
        ml.Notify();
      },
      reinterpret_cast<uword>(&report_events_2_arguments));
  Timeline::Clear();
  recorder.PrintJSON(&js, &filter);
 
  MonitorLocker ml(&synchronization_monitor);
  while (report_events_1_arguments.join_id == OSThread::kInvalidThreadJoinId ||
         report_events_2_arguments.join_id == OSThread::kInvalidThreadJoinId) {
    ml.Wait();
  }
  OSThread::Join(report_events_1_arguments.join_id);
  OSThread::Join(report_events_2_arguments.join_id);
}

TEST_CASE() [592/600]

dart::TEST_CASE

(

TimelineTrackMetadataRace

)

Definition at line 455 of file timeline_test.cc.

                                     {
  struct ReportMetadataArguments {
    Monitor& synchronization_monitor;
    TimelineEventRecorder& recorder;
    ThreadJoinId join_id = OSThread::kInvalidThreadJoinId;
  };
 
  Monitor synchronization_monitor;
  TimelineEventRecorder& recorder = *Timeline::recorder();
 
  // Try concurrently reading from / writing to the metadata map. It is not
  // possible to assert anything about the outcome, because of scheduling
  // uncertainty. This test is just used to ensure that TSAN checks the metadata
  // map code.
  JSONStream js;
  TimelineEventFilter filter;
  ReportMetadataArguments report_metadata_1_arguments{synchronization_monitor,
                                                      recorder};
  ReportMetadataArguments report_metadata_2_arguments{synchronization_monitor,
                                                      recorder};
  OSThread::Start(
      "ReportMetadata1",
      [](uword arguments_ptr) {
        ReportMetadataArguments& arguments =
            *reinterpret_cast<ReportMetadataArguments*>(arguments_ptr);
        arguments.recorder.AddTrackMetadataBasedOnThread(
            FAKE_PROCESS_ID, FAKE_TRACE_ID, "Thread 1");
        MonitorLocker ml(&arguments.synchronization_monitor);
        arguments.join_id =
            OSThread::GetCurrentThreadJoinId(OSThread::Current());
        ml.Notify();
      },
      reinterpret_cast<uword>(&report_metadata_1_arguments));
  OSThread::Start(
      "ReportMetadata2",
      [](uword arguments_ptr) {
        ReportMetadataArguments& arguments =
            *reinterpret_cast<ReportMetadataArguments*>(arguments_ptr);
        arguments.recorder.AddTrackMetadataBasedOnThread(
            FAKE_PROCESS_ID, FAKE_TRACE_ID, "Incorrect Name");
        MonitorLocker ml(&arguments.synchronization_monitor);
        arguments.join_id =
            OSThread::GetCurrentThreadJoinId(OSThread::Current());
        ml.Notify();
      },
      reinterpret_cast<uword>(&report_metadata_2_arguments));
  recorder.PrintJSON(&js, &filter);
  MonitorLocker ml(&synchronization_monitor);
  while (
      report_metadata_1_arguments.join_id == OSThread::kInvalidThreadJoinId ||
      report_metadata_2_arguments.join_id == OSThread::kInvalidThreadJoinId) {
    ml.Wait();
  }
  OSThread::Join(report_metadata_1_arguments.join_id);
  OSThread::Join(report_metadata_2_arguments.join_id);
}

TEST_CASE() [593/600]

dart::TEST_CASE

(

TypeArguments_Cache_ManyInstantiations

)

Definition at line 8190 of file object_test.cc.

                                                  {
  TypeArgumentsHashCacheTest(thread,
                             2 * TypeArguments::Cache::kMaxLinearCacheEntries);
}
 

TEST_CASE() [594/600]

dart::TEST_CASE

(

TypeArguments_Cache_SomeInstantiations

)

Definition at line 8180 of file object_test.cc.

                                                              : cache.IsHash());
      auto const loc =
          cache.FindKeyOrUnused(instantiator_type_args, function_type_args);

TEST_CASE() [595/600]

dart::TEST_CASE

(

TypeParameterTypeRef

)

Definition at line 7377 of file object_test.cc.

                         {0,      0x0a,   0x0d,   0x7f,   0xff,
                          0xffff, 0xd800, 0xdc00, 0xdbff, 0xdfff};
 
  const String& str =
      String::Handle(String::FromUTF32(char_codes, ARRAY_SIZE(char_codes)));
  EXPECT(str.Equals(char_codes, ARRAY_SIZE(char_codes)));
}
 
TEST_CASE(TypeParameterTypeRef) {
  // Regression test for issue 82890.
  const char* kScriptChars =
      "void foo<T extends C<T>>(T x) {}\n"
      "void bar<M extends U<M>>(M x) {}\n"
      "abstract class C<T> {}\n"
      "abstract class U<T> extends C<T> {}\n";
  TestCase::LoadTestScript(kScriptChars, nullptr);
  TransitionNativeToVM transition(thread);

TEST_CASE() [596/600]

dart::TEST_CASE

(

UnhandledExceptions

)

Definition at line 88 of file exceptions_test.cc.

                               {
  const char* kScriptChars =
      R"(
      class UnhandledExceptions {
        @pragma('vm:external-name', 'Unhandled_equals')
        external static equals(var obj1, var obj2);

TEST_CASE() [597/600]

dart::TEST_CASE

(

ValidateNoSuchMethodStackFrameIteration

)

Definition at line 259 of file stack_frame_test.cc.

                                                   {
  const char* kScriptChars;
  // The true stack depends on which strategy we are using for noSuchMethod. The
  // stacktrace as seen by Dart is the same either way because dispatcher
  // methods are marked invisible.
  if (FLAG_lazy_dispatchers) {
    kScriptChars =
        "class StackFrame {"
        "  @pragma('vm:external-name', 'StackFrame_equals')\n"
        "  external static equals(var obj1, var obj2);\n"
        "  @pragma('vm:external-name', 'StackFrame_frameCount')\n"
        "  external static int frameCount();\n"
        "  @pragma('vm:external-name', 'StackFrame_dartFrameCount')\n"
        "  external static int dartFrameCount();\n"
        "  @pragma('vm:external-name', 'StackFrame_validateFrame')\n"
        "  external static validateFrame(int index, String name);"
        "} "
        "class StackFrame2Test {"
        "  StackFrame2Test() {}"
        "  noSuchMethod(Invocation im) {"
        "    /* We should have 6 general frames and 4 dart frames as follows:"
        "     * exit frame"
        "     * dart frame corresponding to StackFrame.frameCount"
        "     * dart frame corresponding to StackFrame2Test.noSuchMethod"
        "     * frame for instance function invocation stub calling "
        "noSuchMethod"
        "     * dart frame corresponding to StackFrame2Test.testMain"
        "     * entry frame"
        "     */"
        "    StackFrame.equals(6, StackFrame.frameCount());"
        "    StackFrame.equals(4, StackFrame.dartFrameCount());"
        "    StackFrame.validateFrame(0, \"StackFrame_validateFrame\");"
        "    StackFrame.validateFrame(1, \"StackFrame2Test_noSuchMethod\");"
        "    StackFrame.validateFrame(2, \"StackFrame2Test_foo\");"
        "    StackFrame.validateFrame(3, \"StackFrame2Test_testMain\");"
        "    return 5;"
        "  }"
        "  static testMain() {"
        "    /* Declare |obj| dynamic so that noSuchMethod can be"
        "     * called in strong mode. */"
        "    dynamic obj = new StackFrame2Test();"
        "    StackFrame.equals(5, obj.foo(101, 202));"
        "  }"
        "}";
  } else {
    kScriptChars =
        "class StackFrame {"
        "  @pragma('vm:external-name', 'StackFrame_equals')\n"
        "  external static equals(var obj1, var obj2);\n"
        "  @pragma('vm:external-name', 'StackFrame_frameCount')\n"
        "  external static int frameCount();\n"
        "  @pragma('vm:external-name', 'StackFrame_dartFrameCount')\n"
        "  external static int dartFrameCount();\n"
        "  @pragma('vm:external-name', 'StackFrame_validateFrame')\n"
        "  external static validateFrame(int index, String name);"
        "} "
        "class StackFrame2Test {"
        "  StackFrame2Test() {}"
        "  noSuchMethod(Invocation im) {"
        "    /* We should have 8 general frames and 3 dart frames as follows:"
        "     * exit frame"
        "     * dart frame corresponding to StackFrame.frameCount"
        "     * dart frame corresponding to StackFrame2Test.noSuchMethod"
        "     * entry frame"
        "     * exit frame (call to runtime NoSuchMethodFromCallStub)"
        "     * IC stub"
        "     * dart frame corresponding to StackFrame2Test.testMain"
        "     * entry frame"
        "     */"
        "    StackFrame.equals(8, StackFrame.frameCount());"
        "    StackFrame.equals(3, StackFrame.dartFrameCount());"
        "    StackFrame.validateFrame(0, \"StackFrame_validateFrame\");"
        "    StackFrame.validateFrame(1, \"StackFrame2Test_noSuchMethod\");"
        "    StackFrame.validateFrame(2, \"StackFrame2Test_testMain\");"
        "    return 5;"
        "  }"
        "  static testMain() {"
        "    /* Declare |obj| dynamic so that noSuchMethod can be"
        "     * called in strong mode. */"
        "    dynamic obj = new StackFrame2Test();"
        "    StackFrame.equals(5, obj.foo(101, 202));"
        "  }"
        "}";
  }
  Dart_Handle lib = TestCase::LoadTestScript(
      kScriptChars, reinterpret_cast<Dart_NativeEntryResolver>(native_lookup));
  Dart_Handle cls = Dart_GetClass(lib, NewString("StackFrame2Test"));
  EXPECT_VALID(Dart_Invoke(cls, NewString("testMain"), 0, nullptr));
}

TEST_CASE() [598/600]

dart::TEST_CASE

(

ValidateStackFrameIteration

)

Definition at line 161 of file stack_frame_test.cc.

                                       {
  const char* nullable_tag = TestCase::NullableTag();
  // clang-format off
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(
          nullptr,
          "class StackFrame {"
          "  @pragma('vm:external-name', 'StackFrame_equals')\n"
          "  external static equals(var obj1, var obj2);\n"
          "  @pragma('vm:external-name', 'StackFrame_frameCount')\n"
          "  external static int frameCount();\n"
          "  @pragma('vm:external-name', 'StackFrame_dartFrameCount')\n"
          "  external static int dartFrameCount();\n"
          "  @pragma('vm:external-name', 'StackFrame_validateFrame')\n"
          "  external static validateFrame(int index, String name);"
          "} "
          "class First {"
          "  First() { }"
          "  int%s method1(int%s param) {"
          "    if (param == 1) {"
          "      param = method2(200);"
          "    } else {"
          "      param = method2(100);"
          "    }"
          "  }"
          "  int%s method2(int param) {"
          "    if (param == 200) {"
          "      First.staticmethod(this, param);"
          "    } else {"
          "      First.staticmethod(this, 10);"
          "    }"
          "  }"
          "  static int%s staticmethod(First obj, int param) {"
          "    if (param == 10) {"
          "      obj.method3(10);"
          "    } else {"
          "      obj.method3(200);"
          "    }"
          "  }"
          "  method3(int param) {"
          "    StackFrame.equals(9, StackFrame.frameCount());"
          "    StackFrame.equals(7, StackFrame.dartFrameCount());"
          "    StackFrame.validateFrame(0, \"StackFrame_validateFrame\");"
          "    StackFrame.validateFrame(1, \"First_method3\");"
          "    StackFrame.validateFrame(2, \"First_staticmethod\");"
          "    StackFrame.validateFrame(3, \"First_method2\");"
          "    StackFrame.validateFrame(4, \"First_method1\");"
          "    StackFrame.validateFrame(5, \"Second_method1\");"
          "    StackFrame.validateFrame(6, \"StackFrameTest_testMain\");"
          "  }"
          "}"
          "class Second {"
          "  Second() { }"
          "  int%s method1(int%s param) {"
          "    if (param == 1) {"
          "      param = method2(200);"
          "    } else {"
          "      First obj = new First();"
          "      param = obj.method1(1);"
          "      param = obj.method1(2);"
          "    }"
          "  }"
          "  int%s method2(int param) {"
          "    Second.staticmethod(this, param);"
          "  }"
          "  static int%s staticmethod(Second obj, int param) {"
          "    obj.method3(10);"
          "  }"
          "  method3(int param) {"
          "    StackFrame.equals(8, StackFrame.frameCount());"
          "    StackFrame.equals(6, StackFrame.dartFrameCount());"
          "    StackFrame.validateFrame(0, \"StackFrame_validateFrame\");"
          "    StackFrame.validateFrame(1, \"Second_method3\");"
          "    StackFrame.validateFrame(2, \"Second_staticmethod\");"
          "    StackFrame.validateFrame(3, \"Second_method2\");"
          "    StackFrame.validateFrame(4, \"Second_method1\");"
          "    StackFrame.validateFrame(5, \"StackFrameTest_testMain\");"
          "  }"
          "}"
          "class StackFrameTest {"
          "  static testMain() {"
          "    Second obj = new Second();"
          "    obj.method1(1);"
          "    obj.method1(2);"
          "  }"
          "}",
          nullable_tag, nullable_tag, nullable_tag, nullable_tag, nullable_tag,
          nullable_tag, nullable_tag, nullable_tag),
      std::free);
  // clang-format on
  Dart_Handle lib = TestCase::LoadTestScript(
      kScriptChars.get(),
      reinterpret_cast<Dart_NativeEntryResolver>(native_lookup));
  Dart_Handle cls = Dart_GetClass(lib, NewString("StackFrameTest"));
  EXPECT_VALID(Dart_Invoke(cls, NewString("testMain"), 0, nullptr));
}

TEST_CASE() [599/600]

dart::TEST_CASE

(

ZoneCStringSet

)

Definition at line 227 of file hash_map_test.cc.

                          {
  auto zone = thread->zone();
 
  const char* const kConst1 = "test";
  const char* const kConst2 = "test 2";
 
  char* const str1 = OS::SCreate(zone, "%s", kConst1);
  char* const str2 = OS::SCreate(zone, "%s", kConst2);
  char* const str3 = OS::SCreate(zone, "%s", kConst1);
 
  // Make sure these strings are pointer-distinct, but C-string-equal.
  EXPECT_NE(str1, str3);
  EXPECT_STREQ(str1, str3);
 
  auto const set = new (zone) ZoneCStringSet(zone);
  EXPECT(set->IsEmpty());
 
  set->Insert(str1);
  EXPECT_NOTNULL(set->Lookup(str1));
  EXPECT_NULLPTR(set->Lookup(str2));
  EXPECT_NOTNULL(set->Lookup(str3));
 
  set->Insert(str2);
  EXPECT_NOTNULL(set->Lookup(str1));
  EXPECT_NOTNULL(set->Lookup(str2));
  EXPECT_NOTNULL(set->Lookup(str3));
 
  EXPECT(set->Remove(str3));
  EXPECT_NULLPTR(set->Lookup(str1));
  EXPECT_NOTNULL(set->Lookup(str2));
  EXPECT_NULLPTR(set->Lookup(str3));
 
  EXPECT(!set->Remove(str3));
  EXPECT(set->Remove(str2));
  EXPECT(set->IsEmpty());
}

TEST_CASE() [600/600]

dart::TEST_CASE

(

ZoneDirectChainedHashMap

)

Definition at line 119 of file hash_map_test.cc.

                                    {
  auto zone = thread->zone();
  auto const map = new (zone)
      ZoneDirectChainedHashMap<PointerSetKeyValueTrait<TestValue>>(zone);
  EXPECT(map->IsEmpty());
  TestValue v1(0);
  TestValue v2(1);
  TestValue v3(0);
  map->Insert(&v1);
  EXPECT(map->LookupValue(&v1) == &v1);
  map->Insert(&v2);
  EXPECT(map->LookupValue(&v1) == &v1);
  EXPECT(map->LookupValue(&v2) == &v2);
  EXPECT(map->LookupValue(&v3) == &v1);
}

Test_CollectNewSpace()

void FUNCTION_NAME() dart::Test_CollectNewSpace

(

Dart_NativeArguments

native_args

)

Definition at line 277 of file unit_test.cc.

                                                                           {
  TransitionNativeToVM transition(Thread::Current());
  GCTestHelper::CollectNewSpace();
}

Test_CollectOldSpace()

void FUNCTION_NAME() dart::Test_CollectOldSpace

(

Dart_NativeArguments

native_args

)

Definition at line 282 of file unit_test.cc.

                                                                           {
  TransitionNativeToVM transition(Thread::Current());
  GCTestHelper::CollectOldSpace();
}

Test_Reload()

void FUNCTION_NAME() dart::Test_Reload

(

Dart_NativeArguments

native_args

)

Definition at line 269 of file unit_test.cc.

                                                                  {
  Dart_Handle result = TestCase::TriggerReload(/* kernel_buffer= */ nullptr,
                                               /* kernel_buffer_size= */ 0);
  if (Dart_IsError(result)) {
    Dart_PropagateError(result);
  }
}

TestAliasingViaRedefinition()

static void dart::TestAliasingViaRedefinition ( Thread *  thread, bool  make_it_escape, std::function< Definition *(CompilerState *S, FlowGraph *, Definition *)>  make_redefinition  )

static

Definition at line 222 of file redundancy_elimination_test.cc.

                           {
  const char* script_chars = R"(
    @pragma("vm:external-name", "BlackholeNative")
    external dynamic blackhole([a, b, c, d, e, f]);
    class K {
      var field;
    }
  )";
  const Library& lib =
      Library::Handle(LoadTestScript(script_chars, NoopNativeLookup));
 
  const Class& cls = Class::ZoneHandle(
      lib.LookupClass(String::Handle(Symbols::New(thread, "K"))));
  const Error& err = Error::Handle(cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
 
  const Field& original_field = Field::Handle(
      cls.LookupField(String::Handle(Symbols::New(thread, "field"))));
  EXPECT(!original_field.IsNull());
  const Field& field = Field::Handle(original_field.CloneFromOriginal());
 
  const Function& blackhole =
      Function::ZoneHandle(GetFunction(lib, "blackhole"));
 
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  // We are going to build the following graph:
  //
  // B0[graph_entry]
  // B1[function_entry]:
  //   v0 <- AllocateObject(class K)
  //   v1 <- LoadField(v0, K.field)
  //   v2 <- make_redefinition(v0)
  //   MoveArgument(v1)
  // #if make_it_escape
  //   MoveArgument(v2)
  // #endif
  //   v3 <- StaticCall(blackhole, v1, v2)
  //   v4 <- LoadField(v2, K.field)
  //   Return v4
 
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
  AllocateObjectInstr* v0;
  LoadFieldInstr* v1;
  StaticCallInstr* call;
  LoadFieldInstr* v4;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    auto& slot = Slot::Get(field, &H.flow_graph()->parsed_function());
    v0 = builder.AddDefinition(
        new AllocateObjectInstr(InstructionSource(), cls, S.GetNextDeoptId()));
    v1 = builder.AddDefinition(
        new LoadFieldInstr(new Value(v0), slot, InstructionSource()));
    auto v2 = builder.AddDefinition(make_redefinition(&S, H.flow_graph(), v0));
    InputsArray args(2);
    args.Add(new Value(v1));
    if (make_it_escape) {
      args.Add(new Value(v2));
    }
    call = builder.AddInstruction(new StaticCallInstr(
        InstructionSource(), blackhole, 0, Array::empty_array(),
        std::move(args), S.GetNextDeoptId(), 0, ICData::RebindRule::kStatic));
    v4 = builder.AddDefinition(
        new LoadFieldInstr(new Value(v2), slot, InstructionSource()));
    ret = builder.AddInstruction(new DartReturnInstr(
        InstructionSource(), new Value(v4), S.GetNextDeoptId()));
  }
  H.FinishGraph();
  DominatorBasedCSE::Optimize(H.flow_graph());
 
  if (make_it_escape) {
    // Allocation must be considered aliased.
    EXPECT_PROPERTY(v0, !it.Identity().IsNotAliased());
  } else {
    // Allocation must be considered not-aliased.
    EXPECT_PROPERTY(v0, it.Identity().IsNotAliased());
  }
 
  // v1 should have been removed from the graph and replaced with constant_null.
  EXPECT_PROPERTY(v1, it.next() == nullptr && it.previous() == nullptr);
  EXPECT_PROPERTY(call, it.ArgumentAt(0) == H.flow_graph()->constant_null());
 
  if (make_it_escape) {
    // v4 however should not be removed from the graph, because v0 escapes into
    // blackhole.
    EXPECT_PROPERTY(v4, it.next() != nullptr && it.previous() != nullptr);
    EXPECT_PROPERTY(ret, it.value()->definition() == v4);
  } else {
    // If v0 it not aliased then v4 should also be removed from the graph.
    EXPECT_PROPERTY(v4, it.next() == nullptr && it.previous() == nullptr);
    EXPECT_PROPERTY(
        ret, it.value()->definition() == H.flow_graph()->constant_null());
  }
}

TestAliasingViaStore()

static void dart::TestAliasingViaStore ( Thread *  thread, bool  make_it_escape, bool  make_host_escape, std::function< Definition *(CompilerState *S, FlowGraph *, Definition *)>  make_redefinition  )

static

Definition at line 386 of file redundancy_elimination_test.cc.

                           {
  const char* script_chars = R"(
    @pragma("vm:external-name", "BlackholeNative")
    external dynamic blackhole([a, b, c, d, e, f]);
    class K {
      var field;
    }
  )";
  const Library& lib =
      Library::Handle(LoadTestScript(script_chars, NoopNativeLookup));
 
  const Class& cls = Class::ZoneHandle(
      lib.LookupClass(String::Handle(Symbols::New(thread, "K"))));
  const Error& err = Error::Handle(cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
 
  const Field& original_field = Field::Handle(
      cls.LookupField(String::Handle(Symbols::New(thread, "field"))));
  EXPECT(!original_field.IsNull());
  const Field& field = Field::Handle(original_field.CloneFromOriginal());
 
  const Function& blackhole =
      Function::ZoneHandle(GetFunction(lib, "blackhole"));
 
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  // We are going to build the following graph:
  //
  // B0[graph_entry]
  // B1[function_entry]:
  //   v0 <- AllocateObject(class K)
  //   v5 <- AllocateObject(class K)
  // #if !make_host_escape
  //   StoreField(v5 . K.field = v0)
  // #endif
  //   v1 <- LoadField(v0, K.field)
  //   v2 <- REDEFINITION(v5)
  //   MoveArgument(v1)
  // #if make_it_escape
  //   v6 <- LoadField(v2, K.field)
  //   MoveArgument(v6)
  // #elif make_host_escape
  //   StoreField(v2 . K.field = v0)
  //   MoveArgument(v5)
  // #endif
  //   v3 <- StaticCall(blackhole, v1, v6)
  //   v4 <- LoadField(v0, K.field)
  //   Return v4
 
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
  AllocateObjectInstr* v0;
  AllocateObjectInstr* v5;
  LoadFieldInstr* v1;
  StaticCallInstr* call;
  LoadFieldInstr* v4;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    auto& slot = Slot::Get(field, &H.flow_graph()->parsed_function());
    v0 = builder.AddDefinition(
        new AllocateObjectInstr(InstructionSource(), cls, S.GetNextDeoptId()));
    v5 = builder.AddDefinition(
        new AllocateObjectInstr(InstructionSource(), cls, S.GetNextDeoptId()));
    if (!make_host_escape) {
      builder.AddInstruction(
          new StoreFieldInstr(slot, new Value(v5), new Value(v0),
                              kEmitStoreBarrier, InstructionSource()));
    }
    v1 = builder.AddDefinition(
        new LoadFieldInstr(new Value(v0), slot, InstructionSource()));
    auto v2 = builder.AddDefinition(make_redefinition(&S, H.flow_graph(), v5));
    InputsArray args(2);
    args.Add(new Value(v1));
    if (make_it_escape) {
      auto v6 = builder.AddDefinition(
          new LoadFieldInstr(new Value(v2), slot, InstructionSource()));
      args.Add(new Value(v6));
    } else if (make_host_escape) {
      builder.AddInstruction(
          new StoreFieldInstr(slot, new Value(v2), new Value(v0),
                              kEmitStoreBarrier, InstructionSource()));
      args.Add(new Value(v5));
    }
    call = builder.AddInstruction(new StaticCallInstr(
        InstructionSource(), blackhole, 0, Array::empty_array(),
        std::move(args), S.GetNextDeoptId(), 0, ICData::RebindRule::kStatic));
    v4 = builder.AddDefinition(
        new LoadFieldInstr(new Value(v0), slot, InstructionSource()));
    ret = builder.AddInstruction(new DartReturnInstr(
        InstructionSource(), new Value(v4), S.GetNextDeoptId()));
  }
  H.FinishGraph();
  DominatorBasedCSE::Optimize(H.flow_graph());
 
  if (make_it_escape || make_host_escape) {
    // Allocation must be considered aliased.
    EXPECT_PROPERTY(v0, !it.Identity().IsNotAliased());
  } else {
    // Allocation must not be considered aliased.
    EXPECT_PROPERTY(v0, it.Identity().IsNotAliased());
  }
 
  if (make_host_escape) {
    EXPECT_PROPERTY(v5, !it.Identity().IsNotAliased());
  } else {
    EXPECT_PROPERTY(v5, it.Identity().IsNotAliased());
  }
 
  // v1 should have been removed from the graph and replaced with constant_null.
  EXPECT_PROPERTY(v1, it.next() == nullptr && it.previous() == nullptr);
  EXPECT_PROPERTY(call, it.ArgumentAt(0) == H.flow_graph()->constant_null());
 
  if (make_it_escape || make_host_escape) {
    // v4 however should not be removed from the graph, because v0 escapes into
    // blackhole.
    EXPECT_PROPERTY(v4, it.next() != nullptr && it.previous() != nullptr);
    EXPECT_PROPERTY(ret, it.value()->definition() == v4);
  } else {
    // If v0 it not aliased then v4 should also be removed from the graph.
    EXPECT_PROPERTY(v4, it.next() == nullptr && it.previous() == nullptr);
    EXPECT_PROPERTY(
        ret, it.value()->definition() == H.flow_graph()->constant_null());
  }
}

TestAsyncPassDoublex6Struct16BytesMixedx4Int32()

DART_EXPORT void dart::TestAsyncPassDoublex6Struct16BytesMixedx4Int32

(

void(*)(double a0, double a1, double a2, double a3, double a4, double a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9, int32_t a10)

f

)

Definition at line 18201 of file ffi_test_functions_generated.cc.

                            {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;
  double a5;
  Struct16BytesMixed a6 = {};
  Struct16BytesMixed a7 = {};
  Struct16BytesMixed a8 = {};
  Struct16BytesMixed a9 = {};
  int32_t a10;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
  a5 = 6.0;
  a6.a0 = -7.0;
  a6.a1 = 8;
  a7.a0 = -9.0;
  a7.a1 = 10;
  a8.a0 = -11.0;
  a8.a1 = 12;
  a9.a0 = -13.0;
  a9.a1 = 14;
  a10 = -15;
 
  std::cout << "Calling TestAsyncPassDoublex6Struct16BytesMixedx4Int32(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", (" << a6.a0 << ", " << a6.a1 << "), (" << a7.a0
            << ", " << a7.a1 << "), (" << a8.a0 << ", " << a8.a1 << "), ("
            << a9.a0 << ", " << a9.a1 << "), " << a10 << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
}

TestAsyncPassFloatStruct16BytesHomogeneousFloatFloatStruct1()

DART_EXPORT void dart::TestAsyncPassFloatStruct16BytesHomogeneousFloatFloatStruct1

(

void(*)(float a0, Struct16BytesHomogeneousFloat a1, float a2, Struct16BytesHomogeneousFloat a3, float a4, Struct16BytesHomogeneousFloat a5, float a6, Struct16BytesHomogeneousFloat a7, float a8)

f

)

Definition at line 18033 of file ffi_test_functions_generated.cc.

                         {
  float a0;
  Struct16BytesHomogeneousFloat a1 = {};
  float a2;
  Struct16BytesHomogeneousFloat a3 = {};
  float a4;
  Struct16BytesHomogeneousFloat a5 = {};
  float a6;
  Struct16BytesHomogeneousFloat a7 = {};
  float a8;
 
  a0 = -1.0;
  a1.a0 = 2.0;
  a1.a1 = -3.0;
  a1.a2 = 4.0;
  a1.a3 = -5.0;
  a2 = 6.0;
  a3.a0 = -7.0;
  a3.a1 = 8.0;
  a3.a2 = -9.0;
  a3.a3 = 10.0;
  a4 = -11.0;
  a5.a0 = 12.0;
  a5.a1 = -13.0;
  a5.a2 = 14.0;
  a5.a3 = -15.0;
  a6 = 16.0;
  a7.a0 = -17.0;
  a7.a1 = 18.0;
  a7.a2 = -19.0;
  a7.a3 = 20.0;
  a8 = -21.0;
 
  std::cout
      << "Calling TestAsyncPassFloatStruct16BytesHomogeneousFloatFloatStruct1("
      << "(" << a0 << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", "
      << a1.a3 << "), " << a2 << ", (" << a3.a0 << ", " << a3.a1 << ", "
      << a3.a2 << ", " << a3.a3 << "), " << a4 << ", (" << a5.a0 << ", "
      << a5.a1 << ", " << a5.a2 << ", " << a5.a3 << "), " << a6 << ", ("
      << a7.a0 << ", " << a7.a1 << ", " << a7.a2 << ", " << a7.a3 << "), " << a8
      << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
}

TestAsyncPassFloatStruct32BytesHomogeneousDoubleFloatStruct()

DART_EXPORT void dart::TestAsyncPassFloatStruct32BytesHomogeneousDoubleFloatStruct

(

void(*)(float a0, Struct32BytesHomogeneousDouble a1, float a2, Struct32BytesHomogeneousDouble a3, float a4, Struct32BytesHomogeneousDouble a5, float a6, Struct32BytesHomogeneousDouble a7, float a8)

f

)

Definition at line 18090 of file ffi_test_functions_generated.cc.

                         {
  float a0;
  Struct32BytesHomogeneousDouble a1 = {};
  float a2;
  Struct32BytesHomogeneousDouble a3 = {};
  float a4;
  Struct32BytesHomogeneousDouble a5 = {};
  float a6;
  Struct32BytesHomogeneousDouble a7 = {};
  float a8;
 
  a0 = -1.0;
  a1.a0 = 2.0;
  a1.a1 = -3.0;
  a1.a2 = 4.0;
  a1.a3 = -5.0;
  a2 = 6.0;
  a3.a0 = -7.0;
  a3.a1 = 8.0;
  a3.a2 = -9.0;
  a3.a3 = 10.0;
  a4 = -11.0;
  a5.a0 = 12.0;
  a5.a1 = -13.0;
  a5.a2 = 14.0;
  a5.a3 = -15.0;
  a6 = 16.0;
  a7.a0 = -17.0;
  a7.a1 = 18.0;
  a7.a2 = -19.0;
  a7.a3 = 20.0;
  a8 = -21.0;
 
  std::cout
      << "Calling TestAsyncPassFloatStruct32BytesHomogeneousDoubleFloatStruct("
      << "(" << a0 << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", "
      << a1.a3 << "), " << a2 << ", (" << a3.a0 << ", " << a3.a1 << ", "
      << a3.a2 << ", " << a3.a3 << "), " << a4 << ", (" << a5.a0 << ", "
      << a5.a1 << ", " << a5.a2 << ", " << a5.a3 << "), " << a6 << ", ("
      << a7.a0 << ", " << a7.a1 << ", " << a7.a2 << ", " << a7.a3 << "), " << a8
      << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
}

TestAsyncPassInt32x4Struct16BytesMixedx4Double()

DART_EXPORT void dart::TestAsyncPassInt32x4Struct16BytesMixedx4Double

(

void(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, double a8)

f

)

Definition at line 18255 of file ffi_test_functions_generated.cc.

                          {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  Struct16BytesMixed a4 = {};
  Struct16BytesMixed a5 = {};
  Struct16BytesMixed a6 = {};
  Struct16BytesMixed a7 = {};
  double a8;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4.a0 = -5.0;
  a4.a1 = 6;
  a5.a0 = -7.0;
  a5.a1 = 8;
  a6.a0 = -9.0;
  a6.a1 = 10;
  a7.a0 = -11.0;
  a7.a1 = 12;
  a8 = -13.0;
 
  std::cout << "Calling TestAsyncPassInt32x4Struct16BytesMixedx4Double(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", (" << a4.a0
            << ", " << a4.a1 << "), (" << a5.a0 << ", " << a5.a1 << "), ("
            << a6.a0 << ", " << a6.a1 << "), (" << a7.a0 << ", " << a7.a1
            << "), " << a8 << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
}

TestAsyncPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int()

DART_EXPORT void dart::TestAsyncPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int

(

void(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, double a8, double a9, double a10, double a11, double a12, double a13, double a14, double a15, int64_t a16, int8_t a17, Struct1ByteInt a18, int64_t a19, int8_t a20, Struct4BytesHomogeneousInt16 a21, int64_t a22, int8_t a23, Struct8BytesInt a24, int64_t a25, int8_t a26, Struct8BytesHomogeneousFloat a27, int64_t a28, int8_t a29, Struct8BytesMixed a30, int64_t a31, int8_t a32, StructAlignmentInt16 a33, int64_t a34, int8_t a35, StructAlignmentInt32 a36, int64_t a37, int8_t a38, StructAlignmentInt64 a39)

f

)

Definition at line 18332 of file ffi_test_functions_generated.cc.

                                         {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
  int32_t a5;
  int32_t a6;
  int32_t a7;
  double a8;
  double a9;
  double a10;
  double a11;
  double a12;
  double a13;
  double a14;
  double a15;
  int64_t a16;
  int8_t a17;
  Struct1ByteInt a18 = {};
  int64_t a19;
  int8_t a20;
  Struct4BytesHomogeneousInt16 a21 = {};
  int64_t a22;
  int8_t a23;
  Struct8BytesInt a24 = {};
  int64_t a25;
  int8_t a26;
  Struct8BytesHomogeneousFloat a27 = {};
  int64_t a28;
  int8_t a29;
  Struct8BytesMixed a30 = {};
  int64_t a31;
  int8_t a32;
  StructAlignmentInt16 a33 = {};
  int64_t a34;
  int8_t a35;
  StructAlignmentInt32 a36 = {};
  int64_t a37;
  int8_t a38;
  StructAlignmentInt64 a39 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7 = 8;
  a8 = -9.0;
  a9 = 10.0;
  a10 = -11.0;
  a11 = 12.0;
  a12 = -13.0;
  a13 = 14.0;
  a14 = -15.0;
  a15 = 16.0;
  a16 = -17;
  a17 = 18;
  a18.a0 = -19;
  a19 = 20;
  a20 = -21;
  a21.a0 = 22;
  a21.a1 = -23;
  a22 = 24;
  a23 = -25;
  a24.a0 = 26;
  a24.a1 = -27;
  a24.a2 = 28;
  a25 = -29;
  a26 = 30;
  a27.a0 = -31.0;
  a27.a1 = 32.0;
  a28 = -33;
  a29 = 34;
  a30.a0 = -35.0;
  a30.a1 = 36;
  a30.a2 = -37;
  a31 = 38;
  a32 = -39;
  a33.a0 = 40;
  a33.a1 = -41;
  a33.a2 = 42;
  a34 = -43;
  a35 = 44;
  a36.a0 = -45;
  a36.a1 = 46;
  a36.a2 = -47;
  a37 = 48;
  a38 = -49;
  a39.a0 = 50;
  a39.a1 = -51;
  a39.a2 = 52;
 
  std::cout
      << "Calling TestAsyncPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int("
      << "(" << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
      << ", " << a5 << ", " << a6 << ", " << a7 << ", " << a8 << ", " << a9
      << ", " << a10 << ", " << a11 << ", " << a12 << ", " << a13 << ", " << a14
      << ", " << a15 << ", " << a16 << ", " << static_cast<int>(a17) << ", ("
      << static_cast<int>(a18.a0) << "), " << a19 << ", "
      << static_cast<int>(a20) << ", (" << a21.a0 << ", " << a21.a1 << "), "
      << a22 << ", " << static_cast<int>(a23) << ", (" << a24.a0 << ", "
      << a24.a1 << ", " << a24.a2 << "), " << a25 << ", "
      << static_cast<int>(a26) << ", (" << a27.a0 << ", " << a27.a1 << "), "
      << a28 << ", " << static_cast<int>(a29) << ", (" << a30.a0 << ", "
      << a30.a1 << ", " << a30.a2 << "), " << a31 << ", "
      << static_cast<int>(a32) << ", (" << static_cast<int>(a33.a0) << ", "
      << a33.a1 << ", " << static_cast<int>(a33.a2) << "), " << a34 << ", "
      << static_cast<int>(a35) << ", (" << static_cast<int>(a36.a0) << ", "
      << a36.a1 << ", " << static_cast<int>(a36.a2) << "), " << a37 << ", "
      << static_cast<int>(a38) << ", (" << static_cast<int>(a39.a0) << ", "
      << a39.a1 << ", " << static_cast<int>(a39.a2) << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16,
    a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31,
    a32, a33, a34, a35, a36, a37, a38, a39);
}

TestAsyncPassInt64x7Struct12BytesHomogeneousInt32()

DART_EXPORT void dart::TestAsyncPassInt64x7Struct12BytesHomogeneousInt32

(

void(*)(int64_t a0, int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5, int64_t a6, Struct12BytesHomogeneousInt32 a7)

f

)

Definition at line 20702 of file ffi_test_functions_generated.cc.

                                                 {
  int64_t a0;
  int64_t a1;
  int64_t a2;
  int64_t a3;
  int64_t a4;
  int64_t a5;
  int64_t a6;
  Struct12BytesHomogeneousInt32 a7 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7.a0 = 8;
  a7.a1 = -9;
  a7.a2 = 10;
 
  std::cout << "Calling TestAsyncPassInt64x7Struct12BytesHomogeneousInt32("
            << "(" << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7);
}

TestAsyncPassInt8Struct16BytesMixedInt8Struct16BytesMixedIn()

DART_EXPORT void dart::TestAsyncPassInt8Struct16BytesMixedInt8Struct16BytesMixedIn

(

void(*)(int8_t a0, Struct16BytesMixed a1, int8_t a2, Struct16BytesMixed a3, int8_t a4, Struct16BytesMixed a5, int8_t a6, Struct16BytesMixed a7, int8_t a8)

f

)

Definition at line 18151 of file ffi_test_functions_generated.cc.

                          {
  int8_t a0;
  Struct16BytesMixed a1 = {};
  int8_t a2;
  Struct16BytesMixed a3 = {};
  int8_t a4;
  Struct16BytesMixed a5 = {};
  int8_t a6;
  Struct16BytesMixed a7 = {};
  int8_t a8;
 
  a0 = -1;
  a1.a0 = 2.0;
  a1.a1 = -3;
  a2 = 4;
  a3.a0 = -5.0;
  a3.a1 = 6;
  a4 = -7;
  a5.a0 = 8.0;
  a5.a1 = -9;
  a6 = 10;
  a7.a0 = -11.0;
  a7.a1 = 12;
  a8 = -13;
 
  std::cout
      << "Calling TestAsyncPassInt8Struct16BytesMixedInt8Struct16BytesMixedIn("
      << "(" << static_cast<int>(a0) << ", (" << a1.a0 << ", " << a1.a1 << "), "
      << static_cast<int>(a2) << ", (" << a3.a0 << ", " << a3.a1 << "), "
      << static_cast<int>(a4) << ", (" << a5.a0 << ", " << a5.a1 << "), "
      << static_cast<int>(a6) << ", (" << a7.a0 << ", " << a7.a1 << "), "
      << static_cast<int>(a8) << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
}

TestAsyncPassStruct1024BytesHomogeneousUint64()

DART_EXPORT void dart::TestAsyncPassStruct1024BytesHomogeneousUint64

(

void(*)(Struct1024BytesHomogeneousUint64 a0)

f

)

Definition at line 17855 of file ffi_test_functions_generated.cc.

                                                    {
  Struct1024BytesHomogeneousUint64 a0 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a0.a5 = 6;
  a0.a6 = 7;
  a0.a7 = 8;
  a0.a8 = 9;
  a0.a9 = 10;
  a0.a10 = 11;
  a0.a11 = 12;
  a0.a12 = 13;
  a0.a13 = 14;
  a0.a14 = 15;
  a0.a15 = 16;
  a0.a16 = 17;
  a0.a17 = 18;
  a0.a18 = 19;
  a0.a19 = 20;
  a0.a20 = 21;
  a0.a21 = 22;
  a0.a22 = 23;
  a0.a23 = 24;
  a0.a24 = 25;
  a0.a25 = 26;
  a0.a26 = 27;
  a0.a27 = 28;
  a0.a28 = 29;
  a0.a29 = 30;
  a0.a30 = 31;
  a0.a31 = 32;
  a0.a32 = 33;
  a0.a33 = 34;
  a0.a34 = 35;
  a0.a35 = 36;
  a0.a36 = 37;
  a0.a37 = 38;
  a0.a38 = 39;
  a0.a39 = 40;
  a0.a40 = 41;
  a0.a41 = 42;
  a0.a42 = 43;
  a0.a43 = 44;
  a0.a44 = 45;
  a0.a45 = 46;
  a0.a46 = 47;
  a0.a47 = 48;
  a0.a48 = 49;
  a0.a49 = 50;
  a0.a50 = 51;
  a0.a51 = 52;
  a0.a52 = 53;
  a0.a53 = 54;
  a0.a54 = 55;
  a0.a55 = 56;
  a0.a56 = 57;
  a0.a57 = 58;
  a0.a58 = 59;
  a0.a59 = 60;
  a0.a60 = 61;
  a0.a61 = 62;
  a0.a62 = 63;
  a0.a63 = 64;
  a0.a64 = 65;
  a0.a65 = 66;
  a0.a66 = 67;
  a0.a67 = 68;
  a0.a68 = 69;
  a0.a69 = 70;
  a0.a70 = 71;
  a0.a71 = 72;
  a0.a72 = 73;
  a0.a73 = 74;
  a0.a74 = 75;
  a0.a75 = 76;
  a0.a76 = 77;
  a0.a77 = 78;
  a0.a78 = 79;
  a0.a79 = 80;
  a0.a80 = 81;
  a0.a81 = 82;
  a0.a82 = 83;
  a0.a83 = 84;
  a0.a84 = 85;
  a0.a85 = 86;
  a0.a86 = 87;
  a0.a87 = 88;
  a0.a88 = 89;
  a0.a89 = 90;
  a0.a90 = 91;
  a0.a91 = 92;
  a0.a92 = 93;
  a0.a93 = 94;
  a0.a94 = 95;
  a0.a95 = 96;
  a0.a96 = 97;
  a0.a97 = 98;
  a0.a98 = 99;
  a0.a99 = 100;
  a0.a100 = 101;
  a0.a101 = 102;
  a0.a102 = 103;
  a0.a103 = 104;
  a0.a104 = 105;
  a0.a105 = 106;
  a0.a106 = 107;
  a0.a107 = 108;
  a0.a108 = 109;
  a0.a109 = 110;
  a0.a110 = 111;
  a0.a111 = 112;
  a0.a112 = 113;
  a0.a113 = 114;
  a0.a114 = 115;
  a0.a115 = 116;
  a0.a116 = 117;
  a0.a117 = 118;
  a0.a118 = 119;
  a0.a119 = 120;
  a0.a120 = 121;
  a0.a121 = 122;
  a0.a122 = 123;
  a0.a123 = 124;
  a0.a124 = 125;
  a0.a125 = 126;
  a0.a126 = 127;
  a0.a127 = 128;
 
  std::cout << "Calling TestAsyncPassStruct1024BytesHomogeneousUint64(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << ", " << a0.a5 << ", " << a0.a6 << ", " << a0.a7 << ", "
            << a0.a8 << ", " << a0.a9 << ", " << a0.a10 << ", " << a0.a11
            << ", " << a0.a12 << ", " << a0.a13 << ", " << a0.a14 << ", "
            << a0.a15 << ", " << a0.a16 << ", " << a0.a17 << ", " << a0.a18
            << ", " << a0.a19 << ", " << a0.a20 << ", " << a0.a21 << ", "
            << a0.a22 << ", " << a0.a23 << ", " << a0.a24 << ", " << a0.a25
            << ", " << a0.a26 << ", " << a0.a27 << ", " << a0.a28 << ", "
            << a0.a29 << ", " << a0.a30 << ", " << a0.a31 << ", " << a0.a32
            << ", " << a0.a33 << ", " << a0.a34 << ", " << a0.a35 << ", "
            << a0.a36 << ", " << a0.a37 << ", " << a0.a38 << ", " << a0.a39
            << ", " << a0.a40 << ", " << a0.a41 << ", " << a0.a42 << ", "
            << a0.a43 << ", " << a0.a44 << ", " << a0.a45 << ", " << a0.a46
            << ", " << a0.a47 << ", " << a0.a48 << ", " << a0.a49 << ", "
            << a0.a50 << ", " << a0.a51 << ", " << a0.a52 << ", " << a0.a53
            << ", " << a0.a54 << ", " << a0.a55 << ", " << a0.a56 << ", "
            << a0.a57 << ", " << a0.a58 << ", " << a0.a59 << ", " << a0.a60
            << ", " << a0.a61 << ", " << a0.a62 << ", " << a0.a63 << ", "
            << a0.a64 << ", " << a0.a65 << ", " << a0.a66 << ", " << a0.a67
            << ", " << a0.a68 << ", " << a0.a69 << ", " << a0.a70 << ", "
            << a0.a71 << ", " << a0.a72 << ", " << a0.a73 << ", " << a0.a74
            << ", " << a0.a75 << ", " << a0.a76 << ", " << a0.a77 << ", "
            << a0.a78 << ", " << a0.a79 << ", " << a0.a80 << ", " << a0.a81
            << ", " << a0.a82 << ", " << a0.a83 << ", " << a0.a84 << ", "
            << a0.a85 << ", " << a0.a86 << ", " << a0.a87 << ", " << a0.a88
            << ", " << a0.a89 << ", " << a0.a90 << ", " << a0.a91 << ", "
            << a0.a92 << ", " << a0.a93 << ", " << a0.a94 << ", " << a0.a95
            << ", " << a0.a96 << ", " << a0.a97 << ", " << a0.a98 << ", "
            << a0.a99 << ", " << a0.a100 << ", " << a0.a101 << ", " << a0.a102
            << ", " << a0.a103 << ", " << a0.a104 << ", " << a0.a105 << ", "
            << a0.a106 << ", " << a0.a107 << ", " << a0.a108 << ", " << a0.a109
            << ", " << a0.a110 << ", " << a0.a111 << ", " << a0.a112 << ", "
            << a0.a113 << ", " << a0.a114 << ", " << a0.a115 << ", " << a0.a116
            << ", " << a0.a117 << ", " << a0.a118 << ", " << a0.a119 << ", "
            << a0.a120 << ", " << a0.a121 << ", " << a0.a122 << ", " << a0.a123
            << ", " << a0.a124 << ", " << a0.a125 << ", " << a0.a126 << ", "
            << a0.a127 << "))" << ")\n";
 
  f(a0);
}

TestAsyncPassStruct12BytesHomogeneousFloatx6()

DART_EXPORT void dart::TestAsyncPassStruct12BytesHomogeneousFloatx6

(

void(*)(Struct12BytesHomogeneousFloat a0, Struct12BytesHomogeneousFloat a1, Struct12BytesHomogeneousFloat a2, Struct12BytesHomogeneousFloat a3, Struct12BytesHomogeneousFloat a4, Struct12BytesHomogeneousFloat a5)

f

)

Definition at line 17033 of file ffi_test_functions_generated.cc.

                                                 {
  Struct12BytesHomogeneousFloat a0 = {};
  Struct12BytesHomogeneousFloat a1 = {};
  Struct12BytesHomogeneousFloat a2 = {};
  Struct12BytesHomogeneousFloat a3 = {};
  Struct12BytesHomogeneousFloat a4 = {};
  Struct12BytesHomogeneousFloat a5 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a1.a0 = 4.0;
  a1.a1 = -5.0;
  a1.a2 = 6.0;
  a2.a0 = -7.0;
  a2.a1 = 8.0;
  a2.a2 = -9.0;
  a3.a0 = 10.0;
  a3.a1 = -11.0;
  a3.a2 = 12.0;
  a4.a0 = -13.0;
  a4.a1 = 14.0;
  a4.a2 = -15.0;
  a5.a0 = 16.0;
  a5.a1 = -17.0;
  a5.a2 = 18.0;
 
  std::cout << "Calling TestAsyncPassStruct12BytesHomogeneousFloatx6(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << "), (" << a1.a0
            << ", " << a1.a1 << ", " << a1.a2 << "), (" << a2.a0 << ", "
            << a2.a1 << ", " << a2.a2 << "), (" << a3.a0 << ", " << a3.a1
            << ", " << a3.a2 << "), (" << a4.a0 << ", " << a4.a1 << ", "
            << a4.a2 << "), (" << a5.a0 << ", " << a5.a1 << ", " << a5.a2
            << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5);
}

TestAsyncPassStruct15BytesInlineArrayMixed()

DART_EXPORT void dart::TestAsyncPassStruct15BytesInlineArrayMixed

(

void(*)(Struct15BytesInlineArrayMixed a0)

f

)

Definition at line 20186 of file ffi_test_functions_generated.cc.

                                                 {
  Struct15BytesInlineArrayMixed a0 = {};
 
  a0.a0[0].a0 = -1.0;
  a0.a0[0].a1 = 2;
  a0.a0[1].a0 = -3.0;
  a0.a0[1].a1 = 4;
  a0.a0[2].a0 = -5.0;
  a0.a0[2].a1 = 6;
 
  std::cout << "Calling TestAsyncPassStruct15BytesInlineArrayMixed(" << "(([("
            << a0.a0[0].a0 << ", " << static_cast<int>(a0.a0[0].a1) << "), ("
            << a0.a0[1].a0 << ", " << static_cast<int>(a0.a0[1].a1) << "), ("
            << a0.a0[2].a0 << ", " << static_cast<int>(a0.a0[2].a1) << ")]))"
            << ")\n";
 
  f(a0);
}

TestAsyncPassStruct16BytesHomogeneousFloatx5()

DART_EXPORT void dart::TestAsyncPassStruct16BytesHomogeneousFloatx5

(

void(*)(Struct16BytesHomogeneousFloat a0, Struct16BytesHomogeneousFloat a1, Struct16BytesHomogeneousFloat a2, Struct16BytesHomogeneousFloat a3, Struct16BytesHomogeneousFloat a4)

f

)

Definition at line 17082 of file ffi_test_functions_generated.cc.

                                                 {
  Struct16BytesHomogeneousFloat a0 = {};
  Struct16BytesHomogeneousFloat a1 = {};
  Struct16BytesHomogeneousFloat a2 = {};
  Struct16BytesHomogeneousFloat a3 = {};
  Struct16BytesHomogeneousFloat a4 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a1.a0 = -5.0;
  a1.a1 = 6.0;
  a1.a2 = -7.0;
  a1.a3 = 8.0;
  a2.a0 = -9.0;
  a2.a1 = 10.0;
  a2.a2 = -11.0;
  a2.a3 = 12.0;
  a3.a0 = -13.0;
  a3.a1 = 14.0;
  a3.a2 = -15.0;
  a3.a3 = 16.0;
  a4.a0 = -17.0;
  a4.a1 = 18.0;
  a4.a2 = -19.0;
  a4.a3 = 20.0;
 
  std::cout << "Calling TestAsyncPassStruct16BytesHomogeneousFloatx5(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
            << "), (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", "
            << a1.a3 << "), (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2
            << ", " << a2.a3 << "), (" << a3.a0 << ", " << a3.a1 << ", "
            << a3.a2 << ", " << a3.a3 << "), (" << a4.a0 << ", " << a4.a1
            << ", " << a4.a2 << ", " << a4.a3 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4);
}

TestAsyncPassStruct16BytesMixed2x10()

DART_EXPORT void dart::TestAsyncPassStruct16BytesMixed2x10

(

void(*)(Struct16BytesMixed2 a0, Struct16BytesMixed2 a1, Struct16BytesMixed2 a2, Struct16BytesMixed2 a3, Struct16BytesMixed2 a4, Struct16BytesMixed2 a5, Struct16BytesMixed2 a6, Struct16BytesMixed2 a7, Struct16BytesMixed2 a8, Struct16BytesMixed2 a9)

f

)

Definition at line 17192 of file ffi_test_functions_generated.cc.

                                       {
  Struct16BytesMixed2 a0 = {};
  Struct16BytesMixed2 a1 = {};
  Struct16BytesMixed2 a2 = {};
  Struct16BytesMixed2 a3 = {};
  Struct16BytesMixed2 a4 = {};
  Struct16BytesMixed2 a5 = {};
  Struct16BytesMixed2 a6 = {};
  Struct16BytesMixed2 a7 = {};
  Struct16BytesMixed2 a8 = {};
  Struct16BytesMixed2 a9 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4;
  a1.a0 = -5.0;
  a1.a1 = 6.0;
  a1.a2 = -7.0;
  a1.a3 = 8;
  a2.a0 = -9.0;
  a2.a1 = 10.0;
  a2.a2 = -11.0;
  a2.a3 = 12;
  a3.a0 = -13.0;
  a3.a1 = 14.0;
  a3.a2 = -15.0;
  a3.a3 = 16;
  a4.a0 = -17.0;
  a4.a1 = 18.0;
  a4.a2 = -19.0;
  a4.a3 = 20;
  a5.a0 = -21.0;
  a5.a1 = 22.0;
  a5.a2 = -23.0;
  a5.a3 = 24;
  a6.a0 = -25.0;
  a6.a1 = 26.0;
  a6.a2 = -27.0;
  a6.a3 = 28;
  a7.a0 = -29.0;
  a7.a1 = 30.0;
  a7.a2 = -31.0;
  a7.a3 = 32;
  a8.a0 = -33.0;
  a8.a1 = 34.0;
  a8.a2 = -35.0;
  a8.a3 = 36;
  a9.a0 = -37.0;
  a9.a1 = 38.0;
  a9.a2 = -39.0;
  a9.a3 = 40;
 
  std::cout << "Calling TestAsyncPassStruct16BytesMixed2x10(" << "((" << a0.a0
            << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << "), ("
            << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", " << a1.a3
            << "), (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2 << ", "
            << a2.a3 << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2
            << ", " << a3.a3 << "), (" << a4.a0 << ", " << a4.a1 << ", "
            << a4.a2 << ", " << a4.a3 << "), (" << a5.a0 << ", " << a5.a1
            << ", " << a5.a2 << ", " << a5.a3 << "), (" << a6.a0 << ", "
            << a6.a1 << ", " << a6.a2 << ", " << a6.a3 << "), (" << a7.a0
            << ", " << a7.a1 << ", " << a7.a2 << ", " << a7.a3 << "), ("
            << a8.a0 << ", " << a8.a1 << ", " << a8.a2 << ", " << a8.a3
            << "), (" << a9.a0 << ", " << a9.a1 << ", " << a9.a2 << ", "
            << a9.a3 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct16BytesMixedx10()

DART_EXPORT void dart::TestAsyncPassStruct16BytesMixedx10

(

void(*)(Struct16BytesMixed a0, Struct16BytesMixed a1, Struct16BytesMixed a2, Struct16BytesMixed a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9)

f

)

Definition at line 17132 of file ffi_test_functions_generated.cc.

                                      {
  Struct16BytesMixed a0 = {};
  Struct16BytesMixed a1 = {};
  Struct16BytesMixed a2 = {};
  Struct16BytesMixed a3 = {};
  Struct16BytesMixed a4 = {};
  Struct16BytesMixed a5 = {};
  Struct16BytesMixed a6 = {};
  Struct16BytesMixed a7 = {};
  Struct16BytesMixed a8 = {};
  Struct16BytesMixed a9 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2;
  a1.a0 = -3.0;
  a1.a1 = 4;
  a2.a0 = -5.0;
  a2.a1 = 6;
  a3.a0 = -7.0;
  a3.a1 = 8;
  a4.a0 = -9.0;
  a4.a1 = 10;
  a5.a0 = -11.0;
  a5.a1 = 12;
  a6.a0 = -13.0;
  a6.a1 = 14;
  a7.a0 = -15.0;
  a7.a1 = 16;
  a8.a0 = -17.0;
  a8.a1 = 18;
  a9.a0 = -19.0;
  a9.a1 = 20;
 
  std::cout << "Calling TestAsyncPassStruct16BytesMixedx10(" << "((" << a0.a0
            << ", " << a0.a1 << "), (" << a1.a0 << ", " << a1.a1 << "), ("
            << a2.a0 << ", " << a2.a1 << "), (" << a3.a0 << ", " << a3.a1
            << "), (" << a4.a0 << ", " << a4.a1 << "), (" << a5.a0 << ", "
            << a5.a1 << "), (" << a6.a0 << ", " << a6.a1 << "), (" << a7.a0
            << ", " << a7.a1 << "), (" << a8.a0 << ", " << a8.a1 << "), ("
            << a9.a0 << ", " << a9.a1 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct16BytesNestedIntx2()

DART_EXPORT void dart::TestAsyncPassStruct16BytesNestedIntx2

(

void(*)(Struct16BytesNestedInt a0, Struct16BytesNestedInt a1)

f

)

Definition at line 18829 of file ffi_test_functions_generated.cc.

                                                                     {
  Struct16BytesNestedInt a0 = {};
  Struct16BytesNestedInt a1 = {};
 
  a0.a0.a0.a0 = -1;
  a0.a0.a0.a1 = 2;
  a0.a0.a1.a0 = -3;
  a0.a0.a1.a1 = 4;
  a0.a1.a0.a0 = -5;
  a0.a1.a0.a1 = 6;
  a0.a1.a1.a0 = -7;
  a0.a1.a1.a1 = 8;
  a1.a0.a0.a0 = -9;
  a1.a0.a0.a1 = 10;
  a1.a0.a1.a0 = -11;
  a1.a0.a1.a1 = 12;
  a1.a1.a0.a0 = -13;
  a1.a1.a0.a1 = 14;
  a1.a1.a1.a0 = -15;
  a1.a1.a1.a1 = 16;
 
  std::cout << "Calling TestAsyncPassStruct16BytesNestedIntx2(" << "(((("
            << a0.a0.a0.a0 << ", " << a0.a0.a0.a1 << "), (" << a0.a0.a1.a0
            << ", " << a0.a0.a1.a1 << ")), ((" << a0.a1.a0.a0 << ", "
            << a0.a1.a0.a1 << "), (" << a0.a1.a1.a0 << ", " << a0.a1.a1.a1
            << "))), (((" << a1.a0.a0.a0 << ", " << a1.a0.a0.a1 << "), ("
            << a1.a0.a1.a0 << ", " << a1.a0.a1.a1 << ")), ((" << a1.a1.a0.a0
            << ", " << a1.a1.a0.a1 << "), (" << a1.a1.a1.a0 << ", "
            << a1.a1.a1.a1 << "))))" << ")\n";
 
  f(a0, a1);
}

TestAsyncPassStruct17BytesIntx10()

DART_EXPORT void dart::TestAsyncPassStruct17BytesIntx10

(

void(*)(Struct17BytesInt a0, Struct17BytesInt a1, Struct17BytesInt a2, Struct17BytesInt a3, Struct17BytesInt a4, Struct17BytesInt a5, Struct17BytesInt a6, Struct17BytesInt a7, Struct17BytesInt a8, Struct17BytesInt a9)

f

)

Definition at line 17276 of file ffi_test_functions_generated.cc.

                                    {
  Struct17BytesInt a0 = {};
  Struct17BytesInt a1 = {};
  Struct17BytesInt a2 = {};
  Struct17BytesInt a3 = {};
  Struct17BytesInt a4 = {};
  Struct17BytesInt a5 = {};
  Struct17BytesInt a6 = {};
  Struct17BytesInt a7 = {};
  Struct17BytesInt a8 = {};
  Struct17BytesInt a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
  a2.a0 = -7;
  a2.a1 = 8;
  a2.a2 = -9;
  a3.a0 = 10;
  a3.a1 = -11;
  a3.a2 = 12;
  a4.a0 = -13;
  a4.a1 = 14;
  a4.a2 = -15;
  a5.a0 = 16;
  a5.a1 = -17;
  a5.a2 = 18;
  a6.a0 = -19;
  a6.a1 = 20;
  a6.a2 = -21;
  a7.a0 = 22;
  a7.a1 = -23;
  a7.a2 = 24;
  a8.a0 = -25;
  a8.a1 = 26;
  a8.a2 = -27;
  a9.a0 = 28;
  a9.a1 = -29;
  a9.a2 = 30;
 
  std::cout << "Calling TestAsyncPassStruct17BytesIntx10(" << "((" << a0.a0
            << ", " << a0.a1 << ", " << static_cast<int>(a0.a2) << "), ("
            << a1.a0 << ", " << a1.a1 << ", " << static_cast<int>(a1.a2)
            << "), (" << a2.a0 << ", " << a2.a1 << ", "
            << static_cast<int>(a2.a2) << "), (" << a3.a0 << ", " << a3.a1
            << ", " << static_cast<int>(a3.a2) << "), (" << a4.a0 << ", "
            << a4.a1 << ", " << static_cast<int>(a4.a2) << "), (" << a5.a0
            << ", " << a5.a1 << ", " << static_cast<int>(a5.a2) << "), ("
            << a6.a0 << ", " << a6.a1 << ", " << static_cast<int>(a6.a2)
            << "), (" << a7.a0 << ", " << a7.a1 << ", "
            << static_cast<int>(a7.a2) << "), (" << a8.a0 << ", " << a8.a1
            << ", " << static_cast<int>(a8.a2) << "), (" << a9.a0 << ", "
            << a9.a1 << ", " << static_cast<int>(a9.a2) << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct19BytesHomogeneousUint8x10()

DART_EXPORT void dart::TestAsyncPassStruct19BytesHomogeneousUint8x10

(

void(*)(Struct19BytesHomogeneousUint8 a0, Struct19BytesHomogeneousUint8 a1, Struct19BytesHomogeneousUint8 a2, Struct19BytesHomogeneousUint8 a3, Struct19BytesHomogeneousUint8 a4, Struct19BytesHomogeneousUint8 a5, Struct19BytesHomogeneousUint8 a6, Struct19BytesHomogeneousUint8 a7, Struct19BytesHomogeneousUint8 a8, Struct19BytesHomogeneousUint8 a9)

f

)

Definition at line 17351 of file ffi_test_functions_generated.cc.

                                                 {
  Struct19BytesHomogeneousUint8 a0 = {};
  Struct19BytesHomogeneousUint8 a1 = {};
  Struct19BytesHomogeneousUint8 a2 = {};
  Struct19BytesHomogeneousUint8 a3 = {};
  Struct19BytesHomogeneousUint8 a4 = {};
  Struct19BytesHomogeneousUint8 a5 = {};
  Struct19BytesHomogeneousUint8 a6 = {};
  Struct19BytesHomogeneousUint8 a7 = {};
  Struct19BytesHomogeneousUint8 a8 = {};
  Struct19BytesHomogeneousUint8 a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a0.a5 = 6;
  a0.a6 = 7;
  a0.a7 = 8;
  a0.a8 = 9;
  a0.a9 = 10;
  a0.a10 = 11;
  a0.a11 = 12;
  a0.a12 = 13;
  a0.a13 = 14;
  a0.a14 = 15;
  a0.a15 = 16;
  a0.a16 = 17;
  a0.a17 = 18;
  a0.a18 = 19;
  a1.a0 = 20;
  a1.a1 = 21;
  a1.a2 = 22;
  a1.a3 = 23;
  a1.a4 = 24;
  a1.a5 = 25;
  a1.a6 = 26;
  a1.a7 = 27;
  a1.a8 = 28;
  a1.a9 = 29;
  a1.a10 = 30;
  a1.a11 = 31;
  a1.a12 = 32;
  a1.a13 = 33;
  a1.a14 = 34;
  a1.a15 = 35;
  a1.a16 = 36;
  a1.a17 = 37;
  a1.a18 = 38;
  a2.a0 = 39;
  a2.a1 = 40;
  a2.a2 = 41;
  a2.a3 = 42;
  a2.a4 = 43;
  a2.a5 = 44;
  a2.a6 = 45;
  a2.a7 = 46;
  a2.a8 = 47;
  a2.a9 = 48;
  a2.a10 = 49;
  a2.a11 = 50;
  a2.a12 = 51;
  a2.a13 = 52;
  a2.a14 = 53;
  a2.a15 = 54;
  a2.a16 = 55;
  a2.a17 = 56;
  a2.a18 = 57;
  a3.a0 = 58;
  a3.a1 = 59;
  a3.a2 = 60;
  a3.a3 = 61;
  a3.a4 = 62;
  a3.a5 = 63;
  a3.a6 = 64;
  a3.a7 = 65;
  a3.a8 = 66;
  a3.a9 = 67;
  a3.a10 = 68;
  a3.a11 = 69;
  a3.a12 = 70;
  a3.a13 = 71;
  a3.a14 = 72;
  a3.a15 = 73;
  a3.a16 = 74;
  a3.a17 = 75;
  a3.a18 = 76;
  a4.a0 = 77;
  a4.a1 = 78;
  a4.a2 = 79;
  a4.a3 = 80;
  a4.a4 = 81;
  a4.a5 = 82;
  a4.a6 = 83;
  a4.a7 = 84;
  a4.a8 = 85;
  a4.a9 = 86;
  a4.a10 = 87;
  a4.a11 = 88;
  a4.a12 = 89;
  a4.a13 = 90;
  a4.a14 = 91;
  a4.a15 = 92;
  a4.a16 = 93;
  a4.a17 = 94;
  a4.a18 = 95;
  a5.a0 = 96;
  a5.a1 = 97;
  a5.a2 = 98;
  a5.a3 = 99;
  a5.a4 = 100;
  a5.a5 = 101;
  a5.a6 = 102;
  a5.a7 = 103;
  a5.a8 = 104;
  a5.a9 = 105;
  a5.a10 = 106;
  a5.a11 = 107;
  a5.a12 = 108;
  a5.a13 = 109;
  a5.a14 = 110;
  a5.a15 = 111;
  a5.a16 = 112;
  a5.a17 = 113;
  a5.a18 = 114;
  a6.a0 = 115;
  a6.a1 = 116;
  a6.a2 = 117;
  a6.a3 = 118;
  a6.a4 = 119;
  a6.a5 = 120;
  a6.a6 = 121;
  a6.a7 = 122;
  a6.a8 = 123;
  a6.a9 = 124;
  a6.a10 = 125;
  a6.a11 = 126;
  a6.a12 = 127;
  a6.a13 = 128;
  a6.a14 = 129;
  a6.a15 = 130;
  a6.a16 = 131;
  a6.a17 = 132;
  a6.a18 = 133;
  a7.a0 = 134;
  a7.a1 = 135;
  a7.a2 = 136;
  a7.a3 = 137;
  a7.a4 = 138;
  a7.a5 = 139;
  a7.a6 = 140;
  a7.a7 = 141;
  a7.a8 = 142;
  a7.a9 = 143;
  a7.a10 = 144;
  a7.a11 = 145;
  a7.a12 = 146;
  a7.a13 = 147;
  a7.a14 = 148;
  a7.a15 = 149;
  a7.a16 = 150;
  a7.a17 = 151;
  a7.a18 = 152;
  a8.a0 = 153;
  a8.a1 = 154;
  a8.a2 = 155;
  a8.a3 = 156;
  a8.a4 = 157;
  a8.a5 = 158;
  a8.a6 = 159;
  a8.a7 = 160;
  a8.a8 = 161;
  a8.a9 = 162;
  a8.a10 = 163;
  a8.a11 = 164;
  a8.a12 = 165;
  a8.a13 = 166;
  a8.a14 = 167;
  a8.a15 = 168;
  a8.a16 = 169;
  a8.a17 = 170;
  a8.a18 = 171;
  a9.a0 = 172;
  a9.a1 = 173;
  a9.a2 = 174;
  a9.a3 = 175;
  a9.a4 = 176;
  a9.a5 = 177;
  a9.a6 = 178;
  a9.a7 = 179;
  a9.a8 = 180;
  a9.a9 = 181;
  a9.a10 = 182;
  a9.a11 = 183;
  a9.a12 = 184;
  a9.a13 = 185;
  a9.a14 = 186;
  a9.a15 = 187;
  a9.a16 = 188;
  a9.a17 = 189;
  a9.a18 = 190;
 
  std::cout
      << "Calling TestAsyncPassStruct19BytesHomogeneousUint8x10(" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << ", " << static_cast<int>(a0.a7) << ", "
      << static_cast<int>(a0.a8) << ", " << static_cast<int>(a0.a9) << ", "
      << static_cast<int>(a0.a10) << ", " << static_cast<int>(a0.a11) << ", "
      << static_cast<int>(a0.a12) << ", " << static_cast<int>(a0.a13) << ", "
      << static_cast<int>(a0.a14) << ", " << static_cast<int>(a0.a15) << ", "
      << static_cast<int>(a0.a16) << ", " << static_cast<int>(a0.a17) << ", "
      << static_cast<int>(a0.a18) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << ", "
      << static_cast<int>(a1.a7) << ", " << static_cast<int>(a1.a8) << ", "
      << static_cast<int>(a1.a9) << ", " << static_cast<int>(a1.a10) << ", "
      << static_cast<int>(a1.a11) << ", " << static_cast<int>(a1.a12) << ", "
      << static_cast<int>(a1.a13) << ", " << static_cast<int>(a1.a14) << ", "
      << static_cast<int>(a1.a15) << ", " << static_cast<int>(a1.a16) << ", "
      << static_cast<int>(a1.a17) << ", " << static_cast<int>(a1.a18) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << ", " << static_cast<int>(a2.a7) << ", "
      << static_cast<int>(a2.a8) << ", " << static_cast<int>(a2.a9) << ", "
      << static_cast<int>(a2.a10) << ", " << static_cast<int>(a2.a11) << ", "
      << static_cast<int>(a2.a12) << ", " << static_cast<int>(a2.a13) << ", "
      << static_cast<int>(a2.a14) << ", " << static_cast<int>(a2.a15) << ", "
      << static_cast<int>(a2.a16) << ", " << static_cast<int>(a2.a17) << ", "
      << static_cast<int>(a2.a18) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << ", "
      << static_cast<int>(a3.a7) << ", " << static_cast<int>(a3.a8) << ", "
      << static_cast<int>(a3.a9) << ", " << static_cast<int>(a3.a10) << ", "
      << static_cast<int>(a3.a11) << ", " << static_cast<int>(a3.a12) << ", "
      << static_cast<int>(a3.a13) << ", " << static_cast<int>(a3.a14) << ", "
      << static_cast<int>(a3.a15) << ", " << static_cast<int>(a3.a16) << ", "
      << static_cast<int>(a3.a17) << ", " << static_cast<int>(a3.a18) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << ", " << static_cast<int>(a4.a7) << ", "
      << static_cast<int>(a4.a8) << ", " << static_cast<int>(a4.a9) << ", "
      << static_cast<int>(a4.a10) << ", " << static_cast<int>(a4.a11) << ", "
      << static_cast<int>(a4.a12) << ", " << static_cast<int>(a4.a13) << ", "
      << static_cast<int>(a4.a14) << ", " << static_cast<int>(a4.a15) << ", "
      << static_cast<int>(a4.a16) << ", " << static_cast<int>(a4.a17) << ", "
      << static_cast<int>(a4.a18) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << ", "
      << static_cast<int>(a5.a7) << ", " << static_cast<int>(a5.a8) << ", "
      << static_cast<int>(a5.a9) << ", " << static_cast<int>(a5.a10) << ", "
      << static_cast<int>(a5.a11) << ", " << static_cast<int>(a5.a12) << ", "
      << static_cast<int>(a5.a13) << ", " << static_cast<int>(a5.a14) << ", "
      << static_cast<int>(a5.a15) << ", " << static_cast<int>(a5.a16) << ", "
      << static_cast<int>(a5.a17) << ", " << static_cast<int>(a5.a18) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << ", " << static_cast<int>(a6.a7) << ", "
      << static_cast<int>(a6.a8) << ", " << static_cast<int>(a6.a9) << ", "
      << static_cast<int>(a6.a10) << ", " << static_cast<int>(a6.a11) << ", "
      << static_cast<int>(a6.a12) << ", " << static_cast<int>(a6.a13) << ", "
      << static_cast<int>(a6.a14) << ", " << static_cast<int>(a6.a15) << ", "
      << static_cast<int>(a6.a16) << ", " << static_cast<int>(a6.a17) << ", "
      << static_cast<int>(a6.a18) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << ", "
      << static_cast<int>(a7.a7) << ", " << static_cast<int>(a7.a8) << ", "
      << static_cast<int>(a7.a9) << ", " << static_cast<int>(a7.a10) << ", "
      << static_cast<int>(a7.a11) << ", " << static_cast<int>(a7.a12) << ", "
      << static_cast<int>(a7.a13) << ", " << static_cast<int>(a7.a14) << ", "
      << static_cast<int>(a7.a15) << ", " << static_cast<int>(a7.a16) << ", "
      << static_cast<int>(a7.a17) << ", " << static_cast<int>(a7.a18) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << ", " << static_cast<int>(a8.a7) << ", "
      << static_cast<int>(a8.a8) << ", " << static_cast<int>(a8.a9) << ", "
      << static_cast<int>(a8.a10) << ", " << static_cast<int>(a8.a11) << ", "
      << static_cast<int>(a8.a12) << ", " << static_cast<int>(a8.a13) << ", "
      << static_cast<int>(a8.a14) << ", " << static_cast<int>(a8.a15) << ", "
      << static_cast<int>(a8.a16) << ", " << static_cast<int>(a8.a17) << ", "
      << static_cast<int>(a8.a18) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << ", "
      << static_cast<int>(a9.a7) << ", " << static_cast<int>(a9.a8) << ", "
      << static_cast<int>(a9.a9) << ", " << static_cast<int>(a9.a10) << ", "
      << static_cast<int>(a9.a11) << ", " << static_cast<int>(a9.a12) << ", "
      << static_cast<int>(a9.a13) << ", " << static_cast<int>(a9.a14) << ", "
      << static_cast<int>(a9.a15) << ", " << static_cast<int>(a9.a16) << ", "
      << static_cast<int>(a9.a17) << ", " << static_cast<int>(a9.a18) << "))"
      << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct1ByteIntx10()

DART_EXPORT void dart::TestAsyncPassStruct1ByteIntx10

(

void(*)(Struct1ByteInt a0, Struct1ByteInt a1, Struct1ByteInt a2, Struct1ByteInt a3, Struct1ByteInt a4, Struct1ByteInt a5, Struct1ByteInt a6, Struct1ByteInt a7, Struct1ByteInt a8, Struct1ByteInt a9)

f

)

Definition at line 16129 of file ffi_test_functions_generated.cc.

                                  {
  Struct1ByteInt a0 = {};
  Struct1ByteInt a1 = {};
  Struct1ByteInt a2 = {};
  Struct1ByteInt a3 = {};
  Struct1ByteInt a4 = {};
  Struct1ByteInt a5 = {};
  Struct1ByteInt a6 = {};
  Struct1ByteInt a7 = {};
  Struct1ByteInt a8 = {};
  Struct1ByteInt a9 = {};
 
  a0.a0 = -1;
  a1.a0 = 2;
  a2.a0 = -3;
  a3.a0 = 4;
  a4.a0 = -5;
  a5.a0 = 6;
  a6.a0 = -7;
  a7.a0 = 8;
  a8.a0 = -9;
  a9.a0 = 10;
 
  std::cout << "Calling TestAsyncPassStruct1ByteIntx10(" << "(("
            << static_cast<int>(a0.a0) << "), (" << static_cast<int>(a1.a0)
            << "), (" << static_cast<int>(a2.a0) << "), ("
            << static_cast<int>(a3.a0) << "), (" << static_cast<int>(a4.a0)
            << "), (" << static_cast<int>(a5.a0) << "), ("
            << static_cast<int>(a6.a0) << "), (" << static_cast<int>(a7.a0)
            << "), (" << static_cast<int>(a8.a0) << "), ("
            << static_cast<int>(a9.a0) << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct20BytesHomogeneousFloat()

DART_EXPORT void dart::TestAsyncPassStruct20BytesHomogeneousFloat

(

void(*)(Struct20BytesHomogeneousFloat a0)

f

)

Definition at line 17767 of file ffi_test_functions_generated.cc.

                                                 {
  Struct20BytesHomogeneousFloat a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a0.a4 = -5.0;
 
  std::cout << "Calling TestAsyncPassStruct20BytesHomogeneousFloat(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << "))" << ")\n";
 
  f(a0);
}

TestAsyncPassStruct20BytesHomogeneousInt32x10()

DART_EXPORT void dart::TestAsyncPassStruct20BytesHomogeneousInt32x10

(

void(*)(Struct20BytesHomogeneousInt32 a0, Struct20BytesHomogeneousInt32 a1, Struct20BytesHomogeneousInt32 a2, Struct20BytesHomogeneousInt32 a3, Struct20BytesHomogeneousInt32 a4, Struct20BytesHomogeneousInt32 a5, Struct20BytesHomogeneousInt32 a6, Struct20BytesHomogeneousInt32 a7, Struct20BytesHomogeneousInt32 a8, Struct20BytesHomogeneousInt32 a9)

f

)

Definition at line 17672 of file ffi_test_functions_generated.cc.

                                                 {
  Struct20BytesHomogeneousInt32 a0 = {};
  Struct20BytesHomogeneousInt32 a1 = {};
  Struct20BytesHomogeneousInt32 a2 = {};
  Struct20BytesHomogeneousInt32 a3 = {};
  Struct20BytesHomogeneousInt32 a4 = {};
  Struct20BytesHomogeneousInt32 a5 = {};
  Struct20BytesHomogeneousInt32 a6 = {};
  Struct20BytesHomogeneousInt32 a7 = {};
  Struct20BytesHomogeneousInt32 a8 = {};
  Struct20BytesHomogeneousInt32 a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a0.a3 = 4;
  a0.a4 = -5;
  a1.a0 = 6;
  a1.a1 = -7;
  a1.a2 = 8;
  a1.a3 = -9;
  a1.a4 = 10;
  a2.a0 = -11;
  a2.a1 = 12;
  a2.a2 = -13;
  a2.a3 = 14;
  a2.a4 = -15;
  a3.a0 = 16;
  a3.a1 = -17;
  a3.a2 = 18;
  a3.a3 = -19;
  a3.a4 = 20;
  a4.a0 = -21;
  a4.a1 = 22;
  a4.a2 = -23;
  a4.a3 = 24;
  a4.a4 = -25;
  a5.a0 = 26;
  a5.a1 = -27;
  a5.a2 = 28;
  a5.a3 = -29;
  a5.a4 = 30;
  a6.a0 = -31;
  a6.a1 = 32;
  a6.a2 = -33;
  a6.a3 = 34;
  a6.a4 = -35;
  a7.a0 = 36;
  a7.a1 = -37;
  a7.a2 = 38;
  a7.a3 = -39;
  a7.a4 = 40;
  a8.a0 = -41;
  a8.a1 = 42;
  a8.a2 = -43;
  a8.a3 = 44;
  a8.a4 = -45;
  a9.a0 = 46;
  a9.a1 = -47;
  a9.a2 = 48;
  a9.a3 = -49;
  a9.a4 = 50;
 
  std::cout << "Calling TestAsyncPassStruct20BytesHomogeneousInt32x10(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << "), (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2
            << ", " << a1.a3 << ", " << a1.a4 << "), (" << a2.a0 << ", "
            << a2.a1 << ", " << a2.a2 << ", " << a2.a3 << ", " << a2.a4
            << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2 << ", "
            << a3.a3 << ", " << a3.a4 << "), (" << a4.a0 << ", " << a4.a1
            << ", " << a4.a2 << ", " << a4.a3 << ", " << a4.a4 << "), ("
            << a5.a0 << ", " << a5.a1 << ", " << a5.a2 << ", " << a5.a3 << ", "
            << a5.a4 << "), (" << a6.a0 << ", " << a6.a1 << ", " << a6.a2
            << ", " << a6.a3 << ", " << a6.a4 << "), (" << a7.a0 << ", "
            << a7.a1 << ", " << a7.a2 << ", " << a7.a3 << ", " << a7.a4
            << "), (" << a8.a0 << ", " << a8.a1 << ", " << a8.a2 << ", "
            << a8.a3 << ", " << a8.a4 << "), (" << a9.a0 << ", " << a9.a1
            << ", " << a9.a2 << ", " << a9.a3 << ", " << a9.a4 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct32BytesHomogeneousDoublex5()

DART_EXPORT void dart::TestAsyncPassStruct32BytesHomogeneousDoublex5

(

void(*)(Struct32BytesHomogeneousDouble a0, Struct32BytesHomogeneousDouble a1, Struct32BytesHomogeneousDouble a2, Struct32BytesHomogeneousDouble a3, Struct32BytesHomogeneousDouble a4)

f

)

Definition at line 17788 of file ffi_test_functions_generated.cc.

                                                  {
  Struct32BytesHomogeneousDouble a0 = {};
  Struct32BytesHomogeneousDouble a1 = {};
  Struct32BytesHomogeneousDouble a2 = {};
  Struct32BytesHomogeneousDouble a3 = {};
  Struct32BytesHomogeneousDouble a4 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a1.a0 = -5.0;
  a1.a1 = 6.0;
  a1.a2 = -7.0;
  a1.a3 = 8.0;
  a2.a0 = -9.0;
  a2.a1 = 10.0;
  a2.a2 = -11.0;
  a2.a3 = 12.0;
  a3.a0 = -13.0;
  a3.a1 = 14.0;
  a3.a2 = -15.0;
  a3.a3 = 16.0;
  a4.a0 = -17.0;
  a4.a1 = 18.0;
  a4.a2 = -19.0;
  a4.a3 = 20.0;
 
  std::cout << "Calling TestAsyncPassStruct32BytesHomogeneousDoublex5(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
            << "), (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", "
            << a1.a3 << "), (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2
            << ", " << a2.a3 << "), (" << a3.a0 << ", " << a3.a1 << ", "
            << a3.a2 << ", " << a3.a3 << "), (" << a4.a0 << ", " << a4.a1
            << ", " << a4.a2 << ", " << a4.a3 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4);
}

TestAsyncPassStruct32BytesNestedIntx2()

DART_EXPORT void dart::TestAsyncPassStruct32BytesNestedIntx2

(

void(*)(Struct32BytesNestedInt a0, Struct32BytesNestedInt a1)

f

)

Definition at line 18866 of file ffi_test_functions_generated.cc.

                                                                     {
  Struct32BytesNestedInt a0 = {};
  Struct32BytesNestedInt a1 = {};
 
  a0.a0.a0.a0.a0 = -1;
  a0.a0.a0.a0.a1 = 2;
  a0.a0.a0.a1.a0 = -3;
  a0.a0.a0.a1.a1 = 4;
  a0.a0.a1.a0.a0 = -5;
  a0.a0.a1.a0.a1 = 6;
  a0.a0.a1.a1.a0 = -7;
  a0.a0.a1.a1.a1 = 8;
  a0.a1.a0.a0.a0 = -9;
  a0.a1.a0.a0.a1 = 10;
  a0.a1.a0.a1.a0 = -11;
  a0.a1.a0.a1.a1 = 12;
  a0.a1.a1.a0.a0 = -13;
  a0.a1.a1.a0.a1 = 14;
  a0.a1.a1.a1.a0 = -15;
  a0.a1.a1.a1.a1 = 16;
  a1.a0.a0.a0.a0 = -17;
  a1.a0.a0.a0.a1 = 18;
  a1.a0.a0.a1.a0 = -19;
  a1.a0.a0.a1.a1 = 20;
  a1.a0.a1.a0.a0 = -21;
  a1.a0.a1.a0.a1 = 22;
  a1.a0.a1.a1.a0 = -23;
  a1.a0.a1.a1.a1 = 24;
  a1.a1.a0.a0.a0 = -25;
  a1.a1.a0.a0.a1 = 26;
  a1.a1.a0.a1.a0 = -27;
  a1.a1.a0.a1.a1 = 28;
  a1.a1.a1.a0.a0 = -29;
  a1.a1.a1.a0.a1 = 30;
  a1.a1.a1.a1.a0 = -31;
  a1.a1.a1.a1.a1 = 32;
 
  std::cout << "Calling TestAsyncPassStruct32BytesNestedIntx2(" << "((((("
            << a0.a0.a0.a0.a0 << ", " << a0.a0.a0.a0.a1 << "), ("
            << a0.a0.a0.a1.a0 << ", " << a0.a0.a0.a1.a1 << ")), (("
            << a0.a0.a1.a0.a0 << ", " << a0.a0.a1.a0.a1 << "), ("
            << a0.a0.a1.a1.a0 << ", " << a0.a0.a1.a1.a1 << "))), ((("
            << a0.a1.a0.a0.a0 << ", " << a0.a1.a0.a0.a1 << "), ("
            << a0.a1.a0.a1.a0 << ", " << a0.a1.a0.a1.a1 << ")), (("
            << a0.a1.a1.a0.a0 << ", " << a0.a1.a1.a0.a1 << "), ("
            << a0.a1.a1.a1.a0 << ", " << a0.a1.a1.a1.a1 << ")))), (((("
            << a1.a0.a0.a0.a0 << ", " << a1.a0.a0.a0.a1 << "), ("
            << a1.a0.a0.a1.a0 << ", " << a1.a0.a0.a1.a1 << ")), (("
            << a1.a0.a1.a0.a0 << ", " << a1.a0.a1.a0.a1 << "), ("
            << a1.a0.a1.a1.a0 << ", " << a1.a0.a1.a1.a1 << "))), ((("
            << a1.a1.a0.a0.a0 << ", " << a1.a1.a0.a0.a1 << "), ("
            << a1.a1.a0.a1.a0 << ", " << a1.a1.a0.a1.a1 << ")), (("
            << a1.a1.a1.a0.a0 << ", " << a1.a1.a1.a0.a1 << "), ("
            << a1.a1.a1.a1.a0 << ", " << a1.a1.a1.a1.a1 << ")))))" << ")\n";
 
  f(a0, a1);
}

TestAsyncPassStruct3BytesHomogeneousUint8x10()

DART_EXPORT void dart::TestAsyncPassStruct3BytesHomogeneousUint8x10

(

void(*)(Struct3BytesHomogeneousUint8 a0, Struct3BytesHomogeneousUint8 a1, Struct3BytesHomogeneousUint8 a2, Struct3BytesHomogeneousUint8 a3, Struct3BytesHomogeneousUint8 a4, Struct3BytesHomogeneousUint8 a5, Struct3BytesHomogeneousUint8 a6, Struct3BytesHomogeneousUint8 a7, Struct3BytesHomogeneousUint8 a8, Struct3BytesHomogeneousUint8 a9)

f

)

Definition at line 16178 of file ffi_test_functions_generated.cc.

                                                {
  Struct3BytesHomogeneousUint8 a0 = {};
  Struct3BytesHomogeneousUint8 a1 = {};
  Struct3BytesHomogeneousUint8 a2 = {};
  Struct3BytesHomogeneousUint8 a3 = {};
  Struct3BytesHomogeneousUint8 a4 = {};
  Struct3BytesHomogeneousUint8 a5 = {};
  Struct3BytesHomogeneousUint8 a6 = {};
  Struct3BytesHomogeneousUint8 a7 = {};
  Struct3BytesHomogeneousUint8 a8 = {};
  Struct3BytesHomogeneousUint8 a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a1.a0 = 4;
  a1.a1 = 5;
  a1.a2 = 6;
  a2.a0 = 7;
  a2.a1 = 8;
  a2.a2 = 9;
  a3.a0 = 10;
  a3.a1 = 11;
  a3.a2 = 12;
  a4.a0 = 13;
  a4.a1 = 14;
  a4.a2 = 15;
  a5.a0 = 16;
  a5.a1 = 17;
  a5.a2 = 18;
  a6.a0 = 19;
  a6.a1 = 20;
  a6.a2 = 21;
  a7.a0 = 22;
  a7.a1 = 23;
  a7.a2 = 24;
  a8.a0 = 25;
  a8.a1 = 26;
  a8.a2 = 27;
  a9.a0 = 28;
  a9.a1 = 29;
  a9.a2 = 30;
 
  std::cout << "Calling TestAsyncPassStruct3BytesHomogeneousUint8x10(" << "(("
            << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1)
            << ", " << static_cast<int>(a0.a2) << "), ("
            << static_cast<int>(a1.a0) << ", " << static_cast<int>(a1.a1)
            << ", " << static_cast<int>(a1.a2) << "), ("
            << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1)
            << ", " << static_cast<int>(a2.a2) << "), ("
            << static_cast<int>(a3.a0) << ", " << static_cast<int>(a3.a1)
            << ", " << static_cast<int>(a3.a2) << "), ("
            << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1)
            << ", " << static_cast<int>(a4.a2) << "), ("
            << static_cast<int>(a5.a0) << ", " << static_cast<int>(a5.a1)
            << ", " << static_cast<int>(a5.a2) << "), ("
            << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1)
            << ", " << static_cast<int>(a6.a2) << "), ("
            << static_cast<int>(a7.a0) << ", " << static_cast<int>(a7.a1)
            << ", " << static_cast<int>(a7.a2) << "), ("
            << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1)
            << ", " << static_cast<int>(a8.a2) << "), ("
            << static_cast<int>(a9.a0) << ", " << static_cast<int>(a9.a1)
            << ", " << static_cast<int>(a9.a2) << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct3BytesInt2ByteAlignedx10()

DART_EXPORT void dart::TestAsyncPassStruct3BytesInt2ByteAlignedx10

(

void(*)(Struct3BytesInt2ByteAligned a0, Struct3BytesInt2ByteAligned a1, Struct3BytesInt2ByteAligned a2, Struct3BytesInt2ByteAligned a3, Struct3BytesInt2ByteAligned a4, Struct3BytesInt2ByteAligned a5, Struct3BytesInt2ByteAligned a6, Struct3BytesInt2ByteAligned a7, Struct3BytesInt2ByteAligned a8, Struct3BytesInt2ByteAligned a9)

f

)

Definition at line 16261 of file ffi_test_functions_generated.cc.

                                               {
  Struct3BytesInt2ByteAligned a0 = {};
  Struct3BytesInt2ByteAligned a1 = {};
  Struct3BytesInt2ByteAligned a2 = {};
  Struct3BytesInt2ByteAligned a3 = {};
  Struct3BytesInt2ByteAligned a4 = {};
  Struct3BytesInt2ByteAligned a5 = {};
  Struct3BytesInt2ByteAligned a6 = {};
  Struct3BytesInt2ByteAligned a7 = {};
  Struct3BytesInt2ByteAligned a8 = {};
  Struct3BytesInt2ByteAligned a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
  a2.a0 = -5;
  a2.a1 = 6;
  a3.a0 = -7;
  a3.a1 = 8;
  a4.a0 = -9;
  a4.a1 = 10;
  a5.a0 = -11;
  a5.a1 = 12;
  a6.a0 = -13;
  a6.a1 = 14;
  a7.a0 = -15;
  a7.a1 = 16;
  a8.a0 = -17;
  a8.a1 = 18;
  a9.a0 = -19;
  a9.a1 = 20;
 
  std::cout << "Calling TestAsyncPassStruct3BytesInt2ByteAlignedx10(" << "(("
            << a0.a0 << ", " << static_cast<int>(a0.a1) << "), (" << a1.a0
            << ", " << static_cast<int>(a1.a1) << "), (" << a2.a0 << ", "
            << static_cast<int>(a2.a1) << "), (" << a3.a0 << ", "
            << static_cast<int>(a3.a1) << "), (" << a4.a0 << ", "
            << static_cast<int>(a4.a1) << "), (" << a5.a0 << ", "
            << static_cast<int>(a5.a1) << "), (" << a6.a0 << ", "
            << static_cast<int>(a6.a1) << "), (" << a7.a0 << ", "
            << static_cast<int>(a7.a1) << "), (" << a8.a0 << ", "
            << static_cast<int>(a8.a1) << "), (" << a9.a0 << ", "
            << static_cast<int>(a9.a1) << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct3BytesPackedIntx10()

DART_EXPORT void dart::TestAsyncPassStruct3BytesPackedIntx10

(

void(*)(Struct3BytesPackedInt a0, Struct3BytesPackedInt a1, Struct3BytesPackedInt a2, Struct3BytesPackedInt a3, Struct3BytesPackedInt a4, Struct3BytesPackedInt a5, Struct3BytesPackedInt a6, Struct3BytesPackedInt a7, Struct3BytesPackedInt a8, Struct3BytesPackedInt a9)

f

)

Definition at line 19887 of file ffi_test_functions_generated.cc.

                                         {
  Struct3BytesPackedInt a0 = {};
  Struct3BytesPackedInt a1 = {};
  Struct3BytesPackedInt a2 = {};
  Struct3BytesPackedInt a3 = {};
  Struct3BytesPackedInt a4 = {};
  Struct3BytesPackedInt a5 = {};
  Struct3BytesPackedInt a6 = {};
  Struct3BytesPackedInt a7 = {};
  Struct3BytesPackedInt a8 = {};
  Struct3BytesPackedInt a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
  a2.a0 = -5;
  a2.a1 = 6;
  a3.a0 = -7;
  a3.a1 = 8;
  a4.a0 = -9;
  a4.a1 = 10;
  a5.a0 = -11;
  a5.a1 = 12;
  a6.a0 = -13;
  a6.a1 = 14;
  a7.a0 = -15;
  a7.a1 = 16;
  a8.a0 = -17;
  a8.a1 = 18;
  a9.a0 = -19;
  a9.a1 = 20;
 
  std::cout << "Calling TestAsyncPassStruct3BytesPackedIntx10(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << "), ("
            << static_cast<int>(a1.a0) << ", " << a1.a1 << "), ("
            << static_cast<int>(a2.a0) << ", " << a2.a1 << "), ("
            << static_cast<int>(a3.a0) << ", " << a3.a1 << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct40BytesHomogeneousDouble()

DART_EXPORT void dart::TestAsyncPassStruct40BytesHomogeneousDouble

(

void(*)(Struct40BytesHomogeneousDouble a0)

f

)

Definition at line 17835 of file ffi_test_functions_generated.cc.

                                                  {
  Struct40BytesHomogeneousDouble a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a0.a4 = -5.0;
 
  std::cout << "Calling TestAsyncPassStruct40BytesHomogeneousDouble(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << "))" << ")\n";
 
  f(a0);
}

TestAsyncPassStruct40BytesHomogeneousDoubleStruct4BytesHomo()

DART_EXPORT void dart::TestAsyncPassStruct40BytesHomogeneousDoubleStruct4BytesHomo

(

void(*)(Struct40BytesHomogeneousDouble a0, Struct4BytesHomogeneousInt16 a1, Struct8BytesHomogeneousFloat a2)

f

)

Definition at line 18302 of file ffi_test_functions_generated.cc.

                                                {
  Struct40BytesHomogeneousDouble a0 = {};
  Struct4BytesHomogeneousInt16 a1 = {};
  Struct8BytesHomogeneousFloat a2 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a0.a4 = -5.0;
  a1.a0 = 6;
  a1.a1 = -7;
  a2.a0 = 8.0;
  a2.a1 = -9.0;
 
  std::cout
      << "Calling TestAsyncPassStruct40BytesHomogeneousDoubleStruct4BytesHomo("
      << "((" << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
      << ", " << a0.a4 << "), (" << a1.a0 << ", " << a1.a1 << "), (" << a2.a0
      << ", " << a2.a1 << "))" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncPassStruct4BytesHomogeneousInt16x10()

DART_EXPORT void dart::TestAsyncPassStruct4BytesHomogeneousInt16x10

(

void(*)(Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1, Struct4BytesHomogeneousInt16 a2, Struct4BytesHomogeneousInt16 a3, Struct4BytesHomogeneousInt16 a4, Struct4BytesHomogeneousInt16 a5, Struct4BytesHomogeneousInt16 a6, Struct4BytesHomogeneousInt16 a7, Struct4BytesHomogeneousInt16 a8, Struct4BytesHomogeneousInt16 a9)

f

)

Definition at line 16323 of file ffi_test_functions_generated.cc.

                                                {
  Struct4BytesHomogeneousInt16 a0 = {};
  Struct4BytesHomogeneousInt16 a1 = {};
  Struct4BytesHomogeneousInt16 a2 = {};
  Struct4BytesHomogeneousInt16 a3 = {};
  Struct4BytesHomogeneousInt16 a4 = {};
  Struct4BytesHomogeneousInt16 a5 = {};
  Struct4BytesHomogeneousInt16 a6 = {};
  Struct4BytesHomogeneousInt16 a7 = {};
  Struct4BytesHomogeneousInt16 a8 = {};
  Struct4BytesHomogeneousInt16 a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
  a2.a0 = -5;
  a2.a1 = 6;
  a3.a0 = -7;
  a3.a1 = 8;
  a4.a0 = -9;
  a4.a1 = 10;
  a5.a0 = -11;
  a5.a1 = 12;
  a6.a0 = -13;
  a6.a1 = 14;
  a7.a0 = -15;
  a7.a1 = 16;
  a8.a0 = -17;
  a8.a1 = 18;
  a9.a0 = -19;
  a9.a1 = 20;
 
  std::cout << "Calling TestAsyncPassStruct4BytesHomogeneousInt16x10(" << "(("
            << a0.a0 << ", " << a0.a1 << "), (" << a1.a0 << ", " << a1.a1
            << "), (" << a2.a0 << ", " << a2.a1 << "), (" << a3.a0 << ", "
            << a3.a1 << "), (" << a4.a0 << ", " << a4.a1 << "), (" << a5.a0
            << ", " << a5.a1 << "), (" << a6.a0 << ", " << a6.a1 << "), ("
            << a7.a0 << ", " << a7.a1 << "), (" << a8.a0 << ", " << a8.a1
            << "), (" << a9.a0 << ", " << a9.a1 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct5BytesPackedMixed()

DART_EXPORT void dart::TestAsyncPassStruct5BytesPackedMixed

(

void(*)(Struct5BytesPackedMixed a0)

f

)

Definition at line 20131 of file ffi_test_functions_generated.cc.

                                           {
  Struct5BytesPackedMixed a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2;
 
  std::cout << "Calling TestAsyncPassStruct5BytesPackedMixed(" << "((" << a0.a0
            << ", " << static_cast<int>(a0.a1) << "))" << ")\n";
 
  f(a0);
}

TestAsyncPassStruct6BytesInlineArrayInt()

DART_EXPORT void dart::TestAsyncPassStruct6BytesInlineArrayInt

(

void(*)(Struct6BytesInlineArrayInt a0)

f

)

Definition at line 20166 of file ffi_test_functions_generated.cc.

                                              {
  Struct6BytesInlineArrayInt a0 = {};
 
  a0.a0[0].a0 = -1;
  a0.a0[0].a1 = 2;
  a0.a0[1].a0 = -3;
  a0.a0[1].a1 = 4;
 
  std::cout << "Calling TestAsyncPassStruct6BytesInlineArrayInt(" << "(([("
            << static_cast<int>(a0.a0[0].a0) << ", " << a0.a0[0].a1 << "), ("
            << static_cast<int>(a0.a0[1].a0) << ", " << a0.a0[1].a1 << ")]))"
            << ")\n";
 
  f(a0);
}

TestAsyncPassStruct7BytesHomogeneousUint8x10()

DART_EXPORT void dart::TestAsyncPassStruct7BytesHomogeneousUint8x10

(

void(*)(Struct7BytesHomogeneousUint8 a0, Struct7BytesHomogeneousUint8 a1, Struct7BytesHomogeneousUint8 a2, Struct7BytesHomogeneousUint8 a3, Struct7BytesHomogeneousUint8 a4, Struct7BytesHomogeneousUint8 a5, Struct7BytesHomogeneousUint8 a6, Struct7BytesHomogeneousUint8 a7, Struct7BytesHomogeneousUint8 a8, Struct7BytesHomogeneousUint8 a9)

f

)

Definition at line 16381 of file ffi_test_functions_generated.cc.

                                                {
  Struct7BytesHomogeneousUint8 a0 = {};
  Struct7BytesHomogeneousUint8 a1 = {};
  Struct7BytesHomogeneousUint8 a2 = {};
  Struct7BytesHomogeneousUint8 a3 = {};
  Struct7BytesHomogeneousUint8 a4 = {};
  Struct7BytesHomogeneousUint8 a5 = {};
  Struct7BytesHomogeneousUint8 a6 = {};
  Struct7BytesHomogeneousUint8 a7 = {};
  Struct7BytesHomogeneousUint8 a8 = {};
  Struct7BytesHomogeneousUint8 a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a0.a5 = 6;
  a0.a6 = 7;
  a1.a0 = 8;
  a1.a1 = 9;
  a1.a2 = 10;
  a1.a3 = 11;
  a1.a4 = 12;
  a1.a5 = 13;
  a1.a6 = 14;
  a2.a0 = 15;
  a2.a1 = 16;
  a2.a2 = 17;
  a2.a3 = 18;
  a2.a4 = 19;
  a2.a5 = 20;
  a2.a6 = 21;
  a3.a0 = 22;
  a3.a1 = 23;
  a3.a2 = 24;
  a3.a3 = 25;
  a3.a4 = 26;
  a3.a5 = 27;
  a3.a6 = 28;
  a4.a0 = 29;
  a4.a1 = 30;
  a4.a2 = 31;
  a4.a3 = 32;
  a4.a4 = 33;
  a4.a5 = 34;
  a4.a6 = 35;
  a5.a0 = 36;
  a5.a1 = 37;
  a5.a2 = 38;
  a5.a3 = 39;
  a5.a4 = 40;
  a5.a5 = 41;
  a5.a6 = 42;
  a6.a0 = 43;
  a6.a1 = 44;
  a6.a2 = 45;
  a6.a3 = 46;
  a6.a4 = 47;
  a6.a5 = 48;
  a6.a6 = 49;
  a7.a0 = 50;
  a7.a1 = 51;
  a7.a2 = 52;
  a7.a3 = 53;
  a7.a4 = 54;
  a7.a5 = 55;
  a7.a6 = 56;
  a8.a0 = 57;
  a8.a1 = 58;
  a8.a2 = 59;
  a8.a3 = 60;
  a8.a4 = 61;
  a8.a5 = 62;
  a8.a6 = 63;
  a9.a0 = 64;
  a9.a1 = 65;
  a9.a2 = 66;
  a9.a3 = 67;
  a9.a4 = 68;
  a9.a5 = 69;
  a9.a6 = 70;
 
  std::cout
      << "Calling TestAsyncPassStruct7BytesHomogeneousUint8x10(" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << "))"
      << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct7BytesInt4ByteAlignedx10()

DART_EXPORT void dart::TestAsyncPassStruct7BytesInt4ByteAlignedx10

(

void(*)(Struct7BytesInt4ByteAligned a0, Struct7BytesInt4ByteAligned a1, Struct7BytesInt4ByteAligned a2, Struct7BytesInt4ByteAligned a3, Struct7BytesInt4ByteAligned a4, Struct7BytesInt4ByteAligned a5, Struct7BytesInt4ByteAligned a6, Struct7BytesInt4ByteAligned a7, Struct7BytesInt4ByteAligned a8, Struct7BytesInt4ByteAligned a9)

f

)

Definition at line 16521 of file ffi_test_functions_generated.cc.

                                               {
  Struct7BytesInt4ByteAligned a0 = {};
  Struct7BytesInt4ByteAligned a1 = {};
  Struct7BytesInt4ByteAligned a2 = {};
  Struct7BytesInt4ByteAligned a3 = {};
  Struct7BytesInt4ByteAligned a4 = {};
  Struct7BytesInt4ByteAligned a5 = {};
  Struct7BytesInt4ByteAligned a6 = {};
  Struct7BytesInt4ByteAligned a7 = {};
  Struct7BytesInt4ByteAligned a8 = {};
  Struct7BytesInt4ByteAligned a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
  a2.a0 = -7;
  a2.a1 = 8;
  a2.a2 = -9;
  a3.a0 = 10;
  a3.a1 = -11;
  a3.a2 = 12;
  a4.a0 = -13;
  a4.a1 = 14;
  a4.a2 = -15;
  a5.a0 = 16;
  a5.a1 = -17;
  a5.a2 = 18;
  a6.a0 = -19;
  a6.a1 = 20;
  a6.a2 = -21;
  a7.a0 = 22;
  a7.a1 = -23;
  a7.a2 = 24;
  a8.a0 = -25;
  a8.a1 = 26;
  a8.a2 = -27;
  a9.a0 = 28;
  a9.a1 = -29;
  a9.a2 = 30;
 
  std::cout << "Calling TestAsyncPassStruct7BytesInt4ByteAlignedx10(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << static_cast<int>(a0.a2)
            << "), (" << a1.a0 << ", " << a1.a1 << ", "
            << static_cast<int>(a1.a2) << "), (" << a2.a0 << ", " << a2.a1
            << ", " << static_cast<int>(a2.a2) << "), (" << a3.a0 << ", "
            << a3.a1 << ", " << static_cast<int>(a3.a2) << "), (" << a4.a0
            << ", " << a4.a1 << ", " << static_cast<int>(a4.a2) << "), ("
            << a5.a0 << ", " << a5.a1 << ", " << static_cast<int>(a5.a2)
            << "), (" << a6.a0 << ", " << a6.a1 << ", "
            << static_cast<int>(a6.a2) << "), (" << a7.a0 << ", " << a7.a1
            << ", " << static_cast<int>(a7.a2) << "), (" << a8.a0 << ", "
            << a8.a1 << ", " << static_cast<int>(a8.a2) << "), (" << a9.a0
            << ", " << a9.a1 << ", " << static_cast<int>(a9.a2) << "))"
            << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct8BytesHomogeneousFloatx10()

DART_EXPORT void dart::TestAsyncPassStruct8BytesHomogeneousFloatx10

(

void(*)(Struct8BytesHomogeneousFloat a0, Struct8BytesHomogeneousFloat a1, Struct8BytesHomogeneousFloat a2, Struct8BytesHomogeneousFloat a3, Struct8BytesHomogeneousFloat a4, Struct8BytesHomogeneousFloat a5, Struct8BytesHomogeneousFloat a6, Struct8BytesHomogeneousFloat a7, Struct8BytesHomogeneousFloat a8, Struct8BytesHomogeneousFloat a9)

f

)

Definition at line 16667 of file ffi_test_functions_generated.cc.

                                                {
  Struct8BytesHomogeneousFloat a0 = {};
  Struct8BytesHomogeneousFloat a1 = {};
  Struct8BytesHomogeneousFloat a2 = {};
  Struct8BytesHomogeneousFloat a3 = {};
  Struct8BytesHomogeneousFloat a4 = {};
  Struct8BytesHomogeneousFloat a5 = {};
  Struct8BytesHomogeneousFloat a6 = {};
  Struct8BytesHomogeneousFloat a7 = {};
  Struct8BytesHomogeneousFloat a8 = {};
  Struct8BytesHomogeneousFloat a9 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a1.a0 = -3.0;
  a1.a1 = 4.0;
  a2.a0 = -5.0;
  a2.a1 = 6.0;
  a3.a0 = -7.0;
  a3.a1 = 8.0;
  a4.a0 = -9.0;
  a4.a1 = 10.0;
  a5.a0 = -11.0;
  a5.a1 = 12.0;
  a6.a0 = -13.0;
  a6.a1 = 14.0;
  a7.a0 = -15.0;
  a7.a1 = 16.0;
  a8.a0 = -17.0;
  a8.a1 = 18.0;
  a9.a0 = -19.0;
  a9.a1 = 20.0;
 
  std::cout << "Calling TestAsyncPassStruct8BytesHomogeneousFloatx10(" << "(("
            << a0.a0 << ", " << a0.a1 << "), (" << a1.a0 << ", " << a1.a1
            << "), (" << a2.a0 << ", " << a2.a1 << "), (" << a3.a0 << ", "
            << a3.a1 << "), (" << a4.a0 << ", " << a4.a1 << "), (" << a5.a0
            << ", " << a5.a1 << "), (" << a6.a0 << ", " << a6.a1 << "), ("
            << a7.a0 << ", " << a7.a1 << "), (" << a8.a0 << ", " << a8.a1
            << "), (" << a9.a0 << ", " << a9.a1 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct8BytesInlineArrayIntx4()

DART_EXPORT void dart::TestAsyncPassStruct8BytesInlineArrayIntx4

(

void(*)(Struct8BytesInlineArrayInt a0, Struct8BytesInlineArrayInt a1, Struct8BytesInlineArrayInt a2, Struct8BytesInlineArrayInt a3)

f

)

Definition at line 19207 of file ffi_test_functions_generated.cc.

                                              {
  Struct8BytesInlineArrayInt a0 = {};
  Struct8BytesInlineArrayInt a1 = {};
  Struct8BytesInlineArrayInt a2 = {};
  Struct8BytesInlineArrayInt a3 = {};
 
  a0.a0[0] = 1;
  a0.a0[1] = 2;
  a0.a0[2] = 3;
  a0.a0[3] = 4;
  a0.a0[4] = 5;
  a0.a0[5] = 6;
  a0.a0[6] = 7;
  a0.a0[7] = 8;
  a1.a0[0] = 9;
  a1.a0[1] = 10;
  a1.a0[2] = 11;
  a1.a0[3] = 12;
  a1.a0[4] = 13;
  a1.a0[5] = 14;
  a1.a0[6] = 15;
  a1.a0[7] = 16;
  a2.a0[0] = 17;
  a2.a0[1] = 18;
  a2.a0[2] = 19;
  a2.a0[3] = 20;
  a2.a0[4] = 21;
  a2.a0[5] = 22;
  a2.a0[6] = 23;
  a2.a0[7] = 24;
  a3.a0[0] = 25;
  a3.a0[1] = 26;
  a3.a0[2] = 27;
  a3.a0[3] = 28;
  a3.a0[4] = 29;
  a3.a0[5] = 30;
  a3.a0[6] = 31;
  a3.a0[7] = 32;
 
  std::cout << "Calling TestAsyncPassStruct8BytesInlineArrayIntx4(" << "((["
            << static_cast<int>(a0.a0[0]) << ", " << static_cast<int>(a0.a0[1])
            << ", " << static_cast<int>(a0.a0[2]) << ", "
            << static_cast<int>(a0.a0[3]) << ", " << static_cast<int>(a0.a0[4])
            << ", " << static_cast<int>(a0.a0[5]) << ", "
            << static_cast<int>(a0.a0[6]) << ", " << static_cast<int>(a0.a0[7])
            << "]), ([" << static_cast<int>(a1.a0[0]) << ", "
            << static_cast<int>(a1.a0[1]) << ", " << static_cast<int>(a1.a0[2])
            << ", " << static_cast<int>(a1.a0[3]) << ", "
            << static_cast<int>(a1.a0[4]) << ", " << static_cast<int>(a1.a0[5])
            << ", " << static_cast<int>(a1.a0[6]) << ", "
            << static_cast<int>(a1.a0[7]) << "]), (["
            << static_cast<int>(a2.a0[0]) << ", " << static_cast<int>(a2.a0[1])
            << ", " << static_cast<int>(a2.a0[2]) << ", "
            << static_cast<int>(a2.a0[3]) << ", " << static_cast<int>(a2.a0[4])
            << ", " << static_cast<int>(a2.a0[5]) << ", "
            << static_cast<int>(a2.a0[6]) << ", " << static_cast<int>(a2.a0[7])
            << "]), ([" << static_cast<int>(a3.a0[0]) << ", "
            << static_cast<int>(a3.a0[1]) << ", " << static_cast<int>(a3.a0[2])
            << ", " << static_cast<int>(a3.a0[3]) << ", "
            << static_cast<int>(a3.a0[4]) << ", " << static_cast<int>(a3.a0[5])
            << ", " << static_cast<int>(a3.a0[6]) << ", "
            << static_cast<int>(a3.a0[7]) << "]))" << ")\n";
 
  f(a0, a1, a2, a3);
}

TestAsyncPassStruct8BytesIntx10()

DART_EXPORT void dart::TestAsyncPassStruct8BytesIntx10

(

void(*)(Struct8BytesInt a0, Struct8BytesInt a1, Struct8BytesInt a2, Struct8BytesInt a3, Struct8BytesInt a4, Struct8BytesInt a5, Struct8BytesInt a6, Struct8BytesInt a7, Struct8BytesInt a8, Struct8BytesInt a9)

f

)

Definition at line 16596 of file ffi_test_functions_generated.cc.

                                   {
  Struct8BytesInt a0 = {};
  Struct8BytesInt a1 = {};
  Struct8BytesInt a2 = {};
  Struct8BytesInt a3 = {};
  Struct8BytesInt a4 = {};
  Struct8BytesInt a5 = {};
  Struct8BytesInt a6 = {};
  Struct8BytesInt a7 = {};
  Struct8BytesInt a8 = {};
  Struct8BytesInt a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
  a2.a0 = -7;
  a2.a1 = 8;
  a2.a2 = -9;
  a3.a0 = 10;
  a3.a1 = -11;
  a3.a2 = 12;
  a4.a0 = -13;
  a4.a1 = 14;
  a4.a2 = -15;
  a5.a0 = 16;
  a5.a1 = -17;
  a5.a2 = 18;
  a6.a0 = -19;
  a6.a1 = 20;
  a6.a2 = -21;
  a7.a0 = 22;
  a7.a1 = -23;
  a7.a2 = 24;
  a8.a0 = -25;
  a8.a1 = 26;
  a8.a2 = -27;
  a9.a0 = 28;
  a9.a1 = -29;
  a9.a2 = 30;
 
  std::cout << "Calling TestAsyncPassStruct8BytesIntx10(" << "((" << a0.a0
            << ", " << a0.a1 << ", " << a0.a2 << "), (" << a1.a0 << ", "
            << a1.a1 << ", " << a1.a2 << "), (" << a2.a0 << ", " << a2.a1
            << ", " << a2.a2 << "), (" << a3.a0 << ", " << a3.a1 << ", "
            << a3.a2 << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2
            << "), (" << a5.a0 << ", " << a5.a1 << ", " << a5.a2 << "), ("
            << a6.a0 << ", " << a6.a1 << ", " << a6.a2 << "), (" << a7.a0
            << ", " << a7.a1 << ", " << a7.a2 << "), (" << a8.a0 << ", "
            << a8.a1 << ", " << a8.a2 << "), (" << a9.a0 << ", " << a9.a1
            << ", " << a9.a2 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct8BytesMixedx10()

DART_EXPORT void dart::TestAsyncPassStruct8BytesMixedx10

(

void(*)(Struct8BytesMixed a0, Struct8BytesMixed a1, Struct8BytesMixed a2, Struct8BytesMixed a3, Struct8BytesMixed a4, Struct8BytesMixed a5, Struct8BytesMixed a6, Struct8BytesMixed a7, Struct8BytesMixed a8, Struct8BytesMixed a9)

f

)

Definition at line 16725 of file ffi_test_functions_generated.cc.

                                     {
  Struct8BytesMixed a0 = {};
  Struct8BytesMixed a1 = {};
  Struct8BytesMixed a2 = {};
  Struct8BytesMixed a3 = {};
  Struct8BytesMixed a4 = {};
  Struct8BytesMixed a5 = {};
  Struct8BytesMixed a6 = {};
  Struct8BytesMixed a7 = {};
  Struct8BytesMixed a8 = {};
  Struct8BytesMixed a9 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4.0;
  a1.a1 = -5;
  a1.a2 = 6;
  a2.a0 = -7.0;
  a2.a1 = 8;
  a2.a2 = -9;
  a3.a0 = 10.0;
  a3.a1 = -11;
  a3.a2 = 12;
  a4.a0 = -13.0;
  a4.a1 = 14;
  a4.a2 = -15;
  a5.a0 = 16.0;
  a5.a1 = -17;
  a5.a2 = 18;
  a6.a0 = -19.0;
  a6.a1 = 20;
  a6.a2 = -21;
  a7.a0 = 22.0;
  a7.a1 = -23;
  a7.a2 = 24;
  a8.a0 = -25.0;
  a8.a1 = 26;
  a8.a2 = -27;
  a9.a0 = 28.0;
  a9.a1 = -29;
  a9.a2 = 30;
 
  std::cout << "Calling TestAsyncPassStruct8BytesMixedx10(" << "((" << a0.a0
            << ", " << a0.a1 << ", " << a0.a2 << "), (" << a1.a0 << ", "
            << a1.a1 << ", " << a1.a2 << "), (" << a2.a0 << ", " << a2.a1
            << ", " << a2.a2 << "), (" << a3.a0 << ", " << a3.a1 << ", "
            << a3.a2 << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2
            << "), (" << a5.a0 << ", " << a5.a1 << ", " << a5.a2 << "), ("
            << a6.a0 << ", " << a6.a1 << ", " << a6.a2 << "), (" << a7.a0
            << ", " << a7.a1 << ", " << a7.a2 << "), (" << a8.a0 << ", "
            << a8.a1 << ", " << a8.a2 << "), (" << a9.a0 << ", " << a9.a1
            << ", " << a9.a2 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct8BytesNestedFloat2x10()

DART_EXPORT void dart::TestAsyncPassStruct8BytesNestedFloat2x10

(

void(*)(Struct8BytesNestedFloat2 a0, Struct8BytesNestedFloat2 a1, Struct8BytesNestedFloat2 a2, Struct8BytesNestedFloat2 a3, Struct8BytesNestedFloat2 a4, Struct8BytesNestedFloat2 a5, Struct8BytesNestedFloat2 a6, Struct8BytesNestedFloat2 a7, Struct8BytesNestedFloat2 a8, Struct8BytesNestedFloat2 a9)

f

)

Definition at line 18698 of file ffi_test_functions_generated.cc.

                                            {
  Struct8BytesNestedFloat2 a0 = {};
  Struct8BytesNestedFloat2 a1 = {};
  Struct8BytesNestedFloat2 a2 = {};
  Struct8BytesNestedFloat2 a3 = {};
  Struct8BytesNestedFloat2 a4 = {};
  Struct8BytesNestedFloat2 a5 = {};
  Struct8BytesNestedFloat2 a6 = {};
  Struct8BytesNestedFloat2 a7 = {};
  Struct8BytesNestedFloat2 a8 = {};
  Struct8BytesNestedFloat2 a9 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1 = 2.0;
  a1.a0.a0 = -3.0;
  a1.a1 = 4.0;
  a2.a0.a0 = -5.0;
  a2.a1 = 6.0;
  a3.a0.a0 = -7.0;
  a3.a1 = 8.0;
  a4.a0.a0 = -9.0;
  a4.a1 = 10.0;
  a5.a0.a0 = -11.0;
  a5.a1 = 12.0;
  a6.a0.a0 = -13.0;
  a6.a1 = 14.0;
  a7.a0.a0 = -15.0;
  a7.a1 = 16.0;
  a8.a0.a0 = -17.0;
  a8.a1 = 18.0;
  a9.a0.a0 = -19.0;
  a9.a1 = 20.0;
 
  std::cout << "Calling TestAsyncPassStruct8BytesNestedFloat2x10(" << "((("
            << a0.a0.a0 << "), " << a0.a1 << "), ((" << a1.a0.a0 << "), "
            << a1.a1 << "), ((" << a2.a0.a0 << "), " << a2.a1 << "), (("
            << a3.a0.a0 << "), " << a3.a1 << "), ((" << a4.a0.a0 << "), "
            << a4.a1 << "), ((" << a5.a0.a0 << "), " << a5.a1 << "), (("
            << a6.a0.a0 << "), " << a6.a1 << "), ((" << a7.a0.a0 << "), "
            << a7.a1 << "), ((" << a8.a0.a0 << "), " << a8.a1 << "), (("
            << a9.a0.a0 << "), " << a9.a1 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct8BytesNestedFloatx10()

DART_EXPORT void dart::TestAsyncPassStruct8BytesNestedFloatx10

(

void(*)(Struct8BytesNestedFloat a0, Struct8BytesNestedFloat a1, Struct8BytesNestedFloat a2, Struct8BytesNestedFloat a3, Struct8BytesNestedFloat a4, Struct8BytesNestedFloat a5, Struct8BytesNestedFloat a6, Struct8BytesNestedFloat a7, Struct8BytesNestedFloat a8, Struct8BytesNestedFloat a9)

f

)

Definition at line 18636 of file ffi_test_functions_generated.cc.

                                           {
  Struct8BytesNestedFloat a0 = {};
  Struct8BytesNestedFloat a1 = {};
  Struct8BytesNestedFloat a2 = {};
  Struct8BytesNestedFloat a3 = {};
  Struct8BytesNestedFloat a4 = {};
  Struct8BytesNestedFloat a5 = {};
  Struct8BytesNestedFloat a6 = {};
  Struct8BytesNestedFloat a7 = {};
  Struct8BytesNestedFloat a8 = {};
  Struct8BytesNestedFloat a9 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1.a0 = 2.0;
  a1.a0.a0 = -3.0;
  a1.a1.a0 = 4.0;
  a2.a0.a0 = -5.0;
  a2.a1.a0 = 6.0;
  a3.a0.a0 = -7.0;
  a3.a1.a0 = 8.0;
  a4.a0.a0 = -9.0;
  a4.a1.a0 = 10.0;
  a5.a0.a0 = -11.0;
  a5.a1.a0 = 12.0;
  a6.a0.a0 = -13.0;
  a6.a1.a0 = 14.0;
  a7.a0.a0 = -15.0;
  a7.a1.a0 = 16.0;
  a8.a0.a0 = -17.0;
  a8.a1.a0 = 18.0;
  a9.a0.a0 = -19.0;
  a9.a1.a0 = 20.0;
 
  std::cout << "Calling TestAsyncPassStruct8BytesNestedFloatx10(" << "((("
            << a0.a0.a0 << "), (" << a0.a1.a0 << ")), ((" << a1.a0.a0 << "), ("
            << a1.a1.a0 << ")), ((" << a2.a0.a0 << "), (" << a2.a1.a0
            << ")), ((" << a3.a0.a0 << "), (" << a3.a1.a0 << ")), (("
            << a4.a0.a0 << "), (" << a4.a1.a0 << ")), ((" << a5.a0.a0 << "), ("
            << a5.a1.a0 << ")), ((" << a6.a0.a0 << "), (" << a6.a1.a0
            << ")), ((" << a7.a0.a0 << "), (" << a7.a1.a0 << ")), (("
            << a8.a0.a0 << "), (" << a8.a1.a0 << ")), ((" << a9.a0.a0 << "), ("
            << a9.a1.a0 << ")))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct8BytesNestedIntx10()

DART_EXPORT void dart::TestAsyncPassStruct8BytesNestedIntx10

(

void(*)(Struct8BytesNestedInt a0, Struct8BytesNestedInt a1, Struct8BytesNestedInt a2, Struct8BytesNestedInt a3, Struct8BytesNestedInt a4, Struct8BytesNestedInt a5, Struct8BytesNestedInt a6, Struct8BytesNestedInt a7, Struct8BytesNestedInt a8, Struct8BytesNestedInt a9)

f

)

Definition at line 18550 of file ffi_test_functions_generated.cc.

                                         {
  Struct8BytesNestedInt a0 = {};
  Struct8BytesNestedInt a1 = {};
  Struct8BytesNestedInt a2 = {};
  Struct8BytesNestedInt a3 = {};
  Struct8BytesNestedInt a4 = {};
  Struct8BytesNestedInt a5 = {};
  Struct8BytesNestedInt a6 = {};
  Struct8BytesNestedInt a7 = {};
  Struct8BytesNestedInt a8 = {};
  Struct8BytesNestedInt a9 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a1.a0 = -3;
  a0.a1.a1 = 4;
  a1.a0.a0 = -5;
  a1.a0.a1 = 6;
  a1.a1.a0 = -7;
  a1.a1.a1 = 8;
  a2.a0.a0 = -9;
  a2.a0.a1 = 10;
  a2.a1.a0 = -11;
  a2.a1.a1 = 12;
  a3.a0.a0 = -13;
  a3.a0.a1 = 14;
  a3.a1.a0 = -15;
  a3.a1.a1 = 16;
  a4.a0.a0 = -17;
  a4.a0.a1 = 18;
  a4.a1.a0 = -19;
  a4.a1.a1 = 20;
  a5.a0.a0 = -21;
  a5.a0.a1 = 22;
  a5.a1.a0 = -23;
  a5.a1.a1 = 24;
  a6.a0.a0 = -25;
  a6.a0.a1 = 26;
  a6.a1.a0 = -27;
  a6.a1.a1 = 28;
  a7.a0.a0 = -29;
  a7.a0.a1 = 30;
  a7.a1.a0 = -31;
  a7.a1.a1 = 32;
  a8.a0.a0 = -33;
  a8.a0.a1 = 34;
  a8.a1.a0 = -35;
  a8.a1.a1 = 36;
  a9.a0.a0 = -37;
  a9.a0.a1 = 38;
  a9.a1.a0 = -39;
  a9.a1.a1 = 40;
 
  std::cout << "Calling TestAsyncPassStruct8BytesNestedIntx10(" << "((("
            << a0.a0.a0 << ", " << a0.a0.a1 << "), (" << a0.a1.a0 << ", "
            << a0.a1.a1 << ")), ((" << a1.a0.a0 << ", " << a1.a0.a1 << "), ("
            << a1.a1.a0 << ", " << a1.a1.a1 << ")), ((" << a2.a0.a0 << ", "
            << a2.a0.a1 << "), (" << a2.a1.a0 << ", " << a2.a1.a1 << ")), (("
            << a3.a0.a0 << ", " << a3.a0.a1 << "), (" << a3.a1.a0 << ", "
            << a3.a1.a1 << ")), ((" << a4.a0.a0 << ", " << a4.a0.a1 << "), ("
            << a4.a1.a0 << ", " << a4.a1.a1 << ")), ((" << a5.a0.a0 << ", "
            << a5.a0.a1 << "), (" << a5.a1.a0 << ", " << a5.a1.a1 << ")), (("
            << a6.a0.a0 << ", " << a6.a0.a1 << "), (" << a6.a1.a0 << ", "
            << a6.a1.a1 << ")), ((" << a7.a0.a0 << ", " << a7.a0.a1 << "), ("
            << a7.a1.a0 << ", " << a7.a1.a1 << ")), ((" << a8.a0.a0 << ", "
            << a8.a0.a1 << "), (" << a8.a1.a0 << ", " << a8.a1.a1 << ")), (("
            << a9.a0.a0 << ", " << a9.a0.a1 << "), (" << a9.a1.a0 << ", "
            << a9.a1.a1 << ")))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct8BytesNestedMixedx10()

DART_EXPORT void dart::TestAsyncPassStruct8BytesNestedMixedx10

(

void(*)(Struct8BytesNestedMixed a0, Struct8BytesNestedMixed a1, Struct8BytesNestedMixed a2, Struct8BytesNestedMixed a3, Struct8BytesNestedMixed a4, Struct8BytesNestedMixed a5, Struct8BytesNestedMixed a6, Struct8BytesNestedMixed a7, Struct8BytesNestedMixed a8, Struct8BytesNestedMixed a9)

f

)

Definition at line 18757 of file ffi_test_functions_generated.cc.

                                           {
  Struct8BytesNestedMixed a0 = {};
  Struct8BytesNestedMixed a1 = {};
  Struct8BytesNestedMixed a2 = {};
  Struct8BytesNestedMixed a3 = {};
  Struct8BytesNestedMixed a4 = {};
  Struct8BytesNestedMixed a5 = {};
  Struct8BytesNestedMixed a6 = {};
  Struct8BytesNestedMixed a7 = {};
  Struct8BytesNestedMixed a8 = {};
  Struct8BytesNestedMixed a9 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a1.a0 = -3.0;
  a1.a0.a0 = 4;
  a1.a0.a1 = -5;
  a1.a1.a0 = 6.0;
  a2.a0.a0 = -7;
  a2.a0.a1 = 8;
  a2.a1.a0 = -9.0;
  a3.a0.a0 = 10;
  a3.a0.a1 = -11;
  a3.a1.a0 = 12.0;
  a4.a0.a0 = -13;
  a4.a0.a1 = 14;
  a4.a1.a0 = -15.0;
  a5.a0.a0 = 16;
  a5.a0.a1 = -17;
  a5.a1.a0 = 18.0;
  a6.a0.a0 = -19;
  a6.a0.a1 = 20;
  a6.a1.a0 = -21.0;
  a7.a0.a0 = 22;
  a7.a0.a1 = -23;
  a7.a1.a0 = 24.0;
  a8.a0.a0 = -25;
  a8.a0.a1 = 26;
  a8.a1.a0 = -27.0;
  a9.a0.a0 = 28;
  a9.a0.a1 = -29;
  a9.a1.a0 = 30.0;
 
  std::cout << "Calling TestAsyncPassStruct8BytesNestedMixedx10(" << "((("
            << a0.a0.a0 << ", " << a0.a0.a1 << "), (" << a0.a1.a0 << ")), (("
            << a1.a0.a0 << ", " << a1.a0.a1 << "), (" << a1.a1.a0 << ")), (("
            << a2.a0.a0 << ", " << a2.a0.a1 << "), (" << a2.a1.a0 << ")), (("
            << a3.a0.a0 << ", " << a3.a0.a1 << "), (" << a3.a1.a0 << ")), (("
            << a4.a0.a0 << ", " << a4.a0.a1 << "), (" << a4.a1.a0 << ")), (("
            << a5.a0.a0 << ", " << a5.a0.a1 << "), (" << a5.a1.a0 << ")), (("
            << a6.a0.a0 << ", " << a6.a0.a1 << "), (" << a6.a1.a0 << ")), (("
            << a7.a0.a0 << ", " << a7.a0.a1 << "), (" << a7.a1.a0 << ")), (("
            << a8.a0.a0 << ", " << a8.a0.a1 << "), (" << a8.a1.a0 << ")), (("
            << a9.a0.a0 << ", " << a9.a0.a1 << "), (" << a9.a1.a0 << ")))"
            << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct8BytesPackedIntx10()

DART_EXPORT void dart::TestAsyncPassStruct8BytesPackedIntx10

(

void(*)(Struct8BytesPackedInt a0, Struct8BytesPackedInt a1, Struct8BytesPackedInt a2, Struct8BytesPackedInt a3, Struct8BytesPackedInt a4, Struct8BytesPackedInt a5, Struct8BytesPackedInt a6, Struct8BytesPackedInt a7, Struct8BytesPackedInt a8, Struct8BytesPackedInt a9)

f

)

Definition at line 19948 of file ffi_test_functions_generated.cc.

                                         {
  Struct8BytesPackedInt a0 = {};
  Struct8BytesPackedInt a1 = {};
  Struct8BytesPackedInt a2 = {};
  Struct8BytesPackedInt a3 = {};
  Struct8BytesPackedInt a4 = {};
  Struct8BytesPackedInt a5 = {};
  Struct8BytesPackedInt a6 = {};
  Struct8BytesPackedInt a7 = {};
  Struct8BytesPackedInt a8 = {};
  Struct8BytesPackedInt a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a1.a0 = 6;
  a1.a1 = 7;
  a1.a2 = 8;
  a1.a3 = 9;
  a1.a4 = 10;
  a2.a0 = 11;
  a2.a1 = 12;
  a2.a2 = 13;
  a2.a3 = 14;
  a2.a4 = 15;
  a3.a0 = 16;
  a3.a1 = 17;
  a3.a2 = 18;
  a3.a3 = 19;
  a3.a4 = 20;
  a4.a0 = 21;
  a4.a1 = 22;
  a4.a2 = 23;
  a4.a3 = 24;
  a4.a4 = 25;
  a5.a0 = 26;
  a5.a1 = 27;
  a5.a2 = 28;
  a5.a3 = 29;
  a5.a4 = 30;
  a6.a0 = 31;
  a6.a1 = 32;
  a6.a2 = 33;
  a6.a3 = 34;
  a6.a4 = 35;
  a7.a0 = 36;
  a7.a1 = 37;
  a7.a2 = 38;
  a7.a3 = 39;
  a7.a4 = 40;
  a8.a0 = 41;
  a8.a1 = 42;
  a8.a2 = 43;
  a8.a3 = 44;
  a8.a4 = 45;
  a9.a0 = 46;
  a9.a1 = 47;
  a9.a2 = 48;
  a9.a3 = 49;
  a9.a4 = 50;
 
  std::cout << "Calling TestAsyncPassStruct8BytesPackedIntx10(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3)
            << ", " << static_cast<int>(a0.a4) << "), ("
            << static_cast<int>(a1.a0) << ", " << a1.a1 << ", "
            << static_cast<int>(a1.a2) << ", " << static_cast<int>(a1.a3)
            << ", " << static_cast<int>(a1.a4) << "), ("
            << static_cast<int>(a2.a0) << ", " << a2.a1 << ", "
            << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3)
            << ", " << static_cast<int>(a2.a4) << "), ("
            << static_cast<int>(a3.a0) << ", " << a3.a1 << ", "
            << static_cast<int>(a3.a2) << ", " << static_cast<int>(a3.a3)
            << ", " << static_cast<int>(a3.a4) << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << ", "
            << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3)
            << ", " << static_cast<int>(a4.a4) << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << ", "
            << static_cast<int>(a5.a2) << ", " << static_cast<int>(a5.a3)
            << ", " << static_cast<int>(a5.a4) << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << ", "
            << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3)
            << ", " << static_cast<int>(a6.a4) << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << ", "
            << static_cast<int>(a7.a2) << ", " << static_cast<int>(a7.a3)
            << ", " << static_cast<int>(a7.a4) << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << ", "
            << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3)
            << ", " << static_cast<int>(a8.a4) << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << ", "
            << static_cast<int>(a9.a2) << ", " << static_cast<int>(a9.a3)
            << ", " << static_cast<int>(a9.a4) << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct9BytesHomogeneousUint8x10()

DART_EXPORT void dart::TestAsyncPassStruct9BytesHomogeneousUint8x10

(

void(*)(Struct9BytesHomogeneousUint8 a0, Struct9BytesHomogeneousUint8 a1, Struct9BytesHomogeneousUint8 a2, Struct9BytesHomogeneousUint8 a3, Struct9BytesHomogeneousUint8 a4, Struct9BytesHomogeneousUint8 a5, Struct9BytesHomogeneousUint8 a6, Struct9BytesHomogeneousUint8 a7, Struct9BytesHomogeneousUint8 a8, Struct9BytesHomogeneousUint8 a9)

f

)

Definition at line 16799 of file ffi_test_functions_generated.cc.

                                                {
  Struct9BytesHomogeneousUint8 a0 = {};
  Struct9BytesHomogeneousUint8 a1 = {};
  Struct9BytesHomogeneousUint8 a2 = {};
  Struct9BytesHomogeneousUint8 a3 = {};
  Struct9BytesHomogeneousUint8 a4 = {};
  Struct9BytesHomogeneousUint8 a5 = {};
  Struct9BytesHomogeneousUint8 a6 = {};
  Struct9BytesHomogeneousUint8 a7 = {};
  Struct9BytesHomogeneousUint8 a8 = {};
  Struct9BytesHomogeneousUint8 a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a0.a5 = 6;
  a0.a6 = 7;
  a0.a7 = 8;
  a0.a8 = 9;
  a1.a0 = 10;
  a1.a1 = 11;
  a1.a2 = 12;
  a1.a3 = 13;
  a1.a4 = 14;
  a1.a5 = 15;
  a1.a6 = 16;
  a1.a7 = 17;
  a1.a8 = 18;
  a2.a0 = 19;
  a2.a1 = 20;
  a2.a2 = 21;
  a2.a3 = 22;
  a2.a4 = 23;
  a2.a5 = 24;
  a2.a6 = 25;
  a2.a7 = 26;
  a2.a8 = 27;
  a3.a0 = 28;
  a3.a1 = 29;
  a3.a2 = 30;
  a3.a3 = 31;
  a3.a4 = 32;
  a3.a5 = 33;
  a3.a6 = 34;
  a3.a7 = 35;
  a3.a8 = 36;
  a4.a0 = 37;
  a4.a1 = 38;
  a4.a2 = 39;
  a4.a3 = 40;
  a4.a4 = 41;
  a4.a5 = 42;
  a4.a6 = 43;
  a4.a7 = 44;
  a4.a8 = 45;
  a5.a0 = 46;
  a5.a1 = 47;
  a5.a2 = 48;
  a5.a3 = 49;
  a5.a4 = 50;
  a5.a5 = 51;
  a5.a6 = 52;
  a5.a7 = 53;
  a5.a8 = 54;
  a6.a0 = 55;
  a6.a1 = 56;
  a6.a2 = 57;
  a6.a3 = 58;
  a6.a4 = 59;
  a6.a5 = 60;
  a6.a6 = 61;
  a6.a7 = 62;
  a6.a8 = 63;
  a7.a0 = 64;
  a7.a1 = 65;
  a7.a2 = 66;
  a7.a3 = 67;
  a7.a4 = 68;
  a7.a5 = 69;
  a7.a6 = 70;
  a7.a7 = 71;
  a7.a8 = 72;
  a8.a0 = 73;
  a8.a1 = 74;
  a8.a2 = 75;
  a8.a3 = 76;
  a8.a4 = 77;
  a8.a5 = 78;
  a8.a6 = 79;
  a8.a7 = 80;
  a8.a8 = 81;
  a9.a0 = 82;
  a9.a1 = 83;
  a9.a2 = 84;
  a9.a3 = 85;
  a9.a4 = 86;
  a9.a5 = 87;
  a9.a6 = 88;
  a9.a7 = 89;
  a9.a8 = 90;
 
  std::cout
      << "Calling TestAsyncPassStruct9BytesHomogeneousUint8x10(" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << ", " << static_cast<int>(a0.a7) << ", "
      << static_cast<int>(a0.a8) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << ", "
      << static_cast<int>(a1.a7) << ", " << static_cast<int>(a1.a8) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << ", " << static_cast<int>(a2.a7) << ", "
      << static_cast<int>(a2.a8) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << ", "
      << static_cast<int>(a3.a7) << ", " << static_cast<int>(a3.a8) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << ", " << static_cast<int>(a4.a7) << ", "
      << static_cast<int>(a4.a8) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << ", "
      << static_cast<int>(a5.a7) << ", " << static_cast<int>(a5.a8) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << ", " << static_cast<int>(a6.a7) << ", "
      << static_cast<int>(a6.a8) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << ", "
      << static_cast<int>(a7.a7) << ", " << static_cast<int>(a7.a8) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << ", " << static_cast<int>(a8.a7) << ", "
      << static_cast<int>(a8.a8) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << ", "
      << static_cast<int>(a9.a7) << ", " << static_cast<int>(a9.a8) << "))"
      << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct9BytesInt4Or8ByteAlignedx10()

DART_EXPORT void dart::TestAsyncPassStruct9BytesInt4Or8ByteAlignedx10

(

void(*)(Struct9BytesInt4Or8ByteAligned a0, Struct9BytesInt4Or8ByteAligned a1, Struct9BytesInt4Or8ByteAligned a2, Struct9BytesInt4Or8ByteAligned a3, Struct9BytesInt4Or8ByteAligned a4, Struct9BytesInt4Or8ByteAligned a5, Struct9BytesInt4Or8ByteAligned a6, Struct9BytesInt4Or8ByteAligned a7, Struct9BytesInt4Or8ByteAligned a8, Struct9BytesInt4Or8ByteAligned a9)

f

)

Definition at line 16970 of file ffi_test_functions_generated.cc.

                                                  {
  Struct9BytesInt4Or8ByteAligned a0 = {};
  Struct9BytesInt4Or8ByteAligned a1 = {};
  Struct9BytesInt4Or8ByteAligned a2 = {};
  Struct9BytesInt4Or8ByteAligned a3 = {};
  Struct9BytesInt4Or8ByteAligned a4 = {};
  Struct9BytesInt4Or8ByteAligned a5 = {};
  Struct9BytesInt4Or8ByteAligned a6 = {};
  Struct9BytesInt4Or8ByteAligned a7 = {};
  Struct9BytesInt4Or8ByteAligned a8 = {};
  Struct9BytesInt4Or8ByteAligned a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
  a2.a0 = -5;
  a2.a1 = 6;
  a3.a0 = -7;
  a3.a1 = 8;
  a4.a0 = -9;
  a4.a1 = 10;
  a5.a0 = -11;
  a5.a1 = 12;
  a6.a0 = -13;
  a6.a1 = 14;
  a7.a0 = -15;
  a7.a1 = 16;
  a8.a0 = -17;
  a8.a1 = 18;
  a9.a0 = -19;
  a9.a1 = 20;
 
  std::cout << "Calling TestAsyncPassStruct9BytesInt4Or8ByteAlignedx10(" << "(("
            << a0.a0 << ", " << static_cast<int>(a0.a1) << "), (" << a1.a0
            << ", " << static_cast<int>(a1.a1) << "), (" << a2.a0 << ", "
            << static_cast<int>(a2.a1) << "), (" << a3.a0 << ", "
            << static_cast<int>(a3.a1) << "), (" << a4.a0 << ", "
            << static_cast<int>(a4.a1) << "), (" << a5.a0 << ", "
            << static_cast<int>(a5.a1) << "), (" << a6.a0 << ", "
            << static_cast<int>(a6.a1) << "), (" << a7.a0 << ", "
            << static_cast<int>(a7.a1) << "), (" << a8.a0 << ", "
            << static_cast<int>(a8.a1) << "), (" << a9.a0 << ", "
            << static_cast<int>(a9.a1) << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStruct9BytesPackedMixedx10DoubleInt32x2()

DART_EXPORT void dart::TestAsyncPassStruct9BytesPackedMixedx10DoubleInt32x2

(

void(*)(Struct9BytesPackedMixed a0, Struct9BytesPackedMixed a1, Struct9BytesPackedMixed a2, Struct9BytesPackedMixed a3, Struct9BytesPackedMixed a4, Struct9BytesPackedMixed a5, Struct9BytesPackedMixed a6, Struct9BytesPackedMixed a7, Struct9BytesPackedMixed a8, Struct9BytesPackedMixed a9, double a10, int32_t a11, int32_t a12)

f

)

Definition at line 20060 of file ffi_test_functions_generated.cc.

                            {
  Struct9BytesPackedMixed a0 = {};
  Struct9BytesPackedMixed a1 = {};
  Struct9BytesPackedMixed a2 = {};
  Struct9BytesPackedMixed a3 = {};
  Struct9BytesPackedMixed a4 = {};
  Struct9BytesPackedMixed a5 = {};
  Struct9BytesPackedMixed a6 = {};
  Struct9BytesPackedMixed a7 = {};
  Struct9BytesPackedMixed a8 = {};
  Struct9BytesPackedMixed a9 = {};
  double a10;
  int32_t a11;
  int32_t a12;
 
  a0.a0 = 1;
  a0.a1 = 2.0;
  a1.a0 = 3;
  a1.a1 = 4.0;
  a2.a0 = 5;
  a2.a1 = 6.0;
  a3.a0 = 7;
  a3.a1 = 8.0;
  a4.a0 = 9;
  a4.a1 = 10.0;
  a5.a0 = 11;
  a5.a1 = 12.0;
  a6.a0 = 13;
  a6.a1 = 14.0;
  a7.a0 = 15;
  a7.a1 = 16.0;
  a8.a0 = 17;
  a8.a1 = 18.0;
  a9.a0 = 19;
  a9.a1 = 20.0;
  a10 = -21.0;
  a11 = 22;
  a12 = -23;
 
  std::cout << "Calling TestAsyncPassStruct9BytesPackedMixedx10DoubleInt32x2("
            << "((" << static_cast<int>(a0.a0) << ", " << a0.a1 << "), ("
            << static_cast<int>(a1.a0) << ", " << a1.a1 << "), ("
            << static_cast<int>(a2.a0) << ", " << a2.a1 << "), ("
            << static_cast<int>(a3.a0) << ", " << a3.a1 << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << "), " << a10 << ", "
            << a11 << ", " << a12 << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
}

TestAsyncPassStructAlignmentInt16()

DART_EXPORT void dart::TestAsyncPassStructAlignmentInt16

(

void(*)(StructAlignmentInt16 a0)

f

)

Definition at line 18495 of file ffi_test_functions_generated.cc.

                                        {
  StructAlignmentInt16 a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
 
  std::cout << "Calling TestAsyncPassStructAlignmentInt16(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "))" << ")\n";
 
  f(a0);
}

TestAsyncPassStructAlignmentInt32()

DART_EXPORT void dart::TestAsyncPassStructAlignmentInt32

(

void(*)(StructAlignmentInt32 a0)

f

)

Definition at line 18513 of file ffi_test_functions_generated.cc.

                                        {
  StructAlignmentInt32 a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
 
  std::cout << "Calling TestAsyncPassStructAlignmentInt32(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "))" << ")\n";
 
  f(a0);
}

TestAsyncPassStructAlignmentInt64()

DART_EXPORT void dart::TestAsyncPassStructAlignmentInt64

(

void(*)(StructAlignmentInt64 a0)

f

)

Definition at line 18531 of file ffi_test_functions_generated.cc.

                                        {
  StructAlignmentInt64 a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
 
  std::cout << "Calling TestAsyncPassStructAlignmentInt64(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "))" << ")\n";
 
  f(a0);
}

TestAsyncPassStructInlineArray100Bytes()

DART_EXPORT void dart::TestAsyncPassStructInlineArray100Bytes

(

void(*)(StructInlineArray100Bytes a0)

f

)

Definition at line 19331 of file ffi_test_functions_generated.cc.

                                             {
  StructInlineArray100Bytes a0 = {};
 
  a0.a0[0] = 1;
  a0.a0[1] = 2;
  a0.a0[2] = 3;
  a0.a0[3] = 4;
  a0.a0[4] = 5;
  a0.a0[5] = 6;
  a0.a0[6] = 7;
  a0.a0[7] = 8;
  a0.a0[8] = 9;
  a0.a0[9] = 10;
  a0.a0[10] = 11;
  a0.a0[11] = 12;
  a0.a0[12] = 13;
  a0.a0[13] = 14;
  a0.a0[14] = 15;
  a0.a0[15] = 16;
  a0.a0[16] = 17;
  a0.a0[17] = 18;
  a0.a0[18] = 19;
  a0.a0[19] = 20;
  a0.a0[20] = 21;
  a0.a0[21] = 22;
  a0.a0[22] = 23;
  a0.a0[23] = 24;
  a0.a0[24] = 25;
  a0.a0[25] = 26;
  a0.a0[26] = 27;
  a0.a0[27] = 28;
  a0.a0[28] = 29;
  a0.a0[29] = 30;
  a0.a0[30] = 31;
  a0.a0[31] = 32;
  a0.a0[32] = 33;
  a0.a0[33] = 34;
  a0.a0[34] = 35;
  a0.a0[35] = 36;
  a0.a0[36] = 37;
  a0.a0[37] = 38;
  a0.a0[38] = 39;
  a0.a0[39] = 40;
  a0.a0[40] = 41;
  a0.a0[41] = 42;
  a0.a0[42] = 43;
  a0.a0[43] = 44;
  a0.a0[44] = 45;
  a0.a0[45] = 46;
  a0.a0[46] = 47;
  a0.a0[47] = 48;
  a0.a0[48] = 49;
  a0.a0[49] = 50;
  a0.a0[50] = 51;
  a0.a0[51] = 52;
  a0.a0[52] = 53;
  a0.a0[53] = 54;
  a0.a0[54] = 55;
  a0.a0[55] = 56;
  a0.a0[56] = 57;
  a0.a0[57] = 58;
  a0.a0[58] = 59;
  a0.a0[59] = 60;
  a0.a0[60] = 61;
  a0.a0[61] = 62;
  a0.a0[62] = 63;
  a0.a0[63] = 64;
  a0.a0[64] = 65;
  a0.a0[65] = 66;
  a0.a0[66] = 67;
  a0.a0[67] = 68;
  a0.a0[68] = 69;
  a0.a0[69] = 70;
  a0.a0[70] = 71;
  a0.a0[71] = 72;
  a0.a0[72] = 73;
  a0.a0[73] = 74;
  a0.a0[74] = 75;
  a0.a0[75] = 76;
  a0.a0[76] = 77;
  a0.a0[77] = 78;
  a0.a0[78] = 79;
  a0.a0[79] = 80;
  a0.a0[80] = 81;
  a0.a0[81] = 82;
  a0.a0[82] = 83;
  a0.a0[83] = 84;
  a0.a0[84] = 85;
  a0.a0[85] = 86;
  a0.a0[86] = 87;
  a0.a0[87] = 88;
  a0.a0[88] = 89;
  a0.a0[89] = 90;
  a0.a0[90] = 91;
  a0.a0[91] = 92;
  a0.a0[92] = 93;
  a0.a0[93] = 94;
  a0.a0[94] = 95;
  a0.a0[95] = 96;
  a0.a0[96] = 97;
  a0.a0[97] = 98;
  a0.a0[98] = 99;
  a0.a0[99] = 100;
 
  std::cout
      << "Calling TestAsyncPassStructInlineArray100Bytes(" << "((["
      << static_cast<int>(a0.a0[0]) << ", " << static_cast<int>(a0.a0[1])
      << ", " << static_cast<int>(a0.a0[2]) << ", "
      << static_cast<int>(a0.a0[3]) << ", " << static_cast<int>(a0.a0[4])
      << ", " << static_cast<int>(a0.a0[5]) << ", "
      << static_cast<int>(a0.a0[6]) << ", " << static_cast<int>(a0.a0[7])
      << ", " << static_cast<int>(a0.a0[8]) << ", "
      << static_cast<int>(a0.a0[9]) << ", " << static_cast<int>(a0.a0[10])
      << ", " << static_cast<int>(a0.a0[11]) << ", "
      << static_cast<int>(a0.a0[12]) << ", " << static_cast<int>(a0.a0[13])
      << ", " << static_cast<int>(a0.a0[14]) << ", "
      << static_cast<int>(a0.a0[15]) << ", " << static_cast<int>(a0.a0[16])
      << ", " << static_cast<int>(a0.a0[17]) << ", "
      << static_cast<int>(a0.a0[18]) << ", " << static_cast<int>(a0.a0[19])
      << ", " << static_cast<int>(a0.a0[20]) << ", "
      << static_cast<int>(a0.a0[21]) << ", " << static_cast<int>(a0.a0[22])
      << ", " << static_cast<int>(a0.a0[23]) << ", "
      << static_cast<int>(a0.a0[24]) << ", " << static_cast<int>(a0.a0[25])
      << ", " << static_cast<int>(a0.a0[26]) << ", "
      << static_cast<int>(a0.a0[27]) << ", " << static_cast<int>(a0.a0[28])
      << ", " << static_cast<int>(a0.a0[29]) << ", "
      << static_cast<int>(a0.a0[30]) << ", " << static_cast<int>(a0.a0[31])
      << ", " << static_cast<int>(a0.a0[32]) << ", "
      << static_cast<int>(a0.a0[33]) << ", " << static_cast<int>(a0.a0[34])
      << ", " << static_cast<int>(a0.a0[35]) << ", "
      << static_cast<int>(a0.a0[36]) << ", " << static_cast<int>(a0.a0[37])
      << ", " << static_cast<int>(a0.a0[38]) << ", "
      << static_cast<int>(a0.a0[39]) << ", " << static_cast<int>(a0.a0[40])
      << ", " << static_cast<int>(a0.a0[41]) << ", "
      << static_cast<int>(a0.a0[42]) << ", " << static_cast<int>(a0.a0[43])
      << ", " << static_cast<int>(a0.a0[44]) << ", "
      << static_cast<int>(a0.a0[45]) << ", " << static_cast<int>(a0.a0[46])
      << ", " << static_cast<int>(a0.a0[47]) << ", "
      << static_cast<int>(a0.a0[48]) << ", " << static_cast<int>(a0.a0[49])
      << ", " << static_cast<int>(a0.a0[50]) << ", "
      << static_cast<int>(a0.a0[51]) << ", " << static_cast<int>(a0.a0[52])
      << ", " << static_cast<int>(a0.a0[53]) << ", "
      << static_cast<int>(a0.a0[54]) << ", " << static_cast<int>(a0.a0[55])
      << ", " << static_cast<int>(a0.a0[56]) << ", "
      << static_cast<int>(a0.a0[57]) << ", " << static_cast<int>(a0.a0[58])
      << ", " << static_cast<int>(a0.a0[59]) << ", "
      << static_cast<int>(a0.a0[60]) << ", " << static_cast<int>(a0.a0[61])
      << ", " << static_cast<int>(a0.a0[62]) << ", "
      << static_cast<int>(a0.a0[63]) << ", " << static_cast<int>(a0.a0[64])
      << ", " << static_cast<int>(a0.a0[65]) << ", "
      << static_cast<int>(a0.a0[66]) << ", " << static_cast<int>(a0.a0[67])
      << ", " << static_cast<int>(a0.a0[68]) << ", "
      << static_cast<int>(a0.a0[69]) << ", " << static_cast<int>(a0.a0[70])
      << ", " << static_cast<int>(a0.a0[71]) << ", "
      << static_cast<int>(a0.a0[72]) << ", " << static_cast<int>(a0.a0[73])
      << ", " << static_cast<int>(a0.a0[74]) << ", "
      << static_cast<int>(a0.a0[75]) << ", " << static_cast<int>(a0.a0[76])
      << ", " << static_cast<int>(a0.a0[77]) << ", "
      << static_cast<int>(a0.a0[78]) << ", " << static_cast<int>(a0.a0[79])
      << ", " << static_cast<int>(a0.a0[80]) << ", "
      << static_cast<int>(a0.a0[81]) << ", " << static_cast<int>(a0.a0[82])
      << ", " << static_cast<int>(a0.a0[83]) << ", "
      << static_cast<int>(a0.a0[84]) << ", " << static_cast<int>(a0.a0[85])
      << ", " << static_cast<int>(a0.a0[86]) << ", "
      << static_cast<int>(a0.a0[87]) << ", " << static_cast<int>(a0.a0[88])
      << ", " << static_cast<int>(a0.a0[89]) << ", "
      << static_cast<int>(a0.a0[90]) << ", " << static_cast<int>(a0.a0[91])
      << ", " << static_cast<int>(a0.a0[92]) << ", "
      << static_cast<int>(a0.a0[93]) << ", " << static_cast<int>(a0.a0[94])
      << ", " << static_cast<int>(a0.a0[95]) << ", "
      << static_cast<int>(a0.a0[96]) << ", " << static_cast<int>(a0.a0[97])
      << ", " << static_cast<int>(a0.a0[98]) << ", "
      << static_cast<int>(a0.a0[99]) << "]))" << ")\n";
 
  f(a0);
}

TestAsyncPassStructInlineArrayIrregularx4()

DART_EXPORT void dart::TestAsyncPassStructInlineArrayIrregularx4

(

void(*)(StructInlineArrayIrregular a0, StructInlineArrayIrregular a1, StructInlineArrayIrregular a2, StructInlineArrayIrregular a3)

f

)

Definition at line 19280 of file ffi_test_functions_generated.cc.

                                              {
  StructInlineArrayIrregular a0 = {};
  StructInlineArrayIrregular a1 = {};
  StructInlineArrayIrregular a2 = {};
  StructInlineArrayIrregular a3 = {};
 
  a0.a0[0].a0 = -1;
  a0.a0[0].a1 = 2;
  a0.a0[1].a0 = -3;
  a0.a0[1].a1 = 4;
  a0.a1 = 5;
  a1.a0[0].a0 = 6;
  a1.a0[0].a1 = -7;
  a1.a0[1].a0 = 8;
  a1.a0[1].a1 = -9;
  a1.a1 = 10;
  a2.a0[0].a0 = -11;
  a2.a0[0].a1 = 12;
  a2.a0[1].a0 = -13;
  a2.a0[1].a1 = 14;
  a2.a1 = 15;
  a3.a0[0].a0 = 16;
  a3.a0[0].a1 = -17;
  a3.a0[1].a0 = 18;
  a3.a0[1].a1 = -19;
  a3.a1 = 20;
 
  std::cout << "Calling TestAsyncPassStructInlineArrayIrregularx4(" << "(([("
            << a0.a0[0].a0 << ", " << static_cast<int>(a0.a0[0].a1) << "), ("
            << a0.a0[1].a0 << ", " << static_cast<int>(a0.a0[1].a1) << ")], "
            << static_cast<int>(a0.a1) << "), ([(" << a1.a0[0].a0 << ", "
            << static_cast<int>(a1.a0[0].a1) << "), (" << a1.a0[1].a0 << ", "
            << static_cast<int>(a1.a0[1].a1) << ")], "
            << static_cast<int>(a1.a1) << "), ([(" << a2.a0[0].a0 << ", "
            << static_cast<int>(a2.a0[0].a1) << "), (" << a2.a0[1].a0 << ", "
            << static_cast<int>(a2.a0[1].a1) << ")], "
            << static_cast<int>(a2.a1) << "), ([(" << a3.a0[0].a0 << ", "
            << static_cast<int>(a3.a0[0].a1) << "), (" << a3.a0[1].a0 << ", "
            << static_cast<int>(a3.a0[1].a1) << ")], "
            << static_cast<int>(a3.a1) << "))" << ")\n";
 
  f(a0, a1, a2, a3);
}

TestAsyncPassStructNestedAlignmentStruct5BytesPackedMixed()

DART_EXPORT void dart::TestAsyncPassStructNestedAlignmentStruct5BytesPackedMixed

(

void(*)(StructNestedAlignmentStruct5BytesPackedMixed a0)

f

)

Definition at line 20147 of file ffi_test_functions_generated.cc.

                                                                {
  StructNestedAlignmentStruct5BytesPackedMixed a0 = {};
 
  a0.a0 = 1;
  a0.a1.a0 = 2.0;
  a0.a1.a1 = 3;
 
  std::cout
      << "Calling TestAsyncPassStructNestedAlignmentStruct5BytesPackedMixed("
      << "((" << static_cast<int>(a0.a0) << ", (" << a0.a1.a0 << ", "
      << static_cast<int>(a0.a1.a1) << ")))" << ")\n";
 
  f(a0);
}

TestAsyncPassStructNestedIntStructAlignmentInt16()

DART_EXPORT void dart::TestAsyncPassStructNestedIntStructAlignmentInt16

(

void(*)(StructNestedIntStructAlignmentInt16 a0)

f

)

Definition at line 18928 of file ffi_test_functions_generated.cc.

                                                       {
  StructNestedIntStructAlignmentInt16 a0 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a0.a2 = -3;
  a0.a1.a0 = 4;
  a0.a1.a1 = -5;
  a0.a1.a2 = 6;
 
  std::cout << "Calling TestAsyncPassStructNestedIntStructAlignmentInt16("
            << "(((" << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << ")\n";
 
  f(a0);
}

TestAsyncPassStructNestedIntStructAlignmentInt32()

DART_EXPORT void dart::TestAsyncPassStructNestedIntStructAlignmentInt32

(

void(*)(StructNestedIntStructAlignmentInt32 a0)

f

)

Definition at line 18951 of file ffi_test_functions_generated.cc.

                                                       {
  StructNestedIntStructAlignmentInt32 a0 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a0.a2 = -3;
  a0.a1.a0 = 4;
  a0.a1.a1 = -5;
  a0.a1.a2 = 6;
 
  std::cout << "Calling TestAsyncPassStructNestedIntStructAlignmentInt32("
            << "(((" << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << ")\n";
 
  f(a0);
}

TestAsyncPassStructNestedIntStructAlignmentInt64()

DART_EXPORT void dart::TestAsyncPassStructNestedIntStructAlignmentInt64

(

void(*)(StructNestedIntStructAlignmentInt64 a0)

f

)

Definition at line 18974 of file ffi_test_functions_generated.cc.

                                                       {
  StructNestedIntStructAlignmentInt64 a0 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a0.a2 = -3;
  a0.a1.a0 = 4;
  a0.a1.a1 = -5;
  a0.a1.a2 = 6;
 
  std::cout << "Calling TestAsyncPassStructNestedIntStructAlignmentInt64("
            << "(((" << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << ")\n";
 
  f(a0);
}

TestAsyncPassStructNestedIrregularEvenBiggerx4()

DART_EXPORT void dart::TestAsyncPassStructNestedIrregularEvenBiggerx4

(

void(*)(StructNestedIrregularEvenBigger a0, StructNestedIrregularEvenBigger a1, StructNestedIrregularEvenBigger a2, StructNestedIrregularEvenBigger a3)

f

)

Definition at line 18997 of file ffi_test_functions_generated.cc.

                                                   {
  StructNestedIrregularEvenBigger a0 = {};
  StructNestedIrregularEvenBigger a1 = {};
  StructNestedIrregularEvenBigger a2 = {};
  StructNestedIrregularEvenBigger a3 = {};
 
  a0.a0 = 1;
  a0.a1.a0.a0 = 2;
  a0.a1.a0.a1.a0.a0 = -3;
  a0.a1.a0.a1.a0.a1 = 4;
  a0.a1.a0.a1.a1.a0 = -5.0;
  a0.a1.a0.a2 = 6;
  a0.a1.a0.a3.a0.a0 = -7.0;
  a0.a1.a0.a3.a1 = 8.0;
  a0.a1.a0.a4 = 9;
  a0.a1.a0.a5.a0.a0 = 10.0;
  a0.a1.a0.a5.a1.a0 = -11.0;
  a0.a1.a0.a6 = 12;
  a0.a1.a1.a0.a0 = -13;
  a0.a1.a1.a0.a1 = 14;
  a0.a1.a1.a1.a0 = -15.0;
  a0.a1.a2 = 16.0;
  a0.a1.a3 = -17.0;
  a0.a2.a0.a0 = 18;
  a0.a2.a0.a1.a0.a0 = -19;
  a0.a2.a0.a1.a0.a1 = 20;
  a0.a2.a0.a1.a1.a0 = -21.0;
  a0.a2.a0.a2 = 22;
  a0.a2.a0.a3.a0.a0 = -23.0;
  a0.a2.a0.a3.a1 = 24.0;
  a0.a2.a0.a4 = 25;
  a0.a2.a0.a5.a0.a0 = 26.0;
  a0.a2.a0.a5.a1.a0 = -27.0;
  a0.a2.a0.a6 = 28;
  a0.a2.a1.a0.a0 = -29;
  a0.a2.a1.a0.a1 = 30;
  a0.a2.a1.a1.a0 = -31.0;
  a0.a2.a2 = 32.0;
  a0.a2.a3 = -33.0;
  a0.a3 = 34.0;
  a1.a0 = 35;
  a1.a1.a0.a0 = 36;
  a1.a1.a0.a1.a0.a0 = -37;
  a1.a1.a0.a1.a0.a1 = 38;
  a1.a1.a0.a1.a1.a0 = -39.0;
  a1.a1.a0.a2 = 40;
  a1.a1.a0.a3.a0.a0 = -41.0;
  a1.a1.a0.a3.a1 = 42.0;
  a1.a1.a0.a4 = 43;
  a1.a1.a0.a5.a0.a0 = 44.0;
  a1.a1.a0.a5.a1.a0 = -45.0;
  a1.a1.a0.a6 = 46;
  a1.a1.a1.a0.a0 = -47;
  a1.a1.a1.a0.a1 = 48;
  a1.a1.a1.a1.a0 = -49.0;
  a1.a1.a2 = 50.0;
  a1.a1.a3 = -51.0;
  a1.a2.a0.a0 = 52;
  a1.a2.a0.a1.a0.a0 = -53;
  a1.a2.a0.a1.a0.a1 = 54;
  a1.a2.a0.a1.a1.a0 = -55.0;
  a1.a2.a0.a2 = 56;
  a1.a2.a0.a3.a0.a0 = -57.0;
  a1.a2.a0.a3.a1 = 58.0;
  a1.a2.a0.a4 = 59;
  a1.a2.a0.a5.a0.a0 = 60.0;
  a1.a2.a0.a5.a1.a0 = -61.0;
  a1.a2.a0.a6 = 62;
  a1.a2.a1.a0.a0 = -63;
  a1.a2.a1.a0.a1 = 64;
  a1.a2.a1.a1.a0 = -65.0;
  a1.a2.a2 = 66.0;
  a1.a2.a3 = -67.0;
  a1.a3 = 68.0;
  a2.a0 = 69;
  a2.a1.a0.a0 = 70;
  a2.a1.a0.a1.a0.a0 = -71;
  a2.a1.a0.a1.a0.a1 = 72;
  a2.a1.a0.a1.a1.a0 = -73.0;
  a2.a1.a0.a2 = 74;
  a2.a1.a0.a3.a0.a0 = -75.0;
  a2.a1.a0.a3.a1 = 76.0;
  a2.a1.a0.a4 = 77;
  a2.a1.a0.a5.a0.a0 = 78.0;
  a2.a1.a0.a5.a1.a0 = -79.0;
  a2.a1.a0.a6 = 80;
  a2.a1.a1.a0.a0 = -81;
  a2.a1.a1.a0.a1 = 82;
  a2.a1.a1.a1.a0 = -83.0;
  a2.a1.a2 = 84.0;
  a2.a1.a3 = -85.0;
  a2.a2.a0.a0 = 86;
  a2.a2.a0.a1.a0.a0 = -87;
  a2.a2.a0.a1.a0.a1 = 88;
  a2.a2.a0.a1.a1.a0 = -89.0;
  a2.a2.a0.a2 = 90;
  a2.a2.a0.a3.a0.a0 = -91.0;
  a2.a2.a0.a3.a1 = 92.0;
  a2.a2.a0.a4 = 93;
  a2.a2.a0.a5.a0.a0 = 94.0;
  a2.a2.a0.a5.a1.a0 = -95.0;
  a2.a2.a0.a6 = 96;
  a2.a2.a1.a0.a0 = -97;
  a2.a2.a1.a0.a1 = 98;
  a2.a2.a1.a1.a0 = -99.0;
  a2.a2.a2 = 100.0;
  a2.a2.a3 = -101.0;
  a2.a3 = 102.0;
  a3.a0 = 103;
  a3.a1.a0.a0 = 104;
  a3.a1.a0.a1.a0.a0 = -105;
  a3.a1.a0.a1.a0.a1 = 106;
  a3.a1.a0.a1.a1.a0 = -107.0;
  a3.a1.a0.a2 = 108;
  a3.a1.a0.a3.a0.a0 = -109.0;
  a3.a1.a0.a3.a1 = 110.0;
  a3.a1.a0.a4 = 111;
  a3.a1.a0.a5.a0.a0 = 112.0;
  a3.a1.a0.a5.a1.a0 = -113.0;
  a3.a1.a0.a6 = 114;
  a3.a1.a1.a0.a0 = -115;
  a3.a1.a1.a0.a1 = 116;
  a3.a1.a1.a1.a0 = -117.0;
  a3.a1.a2 = 118.0;
  a3.a1.a3 = -119.0;
  a3.a2.a0.a0 = 120;
  a3.a2.a0.a1.a0.a0 = -121;
  a3.a2.a0.a1.a0.a1 = 122;
  a3.a2.a0.a1.a1.a0 = -123.0;
  a3.a2.a0.a2 = 124;
  a3.a2.a0.a3.a0.a0 = -125.0;
  a3.a2.a0.a3.a1 = 126.0;
  a3.a2.a0.a4 = 127;
  a3.a2.a0.a5.a0.a0 = 128.0;
  a3.a2.a0.a5.a1.a0 = -129.0;
  a3.a2.a0.a6 = 130;
  a3.a2.a1.a0.a0 = -131;
  a3.a2.a1.a0.a1 = 132;
  a3.a2.a1.a1.a0 = -133.0;
  a3.a2.a2 = 134.0;
  a3.a2.a3 = -135.0;
  a3.a3 = 136.0;
 
  std::cout
      << "Calling TestAsyncPassStructNestedIrregularEvenBiggerx4(" << "(("
      << a0.a0 << ", ((" << a0.a1.a0.a0 << ", ((" << a0.a1.a0.a1.a0.a0 << ", "
      << a0.a1.a0.a1.a0.a1 << "), (" << a0.a1.a0.a1.a1.a0 << ")), "
      << a0.a1.a0.a2 << ", ((" << a0.a1.a0.a3.a0.a0 << "), " << a0.a1.a0.a3.a1
      << "), " << a0.a1.a0.a4 << ", ((" << a0.a1.a0.a5.a0.a0 << "), ("
      << a0.a1.a0.a5.a1.a0 << ")), " << a0.a1.a0.a6 << "), ((" << a0.a1.a1.a0.a0
      << ", " << a0.a1.a1.a0.a1 << "), (" << a0.a1.a1.a1.a0 << ")), "
      << a0.a1.a2 << ", " << a0.a1.a3 << "), ((" << a0.a2.a0.a0 << ", (("
      << a0.a2.a0.a1.a0.a0 << ", " << a0.a2.a0.a1.a0.a1 << "), ("
      << a0.a2.a0.a1.a1.a0 << ")), " << a0.a2.a0.a2 << ", (("
      << a0.a2.a0.a3.a0.a0 << "), " << a0.a2.a0.a3.a1 << "), " << a0.a2.a0.a4
      << ", ((" << a0.a2.a0.a5.a0.a0 << "), (" << a0.a2.a0.a5.a1.a0 << ")), "
      << a0.a2.a0.a6 << "), ((" << a0.a2.a1.a0.a0 << ", " << a0.a2.a1.a0.a1
      << "), (" << a0.a2.a1.a1.a0 << ")), " << a0.a2.a2 << ", " << a0.a2.a3
      << "), " << a0.a3 << "), (" << a1.a0 << ", ((" << a1.a1.a0.a0 << ", (("
      << a1.a1.a0.a1.a0.a0 << ", " << a1.a1.a0.a1.a0.a1 << "), ("
      << a1.a1.a0.a1.a1.a0 << ")), " << a1.a1.a0.a2 << ", (("
      << a1.a1.a0.a3.a0.a0 << "), " << a1.a1.a0.a3.a1 << "), " << a1.a1.a0.a4
      << ", ((" << a1.a1.a0.a5.a0.a0 << "), (" << a1.a1.a0.a5.a1.a0 << ")), "
      << a1.a1.a0.a6 << "), ((" << a1.a1.a1.a0.a0 << ", " << a1.a1.a1.a0.a1
      << "), (" << a1.a1.a1.a1.a0 << ")), " << a1.a1.a2 << ", " << a1.a1.a3
      << "), ((" << a1.a2.a0.a0 << ", ((" << a1.a2.a0.a1.a0.a0 << ", "
      << a1.a2.a0.a1.a0.a1 << "), (" << a1.a2.a0.a1.a1.a0 << ")), "
      << a1.a2.a0.a2 << ", ((" << a1.a2.a0.a3.a0.a0 << "), " << a1.a2.a0.a3.a1
      << "), " << a1.a2.a0.a4 << ", ((" << a1.a2.a0.a5.a0.a0 << "), ("
      << a1.a2.a0.a5.a1.a0 << ")), " << a1.a2.a0.a6 << "), ((" << a1.a2.a1.a0.a0
      << ", " << a1.a2.a1.a0.a1 << "), (" << a1.a2.a1.a1.a0 << ")), "
      << a1.a2.a2 << ", " << a1.a2.a3 << "), " << a1.a3 << "), (" << a2.a0
      << ", ((" << a2.a1.a0.a0 << ", ((" << a2.a1.a0.a1.a0.a0 << ", "
      << a2.a1.a0.a1.a0.a1 << "), (" << a2.a1.a0.a1.a1.a0 << ")), "
      << a2.a1.a0.a2 << ", ((" << a2.a1.a0.a3.a0.a0 << "), " << a2.a1.a0.a3.a1
      << "), " << a2.a1.a0.a4 << ", ((" << a2.a1.a0.a5.a0.a0 << "), ("
      << a2.a1.a0.a5.a1.a0 << ")), " << a2.a1.a0.a6 << "), ((" << a2.a1.a1.a0.a0
      << ", " << a2.a1.a1.a0.a1 << "), (" << a2.a1.a1.a1.a0 << ")), "
      << a2.a1.a2 << ", " << a2.a1.a3 << "), ((" << a2.a2.a0.a0 << ", (("
      << a2.a2.a0.a1.a0.a0 << ", " << a2.a2.a0.a1.a0.a1 << "), ("
      << a2.a2.a0.a1.a1.a0 << ")), " << a2.a2.a0.a2 << ", (("
      << a2.a2.a0.a3.a0.a0 << "), " << a2.a2.a0.a3.a1 << "), " << a2.a2.a0.a4
      << ", ((" << a2.a2.a0.a5.a0.a0 << "), (" << a2.a2.a0.a5.a1.a0 << ")), "
      << a2.a2.a0.a6 << "), ((" << a2.a2.a1.a0.a0 << ", " << a2.a2.a1.a0.a1
      << "), (" << a2.a2.a1.a1.a0 << ")), " << a2.a2.a2 << ", " << a2.a2.a3
      << "), " << a2.a3 << "), (" << a3.a0 << ", ((" << a3.a1.a0.a0 << ", (("
      << a3.a1.a0.a1.a0.a0 << ", " << a3.a1.a0.a1.a0.a1 << "), ("
      << a3.a1.a0.a1.a1.a0 << ")), " << a3.a1.a0.a2 << ", (("
      << a3.a1.a0.a3.a0.a0 << "), " << a3.a1.a0.a3.a1 << "), " << a3.a1.a0.a4
      << ", ((" << a3.a1.a0.a5.a0.a0 << "), (" << a3.a1.a0.a5.a1.a0 << ")), "
      << a3.a1.a0.a6 << "), ((" << a3.a1.a1.a0.a0 << ", " << a3.a1.a1.a0.a1
      << "), (" << a3.a1.a1.a1.a0 << ")), " << a3.a1.a2 << ", " << a3.a1.a3
      << "), ((" << a3.a2.a0.a0 << ", ((" << a3.a2.a0.a1.a0.a0 << ", "
      << a3.a2.a0.a1.a0.a1 << "), (" << a3.a2.a0.a1.a1.a0 << ")), "
      << a3.a2.a0.a2 << ", ((" << a3.a2.a0.a3.a0.a0 << "), " << a3.a2.a0.a3.a1
      << "), " << a3.a2.a0.a4 << ", ((" << a3.a2.a0.a5.a0.a0 << "), ("
      << a3.a2.a0.a5.a1.a0 << ")), " << a3.a2.a0.a6 << "), ((" << a3.a2.a1.a0.a0
      << ", " << a3.a2.a1.a0.a1 << "), (" << a3.a2.a1.a1.a0 << ")), "
      << a3.a2.a2 << ", " << a3.a2.a3 << "), " << a3.a3 << "))" << ")\n";
 
  f(a0, a1, a2, a3);
}

TestAsyncPassStructStruct16BytesHomogeneousFloat2x5()

DART_EXPORT void dart::TestAsyncPassStructStruct16BytesHomogeneousFloat2x5

(

void(*)(StructStruct16BytesHomogeneousFloat2 a0, StructStruct16BytesHomogeneousFloat2 a1, StructStruct16BytesHomogeneousFloat2 a2, StructStruct16BytesHomogeneousFloat2 a3, StructStruct16BytesHomogeneousFloat2 a4)

f

)

Definition at line 19513 of file ffi_test_functions_generated.cc.

                                                        {
  StructStruct16BytesHomogeneousFloat2 a0 = {};
  StructStruct16BytesHomogeneousFloat2 a1 = {};
  StructStruct16BytesHomogeneousFloat2 a2 = {};
  StructStruct16BytesHomogeneousFloat2 a3 = {};
  StructStruct16BytesHomogeneousFloat2 a4 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[1].a0 = -3.0;
  a0.a2 = 4.0;
  a1.a0.a0 = -5.0;
  a1.a1[0].a0 = 6.0;
  a1.a1[1].a0 = -7.0;
  a1.a2 = 8.0;
  a2.a0.a0 = -9.0;
  a2.a1[0].a0 = 10.0;
  a2.a1[1].a0 = -11.0;
  a2.a2 = 12.0;
  a3.a0.a0 = -13.0;
  a3.a1[0].a0 = 14.0;
  a3.a1[1].a0 = -15.0;
  a3.a2 = 16.0;
  a4.a0.a0 = -17.0;
  a4.a1[0].a0 = 18.0;
  a4.a1[1].a0 = -19.0;
  a4.a2 = 20.0;
 
  std::cout << "Calling TestAsyncPassStructStruct16BytesHomogeneousFloat2x5("
            << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), ("
            << a0.a1[1].a0 << ")], " << a0.a2 << "), ((" << a1.a0.a0 << "), [("
            << a1.a1[0].a0 << "), (" << a1.a1[1].a0 << ")], " << a1.a2
            << "), ((" << a2.a0.a0 << "), [(" << a2.a1[0].a0 << "), ("
            << a2.a1[1].a0 << ")], " << a2.a2 << "), ((" << a3.a0.a0 << "), [("
            << a3.a1[0].a0 << "), (" << a3.a1[1].a0 << ")], " << a3.a2
            << "), ((" << a4.a0.a0 << "), [(" << a4.a1[0].a0 << "), ("
            << a4.a1[1].a0 << ")], " << a4.a2 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4);
}

TestAsyncPassStructStruct16BytesMixed3x10()

DART_EXPORT void dart::TestAsyncPassStructStruct16BytesMixed3x10

(

void(*)(StructStruct16BytesMixed3 a0, StructStruct16BytesMixed3 a1, StructStruct16BytesMixed3 a2, StructStruct16BytesMixed3 a3, StructStruct16BytesMixed3 a4, StructStruct16BytesMixed3 a5, StructStruct16BytesMixed3 a6, StructStruct16BytesMixed3 a7, StructStruct16BytesMixed3 a8, StructStruct16BytesMixed3 a9)

f

)

Definition at line 19615 of file ffi_test_functions_generated.cc.

                                             {
  StructStruct16BytesMixed3 a0 = {};
  StructStruct16BytesMixed3 a1 = {};
  StructStruct16BytesMixed3 a2 = {};
  StructStruct16BytesMixed3 a3 = {};
  StructStruct16BytesMixed3 a4 = {};
  StructStruct16BytesMixed3 a5 = {};
  StructStruct16BytesMixed3 a6 = {};
  StructStruct16BytesMixed3 a7 = {};
  StructStruct16BytesMixed3 a8 = {};
  StructStruct16BytesMixed3 a9 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[0].a1 = -3;
  a0.a1[0].a2 = 4;
  a0.a2[0] = -5;
  a0.a2[1] = 6;
  a1.a0.a0 = -7.0;
  a1.a1[0].a0 = 8.0;
  a1.a1[0].a1 = -9;
  a1.a1[0].a2 = 10;
  a1.a2[0] = -11;
  a1.a2[1] = 12;
  a2.a0.a0 = -13.0;
  a2.a1[0].a0 = 14.0;
  a2.a1[0].a1 = -15;
  a2.a1[0].a2 = 16;
  a2.a2[0] = -17;
  a2.a2[1] = 18;
  a3.a0.a0 = -19.0;
  a3.a1[0].a0 = 20.0;
  a3.a1[0].a1 = -21;
  a3.a1[0].a2 = 22;
  a3.a2[0] = -23;
  a3.a2[1] = 24;
  a4.a0.a0 = -25.0;
  a4.a1[0].a0 = 26.0;
  a4.a1[0].a1 = -27;
  a4.a1[0].a2 = 28;
  a4.a2[0] = -29;
  a4.a2[1] = 30;
  a5.a0.a0 = -31.0;
  a5.a1[0].a0 = 32.0;
  a5.a1[0].a1 = -33;
  a5.a1[0].a2 = 34;
  a5.a2[0] = -35;
  a5.a2[1] = 36;
  a6.a0.a0 = -37.0;
  a6.a1[0].a0 = 38.0;
  a6.a1[0].a1 = -39;
  a6.a1[0].a2 = 40;
  a6.a2[0] = -41;
  a6.a2[1] = 42;
  a7.a0.a0 = -43.0;
  a7.a1[0].a0 = 44.0;
  a7.a1[0].a1 = -45;
  a7.a1[0].a2 = 46;
  a7.a2[0] = -47;
  a7.a2[1] = 48;
  a8.a0.a0 = -49.0;
  a8.a1[0].a0 = 50.0;
  a8.a1[0].a1 = -51;
  a8.a1[0].a2 = 52;
  a8.a2[0] = -53;
  a8.a2[1] = 54;
  a9.a0.a0 = -55.0;
  a9.a1[0].a0 = 56.0;
  a9.a1[0].a1 = -57;
  a9.a1[0].a2 = 58;
  a9.a2[0] = -59;
  a9.a2[1] = 60;
 
  std::cout << "Calling TestAsyncPassStructStruct16BytesMixed3x10(" << "((("
            << a0.a0.a0 << "), [(" << a0.a1[0].a0 << ", " << a0.a1[0].a1 << ", "
            << a0.a1[0].a2 << ")], [" << a0.a2[0] << ", " << a0.a2[1]
            << "]), ((" << a1.a0.a0 << "), [(" << a1.a1[0].a0 << ", "
            << a1.a1[0].a1 << ", " << a1.a1[0].a2 << ")], [" << a1.a2[0] << ", "
            << a1.a2[1] << "]), ((" << a2.a0.a0 << "), [(" << a2.a1[0].a0
            << ", " << a2.a1[0].a1 << ", " << a2.a1[0].a2 << ")], [" << a2.a2[0]
            << ", " << a2.a2[1] << "]), ((" << a3.a0.a0 << "), [("
            << a3.a1[0].a0 << ", " << a3.a1[0].a1 << ", " << a3.a1[0].a2
            << ")], [" << a3.a2[0] << ", " << a3.a2[1] << "]), ((" << a4.a0.a0
            << "), [(" << a4.a1[0].a0 << ", " << a4.a1[0].a1 << ", "
            << a4.a1[0].a2 << ")], [" << a4.a2[0] << ", " << a4.a2[1]
            << "]), ((" << a5.a0.a0 << "), [(" << a5.a1[0].a0 << ", "
            << a5.a1[0].a1 << ", " << a5.a1[0].a2 << ")], [" << a5.a2[0] << ", "
            << a5.a2[1] << "]), ((" << a6.a0.a0 << "), [(" << a6.a1[0].a0
            << ", " << a6.a1[0].a1 << ", " << a6.a1[0].a2 << ")], [" << a6.a2[0]
            << ", " << a6.a2[1] << "]), ((" << a7.a0.a0 << "), [("
            << a7.a1[0].a0 << ", " << a7.a1[0].a1 << ", " << a7.a1[0].a2
            << ")], [" << a7.a2[0] << ", " << a7.a2[1] << "]), ((" << a8.a0.a0
            << "), [(" << a8.a1[0].a0 << ", " << a8.a1[0].a1 << ", "
            << a8.a1[0].a2 << ")], [" << a8.a2[0] << ", " << a8.a2[1]
            << "]), ((" << a9.a0.a0 << "), [(" << a9.a1[0].a0 << ", "
            << a9.a1[0].a1 << ", " << a9.a1[0].a2 << ")], [" << a9.a2[0] << ", "
            << a9.a2[1] << "]))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassStructStruct32BytesHomogeneousDouble2x5()

DART_EXPORT void dart::TestAsyncPassStructStruct32BytesHomogeneousDouble2x5

(

void(*)(StructStruct32BytesHomogeneousDouble2 a0, StructStruct32BytesHomogeneousDouble2 a1, StructStruct32BytesHomogeneousDouble2 a2, StructStruct32BytesHomogeneousDouble2 a3, StructStruct32BytesHomogeneousDouble2 a4)

f

)

Definition at line 19563 of file ffi_test_functions_generated.cc.

                                                         {
  StructStruct32BytesHomogeneousDouble2 a0 = {};
  StructStruct32BytesHomogeneousDouble2 a1 = {};
  StructStruct32BytesHomogeneousDouble2 a2 = {};
  StructStruct32BytesHomogeneousDouble2 a3 = {};
  StructStruct32BytesHomogeneousDouble2 a4 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[1].a0 = -3.0;
  a0.a2 = 4.0;
  a1.a0.a0 = -5.0;
  a1.a1[0].a0 = 6.0;
  a1.a1[1].a0 = -7.0;
  a1.a2 = 8.0;
  a2.a0.a0 = -9.0;
  a2.a1[0].a0 = 10.0;
  a2.a1[1].a0 = -11.0;
  a2.a2 = 12.0;
  a3.a0.a0 = -13.0;
  a3.a1[0].a0 = 14.0;
  a3.a1[1].a0 = -15.0;
  a3.a2 = 16.0;
  a4.a0.a0 = -17.0;
  a4.a1[0].a0 = 18.0;
  a4.a1[1].a0 = -19.0;
  a4.a2 = 20.0;
 
  std::cout << "Calling TestAsyncPassStructStruct32BytesHomogeneousDouble2x5("
            << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), ("
            << a0.a1[1].a0 << ")], " << a0.a2 << "), ((" << a1.a0.a0 << "), [("
            << a1.a1[0].a0 << "), (" << a1.a1[1].a0 << ")], " << a1.a2
            << "), ((" << a2.a0.a0 << "), [(" << a2.a1[0].a0 << "), ("
            << a2.a1[1].a0 << ")], " << a2.a2 << "), ((" << a3.a0.a0 << "), [("
            << a3.a1[0].a0 << "), (" << a3.a1[1].a0 << ")], " << a3.a2
            << "), ((" << a4.a0.a0 << "), [(" << a4.a1[0].a0 << "), ("
            << a4.a1[1].a0 << ")], " << a4.a2 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4);
}

TestAsyncPassUint8Boolx9Struct10BytesHomogeneousBoolBool()

DART_EXPORT void dart::TestAsyncPassUint8Boolx9Struct10BytesHomogeneousBoolBool

(

void(*)(uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesHomogeneousBool a10, bool a11)

f

)

Definition at line 20514 of file ffi_test_functions_generated.cc.

                         {
  uint8_t a0;
  bool a1;
  bool a2;
  bool a3;
  bool a4;
  bool a5;
  bool a6;
  bool a7;
  bool a8;
  bool a9;
  Struct10BytesHomogeneousBool a10 = {};
  bool a11;
 
  a0 = 1;
  a1 = false;
  a2 = true;
  a3 = false;
  a4 = true;
  a5 = false;
  a6 = true;
  a7 = false;
  a8 = true;
  a9 = false;
  a10.a0 = true;
  a10.a1 = false;
  a10.a2 = true;
  a10.a3 = false;
  a10.a4 = true;
  a10.a5 = false;
  a10.a6 = true;
  a10.a7 = false;
  a10.a8 = true;
  a10.a9 = false;
  a11 = true;
 
  std::cout
      << "Calling TestAsyncPassUint8Boolx9Struct10BytesHomogeneousBoolBool("
      << "(" << static_cast<int>(a0) << ", " << a1 << ", " << a2 << ", " << a3
      << ", " << a4 << ", " << a5 << ", " << a6 << ", " << a7 << ", " << a8
      << ", " << a9 << ", (" << a10.a0 << ", " << a10.a1 << ", " << a10.a2
      << ", " << a10.a3 << ", " << a10.a4 << ", " << a10.a5 << ", " << a10.a6
      << ", " << a10.a7 << ", " << a10.a8 << ", " << a10.a9 << "), " << a11
      << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
}

TestAsyncPassUint8Boolx9Struct10BytesInlineArrayBoolBool()

DART_EXPORT void dart::TestAsyncPassUint8Boolx9Struct10BytesInlineArrayBoolBool

(

void(*)(uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesInlineArrayBool a10, bool a11)

f

)

Definition at line 20579 of file ffi_test_functions_generated.cc.

                         {
  uint8_t a0;
  bool a1;
  bool a2;
  bool a3;
  bool a4;
  bool a5;
  bool a6;
  bool a7;
  bool a8;
  bool a9;
  Struct10BytesInlineArrayBool a10 = {};
  bool a11;
 
  a0 = 1;
  a1 = false;
  a2 = true;
  a3 = false;
  a4 = true;
  a5 = false;
  a6 = true;
  a7 = false;
  a8 = true;
  a9 = false;
  a10.a0[0] = true;
  a10.a0[1] = false;
  a10.a0[2] = true;
  a10.a0[3] = false;
  a10.a0[4] = true;
  a10.a0[5] = false;
  a10.a0[6] = true;
  a10.a0[7] = false;
  a10.a0[8] = true;
  a10.a0[9] = false;
  a11 = true;
 
  std::cout
      << "Calling TestAsyncPassUint8Boolx9Struct10BytesInlineArrayBoolBool("
      << "(" << static_cast<int>(a0) << ", " << a1 << ", " << a2 << ", " << a3
      << ", " << a4 << ", " << a5 << ", " << a6 << ", " << a7 << ", " << a8
      << ", " << a9 << ", ([" << a10.a0[0] << ", " << a10.a0[1] << ", "
      << a10.a0[2] << ", " << a10.a0[3] << ", " << a10.a0[4] << ", "
      << a10.a0[5] << ", " << a10.a0[6] << ", " << a10.a0[7] << ", "
      << a10.a0[8] << ", " << a10.a0[9] << "]), " << a11 << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
}

TestAsyncPassUint8Struct1ByteBool()

DART_EXPORT void dart::TestAsyncPassUint8Struct1ByteBool

(

void(*)(uint8_t a0, Struct1ByteBool a1)

f

)

Definition at line 20642 of file ffi_test_functions_generated.cc.

                                               {
  uint8_t a0;
  Struct1ByteBool a1 = {};
 
  a0 = 1;
  a1.a0 = false;
 
  std::cout << "Calling TestAsyncPassUint8Struct1ByteBool(" << "("
            << static_cast<int>(a0) << ", (" << a1.a0 << "))" << ")\n";
 
  f(a0, a1);
}

TestAsyncPassUint8Struct32BytesInlineArrayMultiDimensionalI()

DART_EXPORT void dart::TestAsyncPassUint8Struct32BytesInlineArrayMultiDimensionalI

(

void(*)(uint8_t a0, Struct32BytesInlineArrayMultiDimensionalInt a1, uint8_t a2, Struct8BytesInlineArrayMultiDimensionalInt a3, uint8_t a4, Struct8BytesInlineArrayMultiDimensionalInt a5, uint8_t a6)

f

)

Definition at line 19729 of file ffi_test_functions_generated.cc.

                           {
  uint8_t a0;
  Struct32BytesInlineArrayMultiDimensionalInt a1 = {};
  uint8_t a2;
  Struct8BytesInlineArrayMultiDimensionalInt a3 = {};
  uint8_t a4;
  Struct8BytesInlineArrayMultiDimensionalInt a5 = {};
  uint8_t a6;
 
  a0 = 1;
  a1.a0[0][0][0][0][0] = 2;
  a1.a0[0][0][0][0][1] = 3;
  a1.a0[0][0][0][1][0] = 4;
  a1.a0[0][0][0][1][1] = 5;
  a1.a0[0][0][1][0][0] = 6;
  a1.a0[0][0][1][0][1] = 7;
  a1.a0[0][0][1][1][0] = 8;
  a1.a0[0][0][1][1][1] = 9;
  a1.a0[0][1][0][0][0] = 10;
  a1.a0[0][1][0][0][1] = 11;
  a1.a0[0][1][0][1][0] = 12;
  a1.a0[0][1][0][1][1] = 13;
  a1.a0[0][1][1][0][0] = 14;
  a1.a0[0][1][1][0][1] = 15;
  a1.a0[0][1][1][1][0] = 16;
  a1.a0[0][1][1][1][1] = 17;
  a1.a0[1][0][0][0][0] = 18;
  a1.a0[1][0][0][0][1] = 19;
  a1.a0[1][0][0][1][0] = 20;
  a1.a0[1][0][0][1][1] = 21;
  a1.a0[1][0][1][0][0] = 22;
  a1.a0[1][0][1][0][1] = 23;
  a1.a0[1][0][1][1][0] = 24;
  a1.a0[1][0][1][1][1] = 25;
  a1.a0[1][1][0][0][0] = 26;
  a1.a0[1][1][0][0][1] = 27;
  a1.a0[1][1][0][1][0] = 28;
  a1.a0[1][1][0][1][1] = 29;
  a1.a0[1][1][1][0][0] = 30;
  a1.a0[1][1][1][0][1] = 31;
  a1.a0[1][1][1][1][0] = 32;
  a1.a0[1][1][1][1][1] = 33;
  a2 = 34;
  a3.a0[0][0][0] = 35;
  a3.a0[0][0][1] = 36;
  a3.a0[0][1][0] = 37;
  a3.a0[0][1][1] = 38;
  a3.a0[1][0][0] = 39;
  a3.a0[1][0][1] = 40;
  a3.a0[1][1][0] = 41;
  a3.a0[1][1][1] = 42;
  a4 = 43;
  a5.a0[0][0][0] = 44;
  a5.a0[0][0][1] = 45;
  a5.a0[0][1][0] = 46;
  a5.a0[0][1][1] = 47;
  a5.a0[1][0][0] = 48;
  a5.a0[1][0][1] = 49;
  a5.a0[1][1][0] = 50;
  a5.a0[1][1][1] = 51;
  a6 = 52;
 
  std::cout
      << "Calling TestAsyncPassUint8Struct32BytesInlineArrayMultiDimensionalI("
      << "(" << static_cast<int>(a0) << ", ([[[[["
      << static_cast<int>(a1.a0[0][0][0][0][0]) << ", "
      << static_cast<int>(a1.a0[0][0][0][0][1]) << "], ["
      << static_cast<int>(a1.a0[0][0][0][1][0]) << ", "
      << static_cast<int>(a1.a0[0][0][0][1][1]) << "]], [["
      << static_cast<int>(a1.a0[0][0][1][0][0]) << ", "
      << static_cast<int>(a1.a0[0][0][1][0][1]) << "], ["
      << static_cast<int>(a1.a0[0][0][1][1][0]) << ", "
      << static_cast<int>(a1.a0[0][0][1][1][1]) << "]]], [[["
      << static_cast<int>(a1.a0[0][1][0][0][0]) << ", "
      << static_cast<int>(a1.a0[0][1][0][0][1]) << "], ["
      << static_cast<int>(a1.a0[0][1][0][1][0]) << ", "
      << static_cast<int>(a1.a0[0][1][0][1][1]) << "]], [["
      << static_cast<int>(a1.a0[0][1][1][0][0]) << ", "
      << static_cast<int>(a1.a0[0][1][1][0][1]) << "], ["
      << static_cast<int>(a1.a0[0][1][1][1][0]) << ", "
      << static_cast<int>(a1.a0[0][1][1][1][1]) << "]]]], [[[["
      << static_cast<int>(a1.a0[1][0][0][0][0]) << ", "
      << static_cast<int>(a1.a0[1][0][0][0][1]) << "], ["
      << static_cast<int>(a1.a0[1][0][0][1][0]) << ", "
      << static_cast<int>(a1.a0[1][0][0][1][1]) << "]], [["
      << static_cast<int>(a1.a0[1][0][1][0][0]) << ", "
      << static_cast<int>(a1.a0[1][0][1][0][1]) << "], ["
      << static_cast<int>(a1.a0[1][0][1][1][0]) << ", "
      << static_cast<int>(a1.a0[1][0][1][1][1]) << "]]], [[["
      << static_cast<int>(a1.a0[1][1][0][0][0]) << ", "
      << static_cast<int>(a1.a0[1][1][0][0][1]) << "], ["
      << static_cast<int>(a1.a0[1][1][0][1][0]) << ", "
      << static_cast<int>(a1.a0[1][1][0][1][1]) << "]], [["
      << static_cast<int>(a1.a0[1][1][1][0][0]) << ", "
      << static_cast<int>(a1.a0[1][1][1][0][1]) << "], ["
      << static_cast<int>(a1.a0[1][1][1][1][0]) << ", "
      << static_cast<int>(a1.a0[1][1][1][1][1]) << "]]]]]), "
      << static_cast<int>(a2) << ", ([[[" << static_cast<int>(a3.a0[0][0][0])
      << ", " << static_cast<int>(a3.a0[0][0][1]) << "], ["
      << static_cast<int>(a3.a0[0][1][0]) << ", "
      << static_cast<int>(a3.a0[0][1][1]) << "]], [["
      << static_cast<int>(a3.a0[1][0][0]) << ", "
      << static_cast<int>(a3.a0[1][0][1]) << "], ["
      << static_cast<int>(a3.a0[1][1][0]) << ", "
      << static_cast<int>(a3.a0[1][1][1]) << "]]]), " << static_cast<int>(a4)
      << ", ([[[" << static_cast<int>(a5.a0[0][0][0]) << ", "
      << static_cast<int>(a5.a0[0][0][1]) << "], ["
      << static_cast<int>(a5.a0[0][1][0]) << ", "
      << static_cast<int>(a5.a0[0][1][1]) << "]], [["
      << static_cast<int>(a5.a0[1][0][0]) << ", "
      << static_cast<int>(a5.a0[1][0][1]) << "], ["
      << static_cast<int>(a5.a0[1][1][0]) << ", "
      << static_cast<int>(a5.a0[1][1][1]) << "]]]), " << static_cast<int>(a6)
      << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6);
}

TestAsyncPassUint8Struct4BytesInlineArrayMultiDimensionalIn()

DART_EXPORT void dart::TestAsyncPassUint8Struct4BytesInlineArrayMultiDimensionalIn

(

void(*)(uint8_t a0, Struct4BytesInlineArrayMultiDimensionalInt a1, uint8_t a2)

f

)

Definition at line 19857 of file ffi_test_functions_generated.cc.

                           {
  uint8_t a0;
  Struct4BytesInlineArrayMultiDimensionalInt a1 = {};
  uint8_t a2;
 
  a0 = 1;
  a1.a0[0][0].a0 = 2;
  a1.a0[0][1].a0 = -3;
  a1.a0[1][0].a0 = 4;
  a1.a0[1][1].a0 = -5;
  a2 = 6;
 
  std::cout
      << "Calling TestAsyncPassUint8Struct4BytesInlineArrayMultiDimensionalIn("
      << "(" << static_cast<int>(a0) << ", ([[("
      << static_cast<int>(a1.a0[0][0].a0) << "), ("
      << static_cast<int>(a1.a0[0][1].a0) << ")], [("
      << static_cast<int>(a1.a0[1][0].a0) << "), ("
      << static_cast<int>(a1.a0[1][1].a0) << ")]]), " << static_cast<int>(a2)
      << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncPassUnion16BytesNestedFloatx10()

DART_EXPORT void dart::TestAsyncPassUnion16BytesNestedFloatx10

(

void(*)(Union16BytesNestedFloat a0, Union16BytesNestedFloat a1, Union16BytesNestedFloat a2, Union16BytesNestedFloat a3, Union16BytesNestedFloat a4, Union16BytesNestedFloat a5, Union16BytesNestedFloat a6, Union16BytesNestedFloat a7, Union16BytesNestedFloat a8, Union16BytesNestedFloat a9)

f

)

Definition at line 20454 of file ffi_test_functions_generated.cc.

                                           {
  Union16BytesNestedFloat a0 = {};
  Union16BytesNestedFloat a1 = {};
  Union16BytesNestedFloat a2 = {};
  Union16BytesNestedFloat a3 = {};
  Union16BytesNestedFloat a4 = {};
  Union16BytesNestedFloat a5 = {};
  Union16BytesNestedFloat a6 = {};
  Union16BytesNestedFloat a7 = {};
  Union16BytesNestedFloat a8 = {};
  Union16BytesNestedFloat a9 = {};
 
  a0.a0.a0 = -1.0;
  a0.a0.a1 = 2.0;
  a1.a0.a0 = -3.0;
  a1.a0.a1 = 4.0;
  a2.a0.a0 = -5.0;
  a2.a0.a1 = 6.0;
  a3.a0.a0 = -7.0;
  a3.a0.a1 = 8.0;
  a4.a0.a0 = -9.0;
  a4.a0.a1 = 10.0;
  a5.a0.a0 = -11.0;
  a5.a0.a1 = 12.0;
  a6.a0.a0 = -13.0;
  a6.a0.a1 = 14.0;
  a7.a0.a0 = -15.0;
  a7.a0.a1 = 16.0;
  a8.a0.a0 = -17.0;
  a8.a0.a1 = 18.0;
  a9.a0.a0 = -19.0;
  a9.a0.a1 = 20.0;
 
  std::cout << "Calling TestAsyncPassUnion16BytesNestedFloatx10(" << "((("
            << a0.a0.a0 << ", " << a0.a0.a1 << ")), ((" << a1.a0.a0 << ", "
            << a1.a0.a1 << ")), ((" << a2.a0.a0 << ", " << a2.a0.a1 << ")), (("
            << a3.a0.a0 << ", " << a3.a0.a1 << ")), ((" << a4.a0.a0 << ", "
            << a4.a0.a1 << ")), ((" << a5.a0.a0 << ", " << a5.a0.a1 << ")), (("
            << a6.a0.a0 << ", " << a6.a0.a1 << ")), ((" << a7.a0.a0 << ", "
            << a7.a0.a1 << ")), ((" << a8.a0.a0 << ", " << a8.a0.a1 << ")), (("
            << a9.a0.a0 << ", " << a9.a0.a1 << ")))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassUnion16BytesNestedInlineArrayFloatx10()

DART_EXPORT void dart::TestAsyncPassUnion16BytesNestedInlineArrayFloatx10

(

void(*)(Union16BytesNestedInlineArrayFloat a0, Union16BytesNestedInlineArrayFloat a1, Union16BytesNestedInlineArrayFloat a2, Union16BytesNestedInlineArrayFloat a3, Union16BytesNestedInlineArrayFloat a4, Union16BytesNestedInlineArrayFloat a5, Union16BytesNestedInlineArrayFloat a6, Union16BytesNestedInlineArrayFloat a7, Union16BytesNestedInlineArrayFloat a8, Union16BytesNestedInlineArrayFloat a9)

f

)

Definition at line 20369 of file ffi_test_functions_generated.cc.

                                                      {
  Union16BytesNestedInlineArrayFloat a0 = {};
  Union16BytesNestedInlineArrayFloat a1 = {};
  Union16BytesNestedInlineArrayFloat a2 = {};
  Union16BytesNestedInlineArrayFloat a3 = {};
  Union16BytesNestedInlineArrayFloat a4 = {};
  Union16BytesNestedInlineArrayFloat a5 = {};
  Union16BytesNestedInlineArrayFloat a6 = {};
  Union16BytesNestedInlineArrayFloat a7 = {};
  Union16BytesNestedInlineArrayFloat a8 = {};
  Union16BytesNestedInlineArrayFloat a9 = {};
 
  a0.a0[0] = -1.0;
  a0.a0[1] = 2.0;
  a0.a0[2] = -3.0;
  a0.a0[3] = 4.0;
  a1.a0[0] = -5.0;
  a1.a0[1] = 6.0;
  a1.a0[2] = -7.0;
  a1.a0[3] = 8.0;
  a2.a0[0] = -9.0;
  a2.a0[1] = 10.0;
  a2.a0[2] = -11.0;
  a2.a0[3] = 12.0;
  a3.a0[0] = -13.0;
  a3.a0[1] = 14.0;
  a3.a0[2] = -15.0;
  a3.a0[3] = 16.0;
  a4.a0[0] = -17.0;
  a4.a0[1] = 18.0;
  a4.a0[2] = -19.0;
  a4.a0[3] = 20.0;
  a5.a0[0] = -21.0;
  a5.a0[1] = 22.0;
  a5.a0[2] = -23.0;
  a5.a0[3] = 24.0;
  a6.a0[0] = -25.0;
  a6.a0[1] = 26.0;
  a6.a0[2] = -27.0;
  a6.a0[3] = 28.0;
  a7.a0[0] = -29.0;
  a7.a0[1] = 30.0;
  a7.a0[2] = -31.0;
  a7.a0[3] = 32.0;
  a8.a0[0] = -33.0;
  a8.a0[1] = 34.0;
  a8.a0[2] = -35.0;
  a8.a0[3] = 36.0;
  a9.a0[0] = -37.0;
  a9.a0[1] = 38.0;
  a9.a0[2] = -39.0;
  a9.a0[3] = 40.0;
 
  std::cout << "Calling TestAsyncPassUnion16BytesNestedInlineArrayFloatx10("
            << "(([" << a0.a0[0] << ", " << a0.a0[1] << ", " << a0.a0[2] << ", "
            << a0.a0[3] << "]), ([" << a1.a0[0] << ", " << a1.a0[1] << ", "
            << a1.a0[2] << ", " << a1.a0[3] << "]), ([" << a2.a0[0] << ", "
            << a2.a0[1] << ", " << a2.a0[2] << ", " << a2.a0[3] << "]), (["
            << a3.a0[0] << ", " << a3.a0[1] << ", " << a3.a0[2] << ", "
            << a3.a0[3] << "]), ([" << a4.a0[0] << ", " << a4.a0[1] << ", "
            << a4.a0[2] << ", " << a4.a0[3] << "]), ([" << a5.a0[0] << ", "
            << a5.a0[1] << ", " << a5.a0[2] << ", " << a5.a0[3] << "]), (["
            << a6.a0[0] << ", " << a6.a0[1] << ", " << a6.a0[2] << ", "
            << a6.a0[3] << "]), ([" << a7.a0[0] << ", " << a7.a0[1] << ", "
            << a7.a0[2] << ", " << a7.a0[3] << "]), ([" << a8.a0[0] << ", "
            << a8.a0[1] << ", " << a8.a0[2] << ", " << a8.a0[3] << "]), (["
            << a9.a0[0] << ", " << a9.a0[1] << ", " << a9.a0[2] << ", "
            << a9.a0[3] << "]))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassUnion4BytesMixedx10()

DART_EXPORT void dart::TestAsyncPassUnion4BytesMixedx10

(

void(*)(Union4BytesMixed a0, Union4BytesMixed a1, Union4BytesMixed a2, Union4BytesMixed a3, Union4BytesMixed a4, Union4BytesMixed a5, Union4BytesMixed a6, Union4BytesMixed a7, Union4BytesMixed a8, Union4BytesMixed a9)

f

)

Definition at line 20209 of file ffi_test_functions_generated.cc.

                                    {
  Union4BytesMixed a0 = {};
  Union4BytesMixed a1 = {};
  Union4BytesMixed a2 = {};
  Union4BytesMixed a3 = {};
  Union4BytesMixed a4 = {};
  Union4BytesMixed a5 = {};
  Union4BytesMixed a6 = {};
  Union4BytesMixed a7 = {};
  Union4BytesMixed a8 = {};
  Union4BytesMixed a9 = {};
 
  a0.a0 = 1;
  a1.a0 = 2;
  a2.a0 = 3;
  a3.a0 = 4;
  a4.a0 = 5;
  a5.a0 = 6;
  a6.a0 = 7;
  a7.a0 = 8;
  a8.a0 = 9;
  a9.a0 = 10;
 
  std::cout << "Calling TestAsyncPassUnion4BytesMixedx10(" << "((" << a0.a0
            << "), (" << a1.a0 << "), (" << a2.a0 << "), (" << a3.a0 << "), ("
            << a4.a0 << "), (" << a5.a0 << "), (" << a6.a0 << "), (" << a7.a0
            << "), (" << a8.a0 << "), (" << a9.a0 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassUnion8BytesNestedFloatx10()

DART_EXPORT void dart::TestAsyncPassUnion8BytesNestedFloatx10

(

void(*)(Union8BytesNestedFloat a0, Union8BytesNestedFloat a1, Union8BytesNestedFloat a2, Union8BytesNestedFloat a3, Union8BytesNestedFloat a4, Union8BytesNestedFloat a5, Union8BytesNestedFloat a6, Union8BytesNestedFloat a7, Union8BytesNestedFloat a8, Union8BytesNestedFloat a9)

f

)

Definition at line 20253 of file ffi_test_functions_generated.cc.

                                          {
  Union8BytesNestedFloat a0 = {};
  Union8BytesNestedFloat a1 = {};
  Union8BytesNestedFloat a2 = {};
  Union8BytesNestedFloat a3 = {};
  Union8BytesNestedFloat a4 = {};
  Union8BytesNestedFloat a5 = {};
  Union8BytesNestedFloat a6 = {};
  Union8BytesNestedFloat a7 = {};
  Union8BytesNestedFloat a8 = {};
  Union8BytesNestedFloat a9 = {};
 
  a0.a0 = -1.0;
  a1.a0 = 2.0;
  a2.a0 = -3.0;
  a3.a0 = 4.0;
  a4.a0 = -5.0;
  a5.a0 = 6.0;
  a6.a0 = -7.0;
  a7.a0 = 8.0;
  a8.a0 = -9.0;
  a9.a0 = 10.0;
 
  std::cout << "Calling TestAsyncPassUnion8BytesNestedFloatx10(" << "(("
            << a0.a0 << "), (" << a1.a0 << "), (" << a2.a0 << "), (" << a3.a0
            << "), (" << a4.a0 << "), (" << a5.a0 << "), (" << a6.a0 << "), ("
            << a7.a0 << "), (" << a8.a0 << "), (" << a9.a0 << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassUnion9BytesNestedIntx10()

DART_EXPORT void dart::TestAsyncPassUnion9BytesNestedIntx10

(

void(*)(Union9BytesNestedInt a0, Union9BytesNestedInt a1, Union9BytesNestedInt a2, Union9BytesNestedInt a3, Union9BytesNestedInt a4, Union9BytesNestedInt a5, Union9BytesNestedInt a6, Union9BytesNestedInt a7, Union9BytesNestedInt a8, Union9BytesNestedInt a9)

f

)

Definition at line 20297 of file ffi_test_functions_generated.cc.

                                        {
  Union9BytesNestedInt a0 = {};
  Union9BytesNestedInt a1 = {};
  Union9BytesNestedInt a2 = {};
  Union9BytesNestedInt a3 = {};
  Union9BytesNestedInt a4 = {};
  Union9BytesNestedInt a5 = {};
  Union9BytesNestedInt a6 = {};
  Union9BytesNestedInt a7 = {};
  Union9BytesNestedInt a8 = {};
  Union9BytesNestedInt a9 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a0.a2 = -3;
  a1.a0.a0 = 4;
  a1.a0.a1 = -5;
  a1.a0.a2 = 6;
  a2.a0.a0 = -7;
  a2.a0.a1 = 8;
  a2.a0.a2 = -9;
  a3.a0.a0 = 10;
  a3.a0.a1 = -11;
  a3.a0.a2 = 12;
  a4.a0.a0 = -13;
  a4.a0.a1 = 14;
  a4.a0.a2 = -15;
  a5.a0.a0 = 16;
  a5.a0.a1 = -17;
  a5.a0.a2 = 18;
  a6.a0.a0 = -19;
  a6.a0.a1 = 20;
  a6.a0.a2 = -21;
  a7.a0.a0 = 22;
  a7.a0.a1 = -23;
  a7.a0.a2 = 24;
  a8.a0.a0 = -25;
  a8.a0.a1 = 26;
  a8.a0.a2 = -27;
  a9.a0.a0 = 28;
  a9.a0.a1 = -29;
  a9.a0.a2 = 30;
 
  std::cout << "Calling TestAsyncPassUnion9BytesNestedIntx10(" << "((("
            << a0.a0.a0 << ", " << a0.a0.a1 << ", " << a0.a0.a2 << ")), (("
            << a1.a0.a0 << ", " << a1.a0.a1 << ", " << a1.a0.a2 << ")), (("
            << a2.a0.a0 << ", " << a2.a0.a1 << ", " << a2.a0.a2 << ")), (("
            << a3.a0.a0 << ", " << a3.a0.a1 << ", " << a3.a0.a2 << ")), (("
            << a4.a0.a0 << ", " << a4.a0.a1 << ", " << a4.a0.a2 << ")), (("
            << a5.a0.a0 << ", " << a5.a0.a1 << ", " << a5.a0.a2 << ")), (("
            << a6.a0.a0 << ", " << a6.a0.a1 << ", " << a6.a0.a2 << ")), (("
            << a7.a0.a0 << ", " << a7.a0.a1 << ", " << a7.a0.a2 << ")), (("
            << a8.a0.a0 << ", " << a8.a0.a1 << ", " << a8.a0.a2 << ")), (("
            << a9.a0.a0 << ", " << a9.a0.a1 << ", " << a9.a0.a2 << ")))"
            << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
}

TestAsyncPassWCharStructInlineArrayIntUintPtrx2LongUnsigned()

DART_EXPORT void dart::TestAsyncPassWCharStructInlineArrayIntUintPtrx2LongUnsigned

(

void(*)(wchar_t a0, StructInlineArrayInt a1, uintptr_t a2, uintptr_t a3, long a4, unsigned long a5)

f

)

Definition at line 20659 of file ffi_test_functions_generated.cc.

                                   {
  wchar_t a0;
  StructInlineArrayInt a1 = {};
  uintptr_t a2;
  uintptr_t a3;
  /* NOLINT(runtime/int) */ long a4;
  /* NOLINT(runtime/int) */ unsigned long a5;
 
  a0 = 1;
  a1.a0[0] = 2;
  a1.a0[1] = 3;
  a1.a0[2] = 4;
  a1.a0[3] = 5;
  a1.a0[4] = 6;
  a1.a0[5] = 7;
  a1.a0[6] = 8;
  a1.a0[7] = 9;
  a1.a0[8] = 10;
  a1.a0[9] = 11;
  a2 = 12;
  a3 = 13;
  a4 = 14;
  a5 = 15;
 
  std::cout
      << "Calling TestAsyncPassWCharStructInlineArrayIntUintPtrx2LongUnsigned("
      << "(" << a0 << ", ([" << a1.a0[0] << ", " << a1.a0[1] << ", " << a1.a0[2]
      << ", " << a1.a0[3] << ", " << a1.a0[4] << ", " << a1.a0[5] << ", "
      << a1.a0[6] << ", " << a1.a0[7] << ", " << a1.a0[8] << ", " << a1.a0[9]
      << "]), " << a2 << ", " << a3 << ", " << a4 << ", " << a5 << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5);
}

TestAsyncReturnStruct1024BytesHomogeneousUint64()

DART_EXPORT void dart::TestAsyncReturnStruct1024BytesHomogeneousUint64

(

void(*)(uint64_t a0, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6, uint64_t a7, uint64_t a8, uint64_t a9, uint64_t a10, uint64_t a11, uint64_t a12, uint64_t a13, uint64_t a14, uint64_t a15, uint64_t a16, uint64_t a17, uint64_t a18, uint64_t a19, uint64_t a20, uint64_t a21, uint64_t a22, uint64_t a23, uint64_t a24, uint64_t a25, uint64_t a26, uint64_t a27, uint64_t a28, uint64_t a29, uint64_t a30, uint64_t a31, uint64_t a32, uint64_t a33, uint64_t a34, uint64_t a35, uint64_t a36, uint64_t a37, uint64_t a38, uint64_t a39, uint64_t a40, uint64_t a41, uint64_t a42, uint64_t a43, uint64_t a44, uint64_t a45, uint64_t a46, uint64_t a47, uint64_t a48, uint64_t a49, uint64_t a50, uint64_t a51, uint64_t a52, uint64_t a53, uint64_t a54, uint64_t a55, uint64_t a56, uint64_t a57, uint64_t a58, uint64_t a59, uint64_t a60, uint64_t a61, uint64_t a62, uint64_t a63, uint64_t a64, uint64_t a65, uint64_t a66, uint64_t a67, uint64_t a68, uint64_t a69, uint64_t a70, uint64_t a71, uint64_t a72, uint64_t a73, uint64_t a74, uint64_t a75, uint64_t a76, uint64_t a77, uint64_t a78, uint64_t a79, uint64_t a80, uint64_t a81, uint64_t a82, uint64_t a83, uint64_t a84, uint64_t a85, uint64_t a86, uint64_t a87, uint64_t a88, uint64_t a89, uint64_t a90, uint64_t a91, uint64_t a92, uint64_t a93, uint64_t a94, uint64_t a95, uint64_t a96, uint64_t a97, uint64_t a98, uint64_t a99, uint64_t a100, uint64_t a101, uint64_t a102, uint64_t a103, uint64_t a104, uint64_t a105, uint64_t a106, uint64_t a107, uint64_t a108, uint64_t a109, uint64_t a110, uint64_t a111, uint64_t a112, uint64_t a113, uint64_t a114, uint64_t a115, uint64_t a116, uint64_t a117, uint64_t a118, uint64_t a119, uint64_t a120, uint64_t a121, uint64_t a122, uint64_t a123, uint64_t a124, uint64_t a125, uint64_t a126, uint64_t a127)

f

)

Definition at line 21261 of file ffi_test_functions_generated.cc.

                              {
  uint64_t a0;
  uint64_t a1;
  uint64_t a2;
  uint64_t a3;
  uint64_t a4;
  uint64_t a5;
  uint64_t a6;
  uint64_t a7;
  uint64_t a8;
  uint64_t a9;
  uint64_t a10;
  uint64_t a11;
  uint64_t a12;
  uint64_t a13;
  uint64_t a14;
  uint64_t a15;
  uint64_t a16;
  uint64_t a17;
  uint64_t a18;
  uint64_t a19;
  uint64_t a20;
  uint64_t a21;
  uint64_t a22;
  uint64_t a23;
  uint64_t a24;
  uint64_t a25;
  uint64_t a26;
  uint64_t a27;
  uint64_t a28;
  uint64_t a29;
  uint64_t a30;
  uint64_t a31;
  uint64_t a32;
  uint64_t a33;
  uint64_t a34;
  uint64_t a35;
  uint64_t a36;
  uint64_t a37;
  uint64_t a38;
  uint64_t a39;
  uint64_t a40;
  uint64_t a41;
  uint64_t a42;
  uint64_t a43;
  uint64_t a44;
  uint64_t a45;
  uint64_t a46;
  uint64_t a47;
  uint64_t a48;
  uint64_t a49;
  uint64_t a50;
  uint64_t a51;
  uint64_t a52;
  uint64_t a53;
  uint64_t a54;
  uint64_t a55;
  uint64_t a56;
  uint64_t a57;
  uint64_t a58;
  uint64_t a59;
  uint64_t a60;
  uint64_t a61;
  uint64_t a62;
  uint64_t a63;
  uint64_t a64;
  uint64_t a65;
  uint64_t a66;
  uint64_t a67;
  uint64_t a68;
  uint64_t a69;
  uint64_t a70;
  uint64_t a71;
  uint64_t a72;
  uint64_t a73;
  uint64_t a74;
  uint64_t a75;
  uint64_t a76;
  uint64_t a77;
  uint64_t a78;
  uint64_t a79;
  uint64_t a80;
  uint64_t a81;
  uint64_t a82;
  uint64_t a83;
  uint64_t a84;
  uint64_t a85;
  uint64_t a86;
  uint64_t a87;
  uint64_t a88;
  uint64_t a89;
  uint64_t a90;
  uint64_t a91;
  uint64_t a92;
  uint64_t a93;
  uint64_t a94;
  uint64_t a95;
  uint64_t a96;
  uint64_t a97;
  uint64_t a98;
  uint64_t a99;
  uint64_t a100;
  uint64_t a101;
  uint64_t a102;
  uint64_t a103;
  uint64_t a104;
  uint64_t a105;
  uint64_t a106;
  uint64_t a107;
  uint64_t a108;
  uint64_t a109;
  uint64_t a110;
  uint64_t a111;
  uint64_t a112;
  uint64_t a113;
  uint64_t a114;
  uint64_t a115;
  uint64_t a116;
  uint64_t a117;
  uint64_t a118;
  uint64_t a119;
  uint64_t a120;
  uint64_t a121;
  uint64_t a122;
  uint64_t a123;
  uint64_t a124;
  uint64_t a125;
  uint64_t a126;
  uint64_t a127;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;
  a9 = 10;
  a10 = 11;
  a11 = 12;
  a12 = 13;
  a13 = 14;
  a14 = 15;
  a15 = 16;
  a16 = 17;
  a17 = 18;
  a18 = 19;
  a19 = 20;
  a20 = 21;
  a21 = 22;
  a22 = 23;
  a23 = 24;
  a24 = 25;
  a25 = 26;
  a26 = 27;
  a27 = 28;
  a28 = 29;
  a29 = 30;
  a30 = 31;
  a31 = 32;
  a32 = 33;
  a33 = 34;
  a34 = 35;
  a35 = 36;
  a36 = 37;
  a37 = 38;
  a38 = 39;
  a39 = 40;
  a40 = 41;
  a41 = 42;
  a42 = 43;
  a43 = 44;
  a44 = 45;
  a45 = 46;
  a46 = 47;
  a47 = 48;
  a48 = 49;
  a49 = 50;
  a50 = 51;
  a51 = 52;
  a52 = 53;
  a53 = 54;
  a54 = 55;
  a55 = 56;
  a56 = 57;
  a57 = 58;
  a58 = 59;
  a59 = 60;
  a60 = 61;
  a61 = 62;
  a62 = 63;
  a63 = 64;
  a64 = 65;
  a65 = 66;
  a66 = 67;
  a67 = 68;
  a68 = 69;
  a69 = 70;
  a70 = 71;
  a71 = 72;
  a72 = 73;
  a73 = 74;
  a74 = 75;
  a75 = 76;
  a76 = 77;
  a77 = 78;
  a78 = 79;
  a79 = 80;
  a80 = 81;
  a81 = 82;
  a82 = 83;
  a83 = 84;
  a84 = 85;
  a85 = 86;
  a86 = 87;
  a87 = 88;
  a88 = 89;
  a89 = 90;
  a90 = 91;
  a91 = 92;
  a92 = 93;
  a93 = 94;
  a94 = 95;
  a95 = 96;
  a96 = 97;
  a97 = 98;
  a98 = 99;
  a99 = 100;
  a100 = 101;
  a101 = 102;
  a102 = 103;
  a103 = 104;
  a104 = 105;
  a105 = 106;
  a106 = 107;
  a107 = 108;
  a108 = 109;
  a109 = 110;
  a110 = 111;
  a111 = 112;
  a112 = 113;
  a113 = 114;
  a114 = 115;
  a115 = 116;
  a116 = 117;
  a117 = 118;
  a118 = 119;
  a119 = 120;
  a120 = 121;
  a121 = 122;
  a122 = 123;
  a123 = 124;
  a124 = 125;
  a125 = 126;
  a126 = 127;
  a127 = 128;
 
  std::cout << "Calling TestAsyncReturnStruct1024BytesHomogeneousUint64(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", " << a7 << ", " << a8 << ", "
            << a9 << ", " << a10 << ", " << a11 << ", " << a12 << ", " << a13
            << ", " << a14 << ", " << a15 << ", " << a16 << ", " << a17 << ", "
            << a18 << ", " << a19 << ", " << a20 << ", " << a21 << ", " << a22
            << ", " << a23 << ", " << a24 << ", " << a25 << ", " << a26 << ", "
            << a27 << ", " << a28 << ", " << a29 << ", " << a30 << ", " << a31
            << ", " << a32 << ", " << a33 << ", " << a34 << ", " << a35 << ", "
            << a36 << ", " << a37 << ", " << a38 << ", " << a39 << ", " << a40
            << ", " << a41 << ", " << a42 << ", " << a43 << ", " << a44 << ", "
            << a45 << ", " << a46 << ", " << a47 << ", " << a48 << ", " << a49
            << ", " << a50 << ", " << a51 << ", " << a52 << ", " << a53 << ", "
            << a54 << ", " << a55 << ", " << a56 << ", " << a57 << ", " << a58
            << ", " << a59 << ", " << a60 << ", " << a61 << ", " << a62 << ", "
            << a63 << ", " << a64 << ", " << a65 << ", " << a66 << ", " << a67
            << ", " << a68 << ", " << a69 << ", " << a70 << ", " << a71 << ", "
            << a72 << ", " << a73 << ", " << a74 << ", " << a75 << ", " << a76
            << ", " << a77 << ", " << a78 << ", " << a79 << ", " << a80 << ", "
            << a81 << ", " << a82 << ", " << a83 << ", " << a84 << ", " << a85
            << ", " << a86 << ", " << a87 << ", " << a88 << ", " << a89 << ", "
            << a90 << ", " << a91 << ", " << a92 << ", " << a93 << ", " << a94
            << ", " << a95 << ", " << a96 << ", " << a97 << ", " << a98 << ", "
            << a99 << ", " << a100 << ", " << a101 << ", " << a102 << ", "
            << a103 << ", " << a104 << ", " << a105 << ", " << a106 << ", "
            << a107 << ", " << a108 << ", " << a109 << ", " << a110 << ", "
            << a111 << ", " << a112 << ", " << a113 << ", " << a114 << ", "
            << a115 << ", " << a116 << ", " << a117 << ", " << a118 << ", "
            << a119 << ", " << a120 << ", " << a121 << ", " << a122 << ", "
            << a123 << ", " << a124 << ", " << a125 << ", " << a126 << ", "
            << a127 << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16,
    a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31,
    a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46,
    a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61,
    a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, a72, a73, a74, a75, a76,
    a77, a78, a79, a80, a81, a82, a83, a84, a85, a86, a87, a88, a89, a90, a91,
    a92, a93, a94, a95, a96, a97, a98, a99, a100, a101, a102, a103, a104, a105,
    a106, a107, a108, a109, a110, a111, a112, a113, a114, a115, a116, a117,
    a118, a119, a120, a121, a122, a123, a124, a125, a126, a127);
}

TestAsyncReturnStruct12BytesHomogeneousFloat()

DART_EXPORT void dart::TestAsyncReturnStruct12BytesHomogeneousFloat

(

void(*)(float a0, float a1, float a2)

f

)

Definition at line 20987 of file ffi_test_functions_generated.cc.

                                             {
  float a0;
  float a1;
  float a2;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
 
  std::cout << "Calling TestAsyncReturnStruct12BytesHomogeneousFloat(" << "("
            << a0 << ", " << a1 << ", " << a2 << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStruct16BytesHomogeneousFloat()

DART_EXPORT void dart::TestAsyncReturnStruct16BytesHomogeneousFloat

(

void(*)(float a0, float a1, float a2, float a3)

f

)

Definition at line 21006 of file ffi_test_functions_generated.cc.

                                                       {
  float a0;
  float a1;
  float a2;
  float a3;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
 
  std::cout << "Calling TestAsyncReturnStruct16BytesHomogeneousFloat(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ")" << ")\n";
 
  f(a0, a1, a2, a3);
}

TestAsyncReturnStruct16BytesMixed()

DART_EXPORT void dart::TestAsyncReturnStruct16BytesMixed

(

void(*)(double a0, int64_t a1)

f

)

Definition at line 21027 of file ffi_test_functions_generated.cc.

                                      {
  double a0;
  int64_t a1;
 
  a0 = -1.0;
  a1 = 2;
 
  std::cout << "Calling TestAsyncReturnStruct16BytesMixed(" << "(" << a0 << ", "
            << a1 << ")" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct16BytesMixed2()

DART_EXPORT void dart::TestAsyncReturnStruct16BytesMixed2

(

void(*)(float a0, float a1, float a2, int32_t a3)

f

)

Definition at line 21045 of file ffi_test_functions_generated.cc.

                                                         {
  float a0;
  float a1;
  float a2;
  int32_t a3;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4;
 
  std::cout << "Calling TestAsyncReturnStruct16BytesMixed2(" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ")" << ")\n";
 
  f(a0, a1, a2, a3);
}

TestAsyncReturnStruct16BytesNestedInt()

DART_EXPORT void dart::TestAsyncReturnStruct16BytesNestedInt

(

void(*)(Struct8BytesNestedInt a0, Struct8BytesNestedInt a1)

f

)

Definition at line 22189 of file ffi_test_functions_generated.cc.

                                                                   {
  Struct8BytesNestedInt a0 = {};
  Struct8BytesNestedInt a1 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a1.a0 = -3;
  a0.a1.a1 = 4;
  a1.a0.a0 = -5;
  a1.a0.a1 = 6;
  a1.a1.a0 = -7;
  a1.a1.a1 = 8;
 
  std::cout << "Calling TestAsyncReturnStruct16BytesNestedInt(" << "((("
            << a0.a0.a0 << ", " << a0.a0.a1 << "), (" << a0.a1.a0 << ", "
            << a0.a1.a1 << ")), ((" << a1.a0.a0 << ", " << a1.a0.a1 << "), ("
            << a1.a1.a0 << ", " << a1.a1.a1 << ")))" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct17BytesInt()

DART_EXPORT void dart::TestAsyncReturnStruct17BytesInt

(

void(*)(int64_t a0, int64_t a1, int8_t a2)

f

)

Definition at line 21068 of file ffi_test_functions_generated.cc.

                                                  {
  int64_t a0;
  int64_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestAsyncReturnStruct17BytesInt(" << "(" << a0 << ", "
            << a1 << ", " << static_cast<int>(a2) << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStruct19BytesHomogeneousUint8()

DART_EXPORT void dart::TestAsyncReturnStruct19BytesHomogeneousUint8

(

void(*)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8, uint8_t a9, uint8_t a10, uint8_t a11, uint8_t a12, uint8_t a13, uint8_t a14, uint8_t a15, uint8_t a16, uint8_t a17, uint8_t a18)

f

)

Definition at line 21089 of file ffi_test_functions_generated.cc.

                            {
  uint8_t a0;
  uint8_t a1;
  uint8_t a2;
  uint8_t a3;
  uint8_t a4;
  uint8_t a5;
  uint8_t a6;
  uint8_t a7;
  uint8_t a8;
  uint8_t a9;
  uint8_t a10;
  uint8_t a11;
  uint8_t a12;
  uint8_t a13;
  uint8_t a14;
  uint8_t a15;
  uint8_t a16;
  uint8_t a17;
  uint8_t a18;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;
  a9 = 10;
  a10 = 11;
  a11 = 12;
  a12 = 13;
  a13 = 14;
  a14 = 15;
  a15 = 16;
  a16 = 17;
  a17 = 18;
  a18 = 19;
 
  std::cout << "Calling TestAsyncReturnStruct19BytesHomogeneousUint8(" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ", " << static_cast<int>(a7) << ", "
            << static_cast<int>(a8) << ", " << static_cast<int>(a9) << ", "
            << static_cast<int>(a10) << ", " << static_cast<int>(a11) << ", "
            << static_cast<int>(a12) << ", " << static_cast<int>(a13) << ", "
            << static_cast<int>(a14) << ", " << static_cast<int>(a15) << ", "
            << static_cast<int>(a16) << ", " << static_cast<int>(a17) << ", "
            << static_cast<int>(a18) << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16,
    a17, a18);
}

TestAsyncReturnStruct1ByteInt()

DART_EXPORT void dart::TestAsyncReturnStruct1ByteInt

(

void(*)(int8_t a0)

f

)

Definition at line 20742 of file ffi_test_functions_generated.cc.

                          {
  int8_t a0;
 
  a0 = -1;
 
  std::cout << "Calling TestAsyncReturnStruct1ByteInt(" << "("
            << static_cast<int>(a0) << ")" << ")\n";
 
  f(a0);
}

TestAsyncReturnStruct20BytesHomogeneousFloat()

DART_EXPORT void dart::TestAsyncReturnStruct20BytesHomogeneousFloat

(

void(*)(float a0, float a1, float a2, float a3, float a4)

f

)

Definition at line 21192 of file ffi_test_functions_generated.cc.

                                                                 {
  float a0;
  float a1;
  float a2;
  float a3;
  float a4;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
 
  std::cout << "Calling TestAsyncReturnStruct20BytesHomogeneousFloat(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ")"
            << ")\n";
 
  f(a0, a1, a2, a3, a4);
}

TestAsyncReturnStruct20BytesHomogeneousInt32()

DART_EXPORT void dart::TestAsyncReturnStruct20BytesHomogeneousInt32

(

void(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4)

f

)

Definition at line 21168 of file ffi_test_functions_generated.cc.

                                                                           {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
 
  std::cout << "Calling TestAsyncReturnStruct20BytesHomogeneousInt32(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ")"
            << ")\n";
 
  f(a0, a1, a2, a3, a4);
}

TestAsyncReturnStruct32BytesHomogeneousDouble()

DART_EXPORT void dart::TestAsyncReturnStruct32BytesHomogeneousDouble

(

void(*)(double a0, double a1, double a2, double a3)

f

)

Definition at line 21216 of file ffi_test_functions_generated.cc.

                                                           {
  double a0;
  double a1;
  double a2;
  double a3;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
 
  std::cout << "Calling TestAsyncReturnStruct32BytesHomogeneousDouble(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ")" << ")\n";
 
  f(a0, a1, a2, a3);
}

TestAsyncReturnStruct32BytesNestedInt()

DART_EXPORT void dart::TestAsyncReturnStruct32BytesNestedInt

(

void(*)(Struct16BytesNestedInt a0, Struct16BytesNestedInt a1)

f

)

Definition at line 22214 of file ffi_test_functions_generated.cc.

                                                                     {
  Struct16BytesNestedInt a0 = {};
  Struct16BytesNestedInt a1 = {};
 
  a0.a0.a0.a0 = -1;
  a0.a0.a0.a1 = 2;
  a0.a0.a1.a0 = -3;
  a0.a0.a1.a1 = 4;
  a0.a1.a0.a0 = -5;
  a0.a1.a0.a1 = 6;
  a0.a1.a1.a0 = -7;
  a0.a1.a1.a1 = 8;
  a1.a0.a0.a0 = -9;
  a1.a0.a0.a1 = 10;
  a1.a0.a1.a0 = -11;
  a1.a0.a1.a1 = 12;
  a1.a1.a0.a0 = -13;
  a1.a1.a0.a1 = 14;
  a1.a1.a1.a0 = -15;
  a1.a1.a1.a1 = 16;
 
  std::cout << "Calling TestAsyncReturnStruct32BytesNestedInt(" << "(((("
            << a0.a0.a0.a0 << ", " << a0.a0.a0.a1 << "), (" << a0.a0.a1.a0
            << ", " << a0.a0.a1.a1 << ")), ((" << a0.a1.a0.a0 << ", "
            << a0.a1.a0.a1 << "), (" << a0.a1.a1.a0 << ", " << a0.a1.a1.a1
            << "))), (((" << a1.a0.a0.a0 << ", " << a1.a0.a0.a1 << "), ("
            << a1.a0.a1.a0 << ", " << a1.a0.a1.a1 << ")), ((" << a1.a1.a0.a0
            << ", " << a1.a1.a0.a1 << "), (" << a1.a1.a1.a0 << ", "
            << a1.a1.a1.a1 << "))))" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct3BytesHomogeneousUint8()

DART_EXPORT void dart::TestAsyncReturnStruct3BytesHomogeneousUint8

(

void(*)(uint8_t a0, uint8_t a1, uint8_t a2)

f

)

Definition at line 20757 of file ffi_test_functions_generated.cc.

                                                   {
  uint8_t a0;
  uint8_t a1;
  uint8_t a2;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
 
  std::cout << "Calling TestAsyncReturnStruct3BytesHomogeneousUint8(" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStruct3BytesInt2ByteAligned()

DART_EXPORT void dart::TestAsyncReturnStruct3BytesInt2ByteAligned

(

void(*)(int16_t a0, int8_t a1)

f

)

Definition at line 20778 of file ffi_test_functions_generated.cc.

                                      {
  int16_t a0;
  int8_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestAsyncReturnStruct3BytesInt2ByteAligned(" << "("
            << a0 << ", " << static_cast<int>(a1) << ")" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct3BytesPackedInt()

DART_EXPORT void dart::TestAsyncReturnStruct3BytesPackedInt

(

void(*)(int8_t a0, int16_t a1)

f

)

Definition at line 21694 of file ffi_test_functions_generated.cc.

                                      {
  int8_t a0;
  int16_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestAsyncReturnStruct3BytesPackedInt(" << "("
            << static_cast<int>(a0) << ", " << a1 << ")" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct40BytesHomogeneousDouble()

DART_EXPORT void dart::TestAsyncReturnStruct40BytesHomogeneousDouble

(

void(*)(double a0, double a1, double a2, double a3, double a4)

f

)

Definition at line 21237 of file ffi_test_functions_generated.cc.

                                                                      {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
 
  std::cout << "Calling TestAsyncReturnStruct40BytesHomogeneousDouble(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ")"
            << ")\n";
 
  f(a0, a1, a2, a3, a4);
}

TestAsyncReturnStruct4BytesHomogeneousInt16()

DART_EXPORT void dart::TestAsyncReturnStruct4BytesHomogeneousInt16

(

void(*)(int16_t a0, int16_t a1)

f

)

Definition at line 20795 of file ffi_test_functions_generated.cc.

                                       {
  int16_t a0;
  int16_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestAsyncReturnStruct4BytesHomogeneousInt16(" << "("
            << a0 << ", " << a1 << ")" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct7BytesHomogeneousUint8()

DART_EXPORT void dart::TestAsyncReturnStruct7BytesHomogeneousUint8

(

void(*)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6)

f

)

Definition at line 20812 of file ffi_test_functions_generated.cc.

                           {
  uint8_t a0;
  uint8_t a1;
  uint8_t a2;
  uint8_t a3;
  uint8_t a4;
  uint8_t a5;
  uint8_t a6;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
 
  std::cout << "Calling TestAsyncReturnStruct7BytesHomogeneousUint8(" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6);
}

TestAsyncReturnStruct7BytesInt4ByteAligned()

DART_EXPORT void dart::TestAsyncReturnStruct7BytesInt4ByteAligned

(

void(*)(int32_t a0, int16_t a1, int8_t a2)

f

)

Definition at line 20849 of file ffi_test_functions_generated.cc.

                                                  {
  int32_t a0;
  int16_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestAsyncReturnStruct7BytesInt4ByteAligned(" << "("
            << a0 << ", " << a1 << ", " << static_cast<int>(a2) << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStruct8BytesHomogeneousFloat()

DART_EXPORT void dart::TestAsyncReturnStruct8BytesHomogeneousFloat

(

void(*)(float a0, float a1)

f

)

Definition at line 20887 of file ffi_test_functions_generated.cc.

                                   {
  float a0;
  float a1;
 
  a0 = -1.0;
  a1 = 2.0;
 
  std::cout << "Calling TestAsyncReturnStruct8BytesHomogeneousFloat(" << "("
            << a0 << ", " << a1 << ")" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct8BytesInt()

DART_EXPORT void dart::TestAsyncReturnStruct8BytesInt

(

void(*)(int16_t a0, int16_t a1, int32_t a2)

f

)

Definition at line 20868 of file ffi_test_functions_generated.cc.

                                                   {
  int16_t a0;
  int16_t a1;
  int32_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestAsyncReturnStruct8BytesInt(" << "(" << a0 << ", "
            << a1 << ", " << a2 << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStruct8BytesMixed()

DART_EXPORT void dart::TestAsyncReturnStruct8BytesMixed

(

void(*)(float a0, int16_t a1, int16_t a2)

f

)

Definition at line 20904 of file ffi_test_functions_generated.cc.

                                                 {
  float a0;
  int16_t a1;
  int16_t a2;
 
  a0 = -1.0;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestAsyncReturnStruct8BytesMixed(" << "(" << a0 << ", "
            << a1 << ", " << a2 << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStruct8BytesNestedFloat()

DART_EXPORT void dart::TestAsyncReturnStruct8BytesNestedFloat

(

void(*)(Struct4BytesFloat a0, Struct4BytesFloat a1)

f

)

Definition at line 22136 of file ffi_test_functions_generated.cc.

                                                           {
  Struct4BytesFloat a0 = {};
  Struct4BytesFloat a1 = {};
 
  a0.a0 = -1.0;
  a1.a0 = 2.0;
 
  std::cout << "Calling TestAsyncReturnStruct8BytesNestedFloat(" << "(("
            << a0.a0 << "), (" << a1.a0 << "))" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct8BytesNestedFloat2()

DART_EXPORT void dart::TestAsyncReturnStruct8BytesNestedFloat2

(

void(*)(Struct4BytesFloat a0, float a1)

f

)

Definition at line 22154 of file ffi_test_functions_generated.cc.

                                               {
  Struct4BytesFloat a0 = {};
  float a1;
 
  a0.a0 = -1.0;
  a1 = 2.0;
 
  std::cout << "Calling TestAsyncReturnStruct8BytesNestedFloat2(" << "(("
            << a0.a0 << "), " << a1 << ")" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct8BytesNestedInt()

DART_EXPORT void dart::TestAsyncReturnStruct8BytesNestedInt

(

void(*)(Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1)

f

)

Definition at line 22115 of file ffi_test_functions_generated.cc.

                                                {
  Struct4BytesHomogeneousInt16 a0 = {};
  Struct4BytesHomogeneousInt16 a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
 
  std::cout << "Calling TestAsyncReturnStruct8BytesNestedInt(" << "((" << a0.a0
            << ", " << a0.a1 << "), (" << a1.a0 << ", " << a1.a1 << "))"
            << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct8BytesNestedMixed()

DART_EXPORT void dart::TestAsyncReturnStruct8BytesNestedMixed

(

void(*)(Struct4BytesHomogeneousInt16 a0, Struct4BytesFloat a1)

f

)

Definition at line 22171 of file ffi_test_functions_generated.cc.

                                                                      {
  Struct4BytesHomogeneousInt16 a0 = {};
  Struct4BytesFloat a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3.0;
 
  std::cout << "Calling TestAsyncReturnStruct8BytesNestedMixed(" << "(("
            << a0.a0 << ", " << a0.a1 << "), (" << a1.a0 << "))" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct8BytesPackedInt()

DART_EXPORT void dart::TestAsyncReturnStruct8BytesPackedInt

(

void(*)(uint8_t a0, uint32_t a1, uint8_t a2, uint8_t a3, uint8_t a4)

f

)

Definition at line 21711 of file ffi_test_functions_generated.cc.

                                                                            {
  uint8_t a0;
  uint32_t a1;
  uint8_t a2;
  uint8_t a3;
  uint8_t a4;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
 
  std::cout << "Calling TestAsyncReturnStruct8BytesPackedInt(" << "("
            << static_cast<int>(a0) << ", " << a1 << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4);
}

TestAsyncReturnStruct9BytesHomogeneousUint8()

DART_EXPORT void dart::TestAsyncReturnStruct9BytesHomogeneousUint8

(

void(*)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8)

f

)

Definition at line 20925 of file ffi_test_functions_generated.cc.

                           {
  uint8_t a0;
  uint8_t a1;
  uint8_t a2;
  uint8_t a3;
  uint8_t a4;
  uint8_t a5;
  uint8_t a6;
  uint8_t a7;
  uint8_t a8;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;
 
  std::cout << "Calling TestAsyncReturnStruct9BytesHomogeneousUint8(" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ", " << static_cast<int>(a7) << ", "
            << static_cast<int>(a8) << ")" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
}

TestAsyncReturnStruct9BytesInt4Or8ByteAligned()

DART_EXPORT void dart::TestAsyncReturnStruct9BytesInt4Or8ByteAligned

(

void(*)(int64_t a0, int8_t a1)

f

)

Definition at line 20969 of file ffi_test_functions_generated.cc.

                                      {
  int64_t a0;
  int8_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestAsyncReturnStruct9BytesInt4Or8ByteAligned(" << "("
            << a0 << ", " << static_cast<int>(a1) << ")" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStruct9BytesPackedMixed()

DART_EXPORT void dart::TestAsyncReturnStruct9BytesPackedMixed

(

void(*)(uint8_t a0, double a1)

f

)

Definition at line 21737 of file ffi_test_functions_generated.cc.

                                      {
  uint8_t a0;
  double a1;
 
  a0 = 1;
  a1 = 2.0;
 
  std::cout << "Calling TestAsyncReturnStruct9BytesPackedMixed(" << "("
            << static_cast<int>(a0) << ", " << a1 << ")" << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStructAlignmentInt16()

DART_EXPORT void dart::TestAsyncReturnStructAlignmentInt16

(

void(*)(int8_t a0, int16_t a1, int8_t a2)

f

)

Definition at line 22055 of file ffi_test_functions_generated.cc.

                                                 {
  int8_t a0;
  int16_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestAsyncReturnStructAlignmentInt16(" << "("
            << static_cast<int>(a0) << ", " << a1 << ", "
            << static_cast<int>(a2) << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStructAlignmentInt32()

DART_EXPORT void dart::TestAsyncReturnStructAlignmentInt32

(

void(*)(int8_t a0, int32_t a1, int8_t a2)

f

)

Definition at line 22075 of file ffi_test_functions_generated.cc.

                                                 {
  int8_t a0;
  int32_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestAsyncReturnStructAlignmentInt32(" << "("
            << static_cast<int>(a0) << ", " << a1 << ", "
            << static_cast<int>(a2) << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStructAlignmentInt64()

DART_EXPORT void dart::TestAsyncReturnStructAlignmentInt64

(

void(*)(int8_t a0, int64_t a1, int8_t a2)

f

)

Definition at line 22095 of file ffi_test_functions_generated.cc.

                                                 {
  int8_t a0;
  int64_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestAsyncReturnStructAlignmentInt64(" << "("
            << static_cast<int>(a0) << ", " << a1 << ", "
            << static_cast<int>(a2) << ")" << ")\n";
 
  f(a0, a1, a2);
}

TestAsyncReturnStructArgumentInt32x8Struct1ByteInt()

DART_EXPORT void dart::TestAsyncReturnStructArgumentInt32x8Struct1ByteInt

(

void(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct1ByteInt a8)

f

)

Definition at line 21836 of file ffi_test_functions_generated.cc.

                                  {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
  int32_t a5;
  int32_t a6;
  int32_t a7;
  Struct1ByteInt a8 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7 = 8;
  a8.a0 = -9;
 
  std::cout << "Calling TestAsyncReturnStructArgumentInt32x8Struct1ByteInt("
            << "(" << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", " << a7 << ", ("
            << static_cast<int>(a8.a0) << "))" << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
}

TestAsyncReturnStructArgumentInt32x8Struct20BytesHomogeneou()

DART_EXPORT void dart::TestAsyncReturnStructArgumentInt32x8Struct20BytesHomogeneou

(

void(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct20BytesHomogeneousInt32 a8)

f

)

Definition at line 21918 of file ffi_test_functions_generated.cc.

                                                 {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
  int32_t a5;
  int32_t a6;
  int32_t a7;
  Struct20BytesHomogeneousInt32 a8 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7 = 8;
  a8.a0 = -9;
  a8.a1 = 10;
  a8.a2 = -11;
  a8.a3 = 12;
  a8.a4 = -13;
 
  std::cout
      << "Calling TestAsyncReturnStructArgumentInt32x8Struct20BytesHomogeneou("
      << "(" << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
      << ", " << a5 << ", " << a6 << ", " << a7 << ", (" << a8.a0 << ", "
      << a8.a1 << ", " << a8.a2 << ", " << a8.a3 << ", " << a8.a4 << "))"
      << ")\n";
 
  f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
}

TestAsyncReturnStructArgumentStruct1ByteInt()

DART_EXPORT void dart::TestAsyncReturnStructArgumentStruct1ByteInt

(

void(*)(Struct1ByteInt a0)

f

)

Definition at line 21819 of file ffi_test_functions_generated.cc.

                                  {
  Struct1ByteInt a0 = {};
 
  a0.a0 = -1;
 
  std::cout << "Calling TestAsyncReturnStructArgumentStruct1ByteInt(" << "(("
            << static_cast<int>(a0.a0) << "))" << ")\n";
 
  f(a0);
}

TestAsyncReturnStructArgumentStruct20BytesHomogeneousInt32()

DART_EXPORT void dart::TestAsyncReturnStructArgumentStruct20BytesHomogeneousInt32

(

void(*)(Struct20BytesHomogeneousInt32 a0)

f

)

Definition at line 21896 of file ffi_test_functions_generated.cc.

                                                 {
  Struct20BytesHomogeneousInt32 a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a0.a3 = 4;
  a0.a4 = -5;
 
  std::cout
      << "Calling TestAsyncReturnStructArgumentStruct20BytesHomogeneousInt32("
      << "((" << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
      << ", " << a0.a4 << "))" << ")\n";
 
  f(a0);
}

TestAsyncReturnStructArgumentStruct8BytesHomogeneousFloat()

DART_EXPORT void dart::TestAsyncReturnStructArgumentStruct8BytesHomogeneousFloat

(

void(*)(Struct8BytesHomogeneousFloat a0)

f

)

Definition at line 21879 of file ffi_test_functions_generated.cc.

                                                {
  Struct8BytesHomogeneousFloat a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
 
  std::cout
      << "Calling TestAsyncReturnStructArgumentStruct8BytesHomogeneousFloat("
      << "((" << a0.a0 << ", " << a0.a1 << "))" << ")\n";
 
  f(a0);
}

TestAsyncReturnStructArgumentStruct8BytesInlineArrayInt()

DART_EXPORT void dart::TestAsyncReturnStructArgumentStruct8BytesInlineArrayInt

(

void(*)(Struct8BytesInlineArrayInt a0)

f

)

Definition at line 21965 of file ffi_test_functions_generated.cc.

                                              {
  Struct8BytesInlineArrayInt a0 = {};
 
  a0.a0[0] = 1;
  a0.a0[1] = 2;
  a0.a0[2] = 3;
  a0.a0[3] = 4;
  a0.a0[4] = 5;
  a0.a0[5] = 6;
  a0.a0[6] = 7;
  a0.a0[7] = 8;
 
  std::cout
      << "Calling TestAsyncReturnStructArgumentStruct8BytesInlineArrayInt("
      << "(([" << static_cast<int>(a0.a0[0]) << ", "
      << static_cast<int>(a0.a0[1]) << ", " << static_cast<int>(a0.a0[2])
      << ", " << static_cast<int>(a0.a0[3]) << ", "
      << static_cast<int>(a0.a0[4]) << ", " << static_cast<int>(a0.a0[5])
      << ", " << static_cast<int>(a0.a0[6]) << ", "
      << static_cast<int>(a0.a0[7]) << "]))" << ")\n";
 
  f(a0);
}

TestAsyncReturnStructArgumentStructStruct16BytesHomogeneous()

DART_EXPORT void dart::TestAsyncReturnStructArgumentStructStruct16BytesHomogeneous

(

void(*)(StructStruct16BytesHomogeneousFloat2 a0)

f

)

Definition at line 21993 of file ffi_test_functions_generated.cc.

                                                        {
  StructStruct16BytesHomogeneousFloat2 a0 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[1].a0 = -3.0;
  a0.a2 = 4.0;
 
  std::cout
      << "Calling TestAsyncReturnStructArgumentStructStruct16BytesHomogeneous("
      << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), (" << a0.a1[1].a0
      << ")], " << a0.a2 << "))" << ")\n";
 
  f(a0);
}

TestAsyncReturnStructArgumentStructStruct16BytesMixed3()

DART_EXPORT void dart::TestAsyncReturnStructArgumentStructStruct16BytesMixed3

(

void(*)(StructStruct16BytesMixed3 a0)

f

)

Definition at line 22033 of file ffi_test_functions_generated.cc.

                                             {
  StructStruct16BytesMixed3 a0 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[0].a1 = -3;
  a0.a1[0].a2 = 4;
  a0.a2[0] = -5;
  a0.a2[1] = 6;
 
  std::cout << "Calling TestAsyncReturnStructArgumentStructStruct16BytesMixed3("
            << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << ", "
            << a0.a1[0].a1 << ", " << a0.a1[0].a2 << ")], [" << a0.a2[0] << ", "
            << a0.a2[1] << "]))" << ")\n";
 
  f(a0);
}

TestAsyncReturnStructArgumentStructStruct32BytesHomogeneous()

DART_EXPORT void dart::TestAsyncReturnStructArgumentStructStruct32BytesHomogeneous

(

void(*)(StructStruct32BytesHomogeneousDouble2 a0)

f

)

Definition at line 22013 of file ffi_test_functions_generated.cc.

                                                         {
  StructStruct32BytesHomogeneousDouble2 a0 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[1].a0 = -3.0;
  a0.a2 = 4.0;
 
  std::cout
      << "Calling TestAsyncReturnStructArgumentStructStruct32BytesHomogeneous("
      << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), (" << a0.a1[1].a0
      << ")], " << a0.a2 << "))" << ")\n";
 
  f(a0);
}

TestAsyncReturnStructNestedIntStructAlignmentInt16()

DART_EXPORT void dart::TestAsyncReturnStructNestedIntStructAlignmentInt16

(

void(*)(StructAlignmentInt16 a0, StructAlignmentInt16 a1)

f

)

Definition at line 22251 of file ffi_test_functions_generated.cc.

                                                                 {
  StructAlignmentInt16 a0 = {};
  StructAlignmentInt16 a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
 
  std::cout << "Calling TestAsyncReturnStructNestedIntStructAlignmentInt16("
            << "((" << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))"
            << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStructNestedIntStructAlignmentInt32()

DART_EXPORT void dart::TestAsyncReturnStructNestedIntStructAlignmentInt32

(

void(*)(StructAlignmentInt32 a0, StructAlignmentInt32 a1)

f

)

Definition at line 22275 of file ffi_test_functions_generated.cc.

                                                                 {
  StructAlignmentInt32 a0 = {};
  StructAlignmentInt32 a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
 
  std::cout << "Calling TestAsyncReturnStructNestedIntStructAlignmentInt32("
            << "((" << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))"
            << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStructNestedIntStructAlignmentInt64()

DART_EXPORT void dart::TestAsyncReturnStructNestedIntStructAlignmentInt64

(

void(*)(StructAlignmentInt64 a0, StructAlignmentInt64 a1)

f

)

Definition at line 22299 of file ffi_test_functions_generated.cc.

                                                                 {
  StructAlignmentInt64 a0 = {};
  StructAlignmentInt64 a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
 
  std::cout << "Calling TestAsyncReturnStructNestedIntStructAlignmentInt64("
            << "((" << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))"
            << ")\n";
 
  f(a0, a1);
}

TestAsyncReturnStructNestedIrregularEvenBigger()

DART_EXPORT void dart::TestAsyncReturnStructNestedIrregularEvenBigger

(

void(*)(uint64_t a0, StructNestedIrregularBigger a1, StructNestedIrregularBigger a2, double a3)

f

)

Definition at line 22323 of file ffi_test_functions_generated.cc.

                          {
  uint64_t a0;
  StructNestedIrregularBigger a1 = {};
  StructNestedIrregularBigger a2 = {};
  double a3;
 
  a0 = 1;
  a1.a0.a0 = 2;
  a1.a0.a1.a0.a0 = -3;
  a1.a0.a1.a0.a1 = 4;
  a1.a0.a1.a1.a0 = -5.0;
  a1.a0.a2 = 6;
  a1.a0.a3.a0.a0 = -7.0;
  a1.a0.a3.a1 = 8.0;
  a1.a0.a4 = 9;
  a1.a0.a5.a0.a0 = 10.0;
  a1.a0.a5.a1.a0 = -11.0;
  a1.a0.a6 = 12;
  a1.a1.a0.a0 = -13;
  a1.a1.a0.a1 = 14;
  a1.a1.a1.a0 = -15.0;
  a1.a2 = 16.0;
  a1.a3 = -17.0;
  a2.a0.a0 = 18;
  a2.a0.a1.a0.a0 = -19;
  a2.a0.a1.a0.a1 = 20;
  a2.a0.a1.a1.a0 = -21.0;
  a2.a0.a2 = 22;
  a2.a0.a3.a0.a0 = -23.0;
  a2.a0.a3.a1 = 24.0;
  a2.a0.a4 = 25;
  a2.a0.a5.a0.a0 = 26.0;
  a2.a0.a5.a1.a0 = -27.0;
  a2.a0.a6 = 28;
  a2.a1.a0.a0 = -29;
  a2.a1.a0.a1 = 30;
  a2.a1.a1.a0 = -31.0;
  a2.a2 = 32.0;
  a2.a3 = -33.0;
  a3 = 34.0;
 
  std::cout << "Calling TestAsyncReturnStructNestedIrregularEvenBigger(" << "("
            << a0 << ", ((" << a1.a0.a0 << ", ((" << a1.a0.a1.a0.a0 << ", "
            << a1.a0.a1.a0.a1 << "), (" << a1.a0.a1.a1.a0 << ")), " << a1.a0.a2
            << ", ((" << a1.a0.a3.a0.a0 << "), " << a1.a0.a3.a1 << "), "
            << a1.a0.a4 << ", ((" << a1.a0.a5.a0.a0 << "), (" << a1.a0.a5.a1.a0
            << ")), " << a1.a0.a6 << "), ((" << a1.a1.a0.a0 << ", "
            << a1.a1.a0.a1 << "), (" << a1.a1.a1.a0 << ")), " << a1.a2 << ", "
            << a1.a3 << "), ((" << a2.a0.a0 << ", ((" << a2.a0.a1.a0.a0 << ", "
            << a2.a0.a1.a0.a1 << "), (" << a2.a0.a1.a1.a0 << ")), " << a2.a0.a2
            << ", ((" << a2.a0.a3.a0.a0 << "), " << a2.a0.a3.a1 << "), "
            << a2.a0.a4 << ", ((" << a2.a0.a5.a0.a0 << "), (" << a2.a0.a5.a1.a0
            << ")), " << a2.a0.a6 << "), ((" << a2.a1.a0.a0 << ", "
            << a2.a1.a0.a1 << "), (" << a2.a1.a1.a0 << ")), " << a2.a2 << ", "
            << a2.a3 << "), " << a3 << ")" << ")\n";
 
  f(a0, a1, a2, a3);
}

TestAsyncReturnUnion16BytesNestedFloat()

DART_EXPORT void dart::TestAsyncReturnUnion16BytesNestedFloat

(

void(*)(Struct8BytesHomogeneousFloat a0)

f

)

Definition at line 21801 of file ffi_test_functions_generated.cc.

                                                {
  Struct8BytesHomogeneousFloat a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
 
  std::cout << "Calling TestAsyncReturnUnion16BytesNestedFloat(" << "(("
            << a0.a0 << ", " << a0.a1 << "))" << ")\n";
 
  f(a0);
}

TestAsyncReturnUnion4BytesMixed()

DART_EXPORT void dart::TestAsyncReturnUnion4BytesMixed

(

void(*)(uint32_t a0)

f

)

Definition at line 21754 of file ffi_test_functions_generated.cc.

                            {
  uint32_t a0;
 
  a0 = 1;
 
  std::cout << "Calling TestAsyncReturnUnion4BytesMixed(" << "(" << a0 << ")"
            << ")\n";
 
  f(a0);
}

TestAsyncReturnUnion8BytesNestedFloat()

DART_EXPORT void dart::TestAsyncReturnUnion8BytesNestedFloat

(

void(*)(double a0)

f

)

Definition at line 21769 of file ffi_test_functions_generated.cc.

                          {
  double a0;
 
  a0 = -1.0;
 
  std::cout << "Calling TestAsyncReturnUnion8BytesNestedFloat(" << "(" << a0
            << ")" << ")\n";
 
  f(a0);
}

TestAsyncReturnUnion9BytesNestedInt()

DART_EXPORT void dart::TestAsyncReturnUnion9BytesNestedInt

(

void(*)(Struct8BytesInt a0)

f

)

Definition at line 21784 of file ffi_test_functions_generated.cc.

                                   {
  Struct8BytesInt a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
 
  std::cout << "Calling TestAsyncReturnUnion9BytesNestedInt(" << "((" << a0.a0
            << ", " << a0.a1 << ", " << a0.a2 << "))" << ")\n";
 
  f(a0);
}

TestBecomeForward()

void dart::TestBecomeForward	(	Heap::Space	before_space,
		Heap::Space	after_space
	)

Definition at line 15 of file become_test.cc.

                                                                      {
  // Allocate the container in old space to test the remembered set.
  const Array& container = Array::Handle(Array::New(1, Heap::kOld));
 
  const String& before_obj = String::Handle(String::New("old", before_space));
  const String& after_obj = String::Handle(String::New("new", after_space));
  container.SetAt(0, before_obj);
  EXPECT(before_obj.ptr() != after_obj.ptr());
 
  Become become;
  become.Add(before_obj, after_obj);
  become.Forward();
 
  EXPECT(before_obj.ptr() == after_obj.ptr());
  EXPECT(container.At(0) == after_obj.ptr());
 
  GCTestHelper::CollectAllGarbage();
 
  EXPECT(before_obj.ptr() == after_obj.ptr());
  EXPECT(container.At(0) == after_obj.ptr());
}

TestBitSet()

template<intptr_t Size>

void dart::TestBitSet

(

)

Definition at line 12 of file bit_set_test.cc.

                  {
  BitSet<Size> set;
  EXPECT_EQ(-1, set.Last());
  for (int i = 0; i < Size; ++i) {
    EXPECT_EQ(false, set.Test(i));
    set.Set(i, true);
    EXPECT_EQ(true, set.Test(i));
    EXPECT_EQ(i, set.Last());
    for (int j = 0; j < Size; ++j) {
      intptr_t next = set.Next(j);
      if (j <= i) {
        EXPECT_EQ(i, next);
      } else {
        EXPECT_EQ(-1, next);
      }
    }
    set.Set(i, false);
    EXPECT_EQ(false, set.Test(i));
  }
  set.Reset();
  for (int i = 0; i < Size - 1; ++i) {
    set.Set(i, true);
    for (int j = i + 1; j < Size; ++j) {
      set.Set(j, true);
      EXPECT_EQ(j, set.Last());
      EXPECT_EQ(i, set.ClearLastAndFindPrevious(j));
      EXPECT_EQ(false, set.Test(j));
    }
  }
}

TestByteDataDirectAccess()

static void dart::TestByteDataDirectAccess ( )

static

Definition at line 2757 of file dart_api_impl_test.cc.

                                       {
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "class Expect {\n"
      "  static equals(a, b) {\n"
      "    if (a != b) {\n"
      "      throw 'not equal. expected: $a, got: $b';\n"
      "    }\n"
      "  }\n"
      "}\n"
      "void setMain(var list) {"
      "  Expect.equals(10, list.length);"
      "  for (var i = 0; i < 10; i++) {"
      "    list.setInt8(i, i);"
      "  }"
      "}\n"
      "bool testMain(var list) {"
      "  Expect.equals(10, list.length);"
      "  for (var i = 0; i < 10; i++) {"
      "    Expect.equals((10 + i), list.getInt8(i));"
      "  }"
      "  return true;"
      "}\n"
      "ByteData main() {"
      "  var a = new Int8List(100);"
      "  var view = new ByteData.view(a.buffer, 50, 10);"
      "  return view;"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Test with a typed data view object.
  Dart_Handle list_access_test_obj;
  list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(list_access_test_obj);
  TestDirectAccess(lib, list_access_test_obj, Dart_TypedData_kByteData, false);
}

TestCanonicalizationOfTypedDataViewFieldLoads()

static void dart::TestCanonicalizationOfTypedDataViewFieldLoads ( Thread *  thread, TypeDataField  field_kind  )

static

Definition at line 1255 of file il_test.cc.

                              {
  const auto& typed_data_lib = Library::Handle(Library::TypedDataLibrary());
  const auto& view_cls = Class::Handle(
      typed_data_lib.LookupClassAllowPrivate(Symbols::_Float32ArrayView()));
  const Error& err = Error::Handle(view_cls.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
  const auto& factory =
      Function::ZoneHandle(view_cls.LookupFactoryAllowPrivate(String::Handle(
          String::Concat(Symbols::_Float32ArrayView(), Symbols::DotUnder()))));
  EXPECT(!factory.IsNull());
 
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  const Slot* field = nullptr;
  switch (field_kind) {
    case TypedDataBase_length:
      field = &Slot::TypedDataBase_length();
      break;
    case TypedDataView_offset_in_bytes:
      field = &Slot::TypedDataView_offset_in_bytes();
      break;
    case TypedDataView_typed_data:
      field = &Slot::TypedDataView_typed_data();
      break;
  }
 
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
 
  const auto constant_4 = H.IntConstant(4);
  const auto constant_1 = H.IntConstant(1);
 
  Definition* array;
  Definition* load;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    // array <- AllocateTypedData(1)
    array = builder.AddDefinition(new AllocateTypedDataInstr(
        InstructionSource(), kTypedDataFloat64ArrayCid, new Value(constant_1),
        DeoptId::kNone));
    // view <- StaticCall(_Float32ArrayView._, null, array, 4, 1)
    const auto view = builder.AddDefinition(new StaticCallInstr(
        InstructionSource(), factory, 1, Array::empty_array(),
        {new Value(H.flow_graph()->constant_null()), new Value(array),
         new Value(constant_4), new Value(constant_1)},
        DeoptId::kNone, 1, ICData::RebindRule::kStatic));
    // array_alias <- LoadField(view.length)
    load = builder.AddDefinition(
        new LoadFieldInstr(new Value(view), *field, InstructionSource()));
    // Return(load)
    ret = builder.AddReturn(new Value(load));
  }
  H.FinishGraph();
  H.flow_graph()->Canonicalize();
 
  switch (field_kind) {
    case TypedDataBase_length:
      EXPECT_PROPERTY(ret->value()->definition(), &it == constant_1);
      break;
    case TypedDataView_offset_in_bytes:
      EXPECT_PROPERTY(ret->value()->definition(), &it == constant_4);
      break;
    case TypedDataView_typed_data:
      EXPECT_PROPERTY(ret->value()->definition(), &it == array);
      break;
  }
}

TestCardRememberedArray()

static void dart::TestCardRememberedArray ( bool  immutable, bool  compact  )

static

Definition at line 1284 of file heap_test.cc.

                                                                  {
  constexpr intptr_t kNumElements = kNewAllocatableSize / kCompressedWordSize;
  Array& array = Array::Handle(Array::New(kNumElements));
  EXPECT(array.ptr()->untag()->IsCardRemembered());
  EXPECT(Page::Of(array.ptr())->is_large());
 
  {
    HANDLESCOPE(Thread::Current());
    Object& element = Object::Handle();
    for (intptr_t i = 0; i < kNumElements; i++) {
      element = Double::New(i, Heap::kNew);  // Garbage
      element = Double::New(i, Heap::kNew);
      array.SetAt(i, element);
    }
    if (immutable) {
      array.MakeImmutable();
    }
  }
 
  GCTestHelper::CollectAllGarbage(compact);
  GCTestHelper::WaitForGCTasks();
 
  {
    HANDLESCOPE(Thread::Current());
    Object& element = Object::Handle();
    for (intptr_t i = 0; i < kNumElements; i++) {
      element = array.At(i);
      EXPECT(element.IsDouble());
      EXPECT(Double::Cast(element).value() == i);
    }
  }
}

TestCardRememberedWeakArray()

static void dart::TestCardRememberedWeakArray ( bool  compact )

static

Definition at line 1317 of file heap_test.cc.

                                                      {
  constexpr intptr_t kNumElements = kNewAllocatableSize / kCompressedWordSize;
  WeakArray& weak = WeakArray::Handle(WeakArray::New(kNumElements));
  EXPECT(!weak.ptr()->untag()->IsCardRemembered());
  EXPECT(Page::Of(weak.ptr())->is_large());
  Array& strong = Array::Handle(Array::New(kNumElements));
 
  {
    HANDLESCOPE(Thread::Current());
    Object& element = Object::Handle();
    for (intptr_t i = 0; i < kNumElements; i++) {
      element = Double::New(i, Heap::kNew);  // Garbage
      element = Double::New(i, Heap::kNew);
      weak.SetAt(i, element);
      if ((i % 3) == 0) {
        strong.SetAt(i, element);
      }
    }
  }
 
  GCTestHelper::CollectAllGarbage(compact);
  GCTestHelper::WaitForGCTasks();
 
  {
    HANDLESCOPE(Thread::Current());
    Object& element = Object::Handle();
    for (intptr_t i = 0; i < kNumElements; i++) {
      element = weak.At(i);
      if ((i % 3) == 0) {
        EXPECT(element.IsDouble());
        EXPECT(Double::Cast(element).value() == i);
      } else {
        EXPECT(element.IsNull());
      }
    }
  }
}

TestConstantFoldToSmi()

static void dart::TestConstantFoldToSmi ( const Library &  root_library, const char *  function_name, CompilerPass::PipelineMode  mode, intptr_t  expected_value  )

static

Definition at line 1099 of file il_test.cc.

                                                           {
  const auto& function =
      Function::Handle(GetFunction(root_library, function_name));
 
  TestPipeline pipeline(function, mode);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  DartReturnInstr* ret = nullptr;
 
  ILMatcher cursor(flow_graph, entry, true, ParallelMovesHandling::kSkip);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchDartReturn, &ret},
  }));
 
  ConstantInstr* constant = ret->value()->definition()->AsConstant();
  EXPECT(constant != nullptr);
  if (constant != nullptr) {
    const Object& value = constant->value();
    EXPECT(value.IsSmi());
    if (value.IsSmi()) {
      const intptr_t int_value = Smi::Cast(value).Value();
      EXPECT_EQ(expected_value, int_value);
    }
  }
}

TestDeprecatedSymbols()

DART_EXPORT void dart::TestDeprecatedSymbols

(

)

Definition at line 1363 of file ffi_test_functions_vmspecific.cc.

                                         {
  Dart_UpdateExternalSize_DL(nullptr, 0);
  Dart_UpdateFinalizableExternalSize_DL(nullptr, Dart_Null(), 0);
}

TestDirectAccess()

static void dart::TestDirectAccess ( Dart_Handle  lib, Dart_Handle  array, Dart_TypedData_Type  expected_type, bool  is_external  )

static

Definition at line 2514 of file dart_api_impl_test.cc.

                                               {
  Dart_Handle result;
 
  // Invoke the dart function that sets initial values.
  Dart_Handle dart_args[1];
  dart_args[0] = array;
  result = Dart_Invoke(lib, NewString("setMain"), 1, dart_args);
  EXPECT_VALID(result);
 
  // Now Get a direct access to this typed data object and check it's contents.
  const int kLength = 10;
  Dart_TypedData_Type type;
  void* data;
  intptr_t len;
  result = Dart_TypedDataAcquireData(array, &type, &data, &len);
  EXPECT(!Thread::Current()->IsAtSafepoint());
  EXPECT_VALID(result);
  EXPECT_EQ(expected_type, type);
  EXPECT_EQ(kLength, len);
  int8_t* dataP = reinterpret_cast<int8_t*>(data);
  for (int i = 0; i < kLength; i++) {
    EXPECT_EQ(i, dataP[i]);
  }
 
  // Now try allocating a string with outstanding Acquires and it should
  // return an error.
  result = NewString("We expect an error here");
  EXPECT_ERROR(result, "Callbacks into the Dart VM are currently prohibited");
 
  // Now modify the values in the directly accessible array and then check
  // it we see the changes back in dart.
  for (int i = 0; i < kLength; i++) {
    dataP[i] += 10;
  }
 
  // Release direct access to the typed data object.
  EXPECT(!Thread::Current()->IsAtSafepoint());
  result = Dart_TypedDataReleaseData(array);
  EXPECT_VALID(result);
 
  // Invoke the dart function in order to check the modified values.
  result = Dart_Invoke(lib, NewString("testMain"), 1, dart_args);
  EXPECT_VALID(result);
}

TestEndFunction()

void dart::TestEndFunction

(

uword

data

)

Definition at line 127 of file message_handler_test.cc.

                                 {
  return (reinterpret_cast<TestMessageHandler*>(data))->End();
}

TestFieldNotFound()

static void dart::TestFieldNotFound ( Dart_Handle  container, Dart_Handle  name  )

static

Definition at line 5143 of file dart_api_impl_test.cc.

                                                                       {
  EXPECT_ERROR(Dart_GetField(container, name), "NoSuchMethodError");
  EXPECT_ERROR(Dart_SetField(container, name, Dart_Null()),
               "NoSuchMethodError");
}

TestFieldOk()

static void dart::TestFieldOk ( Dart_Handle  container, Dart_Handle  name, bool  final, const char *  initial_value  )

static

Definition at line 5106 of file dart_api_impl_test.cc.

                                                   {
  Dart_Handle result;
 
  // Make sure we have the right initial value.
  result = Dart_GetField(container, name);
  EXPECT_VALID(result);
  const char* value = "";
  EXPECT_VALID(Dart_StringToCString(result, &value));
  EXPECT_STREQ(initial_value, value);
 
  // Use a unique expected value.
  static int counter = 0;
  char buffer[256];
  Utils::SNPrint(buffer, 256, "Expected%d", ++counter);
 
  // Try to change the field value.
  result = Dart_SetField(container, name, NewString(buffer));
  if (final) {
    EXPECT(Dart_IsError(result));
  } else {
    EXPECT_VALID(result);
  }
 
  // Make sure we have the right final value.
  result = Dart_GetField(container, name);
  EXPECT_VALID(result);
  EXPECT_VALID(Dart_StringToCString(result, &value));
  if (final) {
    EXPECT_STREQ(initial_value, value);
  } else {
    EXPECT_STREQ(buffer, value);
  }
}

TestFreeList()

static void dart::TestFreeList ( VirtualMemory *  region, FreeList *  free_list, bool  is_protected  )

static

Definition at line 38 of file freelist_test.cc.

                                            {
  const intptr_t kSmallObjectSize = 4 * kWordSize;
  const intptr_t kMediumObjectSize = 16 * kWordSize;
  const intptr_t kLargeObjectSize = 8 * KB;
  uword blob = region->start();
  // Enqueue the large blob as one free block.
  free_list->Free(blob, region->size());
 
  if (is_protected) {
    // Write protect the whole region.
    region->Protect(VirtualMemory::kReadExecute);
  }
 
  // Allocate a small object. Expect it to be positioned as the first element.
  uword small_object = Allocate(free_list, kSmallObjectSize, is_protected);
  EXPECT_EQ(blob, small_object);
  // Freeing and allocating should give us the same memory back.
  Free(free_list, small_object, kSmallObjectSize, is_protected);
  small_object = Allocate(free_list, kSmallObjectSize, is_protected);
  EXPECT_EQ(blob, small_object);
  // Splitting the remainder further with small and medium objects.
  uword small_object2 = Allocate(free_list, kSmallObjectSize, is_protected);
  EXPECT_EQ(blob + kSmallObjectSize, small_object2);
  uword med_object = Allocate(free_list, kMediumObjectSize, is_protected);
  EXPECT_EQ(small_object2 + kSmallObjectSize, med_object);
  // Allocate a large object.
  uword large_object = Allocate(free_list, kLargeObjectSize, is_protected);
  EXPECT_EQ(med_object + kMediumObjectSize, large_object);
  // Make sure that small objects can still split the remainder.
  uword small_object3 = Allocate(free_list, kSmallObjectSize, is_protected);
  EXPECT_EQ(large_object + kLargeObjectSize, small_object3);
  // Split the large object.
  Free(free_list, large_object, kLargeObjectSize, is_protected);
  uword small_object4 = Allocate(free_list, kSmallObjectSize, is_protected);
  EXPECT_EQ(large_object, small_object4);
  // Get the full remainder of the large object.
  large_object =
      Allocate(free_list, kLargeObjectSize - kSmallObjectSize, is_protected);
  EXPECT_EQ(small_object4 + kSmallObjectSize, large_object);
  // Get another large object from the large unallocated remainder.
  uword large_object2 = Allocate(free_list, kLargeObjectSize, is_protected);
  EXPECT_EQ(small_object3 + kSmallObjectSize, large_object2);
}

testFunction()

static int dart::testFunction ( int  x )

static

Definition at line 95 of file virtual_memory_test.cc.

                               {
  return x * 2;
}

TestGC()

DART_EXPORT intptr_t dart::TestGC

(

void(*)()

do_gc

)

Definition at line 202 of file ffi_test_functions_vmspecific.cc.

                                             {
  ClobberAndCall(do_gc);
  return 0;
}

TestGrowableArray()

template<class GrowableArrayInt , class GrowableArrayInt64 >

void dart::TestGrowableArray

(

)

Definition at line 15 of file growable_array_test.cc.

                         {
  GrowableArrayInt g;
  EXPECT_EQ(0, g.length());
  EXPECT(g.is_empty());
  g.Add(5);
  EXPECT_EQ(5, g[0]);
  EXPECT_EQ(1, g.length());
  EXPECT(!g.is_empty());
  g.Add(3);
  const GrowableArrayInt& temp = g;
  EXPECT_EQ(5, temp[0]);
  EXPECT_EQ(3, temp[1]);
  for (int i = 0; i < 10000; i++) {
    g.Add(i);
  }
  EXPECT_EQ(10002, g.length());
  EXPECT_EQ(10000 - 1, g.Last());
 
  GrowableArrayInt64 f(10);
  EXPECT_EQ(0, f.length());
  f.Add(-1LL);
  f.Add(15LL);
  EXPECT_EQ(2, f.length());
  for (int64_t l = 0; l < 100; l++) {
    f.Add(l);
  }
  EXPECT_EQ(102, f.length());
  EXPECT_EQ(100 - 1, f.Last());
  EXPECT_EQ(-1LL, f[0]);
 
  GrowableArrayInt h;
  EXPECT_EQ(0, h.length());
  h.Add(101);
  h.Add(102);
  h.Add(103);
  EXPECT_EQ(3, h.length());
  EXPECT_EQ(103, h.Last());
  h.RemoveLast();
  EXPECT_EQ(2, h.length());
  EXPECT_EQ(102, h.Last());
  h.RemoveLast();
  EXPECT_EQ(1, h.length());
  EXPECT_EQ(101, h.Last());
  h.RemoveLast();
  EXPECT_EQ(0, h.length());
  EXPECT(h.is_empty());
  h.Add(-8899);
  h.Add(7908);
  EXPECT(!h.is_empty());
  h.Clear();
  EXPECT(h.is_empty());
}

TestIllegalArrayLength()

static void dart::TestIllegalArrayLength ( intptr_t  length )

static

Definition at line 1864 of file object_test.cc.

                                                    {
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "main() {\n"
                 "  List.filled(%" Pd
                 ", null);\n"
                 "}\n",
                 length);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  Utils::SNPrint(buffer, sizeof(buffer),
                 "Unhandled exception:\n"
                 "RangeError (length): Invalid value: "
                 "Not in inclusive range 0..%" Pd ": %" Pd,
                 Array::kMaxElements, length);
  EXPECT_ERROR(result, buffer);
}

TestIllegalTypedDataLength()

static void dart::TestIllegalTypedDataLength ( const char *  class_name, intptr_t  length  )

static

Definition at line 1928 of file object_test.cc.

                                                        {
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "import 'dart:typed_data';\n"
                 "main() {\n"
                 "  new %s(%" Pd
                 ");\n"
                 "}\n",
                 class_name, length);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  Utils::SNPrint(buffer, sizeof(buffer), "%" Pd, length);
  EXPECT_ERROR(result, "RangeError (length): Invalid value");
  EXPECT_ERROR(result, buffer);
}

TestIntComputation()

DART_EXPORT intptr_t dart::TestIntComputation

(

int64_t(*)(int8_t, int16_t, int32_t, int64_t)

fn

)

Definition at line 910 of file ffi_test_functions.cc.

                                                                     {
  const int64_t result = fn(125, 250, 500, 1000);
  std::cout << "result " << result << "\n";
  CHECK_EQ(result, 625);
  CHECK_EQ(0x7FFFFFFFFFFFFFFFLL, fn(0, 0, 0, 0x7FFFFFFFFFFFFFFFLL));
  CHECK_EQ(((int64_t)0x8000000000000000LL), fn(0, 0, 0, 0x8000000000000000LL));
  return 0;
}

TestIntConverterCanonicalizationRule()

bool dart::TestIntConverterCanonicalizationRule	(	Thread *	thread,
		int64_t	min_value,
		int64_t	max_value,
		Representation	initial,
		Representation	intermediate,
		Representation	final
	)

Definition at line 196 of file il_test.cc.

                                                                {
  using compiler::BlockBuilder;
 
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
 
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::IntType()));
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
 
  Definition* v0;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    v0 = builder.AddParameter(0, initial);
    v0->set_range(Range(RangeBoundary::FromConstant(min_value),
                        RangeBoundary::FromConstant(max_value)));
    auto conv1 = builder.AddDefinition(new IntConverterInstr(
        initial, intermediate, new Value(v0), S.GetNextDeoptId()));
    auto conv2 = builder.AddDefinition(new IntConverterInstr(
        intermediate, initial, new Value(conv1), S.GetNextDeoptId()));
    ret = builder.AddReturn(new Value(conv2));
  }
 
  H.FinishGraph();
 
  H.flow_graph()->Canonicalize();
  H.flow_graph()->Canonicalize();
 
  return ret->value()->definition() == v0;
}

TestLargeFrame()

void dart::TestLargeFrame	(	const char *	type,
		const char *	zero,
		const char *	one,
		const char *	main
	)

Definition at line 201 of file flow_graph_test.cc.

                                      {
  SetFlagScope<int> sfs(&FLAG_optimization_counter_threshold, 1000);
  TextBuffer printer(256 * KB);
 
  intptr_t num_locals = 2000;
  printer.Printf("import 'dart:typed_data';\n");
  printer.Printf("@pragma('vm:never-inline')\n");
  printer.Printf("%s one() { return %s; }\n", type, one);
  printer.Printf("@pragma('vm:never-inline')\n");
  printer.Printf("%s largeFrame(int n) {\n", type);
  for (intptr_t i = 0; i < num_locals; i++) {
    printer.Printf("  %s local%" Pd " = %s;\n", type, i, zero);
  }
  printer.Printf("  for (int i = 0; i < n; i++) {\n");
  for (intptr_t i = 0; i < num_locals; i++) {
    printer.Printf("    local%" Pd " += one();\n", i);
  }
  printer.Printf("  }\n");
  printer.Printf("  %s sum = %s;\n", type, zero);
  for (intptr_t i = 0; i < num_locals; i++) {
    printer.Printf("    sum += local%" Pd ";\n", i);
  }
  printer.Printf("  return sum;\n");
  printer.Printf("}\n");
 
  printer.AddString(main);
 
  const auto& root_library = Library::Handle(LoadTestScript(printer.buffer()));
  Invoke(root_library, "main");
}

TestManyArgs()

DART_EXPORT intptr_t dart::TestManyArgs

(

double(*)(intptr_t a, float b, intptr_t c, double d, intptr_t e, float f, intptr_t g, double h, intptr_t i, float j, intptr_t k, double l, intptr_t m, float n, intptr_t o, double p, intptr_t q, float r, intptr_t s, double t)

fn

)

Definition at line 965 of file ffi_test_functions.cc.

                                                          {
  CHECK(210.0 == fn(1, 2.0, 3, 4.0, 5, 6.0, 7, 8.0, 9, 10.0, 11, 12.0, 13, 14.0,
                    15, 16.0, 17, 18.0, 19, 20.0));
  return 0;
}

TestManyDoubles()

DART_EXPORT intptr_t dart::TestManyDoubles

(

double(*)(double, double, double, double, double, double, double, double, double, double)

fn

)

Definition at line 951 of file ffi_test_functions.cc.

                                                           {
  CHECK_EQ(55, fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
  return 0;
}

TestManyInts()

DART_EXPORT intptr_t dart::TestManyInts

(

intptr_t(*)(intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t, intptr_t)

fn

)

Definition at line 937 of file ffi_test_functions.cc.

                                                            {
  CHECK_EQ(55, fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
  return 0;
}

TestMap()

template<typename Map >

void dart::TestMap	(	intptr_t	initial_capacity,
		bool	ordered
	)

Definition at line 217 of file hash_table_test.cc.

                                                      {
  std::map<std::string, int> expected;
  Map actual(HashTables::New<Map>(initial_capacity));
  // Insert the following (strings, int) mapping:
  // aaa...aaa -> 26
  // bbb..bbb -> 25
  // ...
  // yy -> 2
  // z -> 1
  for (int i = 0; i < 2; ++i) {
    for (char ch = 'a'; ch <= 'z'; ++ch) {
      int length = 'z' - ch + 1;
      std::string key(length, ch);
      // Map everything to zero initially, then update to their final values.
      int value = length * i;
      expected[key] = value;
      bool present =
          actual.UpdateOrInsert(String::Handle(String::New(key.c_str())),
                                Smi::Handle(Smi::New(value)));
      EXPECT_EQ((i != 0), present);
      Validate(actual);
      VerifyStringMapsEqual(expected, actual, ordered);
    }
  }
  actual.Clear();
  EXPECT_EQ(0, actual.NumOccupied());
  actual.Release();
}

TestNativeFields()

static void dart::TestNativeFields ( Dart_Handle  retobj )

static

Definition at line 5700 of file dart_api_impl_test.cc.

                                                 {
  // Access and set various instance fields of the object.
  Dart_Handle result = Dart_GetField(retobj, NewString("fld3"));
  EXPECT(Dart_IsError(result));
  result = Dart_GetField(retobj, NewString("fld0"));
  EXPECT_VALID(result);
  EXPECT(Dart_IsNull(result));
  result = Dart_GetField(retobj, NewString("fld1"));
  EXPECT_VALID(result);
  int64_t value = 0;
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(10, value);
  result = Dart_GetField(retobj, NewString("fld2"));
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(20, value);
  result = Dart_SetField(retobj, NewString("fld2"), Dart_NewInteger(40));
  EXPECT(Dart_IsError(result));
  result = Dart_SetField(retobj, NewString("fld1"), Dart_NewInteger(40));
  EXPECT_VALID(result);
  result = Dart_GetField(retobj, NewString("fld1"));
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(40, value);
 
  // Now access and set various native instance fields of the returned object.
  const int kNativeFld0 = 0;
  const int kNativeFld1 = 1;
  const int kNativeFld2 = 2;
  const int kNativeFld3 = 3;
  const int kNativeFld4 = 4;
  int field_count = 0;
  intptr_t field_value = 0;
  EXPECT_VALID(Dart_GetNativeInstanceFieldCount(retobj, &field_count));
  EXPECT_EQ(4, field_count);
  result = Dart_GetNativeInstanceField(retobj, kNativeFld4, &field_value);
  EXPECT(Dart_IsError(result));
  result = Dart_GetNativeInstanceField(retobj, kNativeFld0, &field_value);
  EXPECT_VALID(result);
  EXPECT_EQ(0, field_value);
  result = Dart_GetNativeInstanceField(retobj, kNativeFld1, &field_value);
  EXPECT_VALID(result);
  EXPECT_EQ(0, field_value);
  result = Dart_GetNativeInstanceField(retobj, kNativeFld2, &field_value);
  EXPECT_VALID(result);
  EXPECT_EQ(0, field_value);
  result = Dart_GetNativeInstanceField(retobj, kNativeFld3, &field_value);
  EXPECT_VALID(result);
  EXPECT_EQ(0, field_value);
  result = Dart_SetNativeInstanceField(retobj, kNativeFld4, 40);
  EXPECT(Dart_IsError(result));
  result = Dart_SetNativeInstanceField(retobj, kNativeFld0, 4);
  EXPECT_VALID(result);
  result = Dart_SetNativeInstanceField(retobj, kNativeFld1, 40);
  EXPECT_VALID(result);
  result = Dart_SetNativeInstanceField(retobj, kNativeFld2, 400);
  EXPECT_VALID(result);
  result = Dart_SetNativeInstanceField(retobj, kNativeFld3, 4000);
  EXPECT_VALID(result);
  result = Dart_GetNativeInstanceField(retobj, kNativeFld3, &field_value);
  EXPECT_VALID(result);
  EXPECT_EQ(4000, field_value);
 
  // Now re-access various dart instance fields of the returned object
  // to ensure that there was no corruption while setting native fields.
  result = Dart_GetField(retobj, NewString("fld1"));
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(40, value);
  result = Dart_GetField(retobj, NewString("fld2"));
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &value);
  EXPECT_EQ(20, value);
}

TestNativeFieldsAccess_access()

void dart::TestNativeFieldsAccess_access

(

Dart_NativeArguments

args

)

Definition at line 5580 of file dart_api_impl_test.cc.

                                                              {
  intptr_t field_values[kTestNumNativeFields];
  Dart_Handle result = Dart_GetNativeFieldsOfArgument(
      args, 0, kTestNumNativeFields, field_values);
  EXPECT_VALID(result);
  EXPECT_EQ(kNativeField1Value, field_values[0]);
  EXPECT_EQ(kNativeField2Value, field_values[1]);
  result = Dart_GetNativeFieldsOfArgument(args, 1, kTestNumNativeFields,
                                          field_values);
  EXPECT_VALID(result);
  EXPECT_EQ(0, field_values[0]);
  EXPECT_EQ(0, field_values[1]);
}

TestNativeFieldsAccess_init()

void dart::TestNativeFieldsAccess_init

(

Dart_NativeArguments

args

)

Definition at line 5574 of file dart_api_impl_test.cc.

                                                            {
  Dart_Handle receiver = Dart_GetNativeArgument(args, 0);
  Dart_SetNativeInstanceField(receiver, 0, kNativeField1Value);
  Dart_SetNativeInstanceField(receiver, 1, kNativeField2Value);
}

TestNativeFieldsAccess_invalidAccess()

void dart::TestNativeFieldsAccess_invalidAccess

(

Dart_NativeArguments

args

)

Definition at line 5594 of file dart_api_impl_test.cc.

                                                                     {
  intptr_t field_values[kTestNumNativeFields];
  Dart_Handle result = Dart_GetNativeFieldsOfArgument(
      args, 0, kTestNumNativeFields, field_values);
  EXPECT_ERROR(result,
               "Dart_GetNativeFieldsOfArgument: "
               "expected 0 'num_fields' but was passed in 2");
}

TestNativeFieldsAccess_lookup()

static Dart_NativeFunction dart::TestNativeFieldsAccess_lookup ( Dart_Handle  name, int  argument_count, bool *  auto_scope  )

static

Definition at line 5603 of file dart_api_impl_test.cc.

                                                                           {
  ASSERT(auto_scope != nullptr);
  *auto_scope = true;
  TransitionNativeToVM transition(Thread::Current());
  const Object& obj = Object::Handle(Api::UnwrapHandle(name));
  if (!obj.IsString()) {
    return nullptr;
  }
  const char* function_name = obj.ToCString();
  ASSERT(function_name != nullptr);
  if (strcmp(function_name, "TestNativeFieldsAccess_init") == 0) {
    return TestNativeFieldsAccess_init;
  } else if (strcmp(function_name, "TestNativeFieldsAccess_access") == 0) {
    return TestNativeFieldsAccess_access;
  } else if (strcmp(function_name, "TestNativeFieldsAccess_invalidAccess") ==
             0) {
    return TestNativeFieldsAccess_invalidAccess;
  } else {
    return nullptr;
  }
}

TestNonNullSmiSum()

void dart::TestNonNullSmiSum

(

Dart_NativeArguments

args

)

Definition at line 55 of file native_entry_test.cc.

                                                  {
  int64_t result = 0;
  int arg_count = Dart_GetNativeArgumentCount(args);
  // Test the lower level macro GET_NATIVE_ARGUMENT.
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  Zone* zone = Thread::Current()->zone();  // Used by GET_NATIVE_ARGUMENT.
  for (int i = 0; i < arg_count; i++) {
    Dart_Handle arg = Dart_GetNativeArgument(args, i);
    GET_NATIVE_ARGUMENT(Integer, argument, arguments->NativeArgAt(i));
    EXPECT(argument.IsInteger());                       // May be null.
    EXPECT_EQ(Api::UnwrapHandle(arg), argument.ptr());  // May be null.
    int64_t arg_value = -1;
    if (argument.IsNull()) {
      EXPECT_ERROR(Dart_IntegerToInt64(arg, &arg_value),
                   "Dart_IntegerToInt64 expects argument 'integer' "
                   "to be non-null.");
    } else {
      EXPECT_VALID(Dart_IntegerToInt64(arg, &arg_value));
      EXPECT_EQ(arg_value, argument.AsInt64Value());
      // Ignoring overflow in the addition below.
      result += arg_value;
    }
  }
  Dart_SetReturnValue(args, Dart_NewInteger(result));
}

TestNotSignExtendedBitField()

template<typename T >

static void dart::TestNotSignExtendedBitField ( )

static

Definition at line 48 of file bitfield_test.cc.

                                          {
  class F1 : public BitField<T, intptr_t, 0, 8, /*sign_extend=*/false> {};
  class F2
      : public BitField<T, uintptr_t, F1::kNextBit, 8, /*sign_extend=*/false> {
  };
  class F3
      : public BitField<T, intptr_t, F2::kNextBit, 8, /*sign_extend=*/false> {};
  class F4
      : public BitField<T, uintptr_t, F3::kNextBit, 8, /*sign_extend=*/false> {
  };
 
  const uint32_t value =
      F1::encode(-1) | F2::encode(1) | F3::encode(-2) | F4::encode(2);
  EXPECT_EQ(0x02fe01ffU, value);
  EXPECT_EQ(3, F1::decode(value));
  EXPECT_EQ(1, F2::decode(value));
  EXPECT_EQ(2, F3::decode(value));
  EXPECT_EQ(2, F3::decode(value));
}

TestNullAwareEqualityCompareCanonicalization()

static void dart::TestNullAwareEqualityCompareCanonicalization ( Thread *  thread, bool  allow_representation_change  )

static

Definition at line 396 of file il_test.cc.

                                      {
  using compiler::BlockBuilder;
 
  CompilerState S(thread, /*is_aot=*/true, /*is_optimizing=*/true);
 
  FlowGraphBuilderHelper H(/*num_parameters=*/2);
  H.AddVariable("v0", AbstractType::ZoneHandle(Type::IntType()));
  H.AddVariable("v1", AbstractType::ZoneHandle(Type::IntType()));
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
 
  EqualityCompareInstr* compare = nullptr;
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    Definition* v0 = builder.AddParameter(0, kUnboxedInt64);
    Definition* v1 = builder.AddParameter(1, kUnboxedInt64);
    Definition* box0 = builder.AddDefinition(new BoxInt64Instr(new Value(v0)));
    Definition* box1 = builder.AddDefinition(new BoxInt64Instr(new Value(v1)));
 
    compare = builder.AddDefinition(new EqualityCompareInstr(
        InstructionSource(), Token::kEQ, new Value(box0), new Value(box1),
        kMintCid, S.GetNextDeoptId(), /*null_aware=*/true));
    builder.AddReturn(new Value(compare));
  }
 
  H.FinishGraph();
 
  if (!allow_representation_change) {
    H.flow_graph()->disallow_unmatched_representations();
  }
 
  H.flow_graph()->Canonicalize();
 
  EXPECT(compare->is_null_aware() == !allow_representation_change);
}

TestNullPointers()

DART_EXPORT intptr_t dart::TestNullPointers

(

int64_t *(*)(int64_t *ptr)

fn

)

Definition at line 1109 of file ffi_test_functions.cc.

                                                                    {
  CHECK_EQ(fn(nullptr), reinterpret_cast<void*>(sizeof(int64_t)));
  int64_t p[2] = {0};
  CHECK_EQ(fn(p), p + 1);
  return 0;
}

TestPassDoublex6Struct16BytesMixedx4Int32()

DART_EXPORT intptr_t dart::TestPassDoublex6Struct16BytesMixedx4Int32

(

double(*)(double a0, double a1, double a2, double a3, double a4, double a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9, int32_t a10)

f

)

Definition at line 8937 of file ffi_test_functions_generated.cc.

                              {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;
  double a5;
  Struct16BytesMixed a6 = {};
  Struct16BytesMixed a7 = {};
  Struct16BytesMixed a8 = {};
  Struct16BytesMixed a9 = {};
  int32_t a10;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
  a5 = 6.0;
  a6.a0 = -7.0;
  a6.a1 = 8;
  a7.a0 = -9.0;
  a7.a1 = 10;
  a8.a0 = -11.0;
  a8.a1 = 12;
  a9.a0 = -13.0;
  a9.a1 = 14;
  a10 = -15;
 
  std::cout << "Calling TestPassDoublex6Struct16BytesMixedx4Int32(" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", "
            << a5 << ", (" << a6.a0 << ", " << a6.a1 << "), (" << a7.a0 << ", "
            << a7.a1 << "), (" << a8.a0 << ", " << a8.a1 << "), (" << a9.a0
            << ", " << a9.a1 << "), " << a10 << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-8.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassFloatStruct16BytesHomogeneousFloatFloatStruct1()

DART_EXPORT intptr_t dart::TestPassFloatStruct16BytesHomogeneousFloatFloatStruct1

(

float(*)(float a0, Struct16BytesHomogeneousFloat a1, float a2, Struct16BytesHomogeneousFloat a3, float a4, Struct16BytesHomogeneousFloat a5, float a6, Struct16BytesHomogeneousFloat a7, float a8)

f

)

Definition at line 8712 of file ffi_test_functions_generated.cc.

                          {
  float a0;
  Struct16BytesHomogeneousFloat a1 = {};
  float a2;
  Struct16BytesHomogeneousFloat a3 = {};
  float a4;
  Struct16BytesHomogeneousFloat a5 = {};
  float a6;
  Struct16BytesHomogeneousFloat a7 = {};
  float a8;
 
  a0 = -1.0;
  a1.a0 = 2.0;
  a1.a1 = -3.0;
  a1.a2 = 4.0;
  a1.a3 = -5.0;
  a2 = 6.0;
  a3.a0 = -7.0;
  a3.a1 = 8.0;
  a3.a2 = -9.0;
  a3.a3 = 10.0;
  a4 = -11.0;
  a5.a0 = 12.0;
  a5.a1 = -13.0;
  a5.a2 = 14.0;
  a5.a3 = -15.0;
  a6 = 16.0;
  a7.a0 = -17.0;
  a7.a1 = 18.0;
  a7.a2 = -19.0;
  a7.a3 = 20.0;
  a8 = -21.0;
 
  std::cout << "Calling TestPassFloatStruct16BytesHomogeneousFloatFloatStruct1("
            << "(" << a0 << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2
            << ", " << a1.a3 << "), " << a2 << ", (" << a3.a0 << ", " << a3.a1
            << ", " << a3.a2 << ", " << a3.a3 << "), " << a4 << ", (" << a5.a0
            << ", " << a5.a1 << ", " << a5.a2 << ", " << a5.a3 << "), " << a6
            << ", (" << a7.a0 << ", " << a7.a1 << ", " << a7.a2 << ", " << a7.a3
            << "), " << a8 << ")" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-11.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassFloatStruct32BytesHomogeneousDoubleFloatStruct()

DART_EXPORT intptr_t dart::TestPassFloatStruct32BytesHomogeneousDoubleFloatStruct

(

double(*)(float a0, Struct32BytesHomogeneousDouble a1, float a2, Struct32BytesHomogeneousDouble a3, float a4, Struct32BytesHomogeneousDouble a5, float a6, Struct32BytesHomogeneousDouble a7, float a8)

f

)

Definition at line 8788 of file ffi_test_functions_generated.cc.

                           {
  float a0;
  Struct32BytesHomogeneousDouble a1 = {};
  float a2;
  Struct32BytesHomogeneousDouble a3 = {};
  float a4;
  Struct32BytesHomogeneousDouble a5 = {};
  float a6;
  Struct32BytesHomogeneousDouble a7 = {};
  float a8;
 
  a0 = -1.0;
  a1.a0 = 2.0;
  a1.a1 = -3.0;
  a1.a2 = 4.0;
  a1.a3 = -5.0;
  a2 = 6.0;
  a3.a0 = -7.0;
  a3.a1 = 8.0;
  a3.a2 = -9.0;
  a3.a3 = 10.0;
  a4 = -11.0;
  a5.a0 = 12.0;
  a5.a1 = -13.0;
  a5.a2 = 14.0;
  a5.a3 = -15.0;
  a6 = 16.0;
  a7.a0 = -17.0;
  a7.a1 = 18.0;
  a7.a2 = -19.0;
  a7.a3 = 20.0;
  a8 = -21.0;
 
  std::cout << "Calling TestPassFloatStruct32BytesHomogeneousDoubleFloatStruct("
            << "(" << a0 << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2
            << ", " << a1.a3 << "), " << a2 << ", (" << a3.a0 << ", " << a3.a1
            << ", " << a3.a2 << ", " << a3.a3 << "), " << a4 << ", (" << a5.a0
            << ", " << a5.a1 << ", " << a5.a2 << ", " << a5.a3 << "), " << a6
            << ", (" << a7.a0 << ", " << a7.a1 << ", " << a7.a2 << ", " << a7.a3
            << "), " << a8 << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-11.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassInt32x4Struct16BytesMixedx4Double()

DART_EXPORT intptr_t dart::TestPassInt32x4Struct16BytesMixedx4Double

(

double(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, double a8)

f

)

Definition at line 9011 of file ffi_test_functions_generated.cc.

                            {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  Struct16BytesMixed a4 = {};
  Struct16BytesMixed a5 = {};
  Struct16BytesMixed a6 = {};
  Struct16BytesMixed a7 = {};
  double a8;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4.a0 = -5.0;
  a4.a1 = 6;
  a5.a0 = -7.0;
  a5.a1 = 8;
  a6.a0 = -9.0;
  a6.a1 = 10;
  a7.a0 = -11.0;
  a7.a1 = 12;
  a8 = -13.0;
 
  std::cout << "Calling TestPassInt32x4Struct16BytesMixedx4Double(" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", (" << a4.a0 << ", "
            << a4.a1 << "), (" << a5.a0 << ", " << a5.a1 << "), (" << a6.a0
            << ", " << a6.a1 << "), (" << a7.a0 << ", " << a7.a1 << "), " << a8
            << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-7.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int()

DART_EXPORT intptr_t dart::TestPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int

(

double(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, double a8, double a9, double a10, double a11, double a12, double a13, double a14, double a15, int64_t a16, int8_t a17, Struct1ByteInt a18, int64_t a19, int8_t a20, Struct4BytesHomogeneousInt16 a21, int64_t a22, int8_t a23, Struct8BytesInt a24, int64_t a25, int8_t a26, Struct8BytesHomogeneousFloat a27, int64_t a28, int8_t a29, Struct8BytesMixed a30, int64_t a31, int8_t a32, StructAlignmentInt16 a33, int64_t a34, int8_t a35, StructAlignmentInt32 a36, int64_t a37, int8_t a38, StructAlignmentInt64 a39)

f

)

Definition at line 9127 of file ffi_test_functions_generated.cc.

                                           {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
  int32_t a5;
  int32_t a6;
  int32_t a7;
  double a8;
  double a9;
  double a10;
  double a11;
  double a12;
  double a13;
  double a14;
  double a15;
  int64_t a16;
  int8_t a17;
  Struct1ByteInt a18 = {};
  int64_t a19;
  int8_t a20;
  Struct4BytesHomogeneousInt16 a21 = {};
  int64_t a22;
  int8_t a23;
  Struct8BytesInt a24 = {};
  int64_t a25;
  int8_t a26;
  Struct8BytesHomogeneousFloat a27 = {};
  int64_t a28;
  int8_t a29;
  Struct8BytesMixed a30 = {};
  int64_t a31;
  int8_t a32;
  StructAlignmentInt16 a33 = {};
  int64_t a34;
  int8_t a35;
  StructAlignmentInt32 a36 = {};
  int64_t a37;
  int8_t a38;
  StructAlignmentInt64 a39 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7 = 8;
  a8 = -9.0;
  a9 = 10.0;
  a10 = -11.0;
  a11 = 12.0;
  a12 = -13.0;
  a13 = 14.0;
  a14 = -15.0;
  a15 = 16.0;
  a16 = -17;
  a17 = 18;
  a18.a0 = -19;
  a19 = 20;
  a20 = -21;
  a21.a0 = 22;
  a21.a1 = -23;
  a22 = 24;
  a23 = -25;
  a24.a0 = 26;
  a24.a1 = -27;
  a24.a2 = 28;
  a25 = -29;
  a26 = 30;
  a27.a0 = -31.0;
  a27.a1 = 32.0;
  a28 = -33;
  a29 = 34;
  a30.a0 = -35.0;
  a30.a1 = 36;
  a30.a2 = -37;
  a31 = 38;
  a32 = -39;
  a33.a0 = 40;
  a33.a1 = -41;
  a33.a2 = 42;
  a34 = -43;
  a35 = 44;
  a36.a0 = -45;
  a36.a1 = 46;
  a36.a2 = -47;
  a37 = 48;
  a38 = -49;
  a39.a0 = 50;
  a39.a1 = -51;
  a39.a2 = 52;
 
  std::cout << "Calling TestPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int("
            << "(" << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", " << a7 << ", " << a8 << ", "
            << a9 << ", " << a10 << ", " << a11 << ", " << a12 << ", " << a13
            << ", " << a14 << ", " << a15 << ", " << a16 << ", "
            << static_cast<int>(a17) << ", (" << static_cast<int>(a18.a0)
            << "), " << a19 << ", " << static_cast<int>(a20) << ", (" << a21.a0
            << ", " << a21.a1 << "), " << a22 << ", " << static_cast<int>(a23)
            << ", (" << a24.a0 << ", " << a24.a1 << ", " << a24.a2 << "), "
            << a25 << ", " << static_cast<int>(a26) << ", (" << a27.a0 << ", "
            << a27.a1 << "), " << a28 << ", " << static_cast<int>(a29) << ", ("
            << a30.a0 << ", " << a30.a1 << ", " << a30.a2 << "), " << a31
            << ", " << static_cast<int>(a32) << ", ("
            << static_cast<int>(a33.a0) << ", " << a33.a1 << ", "
            << static_cast<int>(a33.a2) << "), " << a34 << ", "
            << static_cast<int>(a35) << ", (" << static_cast<int>(a36.a0)
            << ", " << a36.a1 << ", " << static_cast<int>(a36.a2) << "), "
            << a37 << ", " << static_cast<int>(a38) << ", ("
            << static_cast<int>(a39.a0) << ", " << a39.a1 << ", "
            << static_cast<int>(a39.a2) << "))" << ")\n";
 
  double result =
      f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
        a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29,
        a30, a31, a32, a33, a34, a35, a36, a37, a38, a39);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(26.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
             a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27,
             a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
             a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27,
             a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassInt64x7Struct12BytesHomogeneousInt32()

DART_EXPORT intptr_t dart::TestPassInt64x7Struct12BytesHomogeneousInt32

(

int64_t(*)(int64_t a0, int64_t a1, int64_t a2, int64_t a3, int64_t a4, int64_t a5, int64_t a6, Struct12BytesHomogeneousInt32 a7)

f

)

Definition at line 12260 of file ffi_test_functions_generated.cc.

                                                    {
  int64_t a0;
  int64_t a1;
  int64_t a2;
  int64_t a3;
  int64_t a4;
  int64_t a5;
  int64_t a6;
  Struct12BytesHomogeneousInt32 a7 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7.a0 = 8;
  a7.a1 = -9;
  a7.a2 = 10;
 
  std::cout << "Calling TestPassInt64x7Struct12BytesHomogeneousInt32(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(5, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassInt8Struct16BytesMixedInt8Struct16BytesMixedIn()

DART_EXPORT intptr_t dart::TestPassInt8Struct16BytesMixedInt8Struct16BytesMixedIn

(

double(*)(int8_t a0, Struct16BytesMixed a1, int8_t a2, Struct16BytesMixed a3, int8_t a4, Struct16BytesMixed a5, int8_t a6, Struct16BytesMixed a7, int8_t a8)

f

)

Definition at line 8868 of file ffi_test_functions_generated.cc.

                            {
  int8_t a0;
  Struct16BytesMixed a1 = {};
  int8_t a2;
  Struct16BytesMixed a3 = {};
  int8_t a4;
  Struct16BytesMixed a5 = {};
  int8_t a6;
  Struct16BytesMixed a7 = {};
  int8_t a8;
 
  a0 = -1;
  a1.a0 = 2.0;
  a1.a1 = -3;
  a2 = 4;
  a3.a0 = -5.0;
  a3.a1 = 6;
  a4 = -7;
  a5.a0 = 8.0;
  a5.a1 = -9;
  a6 = 10;
  a7.a0 = -11.0;
  a7.a1 = 12;
  a8 = -13;
 
  std::cout << "Calling TestPassInt8Struct16BytesMixedInt8Struct16BytesMixedIn("
            << "(" << static_cast<int>(a0) << ", (" << a1.a0 << ", " << a1.a1
            << "), " << static_cast<int>(a2) << ", (" << a3.a0 << ", " << a3.a1
            << "), " << static_cast<int>(a4) << ", (" << a5.a0 << ", " << a5.a1
            << "), " << static_cast<int>(a6) << ", (" << a7.a0 << ", " << a7.a1
            << "), " << static_cast<int>(a8) << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-7.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct1024BytesHomogeneousUint64()

DART_EXPORT intptr_t dart::TestPassStruct1024BytesHomogeneousUint64

(

uint64_t(*)(Struct1024BytesHomogeneousUint64 a0)

f

)

Definition at line 8514 of file ffi_test_functions_generated.cc.

                                                        {
  Struct1024BytesHomogeneousUint64 a0 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a0.a5 = 6;
  a0.a6 = 7;
  a0.a7 = 8;
  a0.a8 = 9;
  a0.a9 = 10;
  a0.a10 = 11;
  a0.a11 = 12;
  a0.a12 = 13;
  a0.a13 = 14;
  a0.a14 = 15;
  a0.a15 = 16;
  a0.a16 = 17;
  a0.a17 = 18;
  a0.a18 = 19;
  a0.a19 = 20;
  a0.a20 = 21;
  a0.a21 = 22;
  a0.a22 = 23;
  a0.a23 = 24;
  a0.a24 = 25;
  a0.a25 = 26;
  a0.a26 = 27;
  a0.a27 = 28;
  a0.a28 = 29;
  a0.a29 = 30;
  a0.a30 = 31;
  a0.a31 = 32;
  a0.a32 = 33;
  a0.a33 = 34;
  a0.a34 = 35;
  a0.a35 = 36;
  a0.a36 = 37;
  a0.a37 = 38;
  a0.a38 = 39;
  a0.a39 = 40;
  a0.a40 = 41;
  a0.a41 = 42;
  a0.a42 = 43;
  a0.a43 = 44;
  a0.a44 = 45;
  a0.a45 = 46;
  a0.a46 = 47;
  a0.a47 = 48;
  a0.a48 = 49;
  a0.a49 = 50;
  a0.a50 = 51;
  a0.a51 = 52;
  a0.a52 = 53;
  a0.a53 = 54;
  a0.a54 = 55;
  a0.a55 = 56;
  a0.a56 = 57;
  a0.a57 = 58;
  a0.a58 = 59;
  a0.a59 = 60;
  a0.a60 = 61;
  a0.a61 = 62;
  a0.a62 = 63;
  a0.a63 = 64;
  a0.a64 = 65;
  a0.a65 = 66;
  a0.a66 = 67;
  a0.a67 = 68;
  a0.a68 = 69;
  a0.a69 = 70;
  a0.a70 = 71;
  a0.a71 = 72;
  a0.a72 = 73;
  a0.a73 = 74;
  a0.a74 = 75;
  a0.a75 = 76;
  a0.a76 = 77;
  a0.a77 = 78;
  a0.a78 = 79;
  a0.a79 = 80;
  a0.a80 = 81;
  a0.a81 = 82;
  a0.a82 = 83;
  a0.a83 = 84;
  a0.a84 = 85;
  a0.a85 = 86;
  a0.a86 = 87;
  a0.a87 = 88;
  a0.a88 = 89;
  a0.a89 = 90;
  a0.a90 = 91;
  a0.a91 = 92;
  a0.a92 = 93;
  a0.a93 = 94;
  a0.a94 = 95;
  a0.a95 = 96;
  a0.a96 = 97;
  a0.a97 = 98;
  a0.a98 = 99;
  a0.a99 = 100;
  a0.a100 = 101;
  a0.a101 = 102;
  a0.a102 = 103;
  a0.a103 = 104;
  a0.a104 = 105;
  a0.a105 = 106;
  a0.a106 = 107;
  a0.a107 = 108;
  a0.a108 = 109;
  a0.a109 = 110;
  a0.a110 = 111;
  a0.a111 = 112;
  a0.a112 = 113;
  a0.a113 = 114;
  a0.a114 = 115;
  a0.a115 = 116;
  a0.a116 = 117;
  a0.a117 = 118;
  a0.a118 = 119;
  a0.a119 = 120;
  a0.a120 = 121;
  a0.a121 = 122;
  a0.a122 = 123;
  a0.a123 = 124;
  a0.a124 = 125;
  a0.a125 = 126;
  a0.a126 = 127;
  a0.a127 = 128;
 
  std::cout << "Calling TestPassStruct1024BytesHomogeneousUint64(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << ", " << a0.a5 << ", " << a0.a6 << ", " << a0.a7 << ", "
            << a0.a8 << ", " << a0.a9 << ", " << a0.a10 << ", " << a0.a11
            << ", " << a0.a12 << ", " << a0.a13 << ", " << a0.a14 << ", "
            << a0.a15 << ", " << a0.a16 << ", " << a0.a17 << ", " << a0.a18
            << ", " << a0.a19 << ", " << a0.a20 << ", " << a0.a21 << ", "
            << a0.a22 << ", " << a0.a23 << ", " << a0.a24 << ", " << a0.a25
            << ", " << a0.a26 << ", " << a0.a27 << ", " << a0.a28 << ", "
            << a0.a29 << ", " << a0.a30 << ", " << a0.a31 << ", " << a0.a32
            << ", " << a0.a33 << ", " << a0.a34 << ", " << a0.a35 << ", "
            << a0.a36 << ", " << a0.a37 << ", " << a0.a38 << ", " << a0.a39
            << ", " << a0.a40 << ", " << a0.a41 << ", " << a0.a42 << ", "
            << a0.a43 << ", " << a0.a44 << ", " << a0.a45 << ", " << a0.a46
            << ", " << a0.a47 << ", " << a0.a48 << ", " << a0.a49 << ", "
            << a0.a50 << ", " << a0.a51 << ", " << a0.a52 << ", " << a0.a53
            << ", " << a0.a54 << ", " << a0.a55 << ", " << a0.a56 << ", "
            << a0.a57 << ", " << a0.a58 << ", " << a0.a59 << ", " << a0.a60
            << ", " << a0.a61 << ", " << a0.a62 << ", " << a0.a63 << ", "
            << a0.a64 << ", " << a0.a65 << ", " << a0.a66 << ", " << a0.a67
            << ", " << a0.a68 << ", " << a0.a69 << ", " << a0.a70 << ", "
            << a0.a71 << ", " << a0.a72 << ", " << a0.a73 << ", " << a0.a74
            << ", " << a0.a75 << ", " << a0.a76 << ", " << a0.a77 << ", "
            << a0.a78 << ", " << a0.a79 << ", " << a0.a80 << ", " << a0.a81
            << ", " << a0.a82 << ", " << a0.a83 << ", " << a0.a84 << ", "
            << a0.a85 << ", " << a0.a86 << ", " << a0.a87 << ", " << a0.a88
            << ", " << a0.a89 << ", " << a0.a90 << ", " << a0.a91 << ", "
            << a0.a92 << ", " << a0.a93 << ", " << a0.a94 << ", " << a0.a95
            << ", " << a0.a96 << ", " << a0.a97 << ", " << a0.a98 << ", "
            << a0.a99 << ", " << a0.a100 << ", " << a0.a101 << ", " << a0.a102
            << ", " << a0.a103 << ", " << a0.a104 << ", " << a0.a105 << ", "
            << a0.a106 << ", " << a0.a107 << ", " << a0.a108 << ", " << a0.a109
            << ", " << a0.a110 << ", " << a0.a111 << ", " << a0.a112 << ", "
            << a0.a113 << ", " << a0.a114 << ", " << a0.a115 << ", " << a0.a116
            << ", " << a0.a117 << ", " << a0.a118 << ", " << a0.a119 << ", "
            << a0.a120 << ", " << a0.a121 << ", " << a0.a122 << ", " << a0.a123
            << ", " << a0.a124 << ", " << a0.a125 << ", " << a0.a126 << ", "
            << a0.a127 << "))" << ")\n";
 
  uint64_t result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(8256, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct12BytesHomogeneousFloatx6()

DART_EXPORT intptr_t dart::TestPassStruct12BytesHomogeneousFloatx6

(

float(*)(Struct12BytesHomogeneousFloat a0, Struct12BytesHomogeneousFloat a1, Struct12BytesHomogeneousFloat a2, Struct12BytesHomogeneousFloat a3, Struct12BytesHomogeneousFloat a4, Struct12BytesHomogeneousFloat a5)

f

)

Definition at line 7492 of file ffi_test_functions_generated.cc.

                                                  {
  Struct12BytesHomogeneousFloat a0 = {};
  Struct12BytesHomogeneousFloat a1 = {};
  Struct12BytesHomogeneousFloat a2 = {};
  Struct12BytesHomogeneousFloat a3 = {};
  Struct12BytesHomogeneousFloat a4 = {};
  Struct12BytesHomogeneousFloat a5 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a1.a0 = 4.0;
  a1.a1 = -5.0;
  a1.a2 = 6.0;
  a2.a0 = -7.0;
  a2.a1 = 8.0;
  a2.a2 = -9.0;
  a3.a0 = 10.0;
  a3.a1 = -11.0;
  a3.a2 = 12.0;
  a4.a0 = -13.0;
  a4.a1 = 14.0;
  a4.a2 = -15.0;
  a5.a0 = 16.0;
  a5.a1 = -17.0;
  a5.a2 = 18.0;
 
  std::cout << "Calling TestPassStruct12BytesHomogeneousFloatx6(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << "), (" << a1.a0
            << ", " << a1.a1 << ", " << a1.a2 << "), (" << a2.a0 << ", "
            << a2.a1 << ", " << a2.a2 << "), (" << a3.a0 << ", " << a3.a1
            << ", " << a3.a2 << "), (" << a4.a0 << ", " << a4.a1 << ", "
            << a4.a2 << "), (" << a5.a0 << ", " << a5.a1 << ", " << a5.a2
            << "))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4, a5);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(9.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct15BytesInlineArrayMixed()

DART_EXPORT intptr_t dart::TestPassStruct15BytesInlineArrayMixed

(

double(*)(Struct15BytesInlineArrayMixed a0)

f

)

Definition at line 11546 of file ffi_test_functions_generated.cc.

                                                   {
  Struct15BytesInlineArrayMixed a0 = {};
 
  a0.a0[0].a0 = -1.0;
  a0.a0[0].a1 = 2;
  a0.a0[1].a0 = -3.0;
  a0.a0[1].a1 = 4;
  a0.a0[2].a0 = -5.0;
  a0.a0[2].a1 = 6;
 
  std::cout << "Calling TestPassStruct15BytesInlineArrayMixed(" << "(([("
            << a0.a0[0].a0 << ", " << static_cast<int>(a0.a0[0].a1) << "), ("
            << a0.a0[1].a0 << ", " << static_cast<int>(a0.a0[1].a1) << "), ("
            << a0.a0[2].a0 << ", " << static_cast<int>(a0.a0[2].a1) << ")]))"
            << ")\n";
 
  double result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(3.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0[0].a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0[0].a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct16BytesHomogeneousFloatx5()

DART_EXPORT intptr_t dart::TestPassStruct16BytesHomogeneousFloatx5

(

float(*)(Struct16BytesHomogeneousFloat a0, Struct16BytesHomogeneousFloat a1, Struct16BytesHomogeneousFloat a2, Struct16BytesHomogeneousFloat a3, Struct16BytesHomogeneousFloat a4)

f

)

Definition at line 7561 of file ffi_test_functions_generated.cc.

                                                  {
  Struct16BytesHomogeneousFloat a0 = {};
  Struct16BytesHomogeneousFloat a1 = {};
  Struct16BytesHomogeneousFloat a2 = {};
  Struct16BytesHomogeneousFloat a3 = {};
  Struct16BytesHomogeneousFloat a4 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a1.a0 = -5.0;
  a1.a1 = 6.0;
  a1.a2 = -7.0;
  a1.a3 = 8.0;
  a2.a0 = -9.0;
  a2.a1 = 10.0;
  a2.a2 = -11.0;
  a2.a3 = 12.0;
  a3.a0 = -13.0;
  a3.a1 = 14.0;
  a3.a2 = -15.0;
  a3.a3 = 16.0;
  a4.a0 = -17.0;
  a4.a1 = 18.0;
  a4.a2 = -19.0;
  a4.a3 = 20.0;
 
  std::cout << "Calling TestPassStruct16BytesHomogeneousFloatx5(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
            << "), (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", "
            << a1.a3 << "), (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2
            << ", " << a2.a3 << "), (" << a3.a0 << ", " << a3.a1 << ", "
            << a3.a2 << ", " << a3.a3 << "), (" << a4.a0 << ", " << a4.a1
            << ", " << a4.a2 << ", " << a4.a3 << "))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct16BytesMixed2x10()

DART_EXPORT intptr_t dart::TestPassStruct16BytesMixed2x10

(

float(*)(Struct16BytesMixed2 a0, Struct16BytesMixed2 a1, Struct16BytesMixed2 a2, Struct16BytesMixed2 a3, Struct16BytesMixed2 a4, Struct16BytesMixed2 a5, Struct16BytesMixed2 a6, Struct16BytesMixed2 a7, Struct16BytesMixed2 a8, Struct16BytesMixed2 a9)

f

)

Definition at line 7711 of file ffi_test_functions_generated.cc.

                                        {
  Struct16BytesMixed2 a0 = {};
  Struct16BytesMixed2 a1 = {};
  Struct16BytesMixed2 a2 = {};
  Struct16BytesMixed2 a3 = {};
  Struct16BytesMixed2 a4 = {};
  Struct16BytesMixed2 a5 = {};
  Struct16BytesMixed2 a6 = {};
  Struct16BytesMixed2 a7 = {};
  Struct16BytesMixed2 a8 = {};
  Struct16BytesMixed2 a9 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4;
  a1.a0 = -5.0;
  a1.a1 = 6.0;
  a1.a2 = -7.0;
  a1.a3 = 8;
  a2.a0 = -9.0;
  a2.a1 = 10.0;
  a2.a2 = -11.0;
  a2.a3 = 12;
  a3.a0 = -13.0;
  a3.a1 = 14.0;
  a3.a2 = -15.0;
  a3.a3 = 16;
  a4.a0 = -17.0;
  a4.a1 = 18.0;
  a4.a2 = -19.0;
  a4.a3 = 20;
  a5.a0 = -21.0;
  a5.a1 = 22.0;
  a5.a2 = -23.0;
  a5.a3 = 24;
  a6.a0 = -25.0;
  a6.a1 = 26.0;
  a6.a2 = -27.0;
  a6.a3 = 28;
  a7.a0 = -29.0;
  a7.a1 = 30.0;
  a7.a2 = -31.0;
  a7.a3 = 32;
  a8.a0 = -33.0;
  a8.a1 = 34.0;
  a8.a2 = -35.0;
  a8.a3 = 36;
  a9.a0 = -37.0;
  a9.a1 = 38.0;
  a9.a2 = -39.0;
  a9.a3 = 40;
 
  std::cout << "Calling TestPassStruct16BytesMixed2x10(" << "((" << a0.a0
            << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << "), ("
            << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", " << a1.a3
            << "), (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2 << ", "
            << a2.a3 << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2
            << ", " << a3.a3 << "), (" << a4.a0 << ", " << a4.a1 << ", "
            << a4.a2 << ", " << a4.a3 << "), (" << a5.a0 << ", " << a5.a1
            << ", " << a5.a2 << ", " << a5.a3 << "), (" << a6.a0 << ", "
            << a6.a1 << ", " << a6.a2 << ", " << a6.a3 << "), (" << a7.a0
            << ", " << a7.a1 << ", " << a7.a2 << ", " << a7.a3 << "), ("
            << a8.a0 << ", " << a8.a1 << ", " << a8.a2 << ", " << a8.a3
            << "), (" << a9.a0 << ", " << a9.a1 << ", " << a9.a2 << ", "
            << a9.a3 << "))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(20.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct16BytesMixedx10()

DART_EXPORT intptr_t dart::TestPassStruct16BytesMixedx10

(

double(*)(Struct16BytesMixed a0, Struct16BytesMixed a1, Struct16BytesMixed a2, Struct16BytesMixed a3, Struct16BytesMixed a4, Struct16BytesMixed a5, Struct16BytesMixed a6, Struct16BytesMixed a7, Struct16BytesMixed a8, Struct16BytesMixed a9)

f

)

Definition at line 7631 of file ffi_test_functions_generated.cc.

                                        {
  Struct16BytesMixed a0 = {};
  Struct16BytesMixed a1 = {};
  Struct16BytesMixed a2 = {};
  Struct16BytesMixed a3 = {};
  Struct16BytesMixed a4 = {};
  Struct16BytesMixed a5 = {};
  Struct16BytesMixed a6 = {};
  Struct16BytesMixed a7 = {};
  Struct16BytesMixed a8 = {};
  Struct16BytesMixed a9 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2;
  a1.a0 = -3.0;
  a1.a1 = 4;
  a2.a0 = -5.0;
  a2.a1 = 6;
  a3.a0 = -7.0;
  a3.a1 = 8;
  a4.a0 = -9.0;
  a4.a1 = 10;
  a5.a0 = -11.0;
  a5.a1 = 12;
  a6.a0 = -13.0;
  a6.a1 = 14;
  a7.a0 = -15.0;
  a7.a1 = 16;
  a8.a0 = -17.0;
  a8.a1 = 18;
  a9.a0 = -19.0;
  a9.a1 = 20;
 
  std::cout << "Calling TestPassStruct16BytesMixedx10(" << "((" << a0.a0 << ", "
            << a0.a1 << "), (" << a1.a0 << ", " << a1.a1 << "), (" << a2.a0
            << ", " << a2.a1 << "), (" << a3.a0 << ", " << a3.a1 << "), ("
            << a4.a0 << ", " << a4.a1 << "), (" << a5.a0 << ", " << a5.a1
            << "), (" << a6.a0 << ", " << a6.a1 << "), (" << a7.a0 << ", "
            << a7.a1 << "), (" << a8.a0 << ", " << a8.a1 << "), (" << a9.a0
            << ", " << a9.a1 << "))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct16BytesNestedIntx2()

DART_EXPORT intptr_t dart::TestPassStruct16BytesNestedIntx2

(

int64_t(*)(Struct16BytesNestedInt a0, Struct16BytesNestedInt a1)

f

)

Definition at line 9790 of file ffi_test_functions_generated.cc.

                                                                        {
  Struct16BytesNestedInt a0 = {};
  Struct16BytesNestedInt a1 = {};
 
  a0.a0.a0.a0 = -1;
  a0.a0.a0.a1 = 2;
  a0.a0.a1.a0 = -3;
  a0.a0.a1.a1 = 4;
  a0.a1.a0.a0 = -5;
  a0.a1.a0.a1 = 6;
  a0.a1.a1.a0 = -7;
  a0.a1.a1.a1 = 8;
  a1.a0.a0.a0 = -9;
  a1.a0.a0.a1 = 10;
  a1.a0.a1.a0 = -11;
  a1.a0.a1.a1 = 12;
  a1.a1.a0.a0 = -13;
  a1.a1.a0.a1 = 14;
  a1.a1.a1.a0 = -15;
  a1.a1.a1.a1 = 16;
 
  std::cout << "Calling TestPassStruct16BytesNestedIntx2(" << "(((("
            << a0.a0.a0.a0 << ", " << a0.a0.a0.a1 << "), (" << a0.a0.a1.a0
            << ", " << a0.a0.a1.a1 << ")), ((" << a0.a1.a0.a0 << ", "
            << a0.a1.a0.a1 << "), (" << a0.a1.a1.a0 << ", " << a0.a1.a1.a1
            << "))), (((" << a1.a0.a0.a0 << ", " << a1.a0.a0.a1 << "), ("
            << a1.a0.a1.a0 << ", " << a1.a0.a1.a1 << ")), ((" << a1.a1.a0.a0
            << ", " << a1.a1.a0.a1 << "), (" << a1.a1.a1.a0 << ", "
            << a1.a1.a1.a1 << "))))" << ")\n";
 
  int64_t result = f(a0, a1);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(8, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct17BytesIntx10()

DART_EXPORT intptr_t dart::TestPassStruct17BytesIntx10

(

int64_t(*)(Struct17BytesInt a0, Struct17BytesInt a1, Struct17BytesInt a2, Struct17BytesInt a3, Struct17BytesInt a4, Struct17BytesInt a5, Struct17BytesInt a6, Struct17BytesInt a7, Struct17BytesInt a8, Struct17BytesInt a9)

f

)

Definition at line 7815 of file ffi_test_functions_generated.cc.

                                       {
  Struct17BytesInt a0 = {};
  Struct17BytesInt a1 = {};
  Struct17BytesInt a2 = {};
  Struct17BytesInt a3 = {};
  Struct17BytesInt a4 = {};
  Struct17BytesInt a5 = {};
  Struct17BytesInt a6 = {};
  Struct17BytesInt a7 = {};
  Struct17BytesInt a8 = {};
  Struct17BytesInt a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
  a2.a0 = -7;
  a2.a1 = 8;
  a2.a2 = -9;
  a3.a0 = 10;
  a3.a1 = -11;
  a3.a2 = 12;
  a4.a0 = -13;
  a4.a1 = 14;
  a4.a2 = -15;
  a5.a0 = 16;
  a5.a1 = -17;
  a5.a2 = 18;
  a6.a0 = -19;
  a6.a1 = 20;
  a6.a2 = -21;
  a7.a0 = 22;
  a7.a1 = -23;
  a7.a2 = 24;
  a8.a0 = -25;
  a8.a1 = 26;
  a8.a2 = -27;
  a9.a0 = 28;
  a9.a1 = -29;
  a9.a2 = 30;
 
  std::cout << "Calling TestPassStruct17BytesIntx10(" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << static_cast<int>(a0.a2) << "), (" << a1.a0
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "), ("
            << a2.a0 << ", " << a2.a1 << ", " << static_cast<int>(a2.a2)
            << "), (" << a3.a0 << ", " << a3.a1 << ", "
            << static_cast<int>(a3.a2) << "), (" << a4.a0 << ", " << a4.a1
            << ", " << static_cast<int>(a4.a2) << "), (" << a5.a0 << ", "
            << a5.a1 << ", " << static_cast<int>(a5.a2) << "), (" << a6.a0
            << ", " << a6.a1 << ", " << static_cast<int>(a6.a2) << "), ("
            << a7.a0 << ", " << a7.a1 << ", " << static_cast<int>(a7.a2)
            << "), (" << a8.a0 << ", " << a8.a1 << ", "
            << static_cast<int>(a8.a2) << "), (" << a9.a0 << ", " << a9.a1
            << ", " << static_cast<int>(a9.a2) << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(15, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct19BytesHomogeneousUint8x10()

DART_EXPORT intptr_t dart::TestPassStruct19BytesHomogeneousUint8x10

(

int64_t(*)(Struct19BytesHomogeneousUint8 a0, Struct19BytesHomogeneousUint8 a1, Struct19BytesHomogeneousUint8 a2, Struct19BytesHomogeneousUint8 a3, Struct19BytesHomogeneousUint8 a4, Struct19BytesHomogeneousUint8 a5, Struct19BytesHomogeneousUint8 a6, Struct19BytesHomogeneousUint8 a7, Struct19BytesHomogeneousUint8 a8, Struct19BytesHomogeneousUint8 a9)

f

)

Definition at line 7910 of file ffi_test_functions_generated.cc.

                                                    {
  Struct19BytesHomogeneousUint8 a0 = {};
  Struct19BytesHomogeneousUint8 a1 = {};
  Struct19BytesHomogeneousUint8 a2 = {};
  Struct19BytesHomogeneousUint8 a3 = {};
  Struct19BytesHomogeneousUint8 a4 = {};
  Struct19BytesHomogeneousUint8 a5 = {};
  Struct19BytesHomogeneousUint8 a6 = {};
  Struct19BytesHomogeneousUint8 a7 = {};
  Struct19BytesHomogeneousUint8 a8 = {};
  Struct19BytesHomogeneousUint8 a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a0.a5 = 6;
  a0.a6 = 7;
  a0.a7 = 8;
  a0.a8 = 9;
  a0.a9 = 10;
  a0.a10 = 11;
  a0.a11 = 12;
  a0.a12 = 13;
  a0.a13 = 14;
  a0.a14 = 15;
  a0.a15 = 16;
  a0.a16 = 17;
  a0.a17 = 18;
  a0.a18 = 19;
  a1.a0 = 20;
  a1.a1 = 21;
  a1.a2 = 22;
  a1.a3 = 23;
  a1.a4 = 24;
  a1.a5 = 25;
  a1.a6 = 26;
  a1.a7 = 27;
  a1.a8 = 28;
  a1.a9 = 29;
  a1.a10 = 30;
  a1.a11 = 31;
  a1.a12 = 32;
  a1.a13 = 33;
  a1.a14 = 34;
  a1.a15 = 35;
  a1.a16 = 36;
  a1.a17 = 37;
  a1.a18 = 38;
  a2.a0 = 39;
  a2.a1 = 40;
  a2.a2 = 41;
  a2.a3 = 42;
  a2.a4 = 43;
  a2.a5 = 44;
  a2.a6 = 45;
  a2.a7 = 46;
  a2.a8 = 47;
  a2.a9 = 48;
  a2.a10 = 49;
  a2.a11 = 50;
  a2.a12 = 51;
  a2.a13 = 52;
  a2.a14 = 53;
  a2.a15 = 54;
  a2.a16 = 55;
  a2.a17 = 56;
  a2.a18 = 57;
  a3.a0 = 58;
  a3.a1 = 59;
  a3.a2 = 60;
  a3.a3 = 61;
  a3.a4 = 62;
  a3.a5 = 63;
  a3.a6 = 64;
  a3.a7 = 65;
  a3.a8 = 66;
  a3.a9 = 67;
  a3.a10 = 68;
  a3.a11 = 69;
  a3.a12 = 70;
  a3.a13 = 71;
  a3.a14 = 72;
  a3.a15 = 73;
  a3.a16 = 74;
  a3.a17 = 75;
  a3.a18 = 76;
  a4.a0 = 77;
  a4.a1 = 78;
  a4.a2 = 79;
  a4.a3 = 80;
  a4.a4 = 81;
  a4.a5 = 82;
  a4.a6 = 83;
  a4.a7 = 84;
  a4.a8 = 85;
  a4.a9 = 86;
  a4.a10 = 87;
  a4.a11 = 88;
  a4.a12 = 89;
  a4.a13 = 90;
  a4.a14 = 91;
  a4.a15 = 92;
  a4.a16 = 93;
  a4.a17 = 94;
  a4.a18 = 95;
  a5.a0 = 96;
  a5.a1 = 97;
  a5.a2 = 98;
  a5.a3 = 99;
  a5.a4 = 100;
  a5.a5 = 101;
  a5.a6 = 102;
  a5.a7 = 103;
  a5.a8 = 104;
  a5.a9 = 105;
  a5.a10 = 106;
  a5.a11 = 107;
  a5.a12 = 108;
  a5.a13 = 109;
  a5.a14 = 110;
  a5.a15 = 111;
  a5.a16 = 112;
  a5.a17 = 113;
  a5.a18 = 114;
  a6.a0 = 115;
  a6.a1 = 116;
  a6.a2 = 117;
  a6.a3 = 118;
  a6.a4 = 119;
  a6.a5 = 120;
  a6.a6 = 121;
  a6.a7 = 122;
  a6.a8 = 123;
  a6.a9 = 124;
  a6.a10 = 125;
  a6.a11 = 126;
  a6.a12 = 127;
  a6.a13 = 128;
  a6.a14 = 129;
  a6.a15 = 130;
  a6.a16 = 131;
  a6.a17 = 132;
  a6.a18 = 133;
  a7.a0 = 134;
  a7.a1 = 135;
  a7.a2 = 136;
  a7.a3 = 137;
  a7.a4 = 138;
  a7.a5 = 139;
  a7.a6 = 140;
  a7.a7 = 141;
  a7.a8 = 142;
  a7.a9 = 143;
  a7.a10 = 144;
  a7.a11 = 145;
  a7.a12 = 146;
  a7.a13 = 147;
  a7.a14 = 148;
  a7.a15 = 149;
  a7.a16 = 150;
  a7.a17 = 151;
  a7.a18 = 152;
  a8.a0 = 153;
  a8.a1 = 154;
  a8.a2 = 155;
  a8.a3 = 156;
  a8.a4 = 157;
  a8.a5 = 158;
  a8.a6 = 159;
  a8.a7 = 160;
  a8.a8 = 161;
  a8.a9 = 162;
  a8.a10 = 163;
  a8.a11 = 164;
  a8.a12 = 165;
  a8.a13 = 166;
  a8.a14 = 167;
  a8.a15 = 168;
  a8.a16 = 169;
  a8.a17 = 170;
  a8.a18 = 171;
  a9.a0 = 172;
  a9.a1 = 173;
  a9.a2 = 174;
  a9.a3 = 175;
  a9.a4 = 176;
  a9.a5 = 177;
  a9.a6 = 178;
  a9.a7 = 179;
  a9.a8 = 180;
  a9.a9 = 181;
  a9.a10 = 182;
  a9.a11 = 183;
  a9.a12 = 184;
  a9.a13 = 185;
  a9.a14 = 186;
  a9.a15 = 187;
  a9.a16 = 188;
  a9.a17 = 189;
  a9.a18 = 190;
 
  std::cout
      << "Calling TestPassStruct19BytesHomogeneousUint8x10(" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << ", " << static_cast<int>(a0.a7) << ", "
      << static_cast<int>(a0.a8) << ", " << static_cast<int>(a0.a9) << ", "
      << static_cast<int>(a0.a10) << ", " << static_cast<int>(a0.a11) << ", "
      << static_cast<int>(a0.a12) << ", " << static_cast<int>(a0.a13) << ", "
      << static_cast<int>(a0.a14) << ", " << static_cast<int>(a0.a15) << ", "
      << static_cast<int>(a0.a16) << ", " << static_cast<int>(a0.a17) << ", "
      << static_cast<int>(a0.a18) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << ", "
      << static_cast<int>(a1.a7) << ", " << static_cast<int>(a1.a8) << ", "
      << static_cast<int>(a1.a9) << ", " << static_cast<int>(a1.a10) << ", "
      << static_cast<int>(a1.a11) << ", " << static_cast<int>(a1.a12) << ", "
      << static_cast<int>(a1.a13) << ", " << static_cast<int>(a1.a14) << ", "
      << static_cast<int>(a1.a15) << ", " << static_cast<int>(a1.a16) << ", "
      << static_cast<int>(a1.a17) << ", " << static_cast<int>(a1.a18) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << ", " << static_cast<int>(a2.a7) << ", "
      << static_cast<int>(a2.a8) << ", " << static_cast<int>(a2.a9) << ", "
      << static_cast<int>(a2.a10) << ", " << static_cast<int>(a2.a11) << ", "
      << static_cast<int>(a2.a12) << ", " << static_cast<int>(a2.a13) << ", "
      << static_cast<int>(a2.a14) << ", " << static_cast<int>(a2.a15) << ", "
      << static_cast<int>(a2.a16) << ", " << static_cast<int>(a2.a17) << ", "
      << static_cast<int>(a2.a18) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << ", "
      << static_cast<int>(a3.a7) << ", " << static_cast<int>(a3.a8) << ", "
      << static_cast<int>(a3.a9) << ", " << static_cast<int>(a3.a10) << ", "
      << static_cast<int>(a3.a11) << ", " << static_cast<int>(a3.a12) << ", "
      << static_cast<int>(a3.a13) << ", " << static_cast<int>(a3.a14) << ", "
      << static_cast<int>(a3.a15) << ", " << static_cast<int>(a3.a16) << ", "
      << static_cast<int>(a3.a17) << ", " << static_cast<int>(a3.a18) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << ", " << static_cast<int>(a4.a7) << ", "
      << static_cast<int>(a4.a8) << ", " << static_cast<int>(a4.a9) << ", "
      << static_cast<int>(a4.a10) << ", " << static_cast<int>(a4.a11) << ", "
      << static_cast<int>(a4.a12) << ", " << static_cast<int>(a4.a13) << ", "
      << static_cast<int>(a4.a14) << ", " << static_cast<int>(a4.a15) << ", "
      << static_cast<int>(a4.a16) << ", " << static_cast<int>(a4.a17) << ", "
      << static_cast<int>(a4.a18) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << ", "
      << static_cast<int>(a5.a7) << ", " << static_cast<int>(a5.a8) << ", "
      << static_cast<int>(a5.a9) << ", " << static_cast<int>(a5.a10) << ", "
      << static_cast<int>(a5.a11) << ", " << static_cast<int>(a5.a12) << ", "
      << static_cast<int>(a5.a13) << ", " << static_cast<int>(a5.a14) << ", "
      << static_cast<int>(a5.a15) << ", " << static_cast<int>(a5.a16) << ", "
      << static_cast<int>(a5.a17) << ", " << static_cast<int>(a5.a18) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << ", " << static_cast<int>(a6.a7) << ", "
      << static_cast<int>(a6.a8) << ", " << static_cast<int>(a6.a9) << ", "
      << static_cast<int>(a6.a10) << ", " << static_cast<int>(a6.a11) << ", "
      << static_cast<int>(a6.a12) << ", " << static_cast<int>(a6.a13) << ", "
      << static_cast<int>(a6.a14) << ", " << static_cast<int>(a6.a15) << ", "
      << static_cast<int>(a6.a16) << ", " << static_cast<int>(a6.a17) << ", "
      << static_cast<int>(a6.a18) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << ", "
      << static_cast<int>(a7.a7) << ", " << static_cast<int>(a7.a8) << ", "
      << static_cast<int>(a7.a9) << ", " << static_cast<int>(a7.a10) << ", "
      << static_cast<int>(a7.a11) << ", " << static_cast<int>(a7.a12) << ", "
      << static_cast<int>(a7.a13) << ", " << static_cast<int>(a7.a14) << ", "
      << static_cast<int>(a7.a15) << ", " << static_cast<int>(a7.a16) << ", "
      << static_cast<int>(a7.a17) << ", " << static_cast<int>(a7.a18) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << ", " << static_cast<int>(a8.a7) << ", "
      << static_cast<int>(a8.a8) << ", " << static_cast<int>(a8.a9) << ", "
      << static_cast<int>(a8.a10) << ", " << static_cast<int>(a8.a11) << ", "
      << static_cast<int>(a8.a12) << ", " << static_cast<int>(a8.a13) << ", "
      << static_cast<int>(a8.a14) << ", " << static_cast<int>(a8.a15) << ", "
      << static_cast<int>(a8.a16) << ", " << static_cast<int>(a8.a17) << ", "
      << static_cast<int>(a8.a18) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << ", "
      << static_cast<int>(a9.a7) << ", " << static_cast<int>(a9.a8) << ", "
      << static_cast<int>(a9.a9) << ", " << static_cast<int>(a9.a10) << ", "
      << static_cast<int>(a9.a11) << ", " << static_cast<int>(a9.a12) << ", "
      << static_cast<int>(a9.a13) << ", " << static_cast<int>(a9.a14) << ", "
      << static_cast<int>(a9.a15) << ", " << static_cast<int>(a9.a16) << ", "
      << static_cast<int>(a9.a17) << ", " << static_cast<int>(a9.a18) << "))"
      << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(18145, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct1ByteIntx10()

DART_EXPORT intptr_t dart::TestPassStruct1ByteIntx10

(

int64_t(*)(Struct1ByteInt a0, Struct1ByteInt a1, Struct1ByteInt a2, Struct1ByteInt a3, Struct1ByteInt a4, Struct1ByteInt a5, Struct1ByteInt a6, Struct1ByteInt a7, Struct1ByteInt a8, Struct1ByteInt a9)

f

)

Definition at line 6368 of file ffi_test_functions_generated.cc.

                                     {
  Struct1ByteInt a0 = {};
  Struct1ByteInt a1 = {};
  Struct1ByteInt a2 = {};
  Struct1ByteInt a3 = {};
  Struct1ByteInt a4 = {};
  Struct1ByteInt a5 = {};
  Struct1ByteInt a6 = {};
  Struct1ByteInt a7 = {};
  Struct1ByteInt a8 = {};
  Struct1ByteInt a9 = {};
 
  a0.a0 = -1;
  a1.a0 = 2;
  a2.a0 = -3;
  a3.a0 = 4;
  a4.a0 = -5;
  a5.a0 = 6;
  a6.a0 = -7;
  a7.a0 = 8;
  a8.a0 = -9;
  a9.a0 = 10;
 
  std::cout << "Calling TestPassStruct1ByteIntx10(" << "(("
            << static_cast<int>(a0.a0) << "), (" << static_cast<int>(a1.a0)
            << "), (" << static_cast<int>(a2.a0) << "), ("
            << static_cast<int>(a3.a0) << "), (" << static_cast<int>(a4.a0)
            << "), (" << static_cast<int>(a5.a0) << "), ("
            << static_cast<int>(a6.a0) << "), (" << static_cast<int>(a7.a0)
            << "), (" << static_cast<int>(a8.a0) << "), ("
            << static_cast<int>(a9.a0) << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(5, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct20BytesHomogeneousFloat()

DART_EXPORT intptr_t dart::TestPassStruct20BytesHomogeneousFloat

(

float(*)(Struct20BytesHomogeneousFloat a0)

f

)

Definition at line 8366 of file ffi_test_functions_generated.cc.

                                                  {
  Struct20BytesHomogeneousFloat a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a0.a4 = -5.0;
 
  std::cout << "Calling TestPassStruct20BytesHomogeneousFloat(" << "((" << a0.a0
            << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", " << a0.a4
            << "))" << ")\n";
 
  float result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-3.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct20BytesHomogeneousInt32x10()

DART_EXPORT intptr_t dart::TestPassStruct20BytesHomogeneousInt32x10

(

int32_t(*)(Struct20BytesHomogeneousInt32 a0, Struct20BytesHomogeneousInt32 a1, Struct20BytesHomogeneousInt32 a2, Struct20BytesHomogeneousInt32 a3, Struct20BytesHomogeneousInt32 a4, Struct20BytesHomogeneousInt32 a5, Struct20BytesHomogeneousInt32 a6, Struct20BytesHomogeneousInt32 a7, Struct20BytesHomogeneousInt32 a8, Struct20BytesHomogeneousInt32 a9)

f

)

Definition at line 8251 of file ffi_test_functions_generated.cc.

                                                    {
  Struct20BytesHomogeneousInt32 a0 = {};
  Struct20BytesHomogeneousInt32 a1 = {};
  Struct20BytesHomogeneousInt32 a2 = {};
  Struct20BytesHomogeneousInt32 a3 = {};
  Struct20BytesHomogeneousInt32 a4 = {};
  Struct20BytesHomogeneousInt32 a5 = {};
  Struct20BytesHomogeneousInt32 a6 = {};
  Struct20BytesHomogeneousInt32 a7 = {};
  Struct20BytesHomogeneousInt32 a8 = {};
  Struct20BytesHomogeneousInt32 a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a0.a3 = 4;
  a0.a4 = -5;
  a1.a0 = 6;
  a1.a1 = -7;
  a1.a2 = 8;
  a1.a3 = -9;
  a1.a4 = 10;
  a2.a0 = -11;
  a2.a1 = 12;
  a2.a2 = -13;
  a2.a3 = 14;
  a2.a4 = -15;
  a3.a0 = 16;
  a3.a1 = -17;
  a3.a2 = 18;
  a3.a3 = -19;
  a3.a4 = 20;
  a4.a0 = -21;
  a4.a1 = 22;
  a4.a2 = -23;
  a4.a3 = 24;
  a4.a4 = -25;
  a5.a0 = 26;
  a5.a1 = -27;
  a5.a2 = 28;
  a5.a3 = -29;
  a5.a4 = 30;
  a6.a0 = -31;
  a6.a1 = 32;
  a6.a2 = -33;
  a6.a3 = 34;
  a6.a4 = -35;
  a7.a0 = 36;
  a7.a1 = -37;
  a7.a2 = 38;
  a7.a3 = -39;
  a7.a4 = 40;
  a8.a0 = -41;
  a8.a1 = 42;
  a8.a2 = -43;
  a8.a3 = 44;
  a8.a4 = -45;
  a9.a0 = 46;
  a9.a1 = -47;
  a9.a2 = 48;
  a9.a3 = -49;
  a9.a4 = 50;
 
  std::cout << "Calling TestPassStruct20BytesHomogeneousInt32x10(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << "), (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2
            << ", " << a1.a3 << ", " << a1.a4 << "), (" << a2.a0 << ", "
            << a2.a1 << ", " << a2.a2 << ", " << a2.a3 << ", " << a2.a4
            << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2 << ", "
            << a3.a3 << ", " << a3.a4 << "), (" << a4.a0 << ", " << a4.a1
            << ", " << a4.a2 << ", " << a4.a3 << ", " << a4.a4 << "), ("
            << a5.a0 << ", " << a5.a1 << ", " << a5.a2 << ", " << a5.a3 << ", "
            << a5.a4 << "), (" << a6.a0 << ", " << a6.a1 << ", " << a6.a2
            << ", " << a6.a3 << ", " << a6.a4 << "), (" << a7.a0 << ", "
            << a7.a1 << ", " << a7.a2 << ", " << a7.a3 << ", " << a7.a4
            << "), (" << a8.a0 << ", " << a8.a1 << ", " << a8.a2 << ", "
            << a8.a3 << ", " << a8.a4 << "), (" << a9.a0 << ", " << a9.a1
            << ", " << a9.a2 << ", " << a9.a3 << ", " << a9.a4 << "))" << ")\n";
 
  int32_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(25, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct32BytesHomogeneousDoublex5()

DART_EXPORT intptr_t dart::TestPassStruct32BytesHomogeneousDoublex5

(

double(*)(Struct32BytesHomogeneousDouble a0, Struct32BytesHomogeneousDouble a1, Struct32BytesHomogeneousDouble a2, Struct32BytesHomogeneousDouble a3, Struct32BytesHomogeneousDouble a4)

f

)

Definition at line 8407 of file ffi_test_functions_generated.cc.

                                                    {
  Struct32BytesHomogeneousDouble a0 = {};
  Struct32BytesHomogeneousDouble a1 = {};
  Struct32BytesHomogeneousDouble a2 = {};
  Struct32BytesHomogeneousDouble a3 = {};
  Struct32BytesHomogeneousDouble a4 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a1.a0 = -5.0;
  a1.a1 = 6.0;
  a1.a2 = -7.0;
  a1.a3 = 8.0;
  a2.a0 = -9.0;
  a2.a1 = 10.0;
  a2.a2 = -11.0;
  a2.a3 = 12.0;
  a3.a0 = -13.0;
  a3.a1 = 14.0;
  a3.a2 = -15.0;
  a3.a3 = 16.0;
  a4.a0 = -17.0;
  a4.a1 = 18.0;
  a4.a2 = -19.0;
  a4.a3 = 20.0;
 
  std::cout << "Calling TestPassStruct32BytesHomogeneousDoublex5(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
            << "), (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", "
            << a1.a3 << "), (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2
            << ", " << a2.a3 << "), (" << a3.a0 << ", " << a3.a1 << ", "
            << a3.a2 << ", " << a3.a3 << "), (" << a4.a0 << ", " << a4.a1
            << ", " << a4.a2 << ", " << a4.a3 << "))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct32BytesNestedIntx2()

DART_EXPORT intptr_t dart::TestPassStruct32BytesNestedIntx2

(

int64_t(*)(Struct32BytesNestedInt a0, Struct32BytesNestedInt a1)

f

)

Definition at line 9847 of file ffi_test_functions_generated.cc.

                                                                        {
  Struct32BytesNestedInt a0 = {};
  Struct32BytesNestedInt a1 = {};
 
  a0.a0.a0.a0.a0 = -1;
  a0.a0.a0.a0.a1 = 2;
  a0.a0.a0.a1.a0 = -3;
  a0.a0.a0.a1.a1 = 4;
  a0.a0.a1.a0.a0 = -5;
  a0.a0.a1.a0.a1 = 6;
  a0.a0.a1.a1.a0 = -7;
  a0.a0.a1.a1.a1 = 8;
  a0.a1.a0.a0.a0 = -9;
  a0.a1.a0.a0.a1 = 10;
  a0.a1.a0.a1.a0 = -11;
  a0.a1.a0.a1.a1 = 12;
  a0.a1.a1.a0.a0 = -13;
  a0.a1.a1.a0.a1 = 14;
  a0.a1.a1.a1.a0 = -15;
  a0.a1.a1.a1.a1 = 16;
  a1.a0.a0.a0.a0 = -17;
  a1.a0.a0.a0.a1 = 18;
  a1.a0.a0.a1.a0 = -19;
  a1.a0.a0.a1.a1 = 20;
  a1.a0.a1.a0.a0 = -21;
  a1.a0.a1.a0.a1 = 22;
  a1.a0.a1.a1.a0 = -23;
  a1.a0.a1.a1.a1 = 24;
  a1.a1.a0.a0.a0 = -25;
  a1.a1.a0.a0.a1 = 26;
  a1.a1.a0.a1.a0 = -27;
  a1.a1.a0.a1.a1 = 28;
  a1.a1.a1.a0.a0 = -29;
  a1.a1.a1.a0.a1 = 30;
  a1.a1.a1.a1.a0 = -31;
  a1.a1.a1.a1.a1 = 32;
 
  std::cout << "Calling TestPassStruct32BytesNestedIntx2(" << "((((("
            << a0.a0.a0.a0.a0 << ", " << a0.a0.a0.a0.a1 << "), ("
            << a0.a0.a0.a1.a0 << ", " << a0.a0.a0.a1.a1 << ")), (("
            << a0.a0.a1.a0.a0 << ", " << a0.a0.a1.a0.a1 << "), ("
            << a0.a0.a1.a1.a0 << ", " << a0.a0.a1.a1.a1 << "))), ((("
            << a0.a1.a0.a0.a0 << ", " << a0.a1.a0.a0.a1 << "), ("
            << a0.a1.a0.a1.a0 << ", " << a0.a1.a0.a1.a1 << ")), (("
            << a0.a1.a1.a0.a0 << ", " << a0.a1.a1.a0.a1 << "), ("
            << a0.a1.a1.a1.a0 << ", " << a0.a1.a1.a1.a1 << ")))), (((("
            << a1.a0.a0.a0.a0 << ", " << a1.a0.a0.a0.a1 << "), ("
            << a1.a0.a0.a1.a0 << ", " << a1.a0.a0.a1.a1 << ")), (("
            << a1.a0.a1.a0.a0 << ", " << a1.a0.a1.a0.a1 << "), ("
            << a1.a0.a1.a1.a0 << ", " << a1.a0.a1.a1.a1 << "))), ((("
            << a1.a1.a0.a0.a0 << ", " << a1.a1.a0.a0.a1 << "), ("
            << a1.a1.a0.a1.a0 << ", " << a1.a1.a0.a1.a1 << ")), (("
            << a1.a1.a1.a0.a0 << ", " << a1.a1.a1.a0.a1 << "), ("
            << a1.a1.a1.a1.a0 << ", " << a1.a1.a1.a1.a1 << ")))))" << ")\n";
 
  int64_t result = f(a0, a1);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(16, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0.a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0.a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct3BytesHomogeneousUint8x10()

DART_EXPORT intptr_t dart::TestPassStruct3BytesHomogeneousUint8x10

(

int64_t(*)(Struct3BytesHomogeneousUint8 a0, Struct3BytesHomogeneousUint8 a1, Struct3BytesHomogeneousUint8 a2, Struct3BytesHomogeneousUint8 a3, Struct3BytesHomogeneousUint8 a4, Struct3BytesHomogeneousUint8 a5, Struct3BytesHomogeneousUint8 a6, Struct3BytesHomogeneousUint8 a7, Struct3BytesHomogeneousUint8 a8, Struct3BytesHomogeneousUint8 a9)

f

)

Definition at line 6437 of file ffi_test_functions_generated.cc.

                                                   {
  Struct3BytesHomogeneousUint8 a0 = {};
  Struct3BytesHomogeneousUint8 a1 = {};
  Struct3BytesHomogeneousUint8 a2 = {};
  Struct3BytesHomogeneousUint8 a3 = {};
  Struct3BytesHomogeneousUint8 a4 = {};
  Struct3BytesHomogeneousUint8 a5 = {};
  Struct3BytesHomogeneousUint8 a6 = {};
  Struct3BytesHomogeneousUint8 a7 = {};
  Struct3BytesHomogeneousUint8 a8 = {};
  Struct3BytesHomogeneousUint8 a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a1.a0 = 4;
  a1.a1 = 5;
  a1.a2 = 6;
  a2.a0 = 7;
  a2.a1 = 8;
  a2.a2 = 9;
  a3.a0 = 10;
  a3.a1 = 11;
  a3.a2 = 12;
  a4.a0 = 13;
  a4.a1 = 14;
  a4.a2 = 15;
  a5.a0 = 16;
  a5.a1 = 17;
  a5.a2 = 18;
  a6.a0 = 19;
  a6.a1 = 20;
  a6.a2 = 21;
  a7.a0 = 22;
  a7.a1 = 23;
  a7.a2 = 24;
  a8.a0 = 25;
  a8.a1 = 26;
  a8.a2 = 27;
  a9.a0 = 28;
  a9.a1 = 29;
  a9.a2 = 30;
 
  std::cout << "Calling TestPassStruct3BytesHomogeneousUint8x10(" << "(("
            << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1)
            << ", " << static_cast<int>(a0.a2) << "), ("
            << static_cast<int>(a1.a0) << ", " << static_cast<int>(a1.a1)
            << ", " << static_cast<int>(a1.a2) << "), ("
            << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1)
            << ", " << static_cast<int>(a2.a2) << "), ("
            << static_cast<int>(a3.a0) << ", " << static_cast<int>(a3.a1)
            << ", " << static_cast<int>(a3.a2) << "), ("
            << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1)
            << ", " << static_cast<int>(a4.a2) << "), ("
            << static_cast<int>(a5.a0) << ", " << static_cast<int>(a5.a1)
            << ", " << static_cast<int>(a5.a2) << "), ("
            << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1)
            << ", " << static_cast<int>(a6.a2) << "), ("
            << static_cast<int>(a7.a0) << ", " << static_cast<int>(a7.a1)
            << ", " << static_cast<int>(a7.a2) << "), ("
            << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1)
            << ", " << static_cast<int>(a8.a2) << "), ("
            << static_cast<int>(a9.a0) << ", " << static_cast<int>(a9.a1)
            << ", " << static_cast<int>(a9.a2) << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(465, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct3BytesInt2ByteAlignedx10()

DART_EXPORT intptr_t dart::TestPassStruct3BytesInt2ByteAlignedx10

(

int64_t(*)(Struct3BytesInt2ByteAligned a0, Struct3BytesInt2ByteAligned a1, Struct3BytesInt2ByteAligned a2, Struct3BytesInt2ByteAligned a3, Struct3BytesInt2ByteAligned a4, Struct3BytesInt2ByteAligned a5, Struct3BytesInt2ByteAligned a6, Struct3BytesInt2ByteAligned a7, Struct3BytesInt2ByteAligned a8, Struct3BytesInt2ByteAligned a9)

f

)

Definition at line 6540 of file ffi_test_functions_generated.cc.

                                                  {
  Struct3BytesInt2ByteAligned a0 = {};
  Struct3BytesInt2ByteAligned a1 = {};
  Struct3BytesInt2ByteAligned a2 = {};
  Struct3BytesInt2ByteAligned a3 = {};
  Struct3BytesInt2ByteAligned a4 = {};
  Struct3BytesInt2ByteAligned a5 = {};
  Struct3BytesInt2ByteAligned a6 = {};
  Struct3BytesInt2ByteAligned a7 = {};
  Struct3BytesInt2ByteAligned a8 = {};
  Struct3BytesInt2ByteAligned a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
  a2.a0 = -5;
  a2.a1 = 6;
  a3.a0 = -7;
  a3.a1 = 8;
  a4.a0 = -9;
  a4.a1 = 10;
  a5.a0 = -11;
  a5.a1 = 12;
  a6.a0 = -13;
  a6.a1 = 14;
  a7.a0 = -15;
  a7.a1 = 16;
  a8.a0 = -17;
  a8.a1 = 18;
  a9.a0 = -19;
  a9.a1 = 20;
 
  std::cout << "Calling TestPassStruct3BytesInt2ByteAlignedx10(" << "(("
            << a0.a0 << ", " << static_cast<int>(a0.a1) << "), (" << a1.a0
            << ", " << static_cast<int>(a1.a1) << "), (" << a2.a0 << ", "
            << static_cast<int>(a2.a1) << "), (" << a3.a0 << ", "
            << static_cast<int>(a3.a1) << "), (" << a4.a0 << ", "
            << static_cast<int>(a4.a1) << "), (" << a5.a0 << ", "
            << static_cast<int>(a5.a1) << "), (" << a6.a0 << ", "
            << static_cast<int>(a6.a1) << "), (" << a7.a0 << ", "
            << static_cast<int>(a7.a1) << "), (" << a8.a0 << ", "
            << static_cast<int>(a8.a1) << "), (" << a9.a0 << ", "
            << static_cast<int>(a9.a1) << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(10, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct3BytesPackedIntx10()

DART_EXPORT intptr_t dart::TestPassStruct3BytesPackedIntx10

(

int64_t(*)(Struct3BytesPackedInt a0, Struct3BytesPackedInt a1, Struct3BytesPackedInt a2, Struct3BytesPackedInt a3, Struct3BytesPackedInt a4, Struct3BytesPackedInt a5, Struct3BytesPackedInt a6, Struct3BytesPackedInt a7, Struct3BytesPackedInt a8, Struct3BytesPackedInt a9)

f

)

Definition at line 11128 of file ffi_test_functions_generated.cc.

                                            {
  Struct3BytesPackedInt a0 = {};
  Struct3BytesPackedInt a1 = {};
  Struct3BytesPackedInt a2 = {};
  Struct3BytesPackedInt a3 = {};
  Struct3BytesPackedInt a4 = {};
  Struct3BytesPackedInt a5 = {};
  Struct3BytesPackedInt a6 = {};
  Struct3BytesPackedInt a7 = {};
  Struct3BytesPackedInt a8 = {};
  Struct3BytesPackedInt a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
  a2.a0 = -5;
  a2.a1 = 6;
  a3.a0 = -7;
  a3.a1 = 8;
  a4.a0 = -9;
  a4.a1 = 10;
  a5.a0 = -11;
  a5.a1 = 12;
  a6.a0 = -13;
  a6.a1 = 14;
  a7.a0 = -15;
  a7.a1 = 16;
  a8.a0 = -17;
  a8.a1 = 18;
  a9.a0 = -19;
  a9.a1 = 20;
 
  std::cout << "Calling TestPassStruct3BytesPackedIntx10(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << "), ("
            << static_cast<int>(a1.a0) << ", " << a1.a1 << "), ("
            << static_cast<int>(a2.a0) << ", " << a2.a1 << "), ("
            << static_cast<int>(a3.a0) << ", " << a3.a1 << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(10, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct40BytesHomogeneousDouble()

DART_EXPORT intptr_t dart::TestPassStruct40BytesHomogeneousDouble

(

double(*)(Struct40BytesHomogeneousDouble a0)

f

)

Definition at line 8474 of file ffi_test_functions_generated.cc.

                                                    {
  Struct40BytesHomogeneousDouble a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a0.a4 = -5.0;
 
  std::cout << "Calling TestPassStruct40BytesHomogeneousDouble(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3 << ", "
            << a0.a4 << "))" << ")\n";
 
  double result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-3.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct40BytesHomogeneousDoubleStruct4BytesHomo()

DART_EXPORT intptr_t dart::TestPassStruct40BytesHomogeneousDoubleStruct4BytesHomo

(

double(*)(Struct40BytesHomogeneousDouble a0, Struct4BytesHomogeneousInt16 a1, Struct8BytesHomogeneousFloat a2)

f

)

Definition at line 9078 of file ffi_test_functions_generated.cc.

                                                  {
  Struct40BytesHomogeneousDouble a0 = {};
  Struct4BytesHomogeneousInt16 a1 = {};
  Struct8BytesHomogeneousFloat a2 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a0.a2 = -3.0;
  a0.a3 = 4.0;
  a0.a4 = -5.0;
  a1.a0 = 6;
  a1.a1 = -7;
  a2.a0 = 8.0;
  a2.a1 = -9.0;
 
  std::cout << "Calling TestPassStruct40BytesHomogeneousDoubleStruct4BytesHomo("
            << "((" << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
            << ", " << a0.a4 << "), (" << a1.a0 << ", " << a1.a1 << "), ("
            << a2.a0 << ", " << a2.a1 << "))" << ")\n";
 
  double result = f(a0, a1, a2);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-5.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct4BytesHomogeneousInt16x10()

DART_EXPORT intptr_t dart::TestPassStruct4BytesHomogeneousInt16x10

(

int64_t(*)(Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1, Struct4BytesHomogeneousInt16 a2, Struct4BytesHomogeneousInt16 a3, Struct4BytesHomogeneousInt16 a4, Struct4BytesHomogeneousInt16 a5, Struct4BytesHomogeneousInt16 a6, Struct4BytesHomogeneousInt16 a7, Struct4BytesHomogeneousInt16 a8, Struct4BytesHomogeneousInt16 a9)

f

)

Definition at line 6622 of file ffi_test_functions_generated.cc.

                                                   {
  Struct4BytesHomogeneousInt16 a0 = {};
  Struct4BytesHomogeneousInt16 a1 = {};
  Struct4BytesHomogeneousInt16 a2 = {};
  Struct4BytesHomogeneousInt16 a3 = {};
  Struct4BytesHomogeneousInt16 a4 = {};
  Struct4BytesHomogeneousInt16 a5 = {};
  Struct4BytesHomogeneousInt16 a6 = {};
  Struct4BytesHomogeneousInt16 a7 = {};
  Struct4BytesHomogeneousInt16 a8 = {};
  Struct4BytesHomogeneousInt16 a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
  a2.a0 = -5;
  a2.a1 = 6;
  a3.a0 = -7;
  a3.a1 = 8;
  a4.a0 = -9;
  a4.a1 = 10;
  a5.a0 = -11;
  a5.a1 = 12;
  a6.a0 = -13;
  a6.a1 = 14;
  a7.a0 = -15;
  a7.a1 = 16;
  a8.a0 = -17;
  a8.a1 = 18;
  a9.a0 = -19;
  a9.a1 = 20;
 
  std::cout << "Calling TestPassStruct4BytesHomogeneousInt16x10(" << "(("
            << a0.a0 << ", " << a0.a1 << "), (" << a1.a0 << ", " << a1.a1
            << "), (" << a2.a0 << ", " << a2.a1 << "), (" << a3.a0 << ", "
            << a3.a1 << "), (" << a4.a0 << ", " << a4.a1 << "), (" << a5.a0
            << ", " << a5.a1 << "), (" << a6.a0 << ", " << a6.a1 << "), ("
            << a7.a0 << ", " << a7.a1 << "), (" << a8.a0 << ", " << a8.a1
            << "), (" << a9.a0 << ", " << a9.a1 << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(10, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct5BytesPackedMixed()

DART_EXPORT intptr_t dart::TestPassStruct5BytesPackedMixed

(

double(*)(Struct5BytesPackedMixed a0)

f

)

Definition at line 11432 of file ffi_test_functions_generated.cc.

                                             {
  Struct5BytesPackedMixed a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2;
 
  std::cout << "Calling TestPassStruct5BytesPackedMixed(" << "((" << a0.a0
            << ", " << static_cast<int>(a0.a1) << "))" << ")\n";
 
  double result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(1.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct6BytesInlineArrayInt()

DART_EXPORT intptr_t dart::TestPassStruct6BytesInlineArrayInt

(

double(*)(Struct6BytesInlineArrayInt a0)

f

)

Definition at line 11506 of file ffi_test_functions_generated.cc.

                                                {
  Struct6BytesInlineArrayInt a0 = {};
 
  a0.a0[0].a0 = -1;
  a0.a0[0].a1 = 2;
  a0.a0[1].a0 = -3;
  a0.a0[1].a1 = 4;
 
  std::cout << "Calling TestPassStruct6BytesInlineArrayInt(" << "(([("
            << static_cast<int>(a0.a0[0].a0) << ", " << a0.a0[0].a1 << "), ("
            << static_cast<int>(a0.a0[1].a0) << ", " << a0.a0[1].a1 << ")]))"
            << ")\n";
 
  double result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(2.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0[0].a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0[0].a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct7BytesHomogeneousUint8x10()

DART_EXPORT intptr_t dart::TestPassStruct7BytesHomogeneousUint8x10

(

int64_t(*)(Struct7BytesHomogeneousUint8 a0, Struct7BytesHomogeneousUint8 a1, Struct7BytesHomogeneousUint8 a2, Struct7BytesHomogeneousUint8 a3, Struct7BytesHomogeneousUint8 a4, Struct7BytesHomogeneousUint8 a5, Struct7BytesHomogeneousUint8 a6, Struct7BytesHomogeneousUint8 a7, Struct7BytesHomogeneousUint8 a8, Struct7BytesHomogeneousUint8 a9)

f

)

Definition at line 6700 of file ffi_test_functions_generated.cc.

                                                   {
  Struct7BytesHomogeneousUint8 a0 = {};
  Struct7BytesHomogeneousUint8 a1 = {};
  Struct7BytesHomogeneousUint8 a2 = {};
  Struct7BytesHomogeneousUint8 a3 = {};
  Struct7BytesHomogeneousUint8 a4 = {};
  Struct7BytesHomogeneousUint8 a5 = {};
  Struct7BytesHomogeneousUint8 a6 = {};
  Struct7BytesHomogeneousUint8 a7 = {};
  Struct7BytesHomogeneousUint8 a8 = {};
  Struct7BytesHomogeneousUint8 a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a0.a5 = 6;
  a0.a6 = 7;
  a1.a0 = 8;
  a1.a1 = 9;
  a1.a2 = 10;
  a1.a3 = 11;
  a1.a4 = 12;
  a1.a5 = 13;
  a1.a6 = 14;
  a2.a0 = 15;
  a2.a1 = 16;
  a2.a2 = 17;
  a2.a3 = 18;
  a2.a4 = 19;
  a2.a5 = 20;
  a2.a6 = 21;
  a3.a0 = 22;
  a3.a1 = 23;
  a3.a2 = 24;
  a3.a3 = 25;
  a3.a4 = 26;
  a3.a5 = 27;
  a3.a6 = 28;
  a4.a0 = 29;
  a4.a1 = 30;
  a4.a2 = 31;
  a4.a3 = 32;
  a4.a4 = 33;
  a4.a5 = 34;
  a4.a6 = 35;
  a5.a0 = 36;
  a5.a1 = 37;
  a5.a2 = 38;
  a5.a3 = 39;
  a5.a4 = 40;
  a5.a5 = 41;
  a5.a6 = 42;
  a6.a0 = 43;
  a6.a1 = 44;
  a6.a2 = 45;
  a6.a3 = 46;
  a6.a4 = 47;
  a6.a5 = 48;
  a6.a6 = 49;
  a7.a0 = 50;
  a7.a1 = 51;
  a7.a2 = 52;
  a7.a3 = 53;
  a7.a4 = 54;
  a7.a5 = 55;
  a7.a6 = 56;
  a8.a0 = 57;
  a8.a1 = 58;
  a8.a2 = 59;
  a8.a3 = 60;
  a8.a4 = 61;
  a8.a5 = 62;
  a8.a6 = 63;
  a9.a0 = 64;
  a9.a1 = 65;
  a9.a2 = 66;
  a9.a3 = 67;
  a9.a4 = 68;
  a9.a5 = 69;
  a9.a6 = 70;
 
  std::cout
      << "Calling TestPassStruct7BytesHomogeneousUint8x10(" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << "))"
      << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(2485, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct7BytesInt4ByteAlignedx10()

DART_EXPORT intptr_t dart::TestPassStruct7BytesInt4ByteAlignedx10

(

int64_t(*)(Struct7BytesInt4ByteAligned a0, Struct7BytesInt4ByteAligned a1, Struct7BytesInt4ByteAligned a2, Struct7BytesInt4ByteAligned a3, Struct7BytesInt4ByteAligned a4, Struct7BytesInt4ByteAligned a5, Struct7BytesInt4ByteAligned a6, Struct7BytesInt4ByteAligned a7, Struct7BytesInt4ByteAligned a8, Struct7BytesInt4ByteAligned a9)

f

)

Definition at line 6860 of file ffi_test_functions_generated.cc.

                                                  {
  Struct7BytesInt4ByteAligned a0 = {};
  Struct7BytesInt4ByteAligned a1 = {};
  Struct7BytesInt4ByteAligned a2 = {};
  Struct7BytesInt4ByteAligned a3 = {};
  Struct7BytesInt4ByteAligned a4 = {};
  Struct7BytesInt4ByteAligned a5 = {};
  Struct7BytesInt4ByteAligned a6 = {};
  Struct7BytesInt4ByteAligned a7 = {};
  Struct7BytesInt4ByteAligned a8 = {};
  Struct7BytesInt4ByteAligned a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
  a2.a0 = -7;
  a2.a1 = 8;
  a2.a2 = -9;
  a3.a0 = 10;
  a3.a1 = -11;
  a3.a2 = 12;
  a4.a0 = -13;
  a4.a1 = 14;
  a4.a2 = -15;
  a5.a0 = 16;
  a5.a1 = -17;
  a5.a2 = 18;
  a6.a0 = -19;
  a6.a1 = 20;
  a6.a2 = -21;
  a7.a0 = 22;
  a7.a1 = -23;
  a7.a2 = 24;
  a8.a0 = -25;
  a8.a1 = 26;
  a8.a2 = -27;
  a9.a0 = 28;
  a9.a1 = -29;
  a9.a2 = 30;
 
  std::cout << "Calling TestPassStruct7BytesInt4ByteAlignedx10(" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << static_cast<int>(a0.a2)
            << "), (" << a1.a0 << ", " << a1.a1 << ", "
            << static_cast<int>(a1.a2) << "), (" << a2.a0 << ", " << a2.a1
            << ", " << static_cast<int>(a2.a2) << "), (" << a3.a0 << ", "
            << a3.a1 << ", " << static_cast<int>(a3.a2) << "), (" << a4.a0
            << ", " << a4.a1 << ", " << static_cast<int>(a4.a2) << "), ("
            << a5.a0 << ", " << a5.a1 << ", " << static_cast<int>(a5.a2)
            << "), (" << a6.a0 << ", " << a6.a1 << ", "
            << static_cast<int>(a6.a2) << "), (" << a7.a0 << ", " << a7.a1
            << ", " << static_cast<int>(a7.a2) << "), (" << a8.a0 << ", "
            << a8.a1 << ", " << static_cast<int>(a8.a2) << "), (" << a9.a0
            << ", " << a9.a1 << ", " << static_cast<int>(a9.a2) << "))"
            << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(15, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct8BytesHomogeneousFloatx10()

DART_EXPORT intptr_t dart::TestPassStruct8BytesHomogeneousFloatx10

(

float(*)(Struct8BytesHomogeneousFloat a0, Struct8BytesHomogeneousFloat a1, Struct8BytesHomogeneousFloat a2, Struct8BytesHomogeneousFloat a3, Struct8BytesHomogeneousFloat a4, Struct8BytesHomogeneousFloat a5, Struct8BytesHomogeneousFloat a6, Struct8BytesHomogeneousFloat a7, Struct8BytesHomogeneousFloat a8, Struct8BytesHomogeneousFloat a9)

f

)

Definition at line 7046 of file ffi_test_functions_generated.cc.

                                                 {
  Struct8BytesHomogeneousFloat a0 = {};
  Struct8BytesHomogeneousFloat a1 = {};
  Struct8BytesHomogeneousFloat a2 = {};
  Struct8BytesHomogeneousFloat a3 = {};
  Struct8BytesHomogeneousFloat a4 = {};
  Struct8BytesHomogeneousFloat a5 = {};
  Struct8BytesHomogeneousFloat a6 = {};
  Struct8BytesHomogeneousFloat a7 = {};
  Struct8BytesHomogeneousFloat a8 = {};
  Struct8BytesHomogeneousFloat a9 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
  a1.a0 = -3.0;
  a1.a1 = 4.0;
  a2.a0 = -5.0;
  a2.a1 = 6.0;
  a3.a0 = -7.0;
  a3.a1 = 8.0;
  a4.a0 = -9.0;
  a4.a1 = 10.0;
  a5.a0 = -11.0;
  a5.a1 = 12.0;
  a6.a0 = -13.0;
  a6.a1 = 14.0;
  a7.a0 = -15.0;
  a7.a1 = 16.0;
  a8.a0 = -17.0;
  a8.a1 = 18.0;
  a9.a0 = -19.0;
  a9.a1 = 20.0;
 
  std::cout << "Calling TestPassStruct8BytesHomogeneousFloatx10(" << "(("
            << a0.a0 << ", " << a0.a1 << "), (" << a1.a0 << ", " << a1.a1
            << "), (" << a2.a0 << ", " << a2.a1 << "), (" << a3.a0 << ", "
            << a3.a1 << "), (" << a4.a0 << ", " << a4.a1 << "), (" << a5.a0
            << ", " << a5.a1 << "), (" << a6.a0 << ", " << a6.a1 << "), ("
            << a7.a0 << ", " << a7.a1 << "), (" << a8.a0 << ", " << a8.a1
            << "), (" << a9.a0 << ", " << a9.a1 << "))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct8BytesInlineArrayIntx4()

DART_EXPORT intptr_t dart::TestPassStruct8BytesInlineArrayIntx4

(

int32_t(*)(Struct8BytesInlineArrayInt a0, Struct8BytesInlineArrayInt a1, Struct8BytesInlineArrayInt a2, Struct8BytesInlineArrayInt a3)

f

)

Definition at line 10288 of file ffi_test_functions_generated.cc.

                                                 {
  Struct8BytesInlineArrayInt a0 = {};
  Struct8BytesInlineArrayInt a1 = {};
  Struct8BytesInlineArrayInt a2 = {};
  Struct8BytesInlineArrayInt a3 = {};
 
  a0.a0[0] = 1;
  a0.a0[1] = 2;
  a0.a0[2] = 3;
  a0.a0[3] = 4;
  a0.a0[4] = 5;
  a0.a0[5] = 6;
  a0.a0[6] = 7;
  a0.a0[7] = 8;
  a1.a0[0] = 9;
  a1.a0[1] = 10;
  a1.a0[2] = 11;
  a1.a0[3] = 12;
  a1.a0[4] = 13;
  a1.a0[5] = 14;
  a1.a0[6] = 15;
  a1.a0[7] = 16;
  a2.a0[0] = 17;
  a2.a0[1] = 18;
  a2.a0[2] = 19;
  a2.a0[3] = 20;
  a2.a0[4] = 21;
  a2.a0[5] = 22;
  a2.a0[6] = 23;
  a2.a0[7] = 24;
  a3.a0[0] = 25;
  a3.a0[1] = 26;
  a3.a0[2] = 27;
  a3.a0[3] = 28;
  a3.a0[4] = 29;
  a3.a0[5] = 30;
  a3.a0[6] = 31;
  a3.a0[7] = 32;
 
  std::cout << "Calling TestPassStruct8BytesInlineArrayIntx4(" << "((["
            << static_cast<int>(a0.a0[0]) << ", " << static_cast<int>(a0.a0[1])
            << ", " << static_cast<int>(a0.a0[2]) << ", "
            << static_cast<int>(a0.a0[3]) << ", " << static_cast<int>(a0.a0[4])
            << ", " << static_cast<int>(a0.a0[5]) << ", "
            << static_cast<int>(a0.a0[6]) << ", " << static_cast<int>(a0.a0[7])
            << "]), ([" << static_cast<int>(a1.a0[0]) << ", "
            << static_cast<int>(a1.a0[1]) << ", " << static_cast<int>(a1.a0[2])
            << ", " << static_cast<int>(a1.a0[3]) << ", "
            << static_cast<int>(a1.a0[4]) << ", " << static_cast<int>(a1.a0[5])
            << ", " << static_cast<int>(a1.a0[6]) << ", "
            << static_cast<int>(a1.a0[7]) << "]), (["
            << static_cast<int>(a2.a0[0]) << ", " << static_cast<int>(a2.a0[1])
            << ", " << static_cast<int>(a2.a0[2]) << ", "
            << static_cast<int>(a2.a0[3]) << ", " << static_cast<int>(a2.a0[4])
            << ", " << static_cast<int>(a2.a0[5]) << ", "
            << static_cast<int>(a2.a0[6]) << ", " << static_cast<int>(a2.a0[7])
            << "]), ([" << static_cast<int>(a3.a0[0]) << ", "
            << static_cast<int>(a3.a0[1]) << ", " << static_cast<int>(a3.a0[2])
            << ", " << static_cast<int>(a3.a0[3]) << ", "
            << static_cast<int>(a3.a0[4]) << ", " << static_cast<int>(a3.a0[5])
            << ", " << static_cast<int>(a3.a0[6]) << ", "
            << static_cast<int>(a3.a0[7]) << "]))" << ")\n";
 
  int32_t result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(528, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0[0] = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0[0] = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct8BytesIntx10()

DART_EXPORT intptr_t dart::TestPassStruct8BytesIntx10

(

int64_t(*)(Struct8BytesInt a0, Struct8BytesInt a1, Struct8BytesInt a2, Struct8BytesInt a3, Struct8BytesInt a4, Struct8BytesInt a5, Struct8BytesInt a6, Struct8BytesInt a7, Struct8BytesInt a8, Struct8BytesInt a9)

f

)

Definition at line 6955 of file ffi_test_functions_generated.cc.

                                      {
  Struct8BytesInt a0 = {};
  Struct8BytesInt a1 = {};
  Struct8BytesInt a2 = {};
  Struct8BytesInt a3 = {};
  Struct8BytesInt a4 = {};
  Struct8BytesInt a5 = {};
  Struct8BytesInt a6 = {};
  Struct8BytesInt a7 = {};
  Struct8BytesInt a8 = {};
  Struct8BytesInt a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
  a2.a0 = -7;
  a2.a1 = 8;
  a2.a2 = -9;
  a3.a0 = 10;
  a3.a1 = -11;
  a3.a2 = 12;
  a4.a0 = -13;
  a4.a1 = 14;
  a4.a2 = -15;
  a5.a0 = 16;
  a5.a1 = -17;
  a5.a2 = 18;
  a6.a0 = -19;
  a6.a1 = 20;
  a6.a2 = -21;
  a7.a0 = 22;
  a7.a1 = -23;
  a7.a2 = 24;
  a8.a0 = -25;
  a8.a1 = 26;
  a8.a2 = -27;
  a9.a0 = 28;
  a9.a1 = -29;
  a9.a2 = 30;
 
  std::cout << "Calling TestPassStruct8BytesIntx10(" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << "), (" << a1.a0 << ", " << a1.a1
            << ", " << a1.a2 << "), (" << a2.a0 << ", " << a2.a1 << ", "
            << a2.a2 << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2
            << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2 << "), ("
            << a5.a0 << ", " << a5.a1 << ", " << a5.a2 << "), (" << a6.a0
            << ", " << a6.a1 << ", " << a6.a2 << "), (" << a7.a0 << ", "
            << a7.a1 << ", " << a7.a2 << "), (" << a8.a0 << ", " << a8.a1
            << ", " << a8.a2 << "), (" << a9.a0 << ", " << a9.a1 << ", "
            << a9.a2 << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(15, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct8BytesMixedx10()

DART_EXPORT intptr_t dart::TestPassStruct8BytesMixedx10

(

float(*)(Struct8BytesMixed a0, Struct8BytesMixed a1, Struct8BytesMixed a2, Struct8BytesMixed a3, Struct8BytesMixed a4, Struct8BytesMixed a5, Struct8BytesMixed a6, Struct8BytesMixed a7, Struct8BytesMixed a8, Struct8BytesMixed a9)

f

)

Definition at line 7124 of file ffi_test_functions_generated.cc.

                                      {
  Struct8BytesMixed a0 = {};
  Struct8BytesMixed a1 = {};
  Struct8BytesMixed a2 = {};
  Struct8BytesMixed a3 = {};
  Struct8BytesMixed a4 = {};
  Struct8BytesMixed a5 = {};
  Struct8BytesMixed a6 = {};
  Struct8BytesMixed a7 = {};
  Struct8BytesMixed a8 = {};
  Struct8BytesMixed a9 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4.0;
  a1.a1 = -5;
  a1.a2 = 6;
  a2.a0 = -7.0;
  a2.a1 = 8;
  a2.a2 = -9;
  a3.a0 = 10.0;
  a3.a1 = -11;
  a3.a2 = 12;
  a4.a0 = -13.0;
  a4.a1 = 14;
  a4.a2 = -15;
  a5.a0 = 16.0;
  a5.a1 = -17;
  a5.a2 = 18;
  a6.a0 = -19.0;
  a6.a1 = 20;
  a6.a2 = -21;
  a7.a0 = 22.0;
  a7.a1 = -23;
  a7.a2 = 24;
  a8.a0 = -25.0;
  a8.a1 = 26;
  a8.a2 = -27;
  a9.a0 = 28.0;
  a9.a1 = -29;
  a9.a2 = 30;
 
  std::cout << "Calling TestPassStruct8BytesMixedx10(" << "((" << a0.a0 << ", "
            << a0.a1 << ", " << a0.a2 << "), (" << a1.a0 << ", " << a1.a1
            << ", " << a1.a2 << "), (" << a2.a0 << ", " << a2.a1 << ", "
            << a2.a2 << "), (" << a3.a0 << ", " << a3.a1 << ", " << a3.a2
            << "), (" << a4.a0 << ", " << a4.a1 << ", " << a4.a2 << "), ("
            << a5.a0 << ", " << a5.a1 << ", " << a5.a2 << "), (" << a6.a0
            << ", " << a6.a1 << ", " << a6.a2 << "), (" << a7.a0 << ", "
            << a7.a1 << ", " << a7.a2 << "), (" << a8.a0 << ", " << a8.a1
            << ", " << a8.a2 << "), (" << a9.a0 << ", " << a9.a1 << ", "
            << a9.a2 << "))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(15.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct8BytesNestedFloat2x10()

DART_EXPORT intptr_t dart::TestPassStruct8BytesNestedFloat2x10

(

float(*)(Struct8BytesNestedFloat2 a0, Struct8BytesNestedFloat2 a1, Struct8BytesNestedFloat2 a2, Struct8BytesNestedFloat2 a3, Struct8BytesNestedFloat2 a4, Struct8BytesNestedFloat2 a5, Struct8BytesNestedFloat2 a6, Struct8BytesNestedFloat2 a7, Struct8BytesNestedFloat2 a8, Struct8BytesNestedFloat2 a9)

f

)

Definition at line 9619 of file ffi_test_functions_generated.cc.

                                             {
  Struct8BytesNestedFloat2 a0 = {};
  Struct8BytesNestedFloat2 a1 = {};
  Struct8BytesNestedFloat2 a2 = {};
  Struct8BytesNestedFloat2 a3 = {};
  Struct8BytesNestedFloat2 a4 = {};
  Struct8BytesNestedFloat2 a5 = {};
  Struct8BytesNestedFloat2 a6 = {};
  Struct8BytesNestedFloat2 a7 = {};
  Struct8BytesNestedFloat2 a8 = {};
  Struct8BytesNestedFloat2 a9 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1 = 2.0;
  a1.a0.a0 = -3.0;
  a1.a1 = 4.0;
  a2.a0.a0 = -5.0;
  a2.a1 = 6.0;
  a3.a0.a0 = -7.0;
  a3.a1 = 8.0;
  a4.a0.a0 = -9.0;
  a4.a1 = 10.0;
  a5.a0.a0 = -11.0;
  a5.a1 = 12.0;
  a6.a0.a0 = -13.0;
  a6.a1 = 14.0;
  a7.a0.a0 = -15.0;
  a7.a1 = 16.0;
  a8.a0.a0 = -17.0;
  a8.a1 = 18.0;
  a9.a0.a0 = -19.0;
  a9.a1 = 20.0;
 
  std::cout << "Calling TestPassStruct8BytesNestedFloat2x10(" << "((("
            << a0.a0.a0 << "), " << a0.a1 << "), ((" << a1.a0.a0 << "), "
            << a1.a1 << "), ((" << a2.a0.a0 << "), " << a2.a1 << "), (("
            << a3.a0.a0 << "), " << a3.a1 << "), ((" << a4.a0.a0 << "), "
            << a4.a1 << "), ((" << a5.a0.a0 << "), " << a5.a1 << "), (("
            << a6.a0.a0 << "), " << a6.a1 << "), ((" << a7.a0.a0 << "), "
            << a7.a1 << "), ((" << a8.a0.a0 << "), " << a8.a1 << "), (("
            << a9.a0.a0 << "), " << a9.a1 << "))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct8BytesNestedFloatx10()

DART_EXPORT intptr_t dart::TestPassStruct8BytesNestedFloatx10

(

float(*)(Struct8BytesNestedFloat a0, Struct8BytesNestedFloat a1, Struct8BytesNestedFloat a2, Struct8BytesNestedFloat a3, Struct8BytesNestedFloat a4, Struct8BytesNestedFloat a5, Struct8BytesNestedFloat a6, Struct8BytesNestedFloat a7, Struct8BytesNestedFloat a8, Struct8BytesNestedFloat a9)

f

)

Definition at line 9537 of file ffi_test_functions_generated.cc.

                                            {
  Struct8BytesNestedFloat a0 = {};
  Struct8BytesNestedFloat a1 = {};
  Struct8BytesNestedFloat a2 = {};
  Struct8BytesNestedFloat a3 = {};
  Struct8BytesNestedFloat a4 = {};
  Struct8BytesNestedFloat a5 = {};
  Struct8BytesNestedFloat a6 = {};
  Struct8BytesNestedFloat a7 = {};
  Struct8BytesNestedFloat a8 = {};
  Struct8BytesNestedFloat a9 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1.a0 = 2.0;
  a1.a0.a0 = -3.0;
  a1.a1.a0 = 4.0;
  a2.a0.a0 = -5.0;
  a2.a1.a0 = 6.0;
  a3.a0.a0 = -7.0;
  a3.a1.a0 = 8.0;
  a4.a0.a0 = -9.0;
  a4.a1.a0 = 10.0;
  a5.a0.a0 = -11.0;
  a5.a1.a0 = 12.0;
  a6.a0.a0 = -13.0;
  a6.a1.a0 = 14.0;
  a7.a0.a0 = -15.0;
  a7.a1.a0 = 16.0;
  a8.a0.a0 = -17.0;
  a8.a1.a0 = 18.0;
  a9.a0.a0 = -19.0;
  a9.a1.a0 = 20.0;
 
  std::cout << "Calling TestPassStruct8BytesNestedFloatx10(" << "((("
            << a0.a0.a0 << "), (" << a0.a1.a0 << ")), ((" << a1.a0.a0 << "), ("
            << a1.a1.a0 << ")), ((" << a2.a0.a0 << "), (" << a2.a1.a0
            << ")), ((" << a3.a0.a0 << "), (" << a3.a1.a0 << ")), (("
            << a4.a0.a0 << "), (" << a4.a1.a0 << ")), ((" << a5.a0.a0 << "), ("
            << a5.a1.a0 << ")), ((" << a6.a0.a0 << "), (" << a6.a1.a0
            << ")), ((" << a7.a0.a0 << "), (" << a7.a1.a0 << ")), (("
            << a8.a0.a0 << "), (" << a8.a1.a0 << ")), ((" << a9.a0.a0 << "), ("
            << a9.a1.a0 << ")))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct8BytesNestedIntx10()

DART_EXPORT intptr_t dart::TestPassStruct8BytesNestedIntx10

(

int64_t(*)(Struct8BytesNestedInt a0, Struct8BytesNestedInt a1, Struct8BytesNestedInt a2, Struct8BytesNestedInt a3, Struct8BytesNestedInt a4, Struct8BytesNestedInt a5, Struct8BytesNestedInt a6, Struct8BytesNestedInt a7, Struct8BytesNestedInt a8, Struct8BytesNestedInt a9)

f

)

Definition at line 9431 of file ffi_test_functions_generated.cc.

                                            {
  Struct8BytesNestedInt a0 = {};
  Struct8BytesNestedInt a1 = {};
  Struct8BytesNestedInt a2 = {};
  Struct8BytesNestedInt a3 = {};
  Struct8BytesNestedInt a4 = {};
  Struct8BytesNestedInt a5 = {};
  Struct8BytesNestedInt a6 = {};
  Struct8BytesNestedInt a7 = {};
  Struct8BytesNestedInt a8 = {};
  Struct8BytesNestedInt a9 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a1.a0 = -3;
  a0.a1.a1 = 4;
  a1.a0.a0 = -5;
  a1.a0.a1 = 6;
  a1.a1.a0 = -7;
  a1.a1.a1 = 8;
  a2.a0.a0 = -9;
  a2.a0.a1 = 10;
  a2.a1.a0 = -11;
  a2.a1.a1 = 12;
  a3.a0.a0 = -13;
  a3.a0.a1 = 14;
  a3.a1.a0 = -15;
  a3.a1.a1 = 16;
  a4.a0.a0 = -17;
  a4.a0.a1 = 18;
  a4.a1.a0 = -19;
  a4.a1.a1 = 20;
  a5.a0.a0 = -21;
  a5.a0.a1 = 22;
  a5.a1.a0 = -23;
  a5.a1.a1 = 24;
  a6.a0.a0 = -25;
  a6.a0.a1 = 26;
  a6.a1.a0 = -27;
  a6.a1.a1 = 28;
  a7.a0.a0 = -29;
  a7.a0.a1 = 30;
  a7.a1.a0 = -31;
  a7.a1.a1 = 32;
  a8.a0.a0 = -33;
  a8.a0.a1 = 34;
  a8.a1.a0 = -35;
  a8.a1.a1 = 36;
  a9.a0.a0 = -37;
  a9.a0.a1 = 38;
  a9.a1.a0 = -39;
  a9.a1.a1 = 40;
 
  std::cout << "Calling TestPassStruct8BytesNestedIntx10(" << "(((" << a0.a0.a0
            << ", " << a0.a0.a1 << "), (" << a0.a1.a0 << ", " << a0.a1.a1
            << ")), ((" << a1.a0.a0 << ", " << a1.a0.a1 << "), (" << a1.a1.a0
            << ", " << a1.a1.a1 << ")), ((" << a2.a0.a0 << ", " << a2.a0.a1
            << "), (" << a2.a1.a0 << ", " << a2.a1.a1 << ")), ((" << a3.a0.a0
            << ", " << a3.a0.a1 << "), (" << a3.a1.a0 << ", " << a3.a1.a1
            << ")), ((" << a4.a0.a0 << ", " << a4.a0.a1 << "), (" << a4.a1.a0
            << ", " << a4.a1.a1 << ")), ((" << a5.a0.a0 << ", " << a5.a0.a1
            << "), (" << a5.a1.a0 << ", " << a5.a1.a1 << ")), ((" << a6.a0.a0
            << ", " << a6.a0.a1 << "), (" << a6.a1.a0 << ", " << a6.a1.a1
            << ")), ((" << a7.a0.a0 << ", " << a7.a0.a1 << "), (" << a7.a1.a0
            << ", " << a7.a1.a1 << ")), ((" << a8.a0.a0 << ", " << a8.a0.a1
            << "), (" << a8.a1.a0 << ", " << a8.a1.a1 << ")), ((" << a9.a0.a0
            << ", " << a9.a0.a1 << "), (" << a9.a1.a0 << ", " << a9.a1.a1
            << ")))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(20, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct8BytesNestedMixedx10()

DART_EXPORT intptr_t dart::TestPassStruct8BytesNestedMixedx10

(

double(*)(Struct8BytesNestedMixed a0, Struct8BytesNestedMixed a1, Struct8BytesNestedMixed a2, Struct8BytesNestedMixed a3, Struct8BytesNestedMixed a4, Struct8BytesNestedMixed a5, Struct8BytesNestedMixed a6, Struct8BytesNestedMixed a7, Struct8BytesNestedMixed a8, Struct8BytesNestedMixed a9)

f

)

Definition at line 9698 of file ffi_test_functions_generated.cc.

                                             {
  Struct8BytesNestedMixed a0 = {};
  Struct8BytesNestedMixed a1 = {};
  Struct8BytesNestedMixed a2 = {};
  Struct8BytesNestedMixed a3 = {};
  Struct8BytesNestedMixed a4 = {};
  Struct8BytesNestedMixed a5 = {};
  Struct8BytesNestedMixed a6 = {};
  Struct8BytesNestedMixed a7 = {};
  Struct8BytesNestedMixed a8 = {};
  Struct8BytesNestedMixed a9 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a1.a0 = -3.0;
  a1.a0.a0 = 4;
  a1.a0.a1 = -5;
  a1.a1.a0 = 6.0;
  a2.a0.a0 = -7;
  a2.a0.a1 = 8;
  a2.a1.a0 = -9.0;
  a3.a0.a0 = 10;
  a3.a0.a1 = -11;
  a3.a1.a0 = 12.0;
  a4.a0.a0 = -13;
  a4.a0.a1 = 14;
  a4.a1.a0 = -15.0;
  a5.a0.a0 = 16;
  a5.a0.a1 = -17;
  a5.a1.a0 = 18.0;
  a6.a0.a0 = -19;
  a6.a0.a1 = 20;
  a6.a1.a0 = -21.0;
  a7.a0.a0 = 22;
  a7.a0.a1 = -23;
  a7.a1.a0 = 24.0;
  a8.a0.a0 = -25;
  a8.a0.a1 = 26;
  a8.a1.a0 = -27.0;
  a9.a0.a0 = 28;
  a9.a0.a1 = -29;
  a9.a1.a0 = 30.0;
 
  std::cout << "Calling TestPassStruct8BytesNestedMixedx10(" << "((("
            << a0.a0.a0 << ", " << a0.a0.a1 << "), (" << a0.a1.a0 << ")), (("
            << a1.a0.a0 << ", " << a1.a0.a1 << "), (" << a1.a1.a0 << ")), (("
            << a2.a0.a0 << ", " << a2.a0.a1 << "), (" << a2.a1.a0 << ")), (("
            << a3.a0.a0 << ", " << a3.a0.a1 << "), (" << a3.a1.a0 << ")), (("
            << a4.a0.a0 << ", " << a4.a0.a1 << "), (" << a4.a1.a0 << ")), (("
            << a5.a0.a0 << ", " << a5.a0.a1 << "), (" << a5.a1.a0 << ")), (("
            << a6.a0.a0 << ", " << a6.a0.a1 << "), (" << a6.a1.a0 << ")), (("
            << a7.a0.a0 << ", " << a7.a0.a1 << "), (" << a7.a1.a0 << ")), (("
            << a8.a0.a0 << ", " << a8.a0.a1 << "), (" << a8.a1.a0 << ")), (("
            << a9.a0.a0 << ", " << a9.a0.a1 << "), (" << a9.a1.a0 << ")))"
            << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(15.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStruct8BytesPackedIntx10()

DART_EXPORT intptr_t dart::TestPassStruct8BytesPackedIntx10

(

int64_t(*)(Struct8BytesPackedInt a0, Struct8BytesPackedInt a1, Struct8BytesPackedInt a2, Struct8BytesPackedInt a3, Struct8BytesPackedInt a4, Struct8BytesPackedInt a5, Struct8BytesPackedInt a6, Struct8BytesPackedInt a7, Struct8BytesPackedInt a8, Struct8BytesPackedInt a9)

f

)

Definition at line 11209 of file ffi_test_functions_generated.cc.

                                            {
  Struct8BytesPackedInt a0 = {};
  Struct8BytesPackedInt a1 = {};
  Struct8BytesPackedInt a2 = {};
  Struct8BytesPackedInt a3 = {};
  Struct8BytesPackedInt a4 = {};
  Struct8BytesPackedInt a5 = {};
  Struct8BytesPackedInt a6 = {};
  Struct8BytesPackedInt a7 = {};
  Struct8BytesPackedInt a8 = {};
  Struct8BytesPackedInt a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a1.a0 = 6;
  a1.a1 = 7;
  a1.a2 = 8;
  a1.a3 = 9;
  a1.a4 = 10;
  a2.a0 = 11;
  a2.a1 = 12;
  a2.a2 = 13;
  a2.a3 = 14;
  a2.a4 = 15;
  a3.a0 = 16;
  a3.a1 = 17;
  a3.a2 = 18;
  a3.a3 = 19;
  a3.a4 = 20;
  a4.a0 = 21;
  a4.a1 = 22;
  a4.a2 = 23;
  a4.a3 = 24;
  a4.a4 = 25;
  a5.a0 = 26;
  a5.a1 = 27;
  a5.a2 = 28;
  a5.a3 = 29;
  a5.a4 = 30;
  a6.a0 = 31;
  a6.a1 = 32;
  a6.a2 = 33;
  a6.a3 = 34;
  a6.a4 = 35;
  a7.a0 = 36;
  a7.a1 = 37;
  a7.a2 = 38;
  a7.a3 = 39;
  a7.a4 = 40;
  a8.a0 = 41;
  a8.a1 = 42;
  a8.a2 = 43;
  a8.a3 = 44;
  a8.a4 = 45;
  a9.a0 = 46;
  a9.a1 = 47;
  a9.a2 = 48;
  a9.a3 = 49;
  a9.a4 = 50;
 
  std::cout << "Calling TestPassStruct8BytesPackedIntx10(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3)
            << ", " << static_cast<int>(a0.a4) << "), ("
            << static_cast<int>(a1.a0) << ", " << a1.a1 << ", "
            << static_cast<int>(a1.a2) << ", " << static_cast<int>(a1.a3)
            << ", " << static_cast<int>(a1.a4) << "), ("
            << static_cast<int>(a2.a0) << ", " << a2.a1 << ", "
            << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3)
            << ", " << static_cast<int>(a2.a4) << "), ("
            << static_cast<int>(a3.a0) << ", " << a3.a1 << ", "
            << static_cast<int>(a3.a2) << ", " << static_cast<int>(a3.a3)
            << ", " << static_cast<int>(a3.a4) << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << ", "
            << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3)
            << ", " << static_cast<int>(a4.a4) << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << ", "
            << static_cast<int>(a5.a2) << ", " << static_cast<int>(a5.a3)
            << ", " << static_cast<int>(a5.a4) << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << ", "
            << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3)
            << ", " << static_cast<int>(a6.a4) << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << ", "
            << static_cast<int>(a7.a2) << ", " << static_cast<int>(a7.a3)
            << ", " << static_cast<int>(a7.a4) << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << ", "
            << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3)
            << ", " << static_cast<int>(a8.a4) << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << ", "
            << static_cast<int>(a9.a2) << ", " << static_cast<int>(a9.a3)
            << ", " << static_cast<int>(a9.a4) << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(1275, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct9BytesHomogeneousUint8x10()

DART_EXPORT intptr_t dart::TestPassStruct9BytesHomogeneousUint8x10

(

int64_t(*)(Struct9BytesHomogeneousUint8 a0, Struct9BytesHomogeneousUint8 a1, Struct9BytesHomogeneousUint8 a2, Struct9BytesHomogeneousUint8 a3, Struct9BytesHomogeneousUint8 a4, Struct9BytesHomogeneousUint8 a5, Struct9BytesHomogeneousUint8 a6, Struct9BytesHomogeneousUint8 a7, Struct9BytesHomogeneousUint8 a8, Struct9BytesHomogeneousUint8 a9)

f

)

Definition at line 7218 of file ffi_test_functions_generated.cc.

                                                   {
  Struct9BytesHomogeneousUint8 a0 = {};
  Struct9BytesHomogeneousUint8 a1 = {};
  Struct9BytesHomogeneousUint8 a2 = {};
  Struct9BytesHomogeneousUint8 a3 = {};
  Struct9BytesHomogeneousUint8 a4 = {};
  Struct9BytesHomogeneousUint8 a5 = {};
  Struct9BytesHomogeneousUint8 a6 = {};
  Struct9BytesHomogeneousUint8 a7 = {};
  Struct9BytesHomogeneousUint8 a8 = {};
  Struct9BytesHomogeneousUint8 a9 = {};
 
  a0.a0 = 1;
  a0.a1 = 2;
  a0.a2 = 3;
  a0.a3 = 4;
  a0.a4 = 5;
  a0.a5 = 6;
  a0.a6 = 7;
  a0.a7 = 8;
  a0.a8 = 9;
  a1.a0 = 10;
  a1.a1 = 11;
  a1.a2 = 12;
  a1.a3 = 13;
  a1.a4 = 14;
  a1.a5 = 15;
  a1.a6 = 16;
  a1.a7 = 17;
  a1.a8 = 18;
  a2.a0 = 19;
  a2.a1 = 20;
  a2.a2 = 21;
  a2.a3 = 22;
  a2.a4 = 23;
  a2.a5 = 24;
  a2.a6 = 25;
  a2.a7 = 26;
  a2.a8 = 27;
  a3.a0 = 28;
  a3.a1 = 29;
  a3.a2 = 30;
  a3.a3 = 31;
  a3.a4 = 32;
  a3.a5 = 33;
  a3.a6 = 34;
  a3.a7 = 35;
  a3.a8 = 36;
  a4.a0 = 37;
  a4.a1 = 38;
  a4.a2 = 39;
  a4.a3 = 40;
  a4.a4 = 41;
  a4.a5 = 42;
  a4.a6 = 43;
  a4.a7 = 44;
  a4.a8 = 45;
  a5.a0 = 46;
  a5.a1 = 47;
  a5.a2 = 48;
  a5.a3 = 49;
  a5.a4 = 50;
  a5.a5 = 51;
  a5.a6 = 52;
  a5.a7 = 53;
  a5.a8 = 54;
  a6.a0 = 55;
  a6.a1 = 56;
  a6.a2 = 57;
  a6.a3 = 58;
  a6.a4 = 59;
  a6.a5 = 60;
  a6.a6 = 61;
  a6.a7 = 62;
  a6.a8 = 63;
  a7.a0 = 64;
  a7.a1 = 65;
  a7.a2 = 66;
  a7.a3 = 67;
  a7.a4 = 68;
  a7.a5 = 69;
  a7.a6 = 70;
  a7.a7 = 71;
  a7.a8 = 72;
  a8.a0 = 73;
  a8.a1 = 74;
  a8.a2 = 75;
  a8.a3 = 76;
  a8.a4 = 77;
  a8.a5 = 78;
  a8.a6 = 79;
  a8.a7 = 80;
  a8.a8 = 81;
  a9.a0 = 82;
  a9.a1 = 83;
  a9.a2 = 84;
  a9.a3 = 85;
  a9.a4 = 86;
  a9.a5 = 87;
  a9.a6 = 88;
  a9.a7 = 89;
  a9.a8 = 90;
 
  std::cout
      << "Calling TestPassStruct9BytesHomogeneousUint8x10(" << "(("
      << static_cast<int>(a0.a0) << ", " << static_cast<int>(a0.a1) << ", "
      << static_cast<int>(a0.a2) << ", " << static_cast<int>(a0.a3) << ", "
      << static_cast<int>(a0.a4) << ", " << static_cast<int>(a0.a5) << ", "
      << static_cast<int>(a0.a6) << ", " << static_cast<int>(a0.a7) << ", "
      << static_cast<int>(a0.a8) << "), (" << static_cast<int>(a1.a0) << ", "
      << static_cast<int>(a1.a1) << ", " << static_cast<int>(a1.a2) << ", "
      << static_cast<int>(a1.a3) << ", " << static_cast<int>(a1.a4) << ", "
      << static_cast<int>(a1.a5) << ", " << static_cast<int>(a1.a6) << ", "
      << static_cast<int>(a1.a7) << ", " << static_cast<int>(a1.a8) << "), ("
      << static_cast<int>(a2.a0) << ", " << static_cast<int>(a2.a1) << ", "
      << static_cast<int>(a2.a2) << ", " << static_cast<int>(a2.a3) << ", "
      << static_cast<int>(a2.a4) << ", " << static_cast<int>(a2.a5) << ", "
      << static_cast<int>(a2.a6) << ", " << static_cast<int>(a2.a7) << ", "
      << static_cast<int>(a2.a8) << "), (" << static_cast<int>(a3.a0) << ", "
      << static_cast<int>(a3.a1) << ", " << static_cast<int>(a3.a2) << ", "
      << static_cast<int>(a3.a3) << ", " << static_cast<int>(a3.a4) << ", "
      << static_cast<int>(a3.a5) << ", " << static_cast<int>(a3.a6) << ", "
      << static_cast<int>(a3.a7) << ", " << static_cast<int>(a3.a8) << "), ("
      << static_cast<int>(a4.a0) << ", " << static_cast<int>(a4.a1) << ", "
      << static_cast<int>(a4.a2) << ", " << static_cast<int>(a4.a3) << ", "
      << static_cast<int>(a4.a4) << ", " << static_cast<int>(a4.a5) << ", "
      << static_cast<int>(a4.a6) << ", " << static_cast<int>(a4.a7) << ", "
      << static_cast<int>(a4.a8) << "), (" << static_cast<int>(a5.a0) << ", "
      << static_cast<int>(a5.a1) << ", " << static_cast<int>(a5.a2) << ", "
      << static_cast<int>(a5.a3) << ", " << static_cast<int>(a5.a4) << ", "
      << static_cast<int>(a5.a5) << ", " << static_cast<int>(a5.a6) << ", "
      << static_cast<int>(a5.a7) << ", " << static_cast<int>(a5.a8) << "), ("
      << static_cast<int>(a6.a0) << ", " << static_cast<int>(a6.a1) << ", "
      << static_cast<int>(a6.a2) << ", " << static_cast<int>(a6.a3) << ", "
      << static_cast<int>(a6.a4) << ", " << static_cast<int>(a6.a5) << ", "
      << static_cast<int>(a6.a6) << ", " << static_cast<int>(a6.a7) << ", "
      << static_cast<int>(a6.a8) << "), (" << static_cast<int>(a7.a0) << ", "
      << static_cast<int>(a7.a1) << ", " << static_cast<int>(a7.a2) << ", "
      << static_cast<int>(a7.a3) << ", " << static_cast<int>(a7.a4) << ", "
      << static_cast<int>(a7.a5) << ", " << static_cast<int>(a7.a6) << ", "
      << static_cast<int>(a7.a7) << ", " << static_cast<int>(a7.a8) << "), ("
      << static_cast<int>(a8.a0) << ", " << static_cast<int>(a8.a1) << ", "
      << static_cast<int>(a8.a2) << ", " << static_cast<int>(a8.a3) << ", "
      << static_cast<int>(a8.a4) << ", " << static_cast<int>(a8.a5) << ", "
      << static_cast<int>(a8.a6) << ", " << static_cast<int>(a8.a7) << ", "
      << static_cast<int>(a8.a8) << "), (" << static_cast<int>(a9.a0) << ", "
      << static_cast<int>(a9.a1) << ", " << static_cast<int>(a9.a2) << ", "
      << static_cast<int>(a9.a3) << ", " << static_cast<int>(a9.a4) << ", "
      << static_cast<int>(a9.a5) << ", " << static_cast<int>(a9.a6) << ", "
      << static_cast<int>(a9.a7) << ", " << static_cast<int>(a9.a8) << "))"
      << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(4095, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct9BytesInt4Or8ByteAlignedx10()

DART_EXPORT intptr_t dart::TestPassStruct9BytesInt4Or8ByteAlignedx10

(

int64_t(*)(Struct9BytesInt4Or8ByteAligned a0, Struct9BytesInt4Or8ByteAligned a1, Struct9BytesInt4Or8ByteAligned a2, Struct9BytesInt4Or8ByteAligned a3, Struct9BytesInt4Or8ByteAligned a4, Struct9BytesInt4Or8ByteAligned a5, Struct9BytesInt4Or8ByteAligned a6, Struct9BytesInt4Or8ByteAligned a7, Struct9BytesInt4Or8ByteAligned a8, Struct9BytesInt4Or8ByteAligned a9)

f

)

Definition at line 7409 of file ffi_test_functions_generated.cc.

                                                     {
  Struct9BytesInt4Or8ByteAligned a0 = {};
  Struct9BytesInt4Or8ByteAligned a1 = {};
  Struct9BytesInt4Or8ByteAligned a2 = {};
  Struct9BytesInt4Or8ByteAligned a3 = {};
  Struct9BytesInt4Or8ByteAligned a4 = {};
  Struct9BytesInt4Or8ByteAligned a5 = {};
  Struct9BytesInt4Or8ByteAligned a6 = {};
  Struct9BytesInt4Or8ByteAligned a7 = {};
  Struct9BytesInt4Or8ByteAligned a8 = {};
  Struct9BytesInt4Or8ByteAligned a9 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
  a2.a0 = -5;
  a2.a1 = 6;
  a3.a0 = -7;
  a3.a1 = 8;
  a4.a0 = -9;
  a4.a1 = 10;
  a5.a0 = -11;
  a5.a1 = 12;
  a6.a0 = -13;
  a6.a1 = 14;
  a7.a0 = -15;
  a7.a1 = 16;
  a8.a0 = -17;
  a8.a1 = 18;
  a9.a0 = -19;
  a9.a1 = 20;
 
  std::cout << "Calling TestPassStruct9BytesInt4Or8ByteAlignedx10(" << "(("
            << a0.a0 << ", " << static_cast<int>(a0.a1) << "), (" << a1.a0
            << ", " << static_cast<int>(a1.a1) << "), (" << a2.a0 << ", "
            << static_cast<int>(a2.a1) << "), (" << a3.a0 << ", "
            << static_cast<int>(a3.a1) << "), (" << a4.a0 << ", "
            << static_cast<int>(a4.a1) << "), (" << a5.a0 << ", "
            << static_cast<int>(a5.a1) << "), (" << a6.a0 << ", "
            << static_cast<int>(a6.a1) << "), (" << a7.a0 << ", "
            << static_cast<int>(a7.a1) << "), (" << a8.a0 << ", "
            << static_cast<int>(a8.a1) << "), (" << a9.a0 << ", "
            << static_cast<int>(a9.a1) << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(10, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStruct9BytesPackedMixedx10DoubleInt32x2()

DART_EXPORT intptr_t dart::TestPassStruct9BytesPackedMixedx10DoubleInt32x2

(

double(*)(Struct9BytesPackedMixed a0, Struct9BytesPackedMixed a1, Struct9BytesPackedMixed a2, Struct9BytesPackedMixed a3, Struct9BytesPackedMixed a4, Struct9BytesPackedMixed a5, Struct9BytesPackedMixed a6, Struct9BytesPackedMixed a7, Struct9BytesPackedMixed a8, Struct9BytesPackedMixed a9, double a10, int32_t a11, int32_t a12)

f

)

Definition at line 11341 of file ffi_test_functions_generated.cc.

                              {
  Struct9BytesPackedMixed a0 = {};
  Struct9BytesPackedMixed a1 = {};
  Struct9BytesPackedMixed a2 = {};
  Struct9BytesPackedMixed a3 = {};
  Struct9BytesPackedMixed a4 = {};
  Struct9BytesPackedMixed a5 = {};
  Struct9BytesPackedMixed a6 = {};
  Struct9BytesPackedMixed a7 = {};
  Struct9BytesPackedMixed a8 = {};
  Struct9BytesPackedMixed a9 = {};
  double a10;
  int32_t a11;
  int32_t a12;
 
  a0.a0 = 1;
  a0.a1 = 2.0;
  a1.a0 = 3;
  a1.a1 = 4.0;
  a2.a0 = 5;
  a2.a1 = 6.0;
  a3.a0 = 7;
  a3.a1 = 8.0;
  a4.a0 = 9;
  a4.a1 = 10.0;
  a5.a0 = 11;
  a5.a1 = 12.0;
  a6.a0 = 13;
  a6.a1 = 14.0;
  a7.a0 = 15;
  a7.a1 = 16.0;
  a8.a0 = 17;
  a8.a1 = 18.0;
  a9.a0 = 19;
  a9.a1 = 20.0;
  a10 = -21.0;
  a11 = 22;
  a12 = -23;
 
  std::cout << "Calling TestPassStruct9BytesPackedMixedx10DoubleInt32x2("
            << "((" << static_cast<int>(a0.a0) << ", " << a0.a1 << "), ("
            << static_cast<int>(a1.a0) << ", " << a1.a1 << "), ("
            << static_cast<int>(a2.a0) << ", " << a2.a1 << "), ("
            << static_cast<int>(a3.a0) << ", " << a3.a1 << "), ("
            << static_cast<int>(a4.a0) << ", " << a4.a1 << "), ("
            << static_cast<int>(a5.a0) << ", " << a5.a1 << "), ("
            << static_cast<int>(a6.a0) << ", " << a6.a1 << "), ("
            << static_cast<int>(a7.a0) << ", " << a7.a1 << "), ("
            << static_cast<int>(a8.a0) << ", " << a8.a1 << "), ("
            << static_cast<int>(a9.a0) << ", " << a9.a1 << "), " << a10 << ", "
            << a11 << ", " << a12 << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(188.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStructAlignmentInt16()

DART_EXPORT intptr_t dart::TestPassStructAlignmentInt16

(

int64_t(*)(StructAlignmentInt16 a0)

f

)

Definition at line 9316 of file ffi_test_functions_generated.cc.

                                           {
  StructAlignmentInt16 a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
 
  std::cout << "Calling TestPassStructAlignmentInt16(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "))" << ")\n";
 
  int64_t result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(-2, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStructAlignmentInt32()

DART_EXPORT intptr_t dart::TestPassStructAlignmentInt32

(

int64_t(*)(StructAlignmentInt32 a0)

f

)

Definition at line 9354 of file ffi_test_functions_generated.cc.

                                           {
  StructAlignmentInt32 a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
 
  std::cout << "Calling TestPassStructAlignmentInt32(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "))" << ")\n";
 
  int64_t result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(-2, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStructAlignmentInt64()

DART_EXPORT intptr_t dart::TestPassStructAlignmentInt64

(

int64_t(*)(StructAlignmentInt64 a0)

f

)

Definition at line 9392 of file ffi_test_functions_generated.cc.

                                           {
  StructAlignmentInt64 a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
 
  std::cout << "Calling TestPassStructAlignmentInt64(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "))" << ")\n";
 
  int64_t result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(-2, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStructInlineArray100Bytes()

DART_EXPORT intptr_t dart::TestPassStructInlineArray100Bytes

(

int32_t(*)(StructInlineArray100Bytes a0)

f

)

Definition at line 10452 of file ffi_test_functions_generated.cc.

                                                {
  StructInlineArray100Bytes a0 = {};
 
  a0.a0[0] = 1;
  a0.a0[1] = 2;
  a0.a0[2] = 3;
  a0.a0[3] = 4;
  a0.a0[4] = 5;
  a0.a0[5] = 6;
  a0.a0[6] = 7;
  a0.a0[7] = 8;
  a0.a0[8] = 9;
  a0.a0[9] = 10;
  a0.a0[10] = 11;
  a0.a0[11] = 12;
  a0.a0[12] = 13;
  a0.a0[13] = 14;
  a0.a0[14] = 15;
  a0.a0[15] = 16;
  a0.a0[16] = 17;
  a0.a0[17] = 18;
  a0.a0[18] = 19;
  a0.a0[19] = 20;
  a0.a0[20] = 21;
  a0.a0[21] = 22;
  a0.a0[22] = 23;
  a0.a0[23] = 24;
  a0.a0[24] = 25;
  a0.a0[25] = 26;
  a0.a0[26] = 27;
  a0.a0[27] = 28;
  a0.a0[28] = 29;
  a0.a0[29] = 30;
  a0.a0[30] = 31;
  a0.a0[31] = 32;
  a0.a0[32] = 33;
  a0.a0[33] = 34;
  a0.a0[34] = 35;
  a0.a0[35] = 36;
  a0.a0[36] = 37;
  a0.a0[37] = 38;
  a0.a0[38] = 39;
  a0.a0[39] = 40;
  a0.a0[40] = 41;
  a0.a0[41] = 42;
  a0.a0[42] = 43;
  a0.a0[43] = 44;
  a0.a0[44] = 45;
  a0.a0[45] = 46;
  a0.a0[46] = 47;
  a0.a0[47] = 48;
  a0.a0[48] = 49;
  a0.a0[49] = 50;
  a0.a0[50] = 51;
  a0.a0[51] = 52;
  a0.a0[52] = 53;
  a0.a0[53] = 54;
  a0.a0[54] = 55;
  a0.a0[55] = 56;
  a0.a0[56] = 57;
  a0.a0[57] = 58;
  a0.a0[58] = 59;
  a0.a0[59] = 60;
  a0.a0[60] = 61;
  a0.a0[61] = 62;
  a0.a0[62] = 63;
  a0.a0[63] = 64;
  a0.a0[64] = 65;
  a0.a0[65] = 66;
  a0.a0[66] = 67;
  a0.a0[67] = 68;
  a0.a0[68] = 69;
  a0.a0[69] = 70;
  a0.a0[70] = 71;
  a0.a0[71] = 72;
  a0.a0[72] = 73;
  a0.a0[73] = 74;
  a0.a0[74] = 75;
  a0.a0[75] = 76;
  a0.a0[76] = 77;
  a0.a0[77] = 78;
  a0.a0[78] = 79;
  a0.a0[79] = 80;
  a0.a0[80] = 81;
  a0.a0[81] = 82;
  a0.a0[82] = 83;
  a0.a0[83] = 84;
  a0.a0[84] = 85;
  a0.a0[85] = 86;
  a0.a0[86] = 87;
  a0.a0[87] = 88;
  a0.a0[88] = 89;
  a0.a0[89] = 90;
  a0.a0[90] = 91;
  a0.a0[91] = 92;
  a0.a0[92] = 93;
  a0.a0[93] = 94;
  a0.a0[94] = 95;
  a0.a0[95] = 96;
  a0.a0[96] = 97;
  a0.a0[97] = 98;
  a0.a0[98] = 99;
  a0.a0[99] = 100;
 
  std::cout
      << "Calling TestPassStructInlineArray100Bytes(" << "((["
      << static_cast<int>(a0.a0[0]) << ", " << static_cast<int>(a0.a0[1])
      << ", " << static_cast<int>(a0.a0[2]) << ", "
      << static_cast<int>(a0.a0[3]) << ", " << static_cast<int>(a0.a0[4])
      << ", " << static_cast<int>(a0.a0[5]) << ", "
      << static_cast<int>(a0.a0[6]) << ", " << static_cast<int>(a0.a0[7])
      << ", " << static_cast<int>(a0.a0[8]) << ", "
      << static_cast<int>(a0.a0[9]) << ", " << static_cast<int>(a0.a0[10])
      << ", " << static_cast<int>(a0.a0[11]) << ", "
      << static_cast<int>(a0.a0[12]) << ", " << static_cast<int>(a0.a0[13])
      << ", " << static_cast<int>(a0.a0[14]) << ", "
      << static_cast<int>(a0.a0[15]) << ", " << static_cast<int>(a0.a0[16])
      << ", " << static_cast<int>(a0.a0[17]) << ", "
      << static_cast<int>(a0.a0[18]) << ", " << static_cast<int>(a0.a0[19])
      << ", " << static_cast<int>(a0.a0[20]) << ", "
      << static_cast<int>(a0.a0[21]) << ", " << static_cast<int>(a0.a0[22])
      << ", " << static_cast<int>(a0.a0[23]) << ", "
      << static_cast<int>(a0.a0[24]) << ", " << static_cast<int>(a0.a0[25])
      << ", " << static_cast<int>(a0.a0[26]) << ", "
      << static_cast<int>(a0.a0[27]) << ", " << static_cast<int>(a0.a0[28])
      << ", " << static_cast<int>(a0.a0[29]) << ", "
      << static_cast<int>(a0.a0[30]) << ", " << static_cast<int>(a0.a0[31])
      << ", " << static_cast<int>(a0.a0[32]) << ", "
      << static_cast<int>(a0.a0[33]) << ", " << static_cast<int>(a0.a0[34])
      << ", " << static_cast<int>(a0.a0[35]) << ", "
      << static_cast<int>(a0.a0[36]) << ", " << static_cast<int>(a0.a0[37])
      << ", " << static_cast<int>(a0.a0[38]) << ", "
      << static_cast<int>(a0.a0[39]) << ", " << static_cast<int>(a0.a0[40])
      << ", " << static_cast<int>(a0.a0[41]) << ", "
      << static_cast<int>(a0.a0[42]) << ", " << static_cast<int>(a0.a0[43])
      << ", " << static_cast<int>(a0.a0[44]) << ", "
      << static_cast<int>(a0.a0[45]) << ", " << static_cast<int>(a0.a0[46])
      << ", " << static_cast<int>(a0.a0[47]) << ", "
      << static_cast<int>(a0.a0[48]) << ", " << static_cast<int>(a0.a0[49])
      << ", " << static_cast<int>(a0.a0[50]) << ", "
      << static_cast<int>(a0.a0[51]) << ", " << static_cast<int>(a0.a0[52])
      << ", " << static_cast<int>(a0.a0[53]) << ", "
      << static_cast<int>(a0.a0[54]) << ", " << static_cast<int>(a0.a0[55])
      << ", " << static_cast<int>(a0.a0[56]) << ", "
      << static_cast<int>(a0.a0[57]) << ", " << static_cast<int>(a0.a0[58])
      << ", " << static_cast<int>(a0.a0[59]) << ", "
      << static_cast<int>(a0.a0[60]) << ", " << static_cast<int>(a0.a0[61])
      << ", " << static_cast<int>(a0.a0[62]) << ", "
      << static_cast<int>(a0.a0[63]) << ", " << static_cast<int>(a0.a0[64])
      << ", " << static_cast<int>(a0.a0[65]) << ", "
      << static_cast<int>(a0.a0[66]) << ", " << static_cast<int>(a0.a0[67])
      << ", " << static_cast<int>(a0.a0[68]) << ", "
      << static_cast<int>(a0.a0[69]) << ", " << static_cast<int>(a0.a0[70])
      << ", " << static_cast<int>(a0.a0[71]) << ", "
      << static_cast<int>(a0.a0[72]) << ", " << static_cast<int>(a0.a0[73])
      << ", " << static_cast<int>(a0.a0[74]) << ", "
      << static_cast<int>(a0.a0[75]) << ", " << static_cast<int>(a0.a0[76])
      << ", " << static_cast<int>(a0.a0[77]) << ", "
      << static_cast<int>(a0.a0[78]) << ", " << static_cast<int>(a0.a0[79])
      << ", " << static_cast<int>(a0.a0[80]) << ", "
      << static_cast<int>(a0.a0[81]) << ", " << static_cast<int>(a0.a0[82])
      << ", " << static_cast<int>(a0.a0[83]) << ", "
      << static_cast<int>(a0.a0[84]) << ", " << static_cast<int>(a0.a0[85])
      << ", " << static_cast<int>(a0.a0[86]) << ", "
      << static_cast<int>(a0.a0[87]) << ", " << static_cast<int>(a0.a0[88])
      << ", " << static_cast<int>(a0.a0[89]) << ", "
      << static_cast<int>(a0.a0[90]) << ", " << static_cast<int>(a0.a0[91])
      << ", " << static_cast<int>(a0.a0[92]) << ", "
      << static_cast<int>(a0.a0[93]) << ", " << static_cast<int>(a0.a0[94])
      << ", " << static_cast<int>(a0.a0[95]) << ", "
      << static_cast<int>(a0.a0[96]) << ", " << static_cast<int>(a0.a0[97])
      << ", " << static_cast<int>(a0.a0[98]) << ", "
      << static_cast<int>(a0.a0[99]) << "]))" << ")\n";
 
  int32_t result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(5050, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0[0] = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0[0] = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStructInlineArrayIrregularx4()

DART_EXPORT intptr_t dart::TestPassStructInlineArrayIrregularx4

(

int32_t(*)(StructInlineArrayIrregular a0, StructInlineArrayIrregular a1, StructInlineArrayIrregular a2, StructInlineArrayIrregular a3)

f

)

Definition at line 10381 of file ffi_test_functions_generated.cc.

                                                 {
  StructInlineArrayIrregular a0 = {};
  StructInlineArrayIrregular a1 = {};
  StructInlineArrayIrregular a2 = {};
  StructInlineArrayIrregular a3 = {};
 
  a0.a0[0].a0 = -1;
  a0.a0[0].a1 = 2;
  a0.a0[1].a0 = -3;
  a0.a0[1].a1 = 4;
  a0.a1 = 5;
  a1.a0[0].a0 = 6;
  a1.a0[0].a1 = -7;
  a1.a0[1].a0 = 8;
  a1.a0[1].a1 = -9;
  a1.a1 = 10;
  a2.a0[0].a0 = -11;
  a2.a0[0].a1 = 12;
  a2.a0[1].a0 = -13;
  a2.a0[1].a1 = 14;
  a2.a1 = 15;
  a3.a0[0].a0 = 16;
  a3.a0[0].a1 = -17;
  a3.a0[1].a0 = 18;
  a3.a0[1].a1 = -19;
  a3.a1 = 20;
 
  std::cout << "Calling TestPassStructInlineArrayIrregularx4(" << "(([("
            << a0.a0[0].a0 << ", " << static_cast<int>(a0.a0[0].a1) << "), ("
            << a0.a0[1].a0 << ", " << static_cast<int>(a0.a0[1].a1) << ")], "
            << static_cast<int>(a0.a1) << "), ([(" << a1.a0[0].a0 << ", "
            << static_cast<int>(a1.a0[0].a1) << "), (" << a1.a0[1].a0 << ", "
            << static_cast<int>(a1.a0[1].a1) << ")], "
            << static_cast<int>(a1.a1) << "), ([(" << a2.a0[0].a0 << ", "
            << static_cast<int>(a2.a0[0].a1) << "), (" << a2.a0[1].a0 << ", "
            << static_cast<int>(a2.a0[1].a1) << ")], "
            << static_cast<int>(a2.a1) << "), ([(" << a3.a0[0].a0 << ", "
            << static_cast<int>(a3.a0[0].a1) << "), (" << a3.a0[1].a0 << ", "
            << static_cast<int>(a3.a0[1].a1) << ")], "
            << static_cast<int>(a3.a1) << "))" << ")\n";
 
  int32_t result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(50, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0[0].a0 = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0[0].a0 = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStructNestedAlignmentStruct5BytesPackedMixed()

DART_EXPORT intptr_t dart::TestPassStructNestedAlignmentStruct5BytesPackedMixed

(

double(*)(StructNestedAlignmentStruct5BytesPackedMixed a0)

f

)

Definition at line 11468 of file ffi_test_functions_generated.cc.

                                                                  {
  StructNestedAlignmentStruct5BytesPackedMixed a0 = {};
 
  a0.a0 = 1;
  a0.a1.a0 = 2.0;
  a0.a1.a1 = 3;
 
  std::cout << "Calling TestPassStructNestedAlignmentStruct5BytesPackedMixed("
            << "((" << static_cast<int>(a0.a0) << ", (" << a0.a1.a0 << ", "
            << static_cast<int>(a0.a1.a1) << ")))" << ")\n";
 
  double result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(6.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStructNestedIntStructAlignmentInt16()

DART_EXPORT intptr_t dart::TestPassStructNestedIntStructAlignmentInt16

(

int64_t(*)(StructNestedIntStructAlignmentInt16 a0)

f

)

Definition at line 9929 of file ffi_test_functions_generated.cc.

                                                          {
  StructNestedIntStructAlignmentInt16 a0 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a0.a2 = -3;
  a0.a1.a0 = 4;
  a0.a1.a1 = -5;
  a0.a1.a2 = 6;
 
  std::cout << "Calling TestPassStructNestedIntStructAlignmentInt16(" << "((("
            << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << ")\n";
 
  int64_t result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(3, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStructNestedIntStructAlignmentInt32()

DART_EXPORT intptr_t dart::TestPassStructNestedIntStructAlignmentInt32

(

int64_t(*)(StructNestedIntStructAlignmentInt32 a0)

f

)

Definition at line 9972 of file ffi_test_functions_generated.cc.

                                                          {
  StructNestedIntStructAlignmentInt32 a0 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a0.a2 = -3;
  a0.a1.a0 = 4;
  a0.a1.a1 = -5;
  a0.a1.a2 = 6;
 
  std::cout << "Calling TestPassStructNestedIntStructAlignmentInt32(" << "((("
            << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << ")\n";
 
  int64_t result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(3, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStructNestedIntStructAlignmentInt64()

DART_EXPORT intptr_t dart::TestPassStructNestedIntStructAlignmentInt64

(

int64_t(*)(StructNestedIntStructAlignmentInt64 a0)

f

)

Definition at line 10015 of file ffi_test_functions_generated.cc.

                                                          {
  StructNestedIntStructAlignmentInt64 a0 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a0.a2 = -3;
  a0.a1.a0 = 4;
  a0.a1.a1 = -5;
  a0.a1.a2 = 6;
 
  std::cout << "Calling TestPassStructNestedIntStructAlignmentInt64(" << "((("
            << static_cast<int>(a0.a0.a0) << ", " << a0.a0.a1 << ", "
            << static_cast<int>(a0.a0.a2) << "), ("
            << static_cast<int>(a0.a1.a0) << ", " << a0.a1.a1 << ", "
            << static_cast<int>(a0.a1.a2) << ")))" << ")\n";
 
  int64_t result = f(a0);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(3, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassStructNestedIrregularEvenBiggerx4()

DART_EXPORT intptr_t dart::TestPassStructNestedIrregularEvenBiggerx4

(

double(*)(StructNestedIrregularEvenBigger a0, StructNestedIrregularEvenBigger a1, StructNestedIrregularEvenBigger a2, StructNestedIrregularEvenBigger a3)

f

)

Definition at line 10058 of file ffi_test_functions_generated.cc.

                                                     {
  StructNestedIrregularEvenBigger a0 = {};
  StructNestedIrregularEvenBigger a1 = {};
  StructNestedIrregularEvenBigger a2 = {};
  StructNestedIrregularEvenBigger a3 = {};
 
  a0.a0 = 1;
  a0.a1.a0.a0 = 2;
  a0.a1.a0.a1.a0.a0 = -3;
  a0.a1.a0.a1.a0.a1 = 4;
  a0.a1.a0.a1.a1.a0 = -5.0;
  a0.a1.a0.a2 = 6;
  a0.a1.a0.a3.a0.a0 = -7.0;
  a0.a1.a0.a3.a1 = 8.0;
  a0.a1.a0.a4 = 9;
  a0.a1.a0.a5.a0.a0 = 10.0;
  a0.a1.a0.a5.a1.a0 = -11.0;
  a0.a1.a0.a6 = 12;
  a0.a1.a1.a0.a0 = -13;
  a0.a1.a1.a0.a1 = 14;
  a0.a1.a1.a1.a0 = -15.0;
  a0.a1.a2 = 16.0;
  a0.a1.a3 = -17.0;
  a0.a2.a0.a0 = 18;
  a0.a2.a0.a1.a0.a0 = -19;
  a0.a2.a0.a1.a0.a1 = 20;
  a0.a2.a0.a1.a1.a0 = -21.0;
  a0.a2.a0.a2 = 22;
  a0.a2.a0.a3.a0.a0 = -23.0;
  a0.a2.a0.a3.a1 = 24.0;
  a0.a2.a0.a4 = 25;
  a0.a2.a0.a5.a0.a0 = 26.0;
  a0.a2.a0.a5.a1.a0 = -27.0;
  a0.a2.a0.a6 = 28;
  a0.a2.a1.a0.a0 = -29;
  a0.a2.a1.a0.a1 = 30;
  a0.a2.a1.a1.a0 = -31.0;
  a0.a2.a2 = 32.0;
  a0.a2.a3 = -33.0;
  a0.a3 = 34.0;
  a1.a0 = 35;
  a1.a1.a0.a0 = 36;
  a1.a1.a0.a1.a0.a0 = -37;
  a1.a1.a0.a1.a0.a1 = 38;
  a1.a1.a0.a1.a1.a0 = -39.0;
  a1.a1.a0.a2 = 40;
  a1.a1.a0.a3.a0.a0 = -41.0;
  a1.a1.a0.a3.a1 = 42.0;
  a1.a1.a0.a4 = 43;
  a1.a1.a0.a5.a0.a0 = 44.0;
  a1.a1.a0.a5.a1.a0 = -45.0;
  a1.a1.a0.a6 = 46;
  a1.a1.a1.a0.a0 = -47;
  a1.a1.a1.a0.a1 = 48;
  a1.a1.a1.a1.a0 = -49.0;
  a1.a1.a2 = 50.0;
  a1.a1.a3 = -51.0;
  a1.a2.a0.a0 = 52;
  a1.a2.a0.a1.a0.a0 = -53;
  a1.a2.a0.a1.a0.a1 = 54;
  a1.a2.a0.a1.a1.a0 = -55.0;
  a1.a2.a0.a2 = 56;
  a1.a2.a0.a3.a0.a0 = -57.0;
  a1.a2.a0.a3.a1 = 58.0;
  a1.a2.a0.a4 = 59;
  a1.a2.a0.a5.a0.a0 = 60.0;
  a1.a2.a0.a5.a1.a0 = -61.0;
  a1.a2.a0.a6 = 62;
  a1.a2.a1.a0.a0 = -63;
  a1.a2.a1.a0.a1 = 64;
  a1.a2.a1.a1.a0 = -65.0;
  a1.a2.a2 = 66.0;
  a1.a2.a3 = -67.0;
  a1.a3 = 68.0;
  a2.a0 = 69;
  a2.a1.a0.a0 = 70;
  a2.a1.a0.a1.a0.a0 = -71;
  a2.a1.a0.a1.a0.a1 = 72;
  a2.a1.a0.a1.a1.a0 = -73.0;
  a2.a1.a0.a2 = 74;
  a2.a1.a0.a3.a0.a0 = -75.0;
  a2.a1.a0.a3.a1 = 76.0;
  a2.a1.a0.a4 = 77;
  a2.a1.a0.a5.a0.a0 = 78.0;
  a2.a1.a0.a5.a1.a0 = -79.0;
  a2.a1.a0.a6 = 80;
  a2.a1.a1.a0.a0 = -81;
  a2.a1.a1.a0.a1 = 82;
  a2.a1.a1.a1.a0 = -83.0;
  a2.a1.a2 = 84.0;
  a2.a1.a3 = -85.0;
  a2.a2.a0.a0 = 86;
  a2.a2.a0.a1.a0.a0 = -87;
  a2.a2.a0.a1.a0.a1 = 88;
  a2.a2.a0.a1.a1.a0 = -89.0;
  a2.a2.a0.a2 = 90;
  a2.a2.a0.a3.a0.a0 = -91.0;
  a2.a2.a0.a3.a1 = 92.0;
  a2.a2.a0.a4 = 93;
  a2.a2.a0.a5.a0.a0 = 94.0;
  a2.a2.a0.a5.a1.a0 = -95.0;
  a2.a2.a0.a6 = 96;
  a2.a2.a1.a0.a0 = -97;
  a2.a2.a1.a0.a1 = 98;
  a2.a2.a1.a1.a0 = -99.0;
  a2.a2.a2 = 100.0;
  a2.a2.a3 = -101.0;
  a2.a3 = 102.0;
  a3.a0 = 103;
  a3.a1.a0.a0 = 104;
  a3.a1.a0.a1.a0.a0 = -105;
  a3.a1.a0.a1.a0.a1 = 106;
  a3.a1.a0.a1.a1.a0 = -107.0;
  a3.a1.a0.a2 = 108;
  a3.a1.a0.a3.a0.a0 = -109.0;
  a3.a1.a0.a3.a1 = 110.0;
  a3.a1.a0.a4 = 111;
  a3.a1.a0.a5.a0.a0 = 112.0;
  a3.a1.a0.a5.a1.a0 = -113.0;
  a3.a1.a0.a6 = 114;
  a3.a1.a1.a0.a0 = -115;
  a3.a1.a1.a0.a1 = 116;
  a3.a1.a1.a1.a0 = -117.0;
  a3.a1.a2 = 118.0;
  a3.a1.a3 = -119.0;
  a3.a2.a0.a0 = 120;
  a3.a2.a0.a1.a0.a0 = -121;
  a3.a2.a0.a1.a0.a1 = 122;
  a3.a2.a0.a1.a1.a0 = -123.0;
  a3.a2.a0.a2 = 124;
  a3.a2.a0.a3.a0.a0 = -125.0;
  a3.a2.a0.a3.a1 = 126.0;
  a3.a2.a0.a4 = 127;
  a3.a2.a0.a5.a0.a0 = 128.0;
  a3.a2.a0.a5.a1.a0 = -129.0;
  a3.a2.a0.a6 = 130;
  a3.a2.a1.a0.a0 = -131;
  a3.a2.a1.a0.a1 = 132;
  a3.a2.a1.a1.a0 = -133.0;
  a3.a2.a2 = 134.0;
  a3.a2.a3 = -135.0;
  a3.a3 = 136.0;
 
  std::cout
      << "Calling TestPassStructNestedIrregularEvenBiggerx4(" << "((" << a0.a0
      << ", ((" << a0.a1.a0.a0 << ", ((" << a0.a1.a0.a1.a0.a0 << ", "
      << a0.a1.a0.a1.a0.a1 << "), (" << a0.a1.a0.a1.a1.a0 << ")), "
      << a0.a1.a0.a2 << ", ((" << a0.a1.a0.a3.a0.a0 << "), " << a0.a1.a0.a3.a1
      << "), " << a0.a1.a0.a4 << ", ((" << a0.a1.a0.a5.a0.a0 << "), ("
      << a0.a1.a0.a5.a1.a0 << ")), " << a0.a1.a0.a6 << "), ((" << a0.a1.a1.a0.a0
      << ", " << a0.a1.a1.a0.a1 << "), (" << a0.a1.a1.a1.a0 << ")), "
      << a0.a1.a2 << ", " << a0.a1.a3 << "), ((" << a0.a2.a0.a0 << ", (("
      << a0.a2.a0.a1.a0.a0 << ", " << a0.a2.a0.a1.a0.a1 << "), ("
      << a0.a2.a0.a1.a1.a0 << ")), " << a0.a2.a0.a2 << ", (("
      << a0.a2.a0.a3.a0.a0 << "), " << a0.a2.a0.a3.a1 << "), " << a0.a2.a0.a4
      << ", ((" << a0.a2.a0.a5.a0.a0 << "), (" << a0.a2.a0.a5.a1.a0 << ")), "
      << a0.a2.a0.a6 << "), ((" << a0.a2.a1.a0.a0 << ", " << a0.a2.a1.a0.a1
      << "), (" << a0.a2.a1.a1.a0 << ")), " << a0.a2.a2 << ", " << a0.a2.a3
      << "), " << a0.a3 << "), (" << a1.a0 << ", ((" << a1.a1.a0.a0 << ", (("
      << a1.a1.a0.a1.a0.a0 << ", " << a1.a1.a0.a1.a0.a1 << "), ("
      << a1.a1.a0.a1.a1.a0 << ")), " << a1.a1.a0.a2 << ", (("
      << a1.a1.a0.a3.a0.a0 << "), " << a1.a1.a0.a3.a1 << "), " << a1.a1.a0.a4
      << ", ((" << a1.a1.a0.a5.a0.a0 << "), (" << a1.a1.a0.a5.a1.a0 << ")), "
      << a1.a1.a0.a6 << "), ((" << a1.a1.a1.a0.a0 << ", " << a1.a1.a1.a0.a1
      << "), (" << a1.a1.a1.a1.a0 << ")), " << a1.a1.a2 << ", " << a1.a1.a3
      << "), ((" << a1.a2.a0.a0 << ", ((" << a1.a2.a0.a1.a0.a0 << ", "
      << a1.a2.a0.a1.a0.a1 << "), (" << a1.a2.a0.a1.a1.a0 << ")), "
      << a1.a2.a0.a2 << ", ((" << a1.a2.a0.a3.a0.a0 << "), " << a1.a2.a0.a3.a1
      << "), " << a1.a2.a0.a4 << ", ((" << a1.a2.a0.a5.a0.a0 << "), ("
      << a1.a2.a0.a5.a1.a0 << ")), " << a1.a2.a0.a6 << "), ((" << a1.a2.a1.a0.a0
      << ", " << a1.a2.a1.a0.a1 << "), (" << a1.a2.a1.a1.a0 << ")), "
      << a1.a2.a2 << ", " << a1.a2.a3 << "), " << a1.a3 << "), (" << a2.a0
      << ", ((" << a2.a1.a0.a0 << ", ((" << a2.a1.a0.a1.a0.a0 << ", "
      << a2.a1.a0.a1.a0.a1 << "), (" << a2.a1.a0.a1.a1.a0 << ")), "
      << a2.a1.a0.a2 << ", ((" << a2.a1.a0.a3.a0.a0 << "), " << a2.a1.a0.a3.a1
      << "), " << a2.a1.a0.a4 << ", ((" << a2.a1.a0.a5.a0.a0 << "), ("
      << a2.a1.a0.a5.a1.a0 << ")), " << a2.a1.a0.a6 << "), ((" << a2.a1.a1.a0.a0
      << ", " << a2.a1.a1.a0.a1 << "), (" << a2.a1.a1.a1.a0 << ")), "
      << a2.a1.a2 << ", " << a2.a1.a3 << "), ((" << a2.a2.a0.a0 << ", (("
      << a2.a2.a0.a1.a0.a0 << ", " << a2.a2.a0.a1.a0.a1 << "), ("
      << a2.a2.a0.a1.a1.a0 << ")), " << a2.a2.a0.a2 << ", (("
      << a2.a2.a0.a3.a0.a0 << "), " << a2.a2.a0.a3.a1 << "), " << a2.a2.a0.a4
      << ", ((" << a2.a2.a0.a5.a0.a0 << "), (" << a2.a2.a0.a5.a1.a0 << ")), "
      << a2.a2.a0.a6 << "), ((" << a2.a2.a1.a0.a0 << ", " << a2.a2.a1.a0.a1
      << "), (" << a2.a2.a1.a1.a0 << ")), " << a2.a2.a2 << ", " << a2.a2.a3
      << "), " << a2.a3 << "), (" << a3.a0 << ", ((" << a3.a1.a0.a0 << ", (("
      << a3.a1.a0.a1.a0.a0 << ", " << a3.a1.a0.a1.a0.a1 << "), ("
      << a3.a1.a0.a1.a1.a0 << ")), " << a3.a1.a0.a2 << ", (("
      << a3.a1.a0.a3.a0.a0 << "), " << a3.a1.a0.a3.a1 << "), " << a3.a1.a0.a4
      << ", ((" << a3.a1.a0.a5.a0.a0 << "), (" << a3.a1.a0.a5.a1.a0 << ")), "
      << a3.a1.a0.a6 << "), ((" << a3.a1.a1.a0.a0 << ", " << a3.a1.a1.a0.a1
      << "), (" << a3.a1.a1.a1.a0 << ")), " << a3.a1.a2 << ", " << a3.a1.a3
      << "), ((" << a3.a2.a0.a0 << ", ((" << a3.a2.a0.a1.a0.a0 << ", "
      << a3.a2.a0.a1.a0.a1 << "), (" << a3.a2.a0.a1.a1.a0 << ")), "
      << a3.a2.a0.a2 << ", ((" << a3.a2.a0.a3.a0.a0 << "), " << a3.a2.a0.a3.a1
      << "), " << a3.a2.a0.a4 << ", ((" << a3.a2.a0.a5.a0.a0 << "), ("
      << a3.a2.a0.a5.a1.a0 << ")), " << a3.a2.a0.a6 << "), ((" << a3.a2.a1.a0.a0
      << ", " << a3.a2.a1.a0.a1 << "), (" << a3.a2.a1.a1.a0 << ")), "
      << a3.a2.a2 << ", " << a3.a2.a3 << "), " << a3.a3 << "))" << ")\n";
 
  double result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(1572.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStructStruct16BytesHomogeneousFloat2x5()

DART_EXPORT intptr_t dart::TestPassStructStruct16BytesHomogeneousFloat2x5

(

float(*)(StructStruct16BytesHomogeneousFloat2 a0, StructStruct16BytesHomogeneousFloat2 a1, StructStruct16BytesHomogeneousFloat2 a2, StructStruct16BytesHomogeneousFloat2 a3, StructStruct16BytesHomogeneousFloat2 a4)

f

)

Definition at line 10654 of file ffi_test_functions_generated.cc.

                                                         {
  StructStruct16BytesHomogeneousFloat2 a0 = {};
  StructStruct16BytesHomogeneousFloat2 a1 = {};
  StructStruct16BytesHomogeneousFloat2 a2 = {};
  StructStruct16BytesHomogeneousFloat2 a3 = {};
  StructStruct16BytesHomogeneousFloat2 a4 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[1].a0 = -3.0;
  a0.a2 = 4.0;
  a1.a0.a0 = -5.0;
  a1.a1[0].a0 = 6.0;
  a1.a1[1].a0 = -7.0;
  a1.a2 = 8.0;
  a2.a0.a0 = -9.0;
  a2.a1[0].a0 = 10.0;
  a2.a1[1].a0 = -11.0;
  a2.a2 = 12.0;
  a3.a0.a0 = -13.0;
  a3.a1[0].a0 = 14.0;
  a3.a1[1].a0 = -15.0;
  a3.a2 = 16.0;
  a4.a0.a0 = -17.0;
  a4.a1[0].a0 = 18.0;
  a4.a1[1].a0 = -19.0;
  a4.a2 = 20.0;
 
  std::cout << "Calling TestPassStructStruct16BytesHomogeneousFloat2x5("
            << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), ("
            << a0.a1[1].a0 << ")], " << a0.a2 << "), ((" << a1.a0.a0 << "), [("
            << a1.a1[0].a0 << "), (" << a1.a1[1].a0 << ")], " << a1.a2
            << "), ((" << a2.a0.a0 << "), [(" << a2.a1[0].a0 << "), ("
            << a2.a1[1].a0 << ")], " << a2.a2 << "), ((" << a3.a0.a0 << "), [("
            << a3.a1[0].a0 << "), (" << a3.a1[1].a0 << ")], " << a3.a2
            << "), ((" << a4.a0.a0 << "), [(" << a4.a1[0].a0 << "), ("
            << a4.a1[1].a0 << ")], " << a4.a2 << "))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStructStruct16BytesMixed3x10()

DART_EXPORT intptr_t dart::TestPassStructStruct16BytesMixed3x10

(

float(*)(StructStruct16BytesMixed3 a0, StructStruct16BytesMixed3 a1, StructStruct16BytesMixed3 a2, StructStruct16BytesMixed3 a3, StructStruct16BytesMixed3 a4, StructStruct16BytesMixed3 a5, StructStruct16BytesMixed3 a6, StructStruct16BytesMixed3 a7, StructStruct16BytesMixed3 a8, StructStruct16BytesMixed3 a9)

f

)

Definition at line 10796 of file ffi_test_functions_generated.cc.

                                              {
  StructStruct16BytesMixed3 a0 = {};
  StructStruct16BytesMixed3 a1 = {};
  StructStruct16BytesMixed3 a2 = {};
  StructStruct16BytesMixed3 a3 = {};
  StructStruct16BytesMixed3 a4 = {};
  StructStruct16BytesMixed3 a5 = {};
  StructStruct16BytesMixed3 a6 = {};
  StructStruct16BytesMixed3 a7 = {};
  StructStruct16BytesMixed3 a8 = {};
  StructStruct16BytesMixed3 a9 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[0].a1 = -3;
  a0.a1[0].a2 = 4;
  a0.a2[0] = -5;
  a0.a2[1] = 6;
  a1.a0.a0 = -7.0;
  a1.a1[0].a0 = 8.0;
  a1.a1[0].a1 = -9;
  a1.a1[0].a2 = 10;
  a1.a2[0] = -11;
  a1.a2[1] = 12;
  a2.a0.a0 = -13.0;
  a2.a1[0].a0 = 14.0;
  a2.a1[0].a1 = -15;
  a2.a1[0].a2 = 16;
  a2.a2[0] = -17;
  a2.a2[1] = 18;
  a3.a0.a0 = -19.0;
  a3.a1[0].a0 = 20.0;
  a3.a1[0].a1 = -21;
  a3.a1[0].a2 = 22;
  a3.a2[0] = -23;
  a3.a2[1] = 24;
  a4.a0.a0 = -25.0;
  a4.a1[0].a0 = 26.0;
  a4.a1[0].a1 = -27;
  a4.a1[0].a2 = 28;
  a4.a2[0] = -29;
  a4.a2[1] = 30;
  a5.a0.a0 = -31.0;
  a5.a1[0].a0 = 32.0;
  a5.a1[0].a1 = -33;
  a5.a1[0].a2 = 34;
  a5.a2[0] = -35;
  a5.a2[1] = 36;
  a6.a0.a0 = -37.0;
  a6.a1[0].a0 = 38.0;
  a6.a1[0].a1 = -39;
  a6.a1[0].a2 = 40;
  a6.a2[0] = -41;
  a6.a2[1] = 42;
  a7.a0.a0 = -43.0;
  a7.a1[0].a0 = 44.0;
  a7.a1[0].a1 = -45;
  a7.a1[0].a2 = 46;
  a7.a2[0] = -47;
  a7.a2[1] = 48;
  a8.a0.a0 = -49.0;
  a8.a1[0].a0 = 50.0;
  a8.a1[0].a1 = -51;
  a8.a1[0].a2 = 52;
  a8.a2[0] = -53;
  a8.a2[1] = 54;
  a9.a0.a0 = -55.0;
  a9.a1[0].a0 = 56.0;
  a9.a1[0].a1 = -57;
  a9.a1[0].a2 = 58;
  a9.a2[0] = -59;
  a9.a2[1] = 60;
 
  std::cout << "Calling TestPassStructStruct16BytesMixed3x10(" << "((("
            << a0.a0.a0 << "), [(" << a0.a1[0].a0 << ", " << a0.a1[0].a1 << ", "
            << a0.a1[0].a2 << ")], [" << a0.a2[0] << ", " << a0.a2[1]
            << "]), ((" << a1.a0.a0 << "), [(" << a1.a1[0].a0 << ", "
            << a1.a1[0].a1 << ", " << a1.a1[0].a2 << ")], [" << a1.a2[0] << ", "
            << a1.a2[1] << "]), ((" << a2.a0.a0 << "), [(" << a2.a1[0].a0
            << ", " << a2.a1[0].a1 << ", " << a2.a1[0].a2 << ")], [" << a2.a2[0]
            << ", " << a2.a2[1] << "]), ((" << a3.a0.a0 << "), [("
            << a3.a1[0].a0 << ", " << a3.a1[0].a1 << ", " << a3.a1[0].a2
            << ")], [" << a3.a2[0] << ", " << a3.a2[1] << "]), ((" << a4.a0.a0
            << "), [(" << a4.a1[0].a0 << ", " << a4.a1[0].a1 << ", "
            << a4.a1[0].a2 << ")], [" << a4.a2[0] << ", " << a4.a2[1]
            << "]), ((" << a5.a0.a0 << "), [(" << a5.a1[0].a0 << ", "
            << a5.a1[0].a1 << ", " << a5.a1[0].a2 << ")], [" << a5.a2[0] << ", "
            << a5.a2[1] << "]), ((" << a6.a0.a0 << "), [(" << a6.a1[0].a0
            << ", " << a6.a1[0].a1 << ", " << a6.a1[0].a2 << ")], [" << a6.a2[0]
            << ", " << a6.a2[1] << "]), ((" << a7.a0.a0 << "), [("
            << a7.a1[0].a0 << ", " << a7.a1[0].a1 << ", " << a7.a1[0].a2
            << ")], [" << a7.a2[0] << ", " << a7.a2[1] << "]), ((" << a8.a0.a0
            << "), [(" << a8.a1[0].a0 << ", " << a8.a1[0].a1 << ", "
            << a8.a1[0].a2 << ")], [" << a8.a2[0] << ", " << a8.a2[1]
            << "]), ((" << a9.a0.a0 << "), [(" << a9.a1[0].a0 << ", "
            << a9.a1[0].a1 << ", " << a9.a1[0].a2 << ")], [" << a9.a2[0] << ", "
            << a9.a2[1] << "]))" << ")\n";
 
  float result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(30.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassStructStruct32BytesHomogeneousDouble2x5()

DART_EXPORT intptr_t dart::TestPassStructStruct32BytesHomogeneousDouble2x5

(

double(*)(StructStruct32BytesHomogeneousDouble2 a0, StructStruct32BytesHomogeneousDouble2 a1, StructStruct32BytesHomogeneousDouble2 a2, StructStruct32BytesHomogeneousDouble2 a3, StructStruct32BytesHomogeneousDouble2 a4)

f

)

Definition at line 10724 of file ffi_test_functions_generated.cc.

                                                           {
  StructStruct32BytesHomogeneousDouble2 a0 = {};
  StructStruct32BytesHomogeneousDouble2 a1 = {};
  StructStruct32BytesHomogeneousDouble2 a2 = {};
  StructStruct32BytesHomogeneousDouble2 a3 = {};
  StructStruct32BytesHomogeneousDouble2 a4 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[1].a0 = -3.0;
  a0.a2 = 4.0;
  a1.a0.a0 = -5.0;
  a1.a1[0].a0 = 6.0;
  a1.a1[1].a0 = -7.0;
  a1.a2 = 8.0;
  a2.a0.a0 = -9.0;
  a2.a1[0].a0 = 10.0;
  a2.a1[1].a0 = -11.0;
  a2.a2 = 12.0;
  a3.a0.a0 = -13.0;
  a3.a1[0].a0 = 14.0;
  a3.a1[1].a0 = -15.0;
  a3.a2 = 16.0;
  a4.a0.a0 = -17.0;
  a4.a1[0].a0 = 18.0;
  a4.a1[1].a0 = -19.0;
  a4.a2 = 20.0;
 
  std::cout << "Calling TestPassStructStruct32BytesHomogeneousDouble2x5("
            << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), ("
            << a0.a1[1].a0 << ")], " << a0.a2 << "), ((" << a1.a0.a0 << "), [("
            << a1.a1[0].a0 << "), (" << a1.a1[1].a0 << ")], " << a1.a2
            << "), ((" << a2.a0.a0 << "), [(" << a2.a1[0].a0 << "), ("
            << a2.a1[1].a0 << ")], " << a2.a2 << "), ((" << a3.a0.a0 << "), [("
            << a3.a1[0].a0 << "), (" << a3.a1[1].a0 << ")], " << a3.a2
            << "), ((" << a4.a0.a0 << "), [(" << a4.a1[0].a0 << "), ("
            << a4.a1[1].a0 << ")], " << a4.a2 << "))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassUint8Boolx9Struct10BytesHomogeneousBoolBool()

DART_EXPORT intptr_t dart::TestPassUint8Boolx9Struct10BytesHomogeneousBoolBool

(

int32_t(*)(uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesHomogeneousBool a10, bool a11)

f

)

Definition at line 11993 of file ffi_test_functions_generated.cc.

                            {
  uint8_t a0;
  bool a1;
  bool a2;
  bool a3;
  bool a4;
  bool a5;
  bool a6;
  bool a7;
  bool a8;
  bool a9;
  Struct10BytesHomogeneousBool a10 = {};
  bool a11;
 
  a0 = 1;
  a1 = false;
  a2 = true;
  a3 = false;
  a4 = true;
  a5 = false;
  a6 = true;
  a7 = false;
  a8 = true;
  a9 = false;
  a10.a0 = true;
  a10.a1 = false;
  a10.a2 = true;
  a10.a3 = false;
  a10.a4 = true;
  a10.a5 = false;
  a10.a6 = true;
  a10.a7 = false;
  a10.a8 = true;
  a10.a9 = false;
  a11 = true;
 
  std::cout << "Calling TestPassUint8Boolx9Struct10BytesHomogeneousBoolBool("
            << "(" << static_cast<int>(a0) << ", " << a1 << ", " << a2 << ", "
            << a3 << ", " << a4 << ", " << a5 << ", " << a6 << ", " << a7
            << ", " << a8 << ", " << a9 << ", (" << a10.a0 << ", " << a10.a1
            << ", " << a10.a2 << ", " << a10.a3 << ", " << a10.a4 << ", "
            << a10.a5 << ", " << a10.a6 << ", " << a10.a7 << ", " << a10.a8
            << ", " << a10.a9 << "), " << a11 << ")" << ")\n";
 
  int32_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(11, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassUint8Boolx9Struct10BytesInlineArrayBoolBool()

DART_EXPORT intptr_t dart::TestPassUint8Boolx9Struct10BytesInlineArrayBoolBool

(

int32_t(*)(uint8_t a0, bool a1, bool a2, bool a3, bool a4, bool a5, bool a6, bool a7, bool a8, bool a9, Struct10BytesInlineArrayBool a10, bool a11)

f

)

Definition at line 12077 of file ffi_test_functions_generated.cc.

                            {
  uint8_t a0;
  bool a1;
  bool a2;
  bool a3;
  bool a4;
  bool a5;
  bool a6;
  bool a7;
  bool a8;
  bool a9;
  Struct10BytesInlineArrayBool a10 = {};
  bool a11;
 
  a0 = 1;
  a1 = false;
  a2 = true;
  a3 = false;
  a4 = true;
  a5 = false;
  a6 = true;
  a7 = false;
  a8 = true;
  a9 = false;
  a10.a0[0] = true;
  a10.a0[1] = false;
  a10.a0[2] = true;
  a10.a0[3] = false;
  a10.a0[4] = true;
  a10.a0[5] = false;
  a10.a0[6] = true;
  a10.a0[7] = false;
  a10.a0[8] = true;
  a10.a0[9] = false;
  a11 = true;
 
  std::cout << "Calling TestPassUint8Boolx9Struct10BytesInlineArrayBoolBool("
            << "(" << static_cast<int>(a0) << ", " << a1 << ", " << a2 << ", "
            << a3 << ", " << a4 << ", " << a5 << ", " << a6 << ", " << a7
            << ", " << a8 << ", " << a9 << ", ([" << a10.a0[0] << ", "
            << a10.a0[1] << ", " << a10.a0[2] << ", " << a10.a0[3] << ", "
            << a10.a0[4] << ", " << a10.a0[5] << ", " << a10.a0[6] << ", "
            << a10.a0[7] << ", " << a10.a0[8] << ", " << a10.a0[9] << "]), "
            << a11 << ")" << ")\n";
 
  int32_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(11, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassUint8Struct1ByteBool()

DART_EXPORT intptr_t dart::TestPassUint8Struct1ByteBool

(

bool(*)(uint8_t a0, Struct1ByteBool a1)

f

)

Definition at line 12160 of file ffi_test_functions_generated.cc.

                                               {
  uint8_t a0;
  Struct1ByteBool a1 = {};
 
  a0 = 1;
  a1.a0 = false;
 
  std::cout << "Calling TestPassUint8Struct1ByteBool(" << "("
            << static_cast<int>(a0) << ", (" << a1.a0 << "))" << ")\n";
 
  bool result = f(a0, a1);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(1, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassUint8Struct32BytesInlineArrayMultiDimensionalI()

DART_EXPORT intptr_t dart::TestPassUint8Struct32BytesInlineArrayMultiDimensionalI

(

uint32_t(*)(uint8_t a0, Struct32BytesInlineArrayMultiDimensionalInt a1, uint8_t a2, Struct8BytesInlineArrayMultiDimensionalInt a3, uint8_t a4, Struct8BytesInlineArrayMultiDimensionalInt a5, uint8_t a6)

f

)

Definition at line 10930 of file ffi_test_functions_generated.cc.

                               {
  uint8_t a0;
  Struct32BytesInlineArrayMultiDimensionalInt a1 = {};
  uint8_t a2;
  Struct8BytesInlineArrayMultiDimensionalInt a3 = {};
  uint8_t a4;
  Struct8BytesInlineArrayMultiDimensionalInt a5 = {};
  uint8_t a6;
 
  a0 = 1;
  a1.a0[0][0][0][0][0] = 2;
  a1.a0[0][0][0][0][1] = 3;
  a1.a0[0][0][0][1][0] = 4;
  a1.a0[0][0][0][1][1] = 5;
  a1.a0[0][0][1][0][0] = 6;
  a1.a0[0][0][1][0][1] = 7;
  a1.a0[0][0][1][1][0] = 8;
  a1.a0[0][0][1][1][1] = 9;
  a1.a0[0][1][0][0][0] = 10;
  a1.a0[0][1][0][0][1] = 11;
  a1.a0[0][1][0][1][0] = 12;
  a1.a0[0][1][0][1][1] = 13;
  a1.a0[0][1][1][0][0] = 14;
  a1.a0[0][1][1][0][1] = 15;
  a1.a0[0][1][1][1][0] = 16;
  a1.a0[0][1][1][1][1] = 17;
  a1.a0[1][0][0][0][0] = 18;
  a1.a0[1][0][0][0][1] = 19;
  a1.a0[1][0][0][1][0] = 20;
  a1.a0[1][0][0][1][1] = 21;
  a1.a0[1][0][1][0][0] = 22;
  a1.a0[1][0][1][0][1] = 23;
  a1.a0[1][0][1][1][0] = 24;
  a1.a0[1][0][1][1][1] = 25;
  a1.a0[1][1][0][0][0] = 26;
  a1.a0[1][1][0][0][1] = 27;
  a1.a0[1][1][0][1][0] = 28;
  a1.a0[1][1][0][1][1] = 29;
  a1.a0[1][1][1][0][0] = 30;
  a1.a0[1][1][1][0][1] = 31;
  a1.a0[1][1][1][1][0] = 32;
  a1.a0[1][1][1][1][1] = 33;
  a2 = 34;
  a3.a0[0][0][0] = 35;
  a3.a0[0][0][1] = 36;
  a3.a0[0][1][0] = 37;
  a3.a0[0][1][1] = 38;
  a3.a0[1][0][0] = 39;
  a3.a0[1][0][1] = 40;
  a3.a0[1][1][0] = 41;
  a3.a0[1][1][1] = 42;
  a4 = 43;
  a5.a0[0][0][0] = 44;
  a5.a0[0][0][1] = 45;
  a5.a0[0][1][0] = 46;
  a5.a0[0][1][1] = 47;
  a5.a0[1][0][0] = 48;
  a5.a0[1][0][1] = 49;
  a5.a0[1][1][0] = 50;
  a5.a0[1][1][1] = 51;
  a6 = 52;
 
  std::cout << "Calling TestPassUint8Struct32BytesInlineArrayMultiDimensionalI("
            << "(" << static_cast<int>(a0) << ", ([[[[["
            << static_cast<int>(a1.a0[0][0][0][0][0]) << ", "
            << static_cast<int>(a1.a0[0][0][0][0][1]) << "], ["
            << static_cast<int>(a1.a0[0][0][0][1][0]) << ", "
            << static_cast<int>(a1.a0[0][0][0][1][1]) << "]], [["
            << static_cast<int>(a1.a0[0][0][1][0][0]) << ", "
            << static_cast<int>(a1.a0[0][0][1][0][1]) << "], ["
            << static_cast<int>(a1.a0[0][0][1][1][0]) << ", "
            << static_cast<int>(a1.a0[0][0][1][1][1]) << "]]], [[["
            << static_cast<int>(a1.a0[0][1][0][0][0]) << ", "
            << static_cast<int>(a1.a0[0][1][0][0][1]) << "], ["
            << static_cast<int>(a1.a0[0][1][0][1][0]) << ", "
            << static_cast<int>(a1.a0[0][1][0][1][1]) << "]], [["
            << static_cast<int>(a1.a0[0][1][1][0][0]) << ", "
            << static_cast<int>(a1.a0[0][1][1][0][1]) << "], ["
            << static_cast<int>(a1.a0[0][1][1][1][0]) << ", "
            << static_cast<int>(a1.a0[0][1][1][1][1]) << "]]]], [[[["
            << static_cast<int>(a1.a0[1][0][0][0][0]) << ", "
            << static_cast<int>(a1.a0[1][0][0][0][1]) << "], ["
            << static_cast<int>(a1.a0[1][0][0][1][0]) << ", "
            << static_cast<int>(a1.a0[1][0][0][1][1]) << "]], [["
            << static_cast<int>(a1.a0[1][0][1][0][0]) << ", "
            << static_cast<int>(a1.a0[1][0][1][0][1]) << "], ["
            << static_cast<int>(a1.a0[1][0][1][1][0]) << ", "
            << static_cast<int>(a1.a0[1][0][1][1][1]) << "]]], [[["
            << static_cast<int>(a1.a0[1][1][0][0][0]) << ", "
            << static_cast<int>(a1.a0[1][1][0][0][1]) << "], ["
            << static_cast<int>(a1.a0[1][1][0][1][0]) << ", "
            << static_cast<int>(a1.a0[1][1][0][1][1]) << "]], [["
            << static_cast<int>(a1.a0[1][1][1][0][0]) << ", "
            << static_cast<int>(a1.a0[1][1][1][0][1]) << "], ["
            << static_cast<int>(a1.a0[1][1][1][1][0]) << ", "
            << static_cast<int>(a1.a0[1][1][1][1][1]) << "]]]]]), "
            << static_cast<int>(a2) << ", ([[["
            << static_cast<int>(a3.a0[0][0][0]) << ", "
            << static_cast<int>(a3.a0[0][0][1]) << "], ["
            << static_cast<int>(a3.a0[0][1][0]) << ", "
            << static_cast<int>(a3.a0[0][1][1]) << "]], [["
            << static_cast<int>(a3.a0[1][0][0]) << ", "
            << static_cast<int>(a3.a0[1][0][1]) << "], ["
            << static_cast<int>(a3.a0[1][1][0]) << ", "
            << static_cast<int>(a3.a0[1][1][1]) << "]]]), "
            << static_cast<int>(a4) << ", ([[["
            << static_cast<int>(a5.a0[0][0][0]) << ", "
            << static_cast<int>(a5.a0[0][0][1]) << "], ["
            << static_cast<int>(a5.a0[0][1][0]) << ", "
            << static_cast<int>(a5.a0[0][1][1]) << "]], [["
            << static_cast<int>(a5.a0[1][0][0]) << ", "
            << static_cast<int>(a5.a0[1][0][1]) << "], ["
            << static_cast<int>(a5.a0[1][1][0]) << ", "
            << static_cast<int>(a5.a0[1][1][1]) << "]]]), "
            << static_cast<int>(a6) << ")" << ")\n";
 
  uint32_t result = f(a0, a1, a2, a3, a4, a5, a6);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(1378, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassUint8Struct4BytesInlineArrayMultiDimensionalIn()

DART_EXPORT intptr_t dart::TestPassUint8Struct4BytesInlineArrayMultiDimensionalIn

(

uint32_t(*)(uint8_t a0, Struct4BytesInlineArrayMultiDimensionalInt a1, uint8_t a2)

f

)

Definition at line 11079 of file ffi_test_functions_generated.cc.

                               {
  uint8_t a0;
  Struct4BytesInlineArrayMultiDimensionalInt a1 = {};
  uint8_t a2;
 
  a0 = 1;
  a1.a0[0][0].a0 = 2;
  a1.a0[0][1].a0 = -3;
  a1.a0[1][0].a0 = 4;
  a1.a0[1][1].a0 = -5;
  a2 = 6;
 
  std::cout << "Calling TestPassUint8Struct4BytesInlineArrayMultiDimensionalIn("
            << "(" << static_cast<int>(a0) << ", ([[("
            << static_cast<int>(a1.a0[0][0].a0) << "), ("
            << static_cast<int>(a1.a0[0][1].a0) << ")], [("
            << static_cast<int>(a1.a0[1][0].a0) << "), ("
            << static_cast<int>(a1.a0[1][1].a0) << ")]]), "
            << static_cast<int>(a2) << ")" << ")\n";
 
  uint32_t result = f(a0, a1, a2);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(5, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPassUnion16BytesNestedFloatx10()

DART_EXPORT intptr_t dart::TestPassUnion16BytesNestedFloatx10

(

double(*)(Union16BytesNestedFloat a0, Union16BytesNestedFloat a1, Union16BytesNestedFloat a2, Union16BytesNestedFloat a3, Union16BytesNestedFloat a4, Union16BytesNestedFloat a5, Union16BytesNestedFloat a6, Union16BytesNestedFloat a7, Union16BytesNestedFloat a8, Union16BytesNestedFloat a9)

f

)

Definition at line 11913 of file ffi_test_functions_generated.cc.

                                             {
  Union16BytesNestedFloat a0 = {};
  Union16BytesNestedFloat a1 = {};
  Union16BytesNestedFloat a2 = {};
  Union16BytesNestedFloat a3 = {};
  Union16BytesNestedFloat a4 = {};
  Union16BytesNestedFloat a5 = {};
  Union16BytesNestedFloat a6 = {};
  Union16BytesNestedFloat a7 = {};
  Union16BytesNestedFloat a8 = {};
  Union16BytesNestedFloat a9 = {};
 
  a0.a0.a0 = -1.0;
  a0.a0.a1 = 2.0;
  a1.a0.a0 = -3.0;
  a1.a0.a1 = 4.0;
  a2.a0.a0 = -5.0;
  a2.a0.a1 = 6.0;
  a3.a0.a0 = -7.0;
  a3.a0.a1 = 8.0;
  a4.a0.a0 = -9.0;
  a4.a0.a1 = 10.0;
  a5.a0.a0 = -11.0;
  a5.a0.a1 = 12.0;
  a6.a0.a0 = -13.0;
  a6.a0.a1 = 14.0;
  a7.a0.a0 = -15.0;
  a7.a0.a1 = 16.0;
  a8.a0.a0 = -17.0;
  a8.a0.a1 = 18.0;
  a9.a0.a0 = -19.0;
  a9.a0.a1 = 20.0;
 
  std::cout << "Calling TestPassUnion16BytesNestedFloatx10(" << "((("
            << a0.a0.a0 << ", " << a0.a0.a1 << ")), ((" << a1.a0.a0 << ", "
            << a1.a0.a1 << ")), ((" << a2.a0.a0 << ", " << a2.a0.a1 << ")), (("
            << a3.a0.a0 << ", " << a3.a0.a1 << ")), ((" << a4.a0.a0 << ", "
            << a4.a0.a1 << ")), ((" << a5.a0.a0 << ", " << a5.a0.a1 << ")), (("
            << a6.a0.a0 << ", " << a6.a0.a1 << ")), ((" << a7.a0.a0 << ", "
            << a7.a0.a1 << ")), ((" << a8.a0.a0 << ", " << a8.a0.a1 << ")), (("
            << a9.a0.a0 << ", " << a9.a0.a1 << ")))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassUnion16BytesNestedInlineArrayFloatx10()

DART_EXPORT intptr_t dart::TestPassUnion16BytesNestedInlineArrayFloatx10

(

double(*)(Union16BytesNestedInlineArrayFloat a0, Union16BytesNestedInlineArrayFloat a1, Union16BytesNestedInlineArrayFloat a2, Union16BytesNestedInlineArrayFloat a3, Union16BytesNestedInlineArrayFloat a4, Union16BytesNestedInlineArrayFloat a5, Union16BytesNestedInlineArrayFloat a6, Union16BytesNestedInlineArrayFloat a7, Union16BytesNestedInlineArrayFloat a8, Union16BytesNestedInlineArrayFloat a9)

f

)

Definition at line 11808 of file ffi_test_functions_generated.cc.

                                                        {
  Union16BytesNestedInlineArrayFloat a0 = {};
  Union16BytesNestedInlineArrayFloat a1 = {};
  Union16BytesNestedInlineArrayFloat a2 = {};
  Union16BytesNestedInlineArrayFloat a3 = {};
  Union16BytesNestedInlineArrayFloat a4 = {};
  Union16BytesNestedInlineArrayFloat a5 = {};
  Union16BytesNestedInlineArrayFloat a6 = {};
  Union16BytesNestedInlineArrayFloat a7 = {};
  Union16BytesNestedInlineArrayFloat a8 = {};
  Union16BytesNestedInlineArrayFloat a9 = {};
 
  a0.a0[0] = -1.0;
  a0.a0[1] = 2.0;
  a0.a0[2] = -3.0;
  a0.a0[3] = 4.0;
  a1.a0[0] = -5.0;
  a1.a0[1] = 6.0;
  a1.a0[2] = -7.0;
  a1.a0[3] = 8.0;
  a2.a0[0] = -9.0;
  a2.a0[1] = 10.0;
  a2.a0[2] = -11.0;
  a2.a0[3] = 12.0;
  a3.a0[0] = -13.0;
  a3.a0[1] = 14.0;
  a3.a0[2] = -15.0;
  a3.a0[3] = 16.0;
  a4.a0[0] = -17.0;
  a4.a0[1] = 18.0;
  a4.a0[2] = -19.0;
  a4.a0[3] = 20.0;
  a5.a0[0] = -21.0;
  a5.a0[1] = 22.0;
  a5.a0[2] = -23.0;
  a5.a0[3] = 24.0;
  a6.a0[0] = -25.0;
  a6.a0[1] = 26.0;
  a6.a0[2] = -27.0;
  a6.a0[3] = 28.0;
  a7.a0[0] = -29.0;
  a7.a0[1] = 30.0;
  a7.a0[2] = -31.0;
  a7.a0[3] = 32.0;
  a8.a0[0] = -33.0;
  a8.a0[1] = 34.0;
  a8.a0[2] = -35.0;
  a8.a0[3] = 36.0;
  a9.a0[0] = -37.0;
  a9.a0[1] = 38.0;
  a9.a0[2] = -39.0;
  a9.a0[3] = 40.0;
 
  std::cout << "Calling TestPassUnion16BytesNestedInlineArrayFloatx10(" << "((["
            << a0.a0[0] << ", " << a0.a0[1] << ", " << a0.a0[2] << ", "
            << a0.a0[3] << "]), ([" << a1.a0[0] << ", " << a1.a0[1] << ", "
            << a1.a0[2] << ", " << a1.a0[3] << "]), ([" << a2.a0[0] << ", "
            << a2.a0[1] << ", " << a2.a0[2] << ", " << a2.a0[3] << "]), (["
            << a3.a0[0] << ", " << a3.a0[1] << ", " << a3.a0[2] << ", "
            << a3.a0[3] << "]), ([" << a4.a0[0] << ", " << a4.a0[1] << ", "
            << a4.a0[2] << ", " << a4.a0[3] << "]), ([" << a5.a0[0] << ", "
            << a5.a0[1] << ", " << a5.a0[2] << ", " << a5.a0[3] << "]), (["
            << a6.a0[0] << ", " << a6.a0[1] << ", " << a6.a0[2] << ", "
            << a6.a0[3] << "]), ([" << a7.a0[0] << ", " << a7.a0[1] << ", "
            << a7.a0[2] << ", " << a7.a0[3] << "]), ([" << a8.a0[0] << ", "
            << a8.a0[1] << ", " << a8.a0[2] << ", " << a8.a0[3] << "]), (["
            << a9.a0[0] << ", " << a9.a0[1] << ", " << a9.a0[2] << ", "
            << a9.a0[3] << "]))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(20.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0[0] = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0[0] = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassUnion4BytesMixedx10()

DART_EXPORT intptr_t dart::TestPassUnion4BytesMixedx10

(

double(*)(Union4BytesMixed a0, Union4BytesMixed a1, Union4BytesMixed a2, Union4BytesMixed a3, Union4BytesMixed a4, Union4BytesMixed a5, Union4BytesMixed a6, Union4BytesMixed a7, Union4BytesMixed a8, Union4BytesMixed a9)

f

)

Definition at line 11589 of file ffi_test_functions_generated.cc.

                                      {
  Union4BytesMixed a0 = {};
  Union4BytesMixed a1 = {};
  Union4BytesMixed a2 = {};
  Union4BytesMixed a3 = {};
  Union4BytesMixed a4 = {};
  Union4BytesMixed a5 = {};
  Union4BytesMixed a6 = {};
  Union4BytesMixed a7 = {};
  Union4BytesMixed a8 = {};
  Union4BytesMixed a9 = {};
 
  a0.a0 = 1;
  a1.a0 = 2;
  a2.a0 = 3;
  a3.a0 = 4;
  a4.a0 = 5;
  a5.a0 = 6;
  a6.a0 = 7;
  a7.a0 = 8;
  a8.a0 = 9;
  a9.a0 = 10;
 
  std::cout << "Calling TestPassUnion4BytesMixedx10(" << "((" << a0.a0 << "), ("
            << a1.a0 << "), (" << a2.a0 << "), (" << a3.a0 << "), (" << a4.a0
            << "), (" << a5.a0 << "), (" << a6.a0 << "), (" << a7.a0 << "), ("
            << a8.a0 << "), (" << a9.a0 << "))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(55.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassUnion8BytesNestedFloatx10()

DART_EXPORT intptr_t dart::TestPassUnion8BytesNestedFloatx10

(

double(*)(Union8BytesNestedFloat a0, Union8BytesNestedFloat a1, Union8BytesNestedFloat a2, Union8BytesNestedFloat a3, Union8BytesNestedFloat a4, Union8BytesNestedFloat a5, Union8BytesNestedFloat a6, Union8BytesNestedFloat a7, Union8BytesNestedFloat a8, Union8BytesNestedFloat a9)

f

)

Definition at line 11653 of file ffi_test_functions_generated.cc.

                                            {
  Union8BytesNestedFloat a0 = {};
  Union8BytesNestedFloat a1 = {};
  Union8BytesNestedFloat a2 = {};
  Union8BytesNestedFloat a3 = {};
  Union8BytesNestedFloat a4 = {};
  Union8BytesNestedFloat a5 = {};
  Union8BytesNestedFloat a6 = {};
  Union8BytesNestedFloat a7 = {};
  Union8BytesNestedFloat a8 = {};
  Union8BytesNestedFloat a9 = {};
 
  a0.a0 = -1.0;
  a1.a0 = 2.0;
  a2.a0 = -3.0;
  a3.a0 = 4.0;
  a4.a0 = -5.0;
  a5.a0 = 6.0;
  a6.a0 = -7.0;
  a7.a0 = 8.0;
  a8.a0 = -9.0;
  a9.a0 = 10.0;
 
  std::cout << "Calling TestPassUnion8BytesNestedFloatx10(" << "((" << a0.a0
            << "), (" << a1.a0 << "), (" << a2.a0 << "), (" << a3.a0 << "), ("
            << a4.a0 << "), (" << a5.a0 << "), (" << a6.a0 << "), (" << a7.a0
            << "), (" << a8.a0 << "), (" << a9.a0 << "))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(5.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassUnion9BytesNestedIntx10()

DART_EXPORT intptr_t dart::TestPassUnion9BytesNestedIntx10

(

double(*)(Union9BytesNestedInt a0, Union9BytesNestedInt a1, Union9BytesNestedInt a2, Union9BytesNestedInt a3, Union9BytesNestedInt a4, Union9BytesNestedInt a5, Union9BytesNestedInt a6, Union9BytesNestedInt a7, Union9BytesNestedInt a8, Union9BytesNestedInt a9)

f

)

Definition at line 11717 of file ffi_test_functions_generated.cc.

                                          {
  Union9BytesNestedInt a0 = {};
  Union9BytesNestedInt a1 = {};
  Union9BytesNestedInt a2 = {};
  Union9BytesNestedInt a3 = {};
  Union9BytesNestedInt a4 = {};
  Union9BytesNestedInt a5 = {};
  Union9BytesNestedInt a6 = {};
  Union9BytesNestedInt a7 = {};
  Union9BytesNestedInt a8 = {};
  Union9BytesNestedInt a9 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a0.a2 = -3;
  a1.a0.a0 = 4;
  a1.a0.a1 = -5;
  a1.a0.a2 = 6;
  a2.a0.a0 = -7;
  a2.a0.a1 = 8;
  a2.a0.a2 = -9;
  a3.a0.a0 = 10;
  a3.a0.a1 = -11;
  a3.a0.a2 = 12;
  a4.a0.a0 = -13;
  a4.a0.a1 = 14;
  a4.a0.a2 = -15;
  a5.a0.a0 = 16;
  a5.a0.a1 = -17;
  a5.a0.a2 = 18;
  a6.a0.a0 = -19;
  a6.a0.a1 = 20;
  a6.a0.a2 = -21;
  a7.a0.a0 = 22;
  a7.a0.a1 = -23;
  a7.a0.a2 = 24;
  a8.a0.a0 = -25;
  a8.a0.a1 = 26;
  a8.a0.a2 = -27;
  a9.a0.a0 = 28;
  a9.a0.a1 = -29;
  a9.a0.a2 = 30;
 
  std::cout << "Calling TestPassUnion9BytesNestedIntx10(" << "(((" << a0.a0.a0
            << ", " << a0.a0.a1 << ", " << a0.a0.a2 << ")), ((" << a1.a0.a0
            << ", " << a1.a0.a1 << ", " << a1.a0.a2 << ")), ((" << a2.a0.a0
            << ", " << a2.a0.a1 << ", " << a2.a0.a2 << ")), ((" << a3.a0.a0
            << ", " << a3.a0.a1 << ", " << a3.a0.a2 << ")), ((" << a4.a0.a0
            << ", " << a4.a0.a1 << ", " << a4.a0.a2 << ")), ((" << a5.a0.a0
            << ", " << a5.a0.a1 << ", " << a5.a0.a2 << ")), ((" << a6.a0.a0
            << ", " << a6.a0.a1 << ", " << a6.a0.a2 << ")), ((" << a7.a0.a0
            << ", " << a7.a0.a1 << ", " << a7.a0.a2 << ")), ((" << a8.a0.a0
            << ", " << a8.a0.a1 << ", " << a8.a0.a2 << ")), ((" << a9.a0.a0
            << ", " << a9.a0.a1 << ", " << a9.a0.a2 << ")))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(15.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestPassWCharStructInlineArrayIntUintPtrx2LongUnsigned()

DART_EXPORT intptr_t dart::TestPassWCharStructInlineArrayIntUintPtrx2LongUnsigned

(

wchar_t(*)(wchar_t a0, StructInlineArrayInt a1, uintptr_t a2, uintptr_t a3, long a4, unsigned long a5)

f

)

Definition at line 12197 of file ffi_test_functions_generated.cc.

                                      {
  wchar_t a0;
  StructInlineArrayInt a1 = {};
  uintptr_t a2;
  uintptr_t a3;
  /* NOLINT(runtime/int) */ long a4;
  /* NOLINT(runtime/int) */ unsigned long a5;
 
  a0 = 1;
  a1.a0[0] = 2;
  a1.a0[1] = 3;
  a1.a0[2] = 4;
  a1.a0[3] = 5;
  a1.a0[4] = 6;
  a1.a0[5] = 7;
  a1.a0[6] = 8;
  a1.a0[7] = 9;
  a1.a0[8] = 10;
  a1.a0[9] = 11;
  a2 = 12;
  a3 = 13;
  a4 = 14;
  a5 = 15;
 
  std::cout << "Calling TestPassWCharStructInlineArrayIntUintPtrx2LongUnsigned("
            << "(" << a0 << ", ([" << a1.a0[0] << ", " << a1.a0[1] << ", "
            << a1.a0[2] << ", " << a1.a0[3] << ", " << a1.a0[4] << ", "
            << a1.a0[5] << ", " << a1.a0[6] << ", " << a1.a0[7] << ", "
            << a1.a0[8] << ", " << a1.a0[9] << "]), " << a2 << ", " << a3
            << ", " << a4 << ", " << a5 << ")" << ")\n";
 
  wchar_t result = f(a0, a1, a2, a3, a4, a5);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(120, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestPhiUnboxingHeuristicSimd()

static void dart::TestPhiUnboxingHeuristicSimd ( const char *  script )

static

Definition at line 359 of file flow_graph_test.cc.

                                                             {
  if (!FlowGraphCompiler::SupportsUnboxedSimd128()) {
    return;
  }
 
  const auto& root_library = Library::Handle(LoadTestScript(script));
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
 
  Invoke(root_library, "main");
 
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                   ParallelMovesHandling::kSkip);
 
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveFunctionEntry,
  }));
  RELEASE_ASSERT(cursor.TryMatch({
      kMatchAndMoveUnbox,  // outside of loop
      kMatchAndMoveCheckSmi,
      kMoveGlob,
 
      // Loop header
      kMatchAndMoveJoinEntry,
      kMatchAndMoveCheckStackOverflow,
      kMatchAndMoveBranchTrue,
 
      // Loop body
      kMatchAndMoveTargetEntry,
      kMatchAndMoveSimdOp,
      kMatchAndMoveBinarySmiOp,
      kMatchAndMoveGoto,
 
      // Loop header, again
      kMatchAndMoveJoinEntry,
      kMatchAndMoveCheckStackOverflow,
      kMatchAndMoveBranchFalse,
 
      // After loop
      kMatchAndMoveTargetEntry,
      kMatchAndMoveBox,
      kMatchDartReturn,
  }));
}

TestPrint()

static void dart::TestPrint ( Dart_NativeArguments  args )

static

Definition at line 454 of file inliner_test.cc.

                                                 {
  Dart_EnterScope();
  Dart_Handle handle = Dart_GetNativeArgument(args, 0);
  const char* str = nullptr;
  Dart_StringToCString(handle, &str);
  OS::Print("%s\n", str);
  Dart_ExitScope();
}

TestPrinter()

static void dart::TestPrinter ( const char *  buffer )

static

Definition at line 22 of file log_test.cc.

                                            {
  if (test_output_ != nullptr) {
    free(const_cast<char*>(test_output_));
    test_output_ = nullptr;
  }
  test_output_ = Utils::StrDup(buffer);
 
  // Also print to stdout to see the overall result.
  OS::PrintErr("%s", test_output_);
}

TestRaw()

template<typename T >

void dart::TestRaw

(

)

Definition at line 88 of file datastream_test.cc.

               {
  MallocWriteStream writer(1 * KB);
  for (T i = kSignedStart; i < kSignedEnd; i++) {
    writer.Write(i);
  }
  DEFINE_LARGE_CONSTANTS(T);
  writer.Write(all_ones);
  writer.Write(min);
  writer.Write(max);
  writer.Write(half_min);
  writer.Write(half_max);
  ReadStream reader(writer.buffer(), writer.bytes_written());
  using Raw = ReadStream::Raw<sizeof(T), T>;
  for (T i = kSignedStart; i < kSignedEnd; i++) {
    const T r = Raw::Read(&reader);
    EXPECT_EQ(i, r);
  }
  const T read_all_ones = Raw::Read(&reader);
  EXPECT_EQ(all_ones, read_all_ones);
  const T read_min = Raw::Read(&reader);
  EXPECT_EQ(min, read_min);
  const T read_max = Raw::Read(&reader);
  EXPECT_EQ(max, read_max);
  const T read_half_min = Raw::Read(&reader);
  EXPECT_EQ(half_min, read_half_min);
  const T read_half_max = Raw::Read(&reader);
  EXPECT_EQ(half_max, read_half_max);
}

TestRegress38528()

static void dart::TestRegress38528 ( intptr_t  header_overlap )

static

Definition at line 188 of file freelist_test.cc.

                                                      {
  // Test the following scenario.
  //
  // | <------------ free list element -----------------> |
  // | <allocated code> | <header> | <remainder - header> | <other code> |
  //                         ^
  //    page boundary around here, depending on header_overlap
  //
  // It is important that after the allocation has been re-protected, the
  // "<other code>" region is also still executable (and not writable).
  std::unique_ptr<FreeList> free_list(new FreeList());
  const uword page = VirtualMemory::PageSize();
  std::unique_ptr<VirtualMemory> blob(VirtualMemory::Allocate(
      2 * page,
      /*is_executable=*/true, /*is_compressed=*/false, "test"));
  const intptr_t remainder_size = page / 2;
  const intptr_t alloc_size = page - header_overlap * kObjectAlignment;
  void* const other_code =
      reinterpret_cast<void*>(blob->start() + alloc_size + remainder_size);
 
  // Load a simple function into the "other code" section which just returns.
  // This is used to ensure that it's still executable.
#if defined(HOST_ARCH_X64) || defined(HOST_ARCH_IA32)
  const uint8_t ret[1] = {0xC3};  // ret
#elif defined(HOST_ARCH_ARM)
  const uint8_t ret[4] = {0x1e, 0xff, 0x2f, 0xe1};  // bx lr
#elif defined(HOST_ARCH_ARM64)
  const uint8_t ret[4] = {0xc0, 0x03, 0x5f, 0xd6};  // ret
#elif defined(HOST_ARCH_RISCV32) || defined(HOST_ARCH_RISCV64)
  const uint8_t ret[2] = {0x82, 0x80};  // c.ret
#else
#error "Unknown architecture."
#endif
  memcpy(other_code, ret, sizeof(ret));  // NOLINT
 
  free_list->Free(blob->start(), alloc_size + remainder_size);
  blob->Protect(VirtualMemory::kReadExecute);  // not writable
  Allocate(free_list.get(), alloc_size, /*protected=*/true);
  VirtualMemory::Protect(blob->address(), alloc_size,
                         VirtualMemory::kReadExecute);
  reinterpret_cast<void (*)()>(other_code)();
}

TestReloadWithFieldChange()

static void dart::TestReloadWithFieldChange ( const char *  prefix, const char *  suffix, const char *  verify, const char *  from_type, const char *  from_init, const char *  to_type, const char *  to_init  )

static

Definition at line 5465 of file isolate_reload_test.cc.

  {
    Dart_EnterScope();
    Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(result);
    {
      TransitionNativeToVM transition(thread);
      cid = Api::ClassId(result);
    }
    Dart_ExitScope();
  }
 
  const char* kReloadScript =
      "class C {\n"
      "}\n"
      "class Foo {\n"
      "}\n"
      "main() {\n"
      "  return '${Foo()}';\n"
      "}\n";
 
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  {
    TransitionNativeToVM transition(thread);
    GCTestHelper::CollectAllGarbage();
 
    {
      HeapIterationScope iteration(thread);
      CidCountingVisitor counting_visitor(cid);
      iteration.IterateObjects(&counting_visitor);
 
      // We still expect to find references to static field values
      // because they are not deleted after hot reload.
      EXPECT_NE(counting_visitor.count(), 0);
    }
  }
}
 
static void TestReloadWithFieldChange(const char* prefix,
                                      const char* suffix,
                                      const char* verify,
                                      const char* from_type,
                                      const char* from_init,
                                      const char* to_type,
                                      const char* to_init) {
  const char* late_tag = TestCase::LateTag();
  // clang-format off
  auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr,
                                                     R"(
    import 'dart:typed_data';
 
    void doubleEq(double got, double expected) {
      if (got != expected) throw 'expected $expected got $got';
    }

TestRepresentationChangeDuringCanonicalization()

static void dart::TestRepresentationChangeDuringCanonicalization ( Thread *  thread, bool  allow_representation_change  )

static

Definition at line 1172 of file il_test.cc.

                                      {
  using compiler::BlockBuilder;
 
  const auto& lib = Library::Handle(Library::CoreLibrary());
  const Class& list_class =
      Class::Handle(lib.LookupClassAllowPrivate(Symbols::_List()));
  EXPECT(!list_class.IsNull());
  const Error& err = Error::Handle(list_class.EnsureIsFinalized(thread));
  EXPECT(err.IsNull());
  const Function& list_filled = Function::ZoneHandle(
      list_class.LookupFactoryAllowPrivate(Symbols::_ListFilledFactory()));
  EXPECT(!list_filled.IsNull());
 
  CompilerState S(thread, /*is_aot=*/true, /*is_optimizing=*/true);
 
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("param", AbstractType::ZoneHandle(Type::IntType()));
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
 
  Definition* param = nullptr;
  LoadFieldInstr* load = nullptr;
  UnboxInstr* unbox = nullptr;
  Definition* add = nullptr;
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    param = builder.AddParameter(0, kUnboxedInt64);
 
    InputsArray args;
    args.Add(new Value(H.flow_graph()->constant_null()));
    args.Add(new Value(param));
    args.Add(new Value(H.IntConstant(0)));
    StaticCallInstr* array = builder.AddDefinition(new StaticCallInstr(
        InstructionSource(), list_filled, 1, Array::empty_array(),
        std::move(args), DeoptId::kNone, 0, ICData::kNoRebind));
    array->UpdateType(CompileType::FromCid(kArrayCid));
    array->SetResultType(thread->zone(), CompileType::FromCid(kArrayCid));
    array->set_is_known_list_constructor(true);
 
    load = builder.AddDefinition(new LoadFieldInstr(
        new Value(array), Slot::Array_length(), InstructionSource()));
 
    unbox = builder.AddDefinition(new UnboxInt64Instr(
        new Value(load), DeoptId::kNone, Instruction::kNotSpeculative));
 
    add = builder.AddDefinition(new BinaryInt64OpInstr(
        Token::kADD, new Value(unbox), new Value(H.IntConstant(1)),
        S.GetNextDeoptId(), Instruction::kNotSpeculative));
 
    Definition* box = builder.AddDefinition(new BoxInt64Instr(new Value(add)));
 
    builder.AddReturn(new Value(box));
  }
 
  H.FinishGraph();
 
  if (!allow_representation_change) {
    H.flow_graph()->disallow_unmatched_representations();
  }
 
  H.flow_graph()->Canonicalize();
 
  if (allow_representation_change) {
    EXPECT(add->InputAt(0)->definition() == param);
  } else {
    EXPECT(add->InputAt(0)->definition() == unbox);
    EXPECT(unbox->value()->definition() == load);
  }
}

TestResolve()

static const char * dart::TestResolve ( const char *  base_uri, const char *  uri  )

static

Definition at line 505 of file uri_test.cc.

                                                                      {
  const char* target_uri;
  EXPECT(ResolveUri(uri, base_uri, &target_uri));
  return target_uri;
}

TestReturnMaxUint8()

DART_EXPORT intptr_t dart::TestReturnMaxUint8

(

uint8_t(*)()

fn

)

Definition at line 1153 of file ffi_test_functions.cc.

                                                         {
  std::cout << "TestReturnMaxUint8(fn): " << static_cast<int>(fn()) << "\n";
  CHECK_EQ(0xFF, fn());
  return 0;
}

TestReturnNull()

DART_EXPORT intptr_t dart::TestReturnNull

(

int32_t(*)()

fn

)

Definition at line 1104 of file ffi_test_functions.cc.

                                                     {
  CHECK_EQ(fn(), 42);
  return 0;
}

TestReturnStruct1024BytesHomogeneousUint64()

DART_EXPORT intptr_t dart::TestReturnStruct1024BytesHomogeneousUint64

(

Struct1024BytesHomogeneousUint64(*)(uint64_t a0, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6, uint64_t a7, uint64_t a8, uint64_t a9, uint64_t a10, uint64_t a11, uint64_t a12, uint64_t a13, uint64_t a14, uint64_t a15, uint64_t a16, uint64_t a17, uint64_t a18, uint64_t a19, uint64_t a20, uint64_t a21, uint64_t a22, uint64_t a23, uint64_t a24, uint64_t a25, uint64_t a26, uint64_t a27, uint64_t a28, uint64_t a29, uint64_t a30, uint64_t a31, uint64_t a32, uint64_t a33, uint64_t a34, uint64_t a35, uint64_t a36, uint64_t a37, uint64_t a38, uint64_t a39, uint64_t a40, uint64_t a41, uint64_t a42, uint64_t a43, uint64_t a44, uint64_t a45, uint64_t a46, uint64_t a47, uint64_t a48, uint64_t a49, uint64_t a50, uint64_t a51, uint64_t a52, uint64_t a53, uint64_t a54, uint64_t a55, uint64_t a56, uint64_t a57, uint64_t a58, uint64_t a59, uint64_t a60, uint64_t a61, uint64_t a62, uint64_t a63, uint64_t a64, uint64_t a65, uint64_t a66, uint64_t a67, uint64_t a68, uint64_t a69, uint64_t a70, uint64_t a71, uint64_t a72, uint64_t a73, uint64_t a74, uint64_t a75, uint64_t a76, uint64_t a77, uint64_t a78, uint64_t a79, uint64_t a80, uint64_t a81, uint64_t a82, uint64_t a83, uint64_t a84, uint64_t a85, uint64_t a86, uint64_t a87, uint64_t a88, uint64_t a89, uint64_t a90, uint64_t a91, uint64_t a92, uint64_t a93, uint64_t a94, uint64_t a95, uint64_t a96, uint64_t a97, uint64_t a98, uint64_t a99, uint64_t a100, uint64_t a101, uint64_t a102, uint64_t a103, uint64_t a104, uint64_t a105, uint64_t a106, uint64_t a107, uint64_t a108, uint64_t a109, uint64_t a110, uint64_t a111, uint64_t a112, uint64_t a113, uint64_t a114, uint64_t a115, uint64_t a116, uint64_t a117, uint64_t a118, uint64_t a119, uint64_t a120, uint64_t a121, uint64_t a122, uint64_t a123, uint64_t a124, uint64_t a125, uint64_t a126, uint64_t a127)

f

)

Definition at line 13530 of file ffi_test_functions_generated.cc.

                                                          {
  uint64_t a0;
  uint64_t a1;
  uint64_t a2;
  uint64_t a3;
  uint64_t a4;
  uint64_t a5;
  uint64_t a6;
  uint64_t a7;
  uint64_t a8;
  uint64_t a9;
  uint64_t a10;
  uint64_t a11;
  uint64_t a12;
  uint64_t a13;
  uint64_t a14;
  uint64_t a15;
  uint64_t a16;
  uint64_t a17;
  uint64_t a18;
  uint64_t a19;
  uint64_t a20;
  uint64_t a21;
  uint64_t a22;
  uint64_t a23;
  uint64_t a24;
  uint64_t a25;
  uint64_t a26;
  uint64_t a27;
  uint64_t a28;
  uint64_t a29;
  uint64_t a30;
  uint64_t a31;
  uint64_t a32;
  uint64_t a33;
  uint64_t a34;
  uint64_t a35;
  uint64_t a36;
  uint64_t a37;
  uint64_t a38;
  uint64_t a39;
  uint64_t a40;
  uint64_t a41;
  uint64_t a42;
  uint64_t a43;
  uint64_t a44;
  uint64_t a45;
  uint64_t a46;
  uint64_t a47;
  uint64_t a48;
  uint64_t a49;
  uint64_t a50;
  uint64_t a51;
  uint64_t a52;
  uint64_t a53;
  uint64_t a54;
  uint64_t a55;
  uint64_t a56;
  uint64_t a57;
  uint64_t a58;
  uint64_t a59;
  uint64_t a60;
  uint64_t a61;
  uint64_t a62;
  uint64_t a63;
  uint64_t a64;
  uint64_t a65;
  uint64_t a66;
  uint64_t a67;
  uint64_t a68;
  uint64_t a69;
  uint64_t a70;
  uint64_t a71;
  uint64_t a72;
  uint64_t a73;
  uint64_t a74;
  uint64_t a75;
  uint64_t a76;
  uint64_t a77;
  uint64_t a78;
  uint64_t a79;
  uint64_t a80;
  uint64_t a81;
  uint64_t a82;
  uint64_t a83;
  uint64_t a84;
  uint64_t a85;
  uint64_t a86;
  uint64_t a87;
  uint64_t a88;
  uint64_t a89;
  uint64_t a90;
  uint64_t a91;
  uint64_t a92;
  uint64_t a93;
  uint64_t a94;
  uint64_t a95;
  uint64_t a96;
  uint64_t a97;
  uint64_t a98;
  uint64_t a99;
  uint64_t a100;
  uint64_t a101;
  uint64_t a102;
  uint64_t a103;
  uint64_t a104;
  uint64_t a105;
  uint64_t a106;
  uint64_t a107;
  uint64_t a108;
  uint64_t a109;
  uint64_t a110;
  uint64_t a111;
  uint64_t a112;
  uint64_t a113;
  uint64_t a114;
  uint64_t a115;
  uint64_t a116;
  uint64_t a117;
  uint64_t a118;
  uint64_t a119;
  uint64_t a120;
  uint64_t a121;
  uint64_t a122;
  uint64_t a123;
  uint64_t a124;
  uint64_t a125;
  uint64_t a126;
  uint64_t a127;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;
  a9 = 10;
  a10 = 11;
  a11 = 12;
  a12 = 13;
  a13 = 14;
  a14 = 15;
  a15 = 16;
  a16 = 17;
  a17 = 18;
  a18 = 19;
  a19 = 20;
  a20 = 21;
  a21 = 22;
  a22 = 23;
  a23 = 24;
  a24 = 25;
  a25 = 26;
  a26 = 27;
  a27 = 28;
  a28 = 29;
  a29 = 30;
  a30 = 31;
  a31 = 32;
  a32 = 33;
  a33 = 34;
  a34 = 35;
  a35 = 36;
  a36 = 37;
  a37 = 38;
  a38 = 39;
  a39 = 40;
  a40 = 41;
  a41 = 42;
  a42 = 43;
  a43 = 44;
  a44 = 45;
  a45 = 46;
  a46 = 47;
  a47 = 48;
  a48 = 49;
  a49 = 50;
  a50 = 51;
  a51 = 52;
  a52 = 53;
  a53 = 54;
  a54 = 55;
  a55 = 56;
  a56 = 57;
  a57 = 58;
  a58 = 59;
  a59 = 60;
  a60 = 61;
  a61 = 62;
  a62 = 63;
  a63 = 64;
  a64 = 65;
  a65 = 66;
  a66 = 67;
  a67 = 68;
  a68 = 69;
  a69 = 70;
  a70 = 71;
  a71 = 72;
  a72 = 73;
  a73 = 74;
  a74 = 75;
  a75 = 76;
  a76 = 77;
  a77 = 78;
  a78 = 79;
  a79 = 80;
  a80 = 81;
  a81 = 82;
  a82 = 83;
  a83 = 84;
  a84 = 85;
  a85 = 86;
  a86 = 87;
  a87 = 88;
  a88 = 89;
  a89 = 90;
  a90 = 91;
  a91 = 92;
  a92 = 93;
  a93 = 94;
  a94 = 95;
  a95 = 96;
  a96 = 97;
  a97 = 98;
  a98 = 99;
  a99 = 100;
  a100 = 101;
  a101 = 102;
  a102 = 103;
  a103 = 104;
  a104 = 105;
  a105 = 106;
  a106 = 107;
  a107 = 108;
  a108 = 109;
  a109 = 110;
  a110 = 111;
  a111 = 112;
  a112 = 113;
  a113 = 114;
  a114 = 115;
  a115 = 116;
  a116 = 117;
  a117 = 118;
  a118 = 119;
  a119 = 120;
  a120 = 121;
  a121 = 122;
  a122 = 123;
  a123 = 124;
  a124 = 125;
  a125 = 126;
  a126 = 127;
  a127 = 128;
 
  std::cout << "Calling TestReturnStruct1024BytesHomogeneousUint64(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", " << a7 << ", " << a8 << ", "
            << a9 << ", " << a10 << ", " << a11 << ", " << a12 << ", " << a13
            << ", " << a14 << ", " << a15 << ", " << a16 << ", " << a17 << ", "
            << a18 << ", " << a19 << ", " << a20 << ", " << a21 << ", " << a22
            << ", " << a23 << ", " << a24 << ", " << a25 << ", " << a26 << ", "
            << a27 << ", " << a28 << ", " << a29 << ", " << a30 << ", " << a31
            << ", " << a32 << ", " << a33 << ", " << a34 << ", " << a35 << ", "
            << a36 << ", " << a37 << ", " << a38 << ", " << a39 << ", " << a40
            << ", " << a41 << ", " << a42 << ", " << a43 << ", " << a44 << ", "
            << a45 << ", " << a46 << ", " << a47 << ", " << a48 << ", " << a49
            << ", " << a50 << ", " << a51 << ", " << a52 << ", " << a53 << ", "
            << a54 << ", " << a55 << ", " << a56 << ", " << a57 << ", " << a58
            << ", " << a59 << ", " << a60 << ", " << a61 << ", " << a62 << ", "
            << a63 << ", " << a64 << ", " << a65 << ", " << a66 << ", " << a67
            << ", " << a68 << ", " << a69 << ", " << a70 << ", " << a71 << ", "
            << a72 << ", " << a73 << ", " << a74 << ", " << a75 << ", " << a76
            << ", " << a77 << ", " << a78 << ", " << a79 << ", " << a80 << ", "
            << a81 << ", " << a82 << ", " << a83 << ", " << a84 << ", " << a85
            << ", " << a86 << ", " << a87 << ", " << a88 << ", " << a89 << ", "
            << a90 << ", " << a91 << ", " << a92 << ", " << a93 << ", " << a94
            << ", " << a95 << ", " << a96 << ", " << a97 << ", " << a98 << ", "
            << a99 << ", " << a100 << ", " << a101 << ", " << a102 << ", "
            << a103 << ", " << a104 << ", " << a105 << ", " << a106 << ", "
            << a107 << ", " << a108 << ", " << a109 << ", " << a110 << ", "
            << a111 << ", " << a112 << ", " << a113 << ", " << a114 << ", "
            << a115 << ", " << a116 << ", " << a117 << ", " << a118 << ", "
            << a119 << ", " << a120 << ", " << a121 << ", " << a122 << ", "
            << a123 << ", " << a124 << ", " << a125 << ", " << a126 << ", "
            << a127 << ")" << ")\n";
 
  Struct1024BytesHomogeneousUint64 result = f(
      a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16,
      a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31,
      a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46,
      a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61,
      a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, a72, a73, a74, a75, a76,
      a77, a78, a79, a80, a81, a82, a83, a84, a85, a86, a87, a88, a89, a90, a91,
      a92, a93, a94, a95, a96, a97, a98, a99, a100, a101, a102, a103, a104,
      a105, a106, a107, a108, a109, a110, a111, a112, a113, a114, a115, a116,
      a117, a118, a119, a120, a121, a122, a123, a124, a125, a126, a127);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ", "
            << result.a5 << ", " << result.a6 << ", " << result.a7 << ", "
            << result.a8 << ", " << result.a9 << ", " << result.a10 << ", "
            << result.a11 << ", " << result.a12 << ", " << result.a13 << ", "
            << result.a14 << ", " << result.a15 << ", " << result.a16 << ", "
            << result.a17 << ", " << result.a18 << ", " << result.a19 << ", "
            << result.a20 << ", " << result.a21 << ", " << result.a22 << ", "
            << result.a23 << ", " << result.a24 << ", " << result.a25 << ", "
            << result.a26 << ", " << result.a27 << ", " << result.a28 << ", "
            << result.a29 << ", " << result.a30 << ", " << result.a31 << ", "
            << result.a32 << ", " << result.a33 << ", " << result.a34 << ", "
            << result.a35 << ", " << result.a36 << ", " << result.a37 << ", "
            << result.a38 << ", " << result.a39 << ", " << result.a40 << ", "
            << result.a41 << ", " << result.a42 << ", " << result.a43 << ", "
            << result.a44 << ", " << result.a45 << ", " << result.a46 << ", "
            << result.a47 << ", " << result.a48 << ", " << result.a49 << ", "
            << result.a50 << ", " << result.a51 << ", " << result.a52 << ", "
            << result.a53 << ", " << result.a54 << ", " << result.a55 << ", "
            << result.a56 << ", " << result.a57 << ", " << result.a58 << ", "
            << result.a59 << ", " << result.a60 << ", " << result.a61 << ", "
            << result.a62 << ", " << result.a63 << ", " << result.a64 << ", "
            << result.a65 << ", " << result.a66 << ", " << result.a67 << ", "
            << result.a68 << ", " << result.a69 << ", " << result.a70 << ", "
            << result.a71 << ", " << result.a72 << ", " << result.a73 << ", "
            << result.a74 << ", " << result.a75 << ", " << result.a76 << ", "
            << result.a77 << ", " << result.a78 << ", " << result.a79 << ", "
            << result.a80 << ", " << result.a81 << ", " << result.a82 << ", "
            << result.a83 << ", " << result.a84 << ", " << result.a85 << ", "
            << result.a86 << ", " << result.a87 << ", " << result.a88 << ", "
            << result.a89 << ", " << result.a90 << ", " << result.a91 << ", "
            << result.a92 << ", " << result.a93 << ", " << result.a94 << ", "
            << result.a95 << ", " << result.a96 << ", " << result.a97 << ", "
            << result.a98 << ", " << result.a99 << ", " << result.a100 << ", "
            << result.a101 << ", " << result.a102 << ", " << result.a103 << ", "
            << result.a104 << ", " << result.a105 << ", " << result.a106 << ", "
            << result.a107 << ", " << result.a108 << ", " << result.a109 << ", "
            << result.a110 << ", " << result.a111 << ", " << result.a112 << ", "
            << result.a113 << ", " << result.a114 << ", " << result.a115 << ", "
            << result.a116 << ", " << result.a117 << ", " << result.a118 << ", "
            << result.a119 << ", " << result.a120 << ", " << result.a121 << ", "
            << result.a122 << ", " << result.a123 << ", " << result.a124 << ", "
            << result.a125 << ", " << result.a126 << ", " << result.a127 << ")"
            << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
  CHECK_EQ(a3, result.a3);
  CHECK_EQ(a4, result.a4);
  CHECK_EQ(a5, result.a5);
  CHECK_EQ(a6, result.a6);
  CHECK_EQ(a7, result.a7);
  CHECK_EQ(a8, result.a8);
  CHECK_EQ(a9, result.a9);
  CHECK_EQ(a10, result.a10);
  CHECK_EQ(a11, result.a11);
  CHECK_EQ(a12, result.a12);
  CHECK_EQ(a13, result.a13);
  CHECK_EQ(a14, result.a14);
  CHECK_EQ(a15, result.a15);
  CHECK_EQ(a16, result.a16);
  CHECK_EQ(a17, result.a17);
  CHECK_EQ(a18, result.a18);
  CHECK_EQ(a19, result.a19);
  CHECK_EQ(a20, result.a20);
  CHECK_EQ(a21, result.a21);
  CHECK_EQ(a22, result.a22);
  CHECK_EQ(a23, result.a23);
  CHECK_EQ(a24, result.a24);
  CHECK_EQ(a25, result.a25);
  CHECK_EQ(a26, result.a26);
  CHECK_EQ(a27, result.a27);
  CHECK_EQ(a28, result.a28);
  CHECK_EQ(a29, result.a29);
  CHECK_EQ(a30, result.a30);
  CHECK_EQ(a31, result.a31);
  CHECK_EQ(a32, result.a32);
  CHECK_EQ(a33, result.a33);
  CHECK_EQ(a34, result.a34);
  CHECK_EQ(a35, result.a35);
  CHECK_EQ(a36, result.a36);
  CHECK_EQ(a37, result.a37);
  CHECK_EQ(a38, result.a38);
  CHECK_EQ(a39, result.a39);
  CHECK_EQ(a40, result.a40);
  CHECK_EQ(a41, result.a41);
  CHECK_EQ(a42, result.a42);
  CHECK_EQ(a43, result.a43);
  CHECK_EQ(a44, result.a44);
  CHECK_EQ(a45, result.a45);
  CHECK_EQ(a46, result.a46);
  CHECK_EQ(a47, result.a47);
  CHECK_EQ(a48, result.a48);
  CHECK_EQ(a49, result.a49);
  CHECK_EQ(a50, result.a50);
  CHECK_EQ(a51, result.a51);
  CHECK_EQ(a52, result.a52);
  CHECK_EQ(a53, result.a53);
  CHECK_EQ(a54, result.a54);
  CHECK_EQ(a55, result.a55);
  CHECK_EQ(a56, result.a56);
  CHECK_EQ(a57, result.a57);
  CHECK_EQ(a58, result.a58);
  CHECK_EQ(a59, result.a59);
  CHECK_EQ(a60, result.a60);
  CHECK_EQ(a61, result.a61);
  CHECK_EQ(a62, result.a62);
  CHECK_EQ(a63, result.a63);
  CHECK_EQ(a64, result.a64);
  CHECK_EQ(a65, result.a65);
  CHECK_EQ(a66, result.a66);
  CHECK_EQ(a67, result.a67);
  CHECK_EQ(a68, result.a68);
  CHECK_EQ(a69, result.a69);
  CHECK_EQ(a70, result.a70);
  CHECK_EQ(a71, result.a71);
  CHECK_EQ(a72, result.a72);
  CHECK_EQ(a73, result.a73);
  CHECK_EQ(a74, result.a74);
  CHECK_EQ(a75, result.a75);
  CHECK_EQ(a76, result.a76);
  CHECK_EQ(a77, result.a77);
  CHECK_EQ(a78, result.a78);
  CHECK_EQ(a79, result.a79);
  CHECK_EQ(a80, result.a80);
  CHECK_EQ(a81, result.a81);
  CHECK_EQ(a82, result.a82);
  CHECK_EQ(a83, result.a83);
  CHECK_EQ(a84, result.a84);
  CHECK_EQ(a85, result.a85);
  CHECK_EQ(a86, result.a86);
  CHECK_EQ(a87, result.a87);
  CHECK_EQ(a88, result.a88);
  CHECK_EQ(a89, result.a89);
  CHECK_EQ(a90, result.a90);
  CHECK_EQ(a91, result.a91);
  CHECK_EQ(a92, result.a92);
  CHECK_EQ(a93, result.a93);
  CHECK_EQ(a94, result.a94);
  CHECK_EQ(a95, result.a95);
  CHECK_EQ(a96, result.a96);
  CHECK_EQ(a97, result.a97);
  CHECK_EQ(a98, result.a98);
  CHECK_EQ(a99, result.a99);
  CHECK_EQ(a100, result.a100);
  CHECK_EQ(a101, result.a101);
  CHECK_EQ(a102, result.a102);
  CHECK_EQ(a103, result.a103);
  CHECK_EQ(a104, result.a104);
  CHECK_EQ(a105, result.a105);
  CHECK_EQ(a106, result.a106);
  CHECK_EQ(a107, result.a107);
  CHECK_EQ(a108, result.a108);
  CHECK_EQ(a109, result.a109);
  CHECK_EQ(a110, result.a110);
  CHECK_EQ(a111, result.a111);
  CHECK_EQ(a112, result.a112);
  CHECK_EQ(a113, result.a113);
  CHECK_EQ(a114, result.a114);
  CHECK_EQ(a115, result.a115);
  CHECK_EQ(a116, result.a116);
  CHECK_EQ(a117, result.a117);
  CHECK_EQ(a118, result.a118);
  CHECK_EQ(a119, result.a119);
  CHECK_EQ(a120, result.a120);
  CHECK_EQ(a121, result.a121);
  CHECK_EQ(a122, result.a122);
  CHECK_EQ(a123, result.a123);
  CHECK_EQ(a124, result.a124);
  CHECK_EQ(a125, result.a125);
  CHECK_EQ(a126, result.a126);
  CHECK_EQ(a127, result.a127);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(
      a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16,
      a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31,
      a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46,
      a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61,
      a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, a72, a73, a74, a75, a76,
      a77, a78, a79, a80, a81, a82, a83, a84, a85, a86, a87, a88, a89, a90, a91,
      a92, a93, a94, a95, a96, a97, a98, a99, a100, a101, a102, a103, a104,
      a105, a106, a107, a108, a109, a110, a111, a112, a113, a114, a115, a116,
      a117, a118, a119, a120, a121, a122, a123, a124, a125, a126, a127);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
  CHECK_EQ(0, result.a5);
  CHECK_EQ(0, result.a6);
  CHECK_EQ(0, result.a7);
  CHECK_EQ(0, result.a8);
  CHECK_EQ(0, result.a9);
  CHECK_EQ(0, result.a10);
  CHECK_EQ(0, result.a11);
  CHECK_EQ(0, result.a12);
  CHECK_EQ(0, result.a13);
  CHECK_EQ(0, result.a14);
  CHECK_EQ(0, result.a15);
  CHECK_EQ(0, result.a16);
  CHECK_EQ(0, result.a17);
  CHECK_EQ(0, result.a18);
  CHECK_EQ(0, result.a19);
  CHECK_EQ(0, result.a20);
  CHECK_EQ(0, result.a21);
  CHECK_EQ(0, result.a22);
  CHECK_EQ(0, result.a23);
  CHECK_EQ(0, result.a24);
  CHECK_EQ(0, result.a25);
  CHECK_EQ(0, result.a26);
  CHECK_EQ(0, result.a27);
  CHECK_EQ(0, result.a28);
  CHECK_EQ(0, result.a29);
  CHECK_EQ(0, result.a30);
  CHECK_EQ(0, result.a31);
  CHECK_EQ(0, result.a32);
  CHECK_EQ(0, result.a33);
  CHECK_EQ(0, result.a34);
  CHECK_EQ(0, result.a35);
  CHECK_EQ(0, result.a36);
  CHECK_EQ(0, result.a37);
  CHECK_EQ(0, result.a38);
  CHECK_EQ(0, result.a39);
  CHECK_EQ(0, result.a40);
  CHECK_EQ(0, result.a41);
  CHECK_EQ(0, result.a42);
  CHECK_EQ(0, result.a43);
  CHECK_EQ(0, result.a44);
  CHECK_EQ(0, result.a45);
  CHECK_EQ(0, result.a46);
  CHECK_EQ(0, result.a47);
  CHECK_EQ(0, result.a48);
  CHECK_EQ(0, result.a49);
  CHECK_EQ(0, result.a50);
  CHECK_EQ(0, result.a51);
  CHECK_EQ(0, result.a52);
  CHECK_EQ(0, result.a53);
  CHECK_EQ(0, result.a54);
  CHECK_EQ(0, result.a55);
  CHECK_EQ(0, result.a56);
  CHECK_EQ(0, result.a57);
  CHECK_EQ(0, result.a58);
  CHECK_EQ(0, result.a59);
  CHECK_EQ(0, result.a60);
  CHECK_EQ(0, result.a61);
  CHECK_EQ(0, result.a62);
  CHECK_EQ(0, result.a63);
  CHECK_EQ(0, result.a64);
  CHECK_EQ(0, result.a65);
  CHECK_EQ(0, result.a66);
  CHECK_EQ(0, result.a67);
  CHECK_EQ(0, result.a68);
  CHECK_EQ(0, result.a69);
  CHECK_EQ(0, result.a70);
  CHECK_EQ(0, result.a71);
  CHECK_EQ(0, result.a72);
  CHECK_EQ(0, result.a73);
  CHECK_EQ(0, result.a74);
  CHECK_EQ(0, result.a75);
  CHECK_EQ(0, result.a76);
  CHECK_EQ(0, result.a77);
  CHECK_EQ(0, result.a78);
  CHECK_EQ(0, result.a79);
  CHECK_EQ(0, result.a80);
  CHECK_EQ(0, result.a81);
  CHECK_EQ(0, result.a82);
  CHECK_EQ(0, result.a83);
  CHECK_EQ(0, result.a84);
  CHECK_EQ(0, result.a85);
  CHECK_EQ(0, result.a86);
  CHECK_EQ(0, result.a87);
  CHECK_EQ(0, result.a88);
  CHECK_EQ(0, result.a89);
  CHECK_EQ(0, result.a90);
  CHECK_EQ(0, result.a91);
  CHECK_EQ(0, result.a92);
  CHECK_EQ(0, result.a93);
  CHECK_EQ(0, result.a94);
  CHECK_EQ(0, result.a95);
  CHECK_EQ(0, result.a96);
  CHECK_EQ(0, result.a97);
  CHECK_EQ(0, result.a98);
  CHECK_EQ(0, result.a99);
  CHECK_EQ(0, result.a100);
  CHECK_EQ(0, result.a101);
  CHECK_EQ(0, result.a102);
  CHECK_EQ(0, result.a103);
  CHECK_EQ(0, result.a104);
  CHECK_EQ(0, result.a105);
  CHECK_EQ(0, result.a106);
  CHECK_EQ(0, result.a107);
  CHECK_EQ(0, result.a108);
  CHECK_EQ(0, result.a109);
  CHECK_EQ(0, result.a110);
  CHECK_EQ(0, result.a111);
  CHECK_EQ(0, result.a112);
  CHECK_EQ(0, result.a113);
  CHECK_EQ(0, result.a114);
  CHECK_EQ(0, result.a115);
  CHECK_EQ(0, result.a116);
  CHECK_EQ(0, result.a117);
  CHECK_EQ(0, result.a118);
  CHECK_EQ(0, result.a119);
  CHECK_EQ(0, result.a120);
  CHECK_EQ(0, result.a121);
  CHECK_EQ(0, result.a122);
  CHECK_EQ(0, result.a123);
  CHECK_EQ(0, result.a124);
  CHECK_EQ(0, result.a125);
  CHECK_EQ(0, result.a126);
  CHECK_EQ(0, result.a127);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(
      a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16,
      a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31,
      a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46,
      a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61,
      a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, a72, a73, a74, a75, a76,
      a77, a78, a79, a80, a81, a82, a83, a84, a85, a86, a87, a88, a89, a90, a91,
      a92, a93, a94, a95, a96, a97, a98, a99, a100, a101, a102, a103, a104,
      a105, a106, a107, a108, a109, a110, a111, a112, a113, a114, a115, a116,
      a117, a118, a119, a120, a121, a122, a123, a124, a125, a126, a127);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
  CHECK_EQ(0, result.a5);
  CHECK_EQ(0, result.a6);
  CHECK_EQ(0, result.a7);
  CHECK_EQ(0, result.a8);
  CHECK_EQ(0, result.a9);
  CHECK_EQ(0, result.a10);
  CHECK_EQ(0, result.a11);
  CHECK_EQ(0, result.a12);
  CHECK_EQ(0, result.a13);
  CHECK_EQ(0, result.a14);
  CHECK_EQ(0, result.a15);
  CHECK_EQ(0, result.a16);
  CHECK_EQ(0, result.a17);
  CHECK_EQ(0, result.a18);
  CHECK_EQ(0, result.a19);
  CHECK_EQ(0, result.a20);
  CHECK_EQ(0, result.a21);
  CHECK_EQ(0, result.a22);
  CHECK_EQ(0, result.a23);
  CHECK_EQ(0, result.a24);
  CHECK_EQ(0, result.a25);
  CHECK_EQ(0, result.a26);
  CHECK_EQ(0, result.a27);
  CHECK_EQ(0, result.a28);
  CHECK_EQ(0, result.a29);
  CHECK_EQ(0, result.a30);
  CHECK_EQ(0, result.a31);
  CHECK_EQ(0, result.a32);
  CHECK_EQ(0, result.a33);
  CHECK_EQ(0, result.a34);
  CHECK_EQ(0, result.a35);
  CHECK_EQ(0, result.a36);
  CHECK_EQ(0, result.a37);
  CHECK_EQ(0, result.a38);
  CHECK_EQ(0, result.a39);
  CHECK_EQ(0, result.a40);
  CHECK_EQ(0, result.a41);
  CHECK_EQ(0, result.a42);
  CHECK_EQ(0, result.a43);
  CHECK_EQ(0, result.a44);
  CHECK_EQ(0, result.a45);
  CHECK_EQ(0, result.a46);
  CHECK_EQ(0, result.a47);
  CHECK_EQ(0, result.a48);
  CHECK_EQ(0, result.a49);
  CHECK_EQ(0, result.a50);
  CHECK_EQ(0, result.a51);
  CHECK_EQ(0, result.a52);
  CHECK_EQ(0, result.a53);
  CHECK_EQ(0, result.a54);
  CHECK_EQ(0, result.a55);
  CHECK_EQ(0, result.a56);
  CHECK_EQ(0, result.a57);
  CHECK_EQ(0, result.a58);
  CHECK_EQ(0, result.a59);
  CHECK_EQ(0, result.a60);
  CHECK_EQ(0, result.a61);
  CHECK_EQ(0, result.a62);
  CHECK_EQ(0, result.a63);
  CHECK_EQ(0, result.a64);
  CHECK_EQ(0, result.a65);
  CHECK_EQ(0, result.a66);
  CHECK_EQ(0, result.a67);
  CHECK_EQ(0, result.a68);
  CHECK_EQ(0, result.a69);
  CHECK_EQ(0, result.a70);
  CHECK_EQ(0, result.a71);
  CHECK_EQ(0, result.a72);
  CHECK_EQ(0, result.a73);
  CHECK_EQ(0, result.a74);
  CHECK_EQ(0, result.a75);
  CHECK_EQ(0, result.a76);
  CHECK_EQ(0, result.a77);
  CHECK_EQ(0, result.a78);
  CHECK_EQ(0, result.a79);
  CHECK_EQ(0, result.a80);
  CHECK_EQ(0, result.a81);
  CHECK_EQ(0, result.a82);
  CHECK_EQ(0, result.a83);
  CHECK_EQ(0, result.a84);
  CHECK_EQ(0, result.a85);
  CHECK_EQ(0, result.a86);
  CHECK_EQ(0, result.a87);
  CHECK_EQ(0, result.a88);
  CHECK_EQ(0, result.a89);
  CHECK_EQ(0, result.a90);
  CHECK_EQ(0, result.a91);
  CHECK_EQ(0, result.a92);
  CHECK_EQ(0, result.a93);
  CHECK_EQ(0, result.a94);
  CHECK_EQ(0, result.a95);
  CHECK_EQ(0, result.a96);
  CHECK_EQ(0, result.a97);
  CHECK_EQ(0, result.a98);
  CHECK_EQ(0, result.a99);
  CHECK_EQ(0, result.a100);
  CHECK_EQ(0, result.a101);
  CHECK_EQ(0, result.a102);
  CHECK_EQ(0, result.a103);
  CHECK_EQ(0, result.a104);
  CHECK_EQ(0, result.a105);
  CHECK_EQ(0, result.a106);
  CHECK_EQ(0, result.a107);
  CHECK_EQ(0, result.a108);
  CHECK_EQ(0, result.a109);
  CHECK_EQ(0, result.a110);
  CHECK_EQ(0, result.a111);
  CHECK_EQ(0, result.a112);
  CHECK_EQ(0, result.a113);
  CHECK_EQ(0, result.a114);
  CHECK_EQ(0, result.a115);
  CHECK_EQ(0, result.a116);
  CHECK_EQ(0, result.a117);
  CHECK_EQ(0, result.a118);
  CHECK_EQ(0, result.a119);
  CHECK_EQ(0, result.a120);
  CHECK_EQ(0, result.a121);
  CHECK_EQ(0, result.a122);
  CHECK_EQ(0, result.a123);
  CHECK_EQ(0, result.a124);
  CHECK_EQ(0, result.a125);
  CHECK_EQ(0, result.a126);
  CHECK_EQ(0, result.a127);
 
  return 0;
}

TestReturnStruct12BytesHomogeneousFloat()

DART_EXPORT intptr_t dart::TestReturnStruct12BytesHomogeneousFloat

(

Struct12BytesHomogeneousFloat(*)(float a0, float a1, float a2)

f

)

Definition at line 12886 of file ffi_test_functions_generated.cc.

                                                                      {
  float a0;
  float a1;
  float a2;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
 
  std::cout << "Calling TestReturnStruct12BytesHomogeneousFloat(" << "(" << a0
            << ", " << a1 << ", " << a2 << ")" << ")\n";
 
  Struct12BytesHomogeneousFloat result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ")" << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_APPROX(a1, result.a1);
  CHECK_APPROX(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
 
  return 0;
}

TestReturnStruct16BytesHomogeneousFloat()

DART_EXPORT intptr_t dart::TestReturnStruct16BytesHomogeneousFloat

(

Struct16BytesHomogeneousFloat( *f)(float a0, float a1, float a2, float a3)

)

Definition at line 12932 of file ffi_test_functions_generated.cc.

                                                     {
  float a0;
  float a1;
  float a2;
  float a3;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
 
  std::cout << "Calling TestReturnStruct16BytesHomogeneousFloat(" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ")" << ")\n";
 
  Struct16BytesHomogeneousFloat result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ")" << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_APPROX(a1, result.a1);
  CHECK_APPROX(a2, result.a2);
  CHECK_APPROX(a3, result.a3);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_APPROX(0.0, result.a3);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_APPROX(0.0, result.a3);
 
  return 0;
}

TestReturnStruct16BytesMixed()

DART_EXPORT intptr_t dart::TestReturnStruct16BytesMixed

(

Struct16BytesMixed(*)(double a0, int64_t a1)

f

)

Definition at line 12984 of file ffi_test_functions_generated.cc.

                                                    {
  double a0;
  int64_t a1;
 
  a0 = -1.0;
  a1 = 2;
 
  std::cout << "Calling TestReturnStruct16BytesMixed(" << "(" << a0 << ", "
            << a1 << ")" << ")\n";
 
  Struct16BytesMixed result = f(a0, a1);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ")"
            << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_EQ(a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_EQ(0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_EQ(0, result.a1);
 
  return 0;
}

TestReturnStruct16BytesMixed2()

DART_EXPORT intptr_t dart::TestReturnStruct16BytesMixed2

(

Struct16BytesMixed2(*)(float a0, float a1, float a2, int32_t a3)

f

)

Definition at line 13026 of file ffi_test_functions_generated.cc.

                                                                        {
  float a0;
  float a1;
  float a2;
  int32_t a3;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4;
 
  std::cout << "Calling TestReturnStruct16BytesMixed2(" << "(" << a0 << ", "
            << a1 << ", " << a2 << ", " << a3 << ")" << ")\n";
 
  Struct16BytesMixed2 result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ")" << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_APPROX(a1, result.a1);
  CHECK_APPROX(a2, result.a2);
  CHECK_EQ(a3, result.a3);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_EQ(0, result.a3);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_EQ(0, result.a3);
 
  return 0;
}

TestReturnStruct16BytesNestedInt()

DART_EXPORT intptr_t dart::TestReturnStruct16BytesNestedInt

(

Struct16BytesNestedInt(*)(Struct8BytesNestedInt a0, Struct8BytesNestedInt a1)

f

)

Definition at line 15556 of file ffi_test_functions_generated.cc.

                                                           {
  Struct8BytesNestedInt a0 = {};
  Struct8BytesNestedInt a1 = {};
 
  a0.a0.a0 = -1;
  a0.a0.a1 = 2;
  a0.a1.a0 = -3;
  a0.a1.a1 = 4;
  a1.a0.a0 = -5;
  a1.a0.a1 = 6;
  a1.a1.a0 = -7;
  a1.a1.a1 = 8;
 
  std::cout << "Calling TestReturnStruct16BytesNestedInt(" << "(((" << a0.a0.a0
            << ", " << a0.a0.a1 << "), (" << a0.a1.a0 << ", " << a0.a1.a1
            << ")), ((" << a1.a0.a0 << ", " << a1.a0.a1 << "), (" << a1.a1.a0
            << ", " << a1.a1.a1 << ")))" << ")\n";
 
  Struct16BytesNestedInt result = f(a0, a1);
 
  std::cout << "result = " << "(((" << result.a0.a0.a0 << ", "
            << result.a0.a0.a1 << "), (" << result.a0.a1.a0 << ", "
            << result.a0.a1.a1 << ")), ((" << result.a1.a0.a0 << ", "
            << result.a1.a0.a1 << "), (" << result.a1.a1.a0 << ", "
            << result.a1.a1.a1 << ")))" << "\n";
 
  CHECK_EQ(a0.a0.a0, result.a0.a0.a0);
  CHECK_EQ(a0.a0.a1, result.a0.a0.a1);
  CHECK_EQ(a0.a1.a0, result.a0.a1.a0);
  CHECK_EQ(a0.a1.a1, result.a0.a1.a1);
  CHECK_EQ(a1.a0.a0, result.a1.a0.a0);
  CHECK_EQ(a1.a0.a1, result.a1.a0.a1);
  CHECK_EQ(a1.a1.a0, result.a1.a1.a0);
  CHECK_EQ(a1.a1.a1, result.a1.a1.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0.a0);
  CHECK_EQ(0, result.a0.a0.a1);
  CHECK_EQ(0, result.a0.a1.a0);
  CHECK_EQ(0, result.a0.a1.a1);
  CHECK_EQ(0, result.a1.a0.a0);
  CHECK_EQ(0, result.a1.a0.a1);
  CHECK_EQ(0, result.a1.a1.a0);
  CHECK_EQ(0, result.a1.a1.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0.a0);
  CHECK_EQ(0, result.a0.a0.a1);
  CHECK_EQ(0, result.a0.a1.a0);
  CHECK_EQ(0, result.a0.a1.a1);
  CHECK_EQ(0, result.a1.a0.a0);
  CHECK_EQ(0, result.a1.a0.a1);
  CHECK_EQ(0, result.a1.a1.a0);
  CHECK_EQ(0, result.a1.a1.a1);
 
  return 0;
}

TestReturnStruct17BytesInt()

DART_EXPORT intptr_t dart::TestReturnStruct17BytesInt

(

Struct17BytesInt(*)(int64_t a0, int64_t a1, int8_t a2)

f

)

Definition at line 13079 of file ffi_test_functions_generated.cc.

                                                              {
  int64_t a0;
  int64_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestReturnStruct17BytesInt(" << "(" << a0 << ", " << a1
            << ", " << static_cast<int>(a2) << ")" << ")\n";
 
  Struct17BytesInt result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << static_cast<int>(result.a2) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  return 0;
}

TestReturnStruct19BytesHomogeneousUint8()

DART_EXPORT intptr_t dart::TestReturnStruct19BytesHomogeneousUint8

(

Struct19BytesHomogeneousUint8(*)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8, uint8_t a9, uint8_t a10, uint8_t a11, uint8_t a12, uint8_t a13, uint8_t a14, uint8_t a15, uint8_t a16, uint8_t a17, uint8_t a18)

f

)

Definition at line 13127 of file ffi_test_functions_generated.cc.

                                                     {
  uint8_t a0;
  uint8_t a1;
  uint8_t a2;
  uint8_t a3;
  uint8_t a4;
  uint8_t a5;
  uint8_t a6;
  uint8_t a7;
  uint8_t a8;
  uint8_t a9;
  uint8_t a10;
  uint8_t a11;
  uint8_t a12;
  uint8_t a13;
  uint8_t a14;
  uint8_t a15;
  uint8_t a16;
  uint8_t a17;
  uint8_t a18;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;
  a9 = 10;
  a10 = 11;
  a11 = 12;
  a12 = 13;
  a13 = 14;
  a14 = 15;
  a15 = 16;
  a16 = 17;
  a17 = 18;
  a18 = 19;
 
  std::cout << "Calling TestReturnStruct19BytesHomogeneousUint8(" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ", " << static_cast<int>(a7) << ", "
            << static_cast<int>(a8) << ", " << static_cast<int>(a9) << ", "
            << static_cast<int>(a10) << ", " << static_cast<int>(a11) << ", "
            << static_cast<int>(a12) << ", " << static_cast<int>(a13) << ", "
            << static_cast<int>(a14) << ", " << static_cast<int>(a15) << ", "
            << static_cast<int>(a16) << ", " << static_cast<int>(a17) << ", "
            << static_cast<int>(a18) << ")" << ")\n";
 
  Struct19BytesHomogeneousUint8 result =
      f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
        a16, a17, a18);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << static_cast<int>(result.a1) << ", "
            << static_cast<int>(result.a2) << ", "
            << static_cast<int>(result.a3) << ", "
            << static_cast<int>(result.a4) << ", "
            << static_cast<int>(result.a5) << ", "
            << static_cast<int>(result.a6) << ", "
            << static_cast<int>(result.a7) << ", "
            << static_cast<int>(result.a8) << ", "
            << static_cast<int>(result.a9) << ", "
            << static_cast<int>(result.a10) << ", "
            << static_cast<int>(result.a11) << ", "
            << static_cast<int>(result.a12) << ", "
            << static_cast<int>(result.a13) << ", "
            << static_cast<int>(result.a14) << ", "
            << static_cast<int>(result.a15) << ", "
            << static_cast<int>(result.a16) << ", "
            << static_cast<int>(result.a17) << ", "
            << static_cast<int>(result.a18) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
  CHECK_EQ(a3, result.a3);
  CHECK_EQ(a4, result.a4);
  CHECK_EQ(a5, result.a5);
  CHECK_EQ(a6, result.a6);
  CHECK_EQ(a7, result.a7);
  CHECK_EQ(a8, result.a8);
  CHECK_EQ(a9, result.a9);
  CHECK_EQ(a10, result.a10);
  CHECK_EQ(a11, result.a11);
  CHECK_EQ(a12, result.a12);
  CHECK_EQ(a13, result.a13);
  CHECK_EQ(a14, result.a14);
  CHECK_EQ(a15, result.a15);
  CHECK_EQ(a16, result.a16);
  CHECK_EQ(a17, result.a17);
  CHECK_EQ(a18, result.a18);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
             a15, a16, a17, a18);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
  CHECK_EQ(0, result.a5);
  CHECK_EQ(0, result.a6);
  CHECK_EQ(0, result.a7);
  CHECK_EQ(0, result.a8);
  CHECK_EQ(0, result.a9);
  CHECK_EQ(0, result.a10);
  CHECK_EQ(0, result.a11);
  CHECK_EQ(0, result.a12);
  CHECK_EQ(0, result.a13);
  CHECK_EQ(0, result.a14);
  CHECK_EQ(0, result.a15);
  CHECK_EQ(0, result.a16);
  CHECK_EQ(0, result.a17);
  CHECK_EQ(0, result.a18);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
             a15, a16, a17, a18);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
  CHECK_EQ(0, result.a5);
  CHECK_EQ(0, result.a6);
  CHECK_EQ(0, result.a7);
  CHECK_EQ(0, result.a8);
  CHECK_EQ(0, result.a9);
  CHECK_EQ(0, result.a10);
  CHECK_EQ(0, result.a11);
  CHECK_EQ(0, result.a12);
  CHECK_EQ(0, result.a13);
  CHECK_EQ(0, result.a14);
  CHECK_EQ(0, result.a15);
  CHECK_EQ(0, result.a16);
  CHECK_EQ(0, result.a17);
  CHECK_EQ(0, result.a18);
 
  return 0;
}

TestReturnStruct1ByteInt()

DART_EXPORT intptr_t dart::TestReturnStruct1ByteInt

(

Struct1ByteInt(*)(int8_t a0)

f

)

Definition at line 12320 of file ffi_test_functions_generated.cc.

                                    {
  int8_t a0;
 
  a0 = -1;
 
  std::cout << "Calling TestReturnStruct1ByteInt(" << "("
            << static_cast<int>(a0) << ")" << ")\n";
 
  Struct1ByteInt result = f(a0);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0);
 
  return 0;
}

TestReturnStruct20BytesHomogeneousFloat()

DART_EXPORT intptr_t dart::TestReturnStruct20BytesHomogeneousFloat

(

Struct20BytesHomogeneousFloat( *f)(float a0, float a1, float a2, float a3, float a4)

)

Definition at line 13360 of file ffi_test_functions_generated.cc.

                                                               {
  float a0;
  float a1;
  float a2;
  float a3;
  float a4;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
 
  std::cout << "Calling TestReturnStruct20BytesHomogeneousFloat(" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ")"
            << ")\n";
 
  Struct20BytesHomogeneousFloat result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_APPROX(a1, result.a1);
  CHECK_APPROX(a2, result.a2);
  CHECK_APPROX(a3, result.a3);
  CHECK_APPROX(a4, result.a4);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_APPROX(0.0, result.a3);
  CHECK_APPROX(0.0, result.a4);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_APPROX(0.0, result.a3);
  CHECK_APPROX(0.0, result.a4);
 
  return 0;
}

TestReturnStruct20BytesHomogeneousInt32()

DART_EXPORT intptr_t dart::TestReturnStruct20BytesHomogeneousInt32

(

Struct20BytesHomogeneousInt32( *f)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4)

)

Definition at line 13301 of file ffi_test_functions_generated.cc.

                                                                         {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
 
  std::cout << "Calling TestReturnStruct20BytesHomogeneousInt32(" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ")"
            << ")\n";
 
  Struct20BytesHomogeneousInt32 result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
  CHECK_EQ(a3, result.a3);
  CHECK_EQ(a4, result.a4);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
 
  return 0;
}

TestReturnStruct32BytesHomogeneousDouble()

DART_EXPORT intptr_t dart::TestReturnStruct32BytesHomogeneousDouble

(

Struct32BytesHomogeneousDouble( *f)(double a0, double a1, double a2, double a3)

)

Definition at line 13419 of file ffi_test_functions_generated.cc.

                                                         {
  double a0;
  double a1;
  double a2;
  double a3;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
 
  std::cout << "Calling TestReturnStruct32BytesHomogeneousDouble(" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ")" << ")\n";
 
  Struct32BytesHomogeneousDouble result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ")" << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_APPROX(a1, result.a1);
  CHECK_APPROX(a2, result.a2);
  CHECK_APPROX(a3, result.a3);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_APPROX(0.0, result.a3);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_APPROX(0.0, result.a3);
 
  return 0;
}

TestReturnStruct32BytesNestedInt()

DART_EXPORT intptr_t dart::TestReturnStruct32BytesNestedInt

(

Struct32BytesNestedInt(*)(Struct16BytesNestedInt a0, Struct16BytesNestedInt a1)

f

)

Definition at line 15627 of file ffi_test_functions_generated.cc.

                                                            {
  Struct16BytesNestedInt a0 = {};
  Struct16BytesNestedInt a1 = {};
 
  a0.a0.a0.a0 = -1;
  a0.a0.a0.a1 = 2;
  a0.a0.a1.a0 = -3;
  a0.a0.a1.a1 = 4;
  a0.a1.a0.a0 = -5;
  a0.a1.a0.a1 = 6;
  a0.a1.a1.a0 = -7;
  a0.a1.a1.a1 = 8;
  a1.a0.a0.a0 = -9;
  a1.a0.a0.a1 = 10;
  a1.a0.a1.a0 = -11;
  a1.a0.a1.a1 = 12;
  a1.a1.a0.a0 = -13;
  a1.a1.a0.a1 = 14;
  a1.a1.a1.a0 = -15;
  a1.a1.a1.a1 = 16;
 
  std::cout << "Calling TestReturnStruct32BytesNestedInt(" << "(((("
            << a0.a0.a0.a0 << ", " << a0.a0.a0.a1 << "), (" << a0.a0.a1.a0
            << ", " << a0.a0.a1.a1 << ")), ((" << a0.a1.a0.a0 << ", "
            << a0.a1.a0.a1 << "), (" << a0.a1.a1.a0 << ", " << a0.a1.a1.a1
            << "))), (((" << a1.a0.a0.a0 << ", " << a1.a0.a0.a1 << "), ("
            << a1.a0.a1.a0 << ", " << a1.a0.a1.a1 << ")), ((" << a1.a1.a0.a0
            << ", " << a1.a1.a0.a1 << "), (" << a1.a1.a1.a0 << ", "
            << a1.a1.a1.a1 << "))))" << ")\n";
 
  Struct32BytesNestedInt result = f(a0, a1);
 
  std::cout << "result = " << "((((" << result.a0.a0.a0.a0 << ", "
            << result.a0.a0.a0.a1 << "), (" << result.a0.a0.a1.a0 << ", "
            << result.a0.a0.a1.a1 << ")), ((" << result.a0.a1.a0.a0 << ", "
            << result.a0.a1.a0.a1 << "), (" << result.a0.a1.a1.a0 << ", "
            << result.a0.a1.a1.a1 << "))), (((" << result.a1.a0.a0.a0 << ", "
            << result.a1.a0.a0.a1 << "), (" << result.a1.a0.a1.a0 << ", "
            << result.a1.a0.a1.a1 << ")), ((" << result.a1.a1.a0.a0 << ", "
            << result.a1.a1.a0.a1 << "), (" << result.a1.a1.a1.a0 << ", "
            << result.a1.a1.a1.a1 << "))))" << "\n";
 
  CHECK_EQ(a0.a0.a0.a0, result.a0.a0.a0.a0);
  CHECK_EQ(a0.a0.a0.a1, result.a0.a0.a0.a1);
  CHECK_EQ(a0.a0.a1.a0, result.a0.a0.a1.a0);
  CHECK_EQ(a0.a0.a1.a1, result.a0.a0.a1.a1);
  CHECK_EQ(a0.a1.a0.a0, result.a0.a1.a0.a0);
  CHECK_EQ(a0.a1.a0.a1, result.a0.a1.a0.a1);
  CHECK_EQ(a0.a1.a1.a0, result.a0.a1.a1.a0);
  CHECK_EQ(a0.a1.a1.a1, result.a0.a1.a1.a1);
  CHECK_EQ(a1.a0.a0.a0, result.a1.a0.a0.a0);
  CHECK_EQ(a1.a0.a0.a1, result.a1.a0.a0.a1);
  CHECK_EQ(a1.a0.a1.a0, result.a1.a0.a1.a0);
  CHECK_EQ(a1.a0.a1.a1, result.a1.a0.a1.a1);
  CHECK_EQ(a1.a1.a0.a0, result.a1.a1.a0.a0);
  CHECK_EQ(a1.a1.a0.a1, result.a1.a1.a0.a1);
  CHECK_EQ(a1.a1.a1.a0, result.a1.a1.a1.a0);
  CHECK_EQ(a1.a1.a1.a1, result.a1.a1.a1.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0.a0.a0);
  CHECK_EQ(0, result.a0.a0.a0.a1);
  CHECK_EQ(0, result.a0.a0.a1.a0);
  CHECK_EQ(0, result.a0.a0.a1.a1);
  CHECK_EQ(0, result.a0.a1.a0.a0);
  CHECK_EQ(0, result.a0.a1.a0.a1);
  CHECK_EQ(0, result.a0.a1.a1.a0);
  CHECK_EQ(0, result.a0.a1.a1.a1);
  CHECK_EQ(0, result.a1.a0.a0.a0);
  CHECK_EQ(0, result.a1.a0.a0.a1);
  CHECK_EQ(0, result.a1.a0.a1.a0);
  CHECK_EQ(0, result.a1.a0.a1.a1);
  CHECK_EQ(0, result.a1.a1.a0.a0);
  CHECK_EQ(0, result.a1.a1.a0.a1);
  CHECK_EQ(0, result.a1.a1.a1.a0);
  CHECK_EQ(0, result.a1.a1.a1.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0.a0.a0);
  CHECK_EQ(0, result.a0.a0.a0.a1);
  CHECK_EQ(0, result.a0.a0.a1.a0);
  CHECK_EQ(0, result.a0.a0.a1.a1);
  CHECK_EQ(0, result.a0.a1.a0.a0);
  CHECK_EQ(0, result.a0.a1.a0.a1);
  CHECK_EQ(0, result.a0.a1.a1.a0);
  CHECK_EQ(0, result.a0.a1.a1.a1);
  CHECK_EQ(0, result.a1.a0.a0.a0);
  CHECK_EQ(0, result.a1.a0.a0.a1);
  CHECK_EQ(0, result.a1.a0.a1.a0);
  CHECK_EQ(0, result.a1.a0.a1.a1);
  CHECK_EQ(0, result.a1.a1.a0.a0);
  CHECK_EQ(0, result.a1.a1.a0.a1);
  CHECK_EQ(0, result.a1.a1.a1.a0);
  CHECK_EQ(0, result.a1.a1.a1.a1);
 
  return 0;
}

TestReturnStruct3BytesHomogeneousUint8()

DART_EXPORT intptr_t dart::TestReturnStruct3BytesHomogeneousUint8

(

Struct3BytesHomogeneousUint8(*)(uint8_t a0, uint8_t a1, uint8_t a2)

f

)

Definition at line 12355 of file ffi_test_functions_generated.cc.

                                                                           {
  uint8_t a0;
  uint8_t a1;
  uint8_t a2;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
 
  std::cout << "Calling TestReturnStruct3BytesHomogeneousUint8(" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ")" << ")\n";
 
  Struct3BytesHomogeneousUint8 result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << static_cast<int>(result.a1) << ", "
            << static_cast<int>(result.a2) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  return 0;
}

TestReturnStruct3BytesInt2ByteAligned()

DART_EXPORT intptr_t dart::TestReturnStruct3BytesInt2ByteAligned

(

Struct3BytesInt2ByteAligned(*)(int16_t a0, int8_t a1)

f

)

Definition at line 12404 of file ffi_test_functions_generated.cc.

                                                             {
  int16_t a0;
  int8_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestReturnStruct3BytesInt2ByteAligned(" << "(" << a0
            << ", " << static_cast<int>(a1) << ")" << ")\n";
 
  Struct3BytesInt2ByteAligned result = f(a0, a1);
 
  std::cout << "result = " << "(" << result.a0 << ", "
            << static_cast<int>(result.a1) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
 
  return 0;
}

TestReturnStruct3BytesPackedInt()

DART_EXPORT intptr_t dart::TestReturnStruct3BytesPackedInt

(

Struct3BytesPackedInt(*)(int8_t a0, int16_t a1)

f

)

Definition at line 14426 of file ffi_test_functions_generated.cc.

                                                       {
  int8_t a0;
  int16_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestReturnStruct3BytesPackedInt(" << "("
            << static_cast<int>(a0) << ", " << a1 << ")" << ")\n";
 
  Struct3BytesPackedInt result = f(a0, a1);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
 
  return 0;
}

TestReturnStruct40BytesHomogeneousDouble()

DART_EXPORT intptr_t dart::TestReturnStruct40BytesHomogeneousDouble

(

Struct40BytesHomogeneousDouble( *f)(double a0, double a1, double a2, double a3, double a4)

)

Definition at line 13471 of file ffi_test_functions_generated.cc.

                                                                    {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
 
  std::cout << "Calling TestReturnStruct40BytesHomogeneousDouble(" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ")"
            << ")\n";
 
  Struct40BytesHomogeneousDouble result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_APPROX(a1, result.a1);
  CHECK_APPROX(a2, result.a2);
  CHECK_APPROX(a3, result.a3);
  CHECK_APPROX(a4, result.a4);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_APPROX(0.0, result.a3);
  CHECK_APPROX(0.0, result.a4);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
  CHECK_APPROX(0.0, result.a2);
  CHECK_APPROX(0.0, result.a3);
  CHECK_APPROX(0.0, result.a4);
 
  return 0;
}

TestReturnStruct4BytesHomogeneousInt16()

DART_EXPORT intptr_t dart::TestReturnStruct4BytesHomogeneousInt16

(

Struct4BytesHomogeneousInt16(*)(int16_t a0, int16_t a1)

f

)

Definition at line 12445 of file ffi_test_functions_generated.cc.

                                                               {
  int16_t a0;
  int16_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestReturnStruct4BytesHomogeneousInt16(" << "(" << a0
            << ", " << a1 << ")" << ")\n";
 
  Struct4BytesHomogeneousInt16 result = f(a0, a1);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ")"
            << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
 
  return 0;
}

TestReturnStruct7BytesHomogeneousUint8()

DART_EXPORT intptr_t dart::TestReturnStruct7BytesHomogeneousUint8

(

Struct7BytesHomogeneousUint8(*)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6)

f

)

Definition at line 12486 of file ffi_test_functions_generated.cc.

                                                   {
  uint8_t a0;
  uint8_t a1;
  uint8_t a2;
  uint8_t a3;
  uint8_t a4;
  uint8_t a5;
  uint8_t a6;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
 
  std::cout << "Calling TestReturnStruct7BytesHomogeneousUint8(" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ")" << ")\n";
 
  Struct7BytesHomogeneousUint8 result = f(a0, a1, a2, a3, a4, a5, a6);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << static_cast<int>(result.a1) << ", "
            << static_cast<int>(result.a2) << ", "
            << static_cast<int>(result.a3) << ", "
            << static_cast<int>(result.a4) << ", "
            << static_cast<int>(result.a5) << ", "
            << static_cast<int>(result.a6) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
  CHECK_EQ(a3, result.a3);
  CHECK_EQ(a4, result.a4);
  CHECK_EQ(a5, result.a5);
  CHECK_EQ(a6, result.a6);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
  CHECK_EQ(0, result.a5);
  CHECK_EQ(0, result.a6);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
  CHECK_EQ(0, result.a5);
  CHECK_EQ(0, result.a6);
 
  return 0;
}

TestReturnStruct7BytesInt4ByteAligned()

DART_EXPORT intptr_t dart::TestReturnStruct7BytesInt4ByteAligned

(

Struct7BytesInt4ByteAligned(*)(int32_t a0, int16_t a1, int8_t a2)

f

)

Definition at line 12567 of file ffi_test_functions_generated.cc.

                                                                         {
  int32_t a0;
  int16_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestReturnStruct7BytesInt4ByteAligned(" << "(" << a0
            << ", " << a1 << ", " << static_cast<int>(a2) << ")" << ")\n";
 
  Struct7BytesInt4ByteAligned result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << static_cast<int>(result.a2) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  return 0;
}

TestReturnStruct8BytesHomogeneousFloat()

DART_EXPORT intptr_t dart::TestReturnStruct8BytesHomogeneousFloat

(

Struct8BytesHomogeneousFloat(*)(float a0, float a1)

f

)

Definition at line 12659 of file ffi_test_functions_generated.cc.

                                                           {
  float a0;
  float a1;
 
  a0 = -1.0;
  a1 = 2.0;
 
  std::cout << "Calling TestReturnStruct8BytesHomogeneousFloat(" << "(" << a0
            << ", " << a1 << ")" << ")\n";
 
  Struct8BytesHomogeneousFloat result = f(a0, a1);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ")"
            << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_APPROX(a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
 
  return 0;
}

TestReturnStruct8BytesInt()

DART_EXPORT intptr_t dart::TestReturnStruct8BytesInt

(

Struct8BytesInt(*)(int16_t a0, int16_t a1, int32_t a2)

f

)

Definition at line 12613 of file ffi_test_functions_generated.cc.

                                                              {
  int16_t a0;
  int16_t a1;
  int32_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestReturnStruct8BytesInt(" << "(" << a0 << ", " << a1
            << ", " << a2 << ")" << ")\n";
 
  Struct8BytesInt result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  return 0;
}

TestReturnStruct8BytesMixed()

DART_EXPORT intptr_t dart::TestReturnStruct8BytesMixed

(

Struct8BytesMixed(*)(float a0, int16_t a1, int16_t a2)

f

)

Definition at line 12700 of file ffi_test_functions_generated.cc.

                                                              {
  float a0;
  int16_t a1;
  int16_t a2;
 
  a0 = -1.0;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestReturnStruct8BytesMixed(" << "(" << a0 << ", " << a1
            << ", " << a2 << ")" << ")\n";
 
  Struct8BytesMixed result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ")" << "\n";
 
  CHECK_APPROX(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  return 0;
}

TestReturnStruct8BytesNestedFloat()

DART_EXPORT intptr_t dart::TestReturnStruct8BytesNestedFloat

(

Struct8BytesNestedFloat(*)(Struct4BytesFloat a0, Struct4BytesFloat a1)

f

)

Definition at line 15427 of file ffi_test_functions_generated.cc.

                                                                              {
  Struct4BytesFloat a0 = {};
  Struct4BytesFloat a1 = {};
 
  a0.a0 = -1.0;
  a1.a0 = 2.0;
 
  std::cout << "Calling TestReturnStruct8BytesNestedFloat(" << "((" << a0.a0
            << "), (" << a1.a0 << "))" << ")\n";
 
  Struct8BytesNestedFloat result = f(a0, a1);
 
  std::cout << "result = " << "((" << result.a0.a0 << "), (" << result.a1.a0
            << "))" << "\n";
 
  CHECK_APPROX(a0.a0, result.a0.a0);
  CHECK_APPROX(a1.a0, result.a1.a0);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result.a0.a0);
  CHECK_APPROX(0.0, result.a1.a0);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result.a0.a0);
  CHECK_APPROX(0.0, result.a1.a0);
 
  return 0;
}

TestReturnStruct8BytesNestedFloat2()

DART_EXPORT intptr_t dart::TestReturnStruct8BytesNestedFloat2

(

Struct8BytesNestedFloat2(*)(Struct4BytesFloat a0, float a1)

f

)

Definition at line 15469 of file ffi_test_functions_generated.cc.

                                                                   {
  Struct4BytesFloat a0 = {};
  float a1;
 
  a0.a0 = -1.0;
  a1 = 2.0;
 
  std::cout << "Calling TestReturnStruct8BytesNestedFloat2(" << "((" << a0.a0
            << "), " << a1 << ")" << ")\n";
 
  Struct8BytesNestedFloat2 result = f(a0, a1);
 
  std::cout << "result = " << "((" << result.a0.a0 << "), " << result.a1 << ")"
            << "\n";
 
  CHECK_APPROX(a0.a0, result.a0.a0);
  CHECK_APPROX(a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result.a0.a0);
  CHECK_APPROX(0.0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result.a0.a0);
  CHECK_APPROX(0.0, result.a1);
 
  return 0;
}

TestReturnStruct8BytesNestedInt()

DART_EXPORT intptr_t dart::TestReturnStruct8BytesNestedInt

(

Struct8BytesNestedInt(*)(Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1)

f

)

Definition at line 15376 of file ffi_test_functions_generated.cc.

                                                                 {
  Struct4BytesHomogeneousInt16 a0 = {};
  Struct4BytesHomogeneousInt16 a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3;
  a1.a1 = 4;
 
  std::cout << "Calling TestReturnStruct8BytesNestedInt(" << "((" << a0.a0
            << ", " << a0.a1 << "), (" << a1.a0 << ", " << a1.a1 << "))"
            << ")\n";
 
  Struct8BytesNestedInt result = f(a0, a1);
 
  std::cout << "result = " << "((" << result.a0.a0 << ", " << result.a0.a1
            << "), (" << result.a1.a0 << ", " << result.a1.a1 << "))" << "\n";
 
  CHECK_EQ(a0.a0, result.a0.a0);
  CHECK_EQ(a0.a1, result.a0.a1);
  CHECK_EQ(a1.a0, result.a1.a0);
  CHECK_EQ(a1.a1, result.a1.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a1.a0);
  CHECK_EQ(0, result.a1.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a1.a0);
  CHECK_EQ(0, result.a1.a1);
 
  return 0;
}

TestReturnStruct8BytesNestedMixed()

DART_EXPORT intptr_t dart::TestReturnStruct8BytesNestedMixed

(

Struct8BytesNestedMixed(*)(Struct4BytesHomogeneousInt16 a0, Struct4BytesFloat a1)

f

)

Definition at line 15510 of file ffi_test_functions_generated.cc.

                                                        {
  Struct4BytesHomogeneousInt16 a0 = {};
  Struct4BytesFloat a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a1.a0 = -3.0;
 
  std::cout << "Calling TestReturnStruct8BytesNestedMixed(" << "((" << a0.a0
            << ", " << a0.a1 << "), (" << a1.a0 << "))" << ")\n";
 
  Struct8BytesNestedMixed result = f(a0, a1);
 
  std::cout << "result = " << "((" << result.a0.a0 << ", " << result.a0.a1
            << "), (" << result.a1.a0 << "))" << "\n";
 
  CHECK_EQ(a0.a0, result.a0.a0);
  CHECK_EQ(a0.a1, result.a0.a1);
  CHECK_APPROX(a1.a0, result.a1.a0);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_APPROX(0.0, result.a1.a0);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_APPROX(0.0, result.a1.a0);
 
  return 0;
}

TestReturnStruct8BytesPackedInt()

DART_EXPORT intptr_t dart::TestReturnStruct8BytesPackedInt

(

Struct8BytesPackedInt( *f)(uint8_t a0, uint32_t a1, uint8_t a2, uint8_t a3, uint8_t a4)

)

Definition at line 14467 of file ffi_test_functions_generated.cc.

                                                                          {
  uint8_t a0;
  uint32_t a1;
  uint8_t a2;
  uint8_t a3;
  uint8_t a4;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
 
  std::cout << "Calling TestReturnStruct8BytesPackedInt(" << "("
            << static_cast<int>(a0) << ", " << a1 << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ")" << ")\n";
 
  Struct8BytesPackedInt result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ", " << static_cast<int>(result.a2) << ", "
            << static_cast<int>(result.a3) << ", "
            << static_cast<int>(result.a4) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
  CHECK_EQ(a3, result.a3);
  CHECK_EQ(a4, result.a4);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
 
  return 0;
}

TestReturnStruct9BytesHomogeneousUint8()

DART_EXPORT intptr_t dart::TestReturnStruct9BytesHomogeneousUint8

(

Struct9BytesHomogeneousUint8(*)(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8)

f

)

Definition at line 12748 of file ffi_test_functions_generated.cc.

                                                   {
  uint8_t a0;
  uint8_t a1;
  uint8_t a2;
  uint8_t a3;
  uint8_t a4;
  uint8_t a5;
  uint8_t a6;
  uint8_t a7;
  uint8_t a8;
 
  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;
 
  std::cout << "Calling TestReturnStruct9BytesHomogeneousUint8(" << "("
            << static_cast<int>(a0) << ", " << static_cast<int>(a1) << ", "
            << static_cast<int>(a2) << ", " << static_cast<int>(a3) << ", "
            << static_cast<int>(a4) << ", " << static_cast<int>(a5) << ", "
            << static_cast<int>(a6) << ", " << static_cast<int>(a7) << ", "
            << static_cast<int>(a8) << ")" << ")\n";
 
  Struct9BytesHomogeneousUint8 result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << static_cast<int>(result.a1) << ", "
            << static_cast<int>(result.a2) << ", "
            << static_cast<int>(result.a3) << ", "
            << static_cast<int>(result.a4) << ", "
            << static_cast<int>(result.a5) << ", "
            << static_cast<int>(result.a6) << ", "
            << static_cast<int>(result.a7) << ", "
            << static_cast<int>(result.a8) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
  CHECK_EQ(a3, result.a3);
  CHECK_EQ(a4, result.a4);
  CHECK_EQ(a5, result.a5);
  CHECK_EQ(a6, result.a6);
  CHECK_EQ(a7, result.a7);
  CHECK_EQ(a8, result.a8);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
  CHECK_EQ(0, result.a5);
  CHECK_EQ(0, result.a6);
  CHECK_EQ(0, result.a7);
  CHECK_EQ(0, result.a8);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
  CHECK_EQ(0, result.a5);
  CHECK_EQ(0, result.a6);
  CHECK_EQ(0, result.a7);
  CHECK_EQ(0, result.a8);
 
  return 0;
}

TestReturnStruct9BytesInt4Or8ByteAligned()

DART_EXPORT intptr_t dart::TestReturnStruct9BytesInt4Or8ByteAligned

(

Struct9BytesInt4Or8ByteAligned(*)(int64_t a0, int8_t a1)

f

)

Definition at line 12844 of file ffi_test_functions_generated.cc.

                                                                {
  int64_t a0;
  int8_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestReturnStruct9BytesInt4Or8ByteAligned(" << "(" << a0
            << ", " << static_cast<int>(a1) << ")" << ")\n";
 
  Struct9BytesInt4Or8ByteAligned result = f(a0, a1);
 
  std::cout << "result = " << "(" << result.a0 << ", "
            << static_cast<int>(result.a1) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
 
  return 0;
}

TestReturnStruct9BytesPackedMixed()

DART_EXPORT intptr_t dart::TestReturnStruct9BytesPackedMixed

(

Struct9BytesPackedMixed(*)(uint8_t a0, double a1)

f

)

Definition at line 14529 of file ffi_test_functions_generated.cc.

                                                         {
  uint8_t a0;
  double a1;
 
  a0 = 1;
  a1 = 2.0;
 
  std::cout << "Calling TestReturnStruct9BytesPackedMixed(" << "("
            << static_cast<int>(a0) << ", " << a1 << ")" << ")\n";
 
  Struct9BytesPackedMixed result = f(a0, a1);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_APPROX(a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_APPROX(0.0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0);
  CHECK_APPROX(0.0, result.a1);
 
  return 0;
}

TestReturnStructAlignmentInt16()

DART_EXPORT intptr_t dart::TestReturnStructAlignmentInt16

(

StructAlignmentInt16(*)(int8_t a0, int16_t a1, int8_t a2)

f

)

Definition at line 15235 of file ffi_test_functions_generated.cc.

                                                                 {
  int8_t a0;
  int16_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestReturnStructAlignmentInt16(" << "("
            << static_cast<int>(a0) << ", " << a1 << ", "
            << static_cast<int>(a2) << ")" << ")\n";
 
  StructAlignmentInt16 result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ", " << static_cast<int>(result.a2) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  return 0;
}

TestReturnStructAlignmentInt32()

DART_EXPORT intptr_t dart::TestReturnStructAlignmentInt32

(

StructAlignmentInt32(*)(int8_t a0, int32_t a1, int8_t a2)

f

)

Definition at line 15282 of file ffi_test_functions_generated.cc.

                                                                 {
  int8_t a0;
  int32_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestReturnStructAlignmentInt32(" << "("
            << static_cast<int>(a0) << ", " << a1 << ", "
            << static_cast<int>(a2) << ")" << ")\n";
 
  StructAlignmentInt32 result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ", " << static_cast<int>(result.a2) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  return 0;
}

TestReturnStructAlignmentInt64()

DART_EXPORT intptr_t dart::TestReturnStructAlignmentInt64

(

StructAlignmentInt64(*)(int8_t a0, int64_t a1, int8_t a2)

f

)

Definition at line 15329 of file ffi_test_functions_generated.cc.

                                                                 {
  int8_t a0;
  int64_t a1;
  int8_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestReturnStructAlignmentInt64(" << "("
            << static_cast<int>(a0) << ", " << a1 << ", "
            << static_cast<int>(a2) << ")" << ")\n";
 
  StructAlignmentInt64 result = f(a0, a1, a2);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ", "
            << result.a1 << ", " << static_cast<int>(result.a2) << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1, result.a1);
  CHECK_EQ(a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
 
  return 0;
}

TestReturnStructArgumentInt32x8Struct1ByteInt()

DART_EXPORT intptr_t dart::TestReturnStructArgumentInt32x8Struct1ByteInt

(

Struct1ByteInt(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct1ByteInt a8)

f

)

Definition at line 14763 of file ffi_test_functions_generated.cc.

                                            {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
  int32_t a5;
  int32_t a6;
  int32_t a7;
  Struct1ByteInt a8 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7 = 8;
  a8.a0 = -9;
 
  std::cout << "Calling TestReturnStructArgumentInt32x8Struct1ByteInt(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", " << a7 << ", ("
            << static_cast<int>(a8.a0) << "))" << ")\n";
 
  Struct1ByteInt result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ")" << "\n";
 
  CHECK_EQ(a8.a0, result.a0);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_EQ(0, result.a0);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_EQ(0, result.a0);
 
  return 0;
}

TestReturnStructArgumentInt32x8Struct20BytesHomogeneou()

DART_EXPORT intptr_t dart::TestReturnStructArgumentInt32x8Struct20BytesHomogeneou

(

Struct20BytesHomogeneousInt32(*)(int32_t a0, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, Struct20BytesHomogeneousInt32 a8)

f

)

Definition at line 14921 of file ffi_test_functions_generated.cc.

                                                                          {
  int32_t a0;
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
  int32_t a5;
  int32_t a6;
  int32_t a7;
  Struct20BytesHomogeneousInt32 a8 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7 = 8;
  a8.a0 = -9;
  a8.a1 = 10;
  a8.a2 = -11;
  a8.a3 = 12;
  a8.a4 = -13;
 
  std::cout << "Calling TestReturnStructArgumentInt32x8Struct20BytesHomogeneou("
            << "(" << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", " << a7 << ", (" << a8.a0 << ", "
            << a8.a1 << ", " << a8.a2 << ", " << a8.a3 << ", " << a8.a4 << "))"
            << ")\n";
 
  Struct20BytesHomogeneousInt32 result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  CHECK_EQ(a8.a0, result.a0);
  CHECK_EQ(a8.a1, result.a1);
  CHECK_EQ(a8.a2, result.a2);
  CHECK_EQ(a8.a3, result.a3);
  CHECK_EQ(a8.a4, result.a4);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
 
  return 0;
}

TestReturnStructArgumentStruct1ByteInt()

DART_EXPORT intptr_t dart::TestReturnStructArgumentStruct1ByteInt

(

Struct1ByteInt(*)(Struct1ByteInt a0)

f

)

Definition at line 14726 of file ffi_test_functions_generated.cc.

                                            {
  Struct1ByteInt a0 = {};
 
  a0.a0 = -1;
 
  std::cout << "Calling TestReturnStructArgumentStruct1ByteInt(" << "(("
            << static_cast<int>(a0.a0) << "))" << ")\n";
 
  Struct1ByteInt result = f(a0);
 
  std::cout << "result = " << "(" << static_cast<int>(result.a0) << ")" << "\n";
 
  CHECK_EQ(a0.a0, result.a0);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0);
 
  return 0;
}

TestReturnStructArgumentStruct20BytesHomogeneousInt32()

DART_EXPORT intptr_t dart::TestReturnStructArgumentStruct20BytesHomogeneousInt32

(

Struct20BytesHomogeneousInt32(*)(Struct20BytesHomogeneousInt32 a0)

f

)

Definition at line 14866 of file ffi_test_functions_generated.cc.

                                                                          {
  Struct20BytesHomogeneousInt32 a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a0.a3 = 4;
  a0.a4 = -5;
 
  std::cout << "Calling TestReturnStructArgumentStruct20BytesHomogeneousInt32("
            << "((" << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << ", " << a0.a3
            << ", " << a0.a4 << "))" << ")\n";
 
  Struct20BytesHomogeneousInt32 result = f(a0);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ", "
            << result.a2 << ", " << result.a3 << ", " << result.a4 << ")"
            << "\n";
 
  CHECK_EQ(a0.a0, result.a0);
  CHECK_EQ(a0.a1, result.a1);
  CHECK_EQ(a0.a2, result.a2);
  CHECK_EQ(a0.a3, result.a3);
  CHECK_EQ(a0.a4, result.a4);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1);
  CHECK_EQ(0, result.a2);
  CHECK_EQ(0, result.a3);
  CHECK_EQ(0, result.a4);
 
  return 0;
}

TestReturnStructArgumentStruct8BytesHomogeneousFloat()

DART_EXPORT intptr_t dart::TestReturnStructArgumentStruct8BytesHomogeneousFloat

(

Struct8BytesHomogeneousFloat(*)(Struct8BytesHomogeneousFloat a0)

f

)

Definition at line 14826 of file ffi_test_functions_generated.cc.

                                                                        {
  Struct8BytesHomogeneousFloat a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
 
  std::cout << "Calling TestReturnStructArgumentStruct8BytesHomogeneousFloat("
            << "((" << a0.a0 << ", " << a0.a1 << "))" << ")\n";
 
  Struct8BytesHomogeneousFloat result = f(a0);
 
  std::cout << "result = " << "(" << result.a0 << ", " << result.a1 << ")"
            << "\n";
 
  CHECK_APPROX(a0.a0, result.a0);
  CHECK_APPROX(a0.a1, result.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0);
  CHECK_APPROX(0.0, result.a1);
 
  return 0;
}

TestReturnStructArgumentStruct8BytesInlineArrayInt()

DART_EXPORT intptr_t dart::TestReturnStructArgumentStruct8BytesInlineArrayInt

(

Struct8BytesInlineArrayInt(*)(Struct8BytesInlineArrayInt a0)

f

)

Definition at line 15001 of file ffi_test_functions_generated.cc.

                                                                    {
  Struct8BytesInlineArrayInt a0 = {};
 
  a0.a0[0] = 1;
  a0.a0[1] = 2;
  a0.a0[2] = 3;
  a0.a0[3] = 4;
  a0.a0[4] = 5;
  a0.a0[5] = 6;
  a0.a0[6] = 7;
  a0.a0[7] = 8;
 
  std::cout << "Calling TestReturnStructArgumentStruct8BytesInlineArrayInt("
            << "(([" << static_cast<int>(a0.a0[0]) << ", "
            << static_cast<int>(a0.a0[1]) << ", " << static_cast<int>(a0.a0[2])
            << ", " << static_cast<int>(a0.a0[3]) << ", "
            << static_cast<int>(a0.a0[4]) << ", " << static_cast<int>(a0.a0[5])
            << ", " << static_cast<int>(a0.a0[6]) << ", "
            << static_cast<int>(a0.a0[7]) << "]))" << ")\n";
 
  Struct8BytesInlineArrayInt result = f(a0);
 
  std::cout << "result = " << "([" << static_cast<int>(result.a0[0]) << ", "
            << static_cast<int>(result.a0[1]) << ", "
            << static_cast<int>(result.a0[2]) << ", "
            << static_cast<int>(result.a0[3]) << ", "
            << static_cast<int>(result.a0[4]) << ", "
            << static_cast<int>(result.a0[5]) << ", "
            << static_cast<int>(result.a0[6]) << ", "
            << static_cast<int>(result.a0[7]) << "])" << "\n";
 
  for (intptr_t i = 0; i < 8; i++) {
    CHECK_EQ(a0.a0[i], result.a0[i]);
  }
 
  // Pass argument that will make the Dart callback throw.
  a0.a0[0] = 42;
 
  result = f(a0);
 
  for (intptr_t i = 0; i < 8; i++) {
    CHECK_EQ(0, result.a0[i]);
  }
 
  // Pass argument that will make the Dart callback return null.
  a0.a0[0] = 84;
 
  result = f(a0);
 
  for (intptr_t i = 0; i < 8; i++) {
    CHECK_EQ(0, result.a0[i]);
  }
 
  return 0;
}

TestReturnStructArgumentStructStruct16BytesHomogeneous()

DART_EXPORT intptr_t dart::TestReturnStructArgumentStructStruct16BytesHomogeneous

(

StructStruct16BytesHomogeneousFloat2(*)(StructStruct16BytesHomogeneousFloat2 a0)

f

)

Definition at line 15061 of file ffi_test_functions_generated.cc.

                                                  {
  StructStruct16BytesHomogeneousFloat2 a0 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[1].a0 = -3.0;
  a0.a2 = 4.0;
 
  std::cout << "Calling TestReturnStructArgumentStructStruct16BytesHomogeneous("
            << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), ("
            << a0.a1[1].a0 << ")], " << a0.a2 << "))" << ")\n";
 
  StructStruct16BytesHomogeneousFloat2 result = f(a0);
 
  std::cout << "result = " << "((" << result.a0.a0 << "), [(" << result.a1[0].a0
            << "), (" << result.a1[1].a0 << ")], " << result.a2 << ")" << "\n";
 
  CHECK_APPROX(a0.a0.a0, result.a0.a0);
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_APPROX(a0.a1[i].a0, result.a1[i].a0);
  }
  CHECK_APPROX(a0.a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0.a0);
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_APPROX(0.0, result.a1[i].a0);
  }
  CHECK_APPROX(0.0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0.a0);
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_APPROX(0.0, result.a1[i].a0);
  }
  CHECK_APPROX(0.0, result.a2);
 
  return 0;
}

TestReturnStructArgumentStructStruct16BytesMixed3()

DART_EXPORT intptr_t dart::TestReturnStructArgumentStructStruct16BytesMixed3

(

StructStruct16BytesMixed3(*)(StructStruct16BytesMixed3 a0)

f

)

Definition at line 15167 of file ffi_test_functions_generated.cc.

                                                                  {
  StructStruct16BytesMixed3 a0 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[0].a1 = -3;
  a0.a1[0].a2 = 4;
  a0.a2[0] = -5;
  a0.a2[1] = 6;
 
  std::cout << "Calling TestReturnStructArgumentStructStruct16BytesMixed3("
            << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << ", "
            << a0.a1[0].a1 << ", " << a0.a1[0].a2 << ")], [" << a0.a2[0] << ", "
            << a0.a2[1] << "]))" << ")\n";
 
  StructStruct16BytesMixed3 result = f(a0);
 
  std::cout << "result = " << "((" << result.a0.a0 << "), [(" << result.a1[0].a0
            << ", " << result.a1[0].a1 << ", " << result.a1[0].a2 << ")], ["
            << result.a2[0] << ", " << result.a2[1] << "])" << "\n";
 
  CHECK_APPROX(a0.a0.a0, result.a0.a0);
  for (intptr_t i = 0; i < 1; i++) {
    CHECK_APPROX(a0.a1[i].a0, result.a1[i].a0);
    CHECK_EQ(a0.a1[i].a1, result.a1[i].a1);
    CHECK_EQ(a0.a1[i].a2, result.a1[i].a2);
  }
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_EQ(a0.a2[i], result.a2[i]);
  }
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0.a0);
  for (intptr_t i = 0; i < 1; i++) {
    CHECK_APPROX(0.0, result.a1[i].a0);
    CHECK_EQ(0, result.a1[i].a1);
    CHECK_EQ(0, result.a1[i].a2);
  }
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_EQ(0, result.a2[i]);
  }
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0.a0);
  for (intptr_t i = 0; i < 1; i++) {
    CHECK_APPROX(0.0, result.a1[i].a0);
    CHECK_EQ(0, result.a1[i].a1);
    CHECK_EQ(0, result.a1[i].a2);
  }
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_EQ(0, result.a2[i]);
  }
 
  return 0;
}

TestReturnStructArgumentStructStruct32BytesHomogeneous()

DART_EXPORT intptr_t dart::TestReturnStructArgumentStructStruct32BytesHomogeneous

(

StructStruct32BytesHomogeneousDouble2(*)(StructStruct32BytesHomogeneousDouble2 a0)

f

)

Definition at line 15114 of file ffi_test_functions_generated.cc.

                                                   {
  StructStruct32BytesHomogeneousDouble2 a0 = {};
 
  a0.a0.a0 = -1.0;
  a0.a1[0].a0 = 2.0;
  a0.a1[1].a0 = -3.0;
  a0.a2 = 4.0;
 
  std::cout << "Calling TestReturnStructArgumentStructStruct32BytesHomogeneous("
            << "(((" << a0.a0.a0 << "), [(" << a0.a1[0].a0 << "), ("
            << a0.a1[1].a0 << ")], " << a0.a2 << "))" << ")\n";
 
  StructStruct32BytesHomogeneousDouble2 result = f(a0);
 
  std::cout << "result = " << "((" << result.a0.a0 << "), [(" << result.a1[0].a0
            << "), (" << result.a1[1].a0 << ")], " << result.a2 << ")" << "\n";
 
  CHECK_APPROX(a0.a0.a0, result.a0.a0);
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_APPROX(a0.a1[i].a0, result.a1[i].a0);
  }
  CHECK_APPROX(a0.a2, result.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0.a0);
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_APPROX(0.0, result.a1[i].a0);
  }
  CHECK_APPROX(0.0, result.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0.a0);
  for (intptr_t i = 0; i < 2; i++) {
    CHECK_APPROX(0.0, result.a1[i].a0);
  }
  CHECK_APPROX(0.0, result.a2);
 
  return 0;
}

TestReturnStructNestedIntStructAlignmentInt16()

DART_EXPORT intptr_t dart::TestReturnStructNestedIntStructAlignmentInt16

(

StructNestedIntStructAlignmentInt16(*)(StructAlignmentInt16 a0, StructAlignmentInt16 a1)

f

)

Definition at line 15738 of file ffi_test_functions_generated.cc.

                                                                       {
  StructAlignmentInt16 a0 = {};
  StructAlignmentInt16 a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
 
  std::cout << "Calling TestReturnStructNestedIntStructAlignmentInt16(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))"
            << ")\n";
 
  StructNestedIntStructAlignmentInt16 result = f(a0, a1);
 
  std::cout << "result = " << "((" << static_cast<int>(result.a0.a0) << ", "
            << result.a0.a1 << ", " << static_cast<int>(result.a0.a2) << "), ("
            << static_cast<int>(result.a1.a0) << ", " << result.a1.a1 << ", "
            << static_cast<int>(result.a1.a2) << "))" << "\n";
 
  CHECK_EQ(a0.a0, result.a0.a0);
  CHECK_EQ(a0.a1, result.a0.a1);
  CHECK_EQ(a0.a2, result.a0.a2);
  CHECK_EQ(a1.a0, result.a1.a0);
  CHECK_EQ(a1.a1, result.a1.a1);
  CHECK_EQ(a1.a2, result.a1.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a0.a2);
  CHECK_EQ(0, result.a1.a0);
  CHECK_EQ(0, result.a1.a1);
  CHECK_EQ(0, result.a1.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a0.a2);
  CHECK_EQ(0, result.a1.a0);
  CHECK_EQ(0, result.a1.a1);
  CHECK_EQ(0, result.a1.a2);
 
  return 0;
}

TestReturnStructNestedIntStructAlignmentInt32()

DART_EXPORT intptr_t dart::TestReturnStructNestedIntStructAlignmentInt32

(

StructNestedIntStructAlignmentInt32(*)(StructAlignmentInt32 a0, StructAlignmentInt32 a1)

f

)

Definition at line 15801 of file ffi_test_functions_generated.cc.

                                                                       {
  StructAlignmentInt32 a0 = {};
  StructAlignmentInt32 a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
 
  std::cout << "Calling TestReturnStructNestedIntStructAlignmentInt32(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))"
            << ")\n";
 
  StructNestedIntStructAlignmentInt32 result = f(a0, a1);
 
  std::cout << "result = " << "((" << static_cast<int>(result.a0.a0) << ", "
            << result.a0.a1 << ", " << static_cast<int>(result.a0.a2) << "), ("
            << static_cast<int>(result.a1.a0) << ", " << result.a1.a1 << ", "
            << static_cast<int>(result.a1.a2) << "))" << "\n";
 
  CHECK_EQ(a0.a0, result.a0.a0);
  CHECK_EQ(a0.a1, result.a0.a1);
  CHECK_EQ(a0.a2, result.a0.a2);
  CHECK_EQ(a1.a0, result.a1.a0);
  CHECK_EQ(a1.a1, result.a1.a1);
  CHECK_EQ(a1.a2, result.a1.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a0.a2);
  CHECK_EQ(0, result.a1.a0);
  CHECK_EQ(0, result.a1.a1);
  CHECK_EQ(0, result.a1.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a0.a2);
  CHECK_EQ(0, result.a1.a0);
  CHECK_EQ(0, result.a1.a1);
  CHECK_EQ(0, result.a1.a2);
 
  return 0;
}

TestReturnStructNestedIntStructAlignmentInt64()

DART_EXPORT intptr_t dart::TestReturnStructNestedIntStructAlignmentInt64

(

StructNestedIntStructAlignmentInt64(*)(StructAlignmentInt64 a0, StructAlignmentInt64 a1)

f

)

Definition at line 15864 of file ffi_test_functions_generated.cc.

                                                                       {
  StructAlignmentInt64 a0 = {};
  StructAlignmentInt64 a1 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1.a0 = 4;
  a1.a1 = -5;
  a1.a2 = 6;
 
  std::cout << "Calling TestReturnStructNestedIntStructAlignmentInt64(" << "(("
            << static_cast<int>(a0.a0) << ", " << a0.a1 << ", "
            << static_cast<int>(a0.a2) << "), (" << static_cast<int>(a1.a0)
            << ", " << a1.a1 << ", " << static_cast<int>(a1.a2) << "))"
            << ")\n";
 
  StructNestedIntStructAlignmentInt64 result = f(a0, a1);
 
  std::cout << "result = " << "((" << static_cast<int>(result.a0.a0) << ", "
            << result.a0.a1 << ", " << static_cast<int>(result.a0.a2) << "), ("
            << static_cast<int>(result.a1.a0) << ", " << result.a1.a1 << ", "
            << static_cast<int>(result.a1.a2) << "))" << "\n";
 
  CHECK_EQ(a0.a0, result.a0.a0);
  CHECK_EQ(a0.a1, result.a0.a1);
  CHECK_EQ(a0.a2, result.a0.a2);
  CHECK_EQ(a1.a0, result.a1.a0);
  CHECK_EQ(a1.a1, result.a1.a1);
  CHECK_EQ(a1.a2, result.a1.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a0.a2);
  CHECK_EQ(0, result.a1.a0);
  CHECK_EQ(0, result.a1.a1);
  CHECK_EQ(0, result.a1.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a0.a2);
  CHECK_EQ(0, result.a1.a0);
  CHECK_EQ(0, result.a1.a1);
  CHECK_EQ(0, result.a1.a2);
 
  return 0;
}

TestReturnStructNestedIrregularEvenBigger()

DART_EXPORT intptr_t dart::TestReturnStructNestedIrregularEvenBigger

(

StructNestedIrregularEvenBigger(*)(uint64_t a0, StructNestedIrregularBigger a1, StructNestedIrregularBigger a2, double a3)

f

)

Definition at line 15927 of file ffi_test_functions_generated.cc.

                                                     {
  uint64_t a0;
  StructNestedIrregularBigger a1 = {};
  StructNestedIrregularBigger a2 = {};
  double a3;
 
  a0 = 1;
  a1.a0.a0 = 2;
  a1.a0.a1.a0.a0 = -3;
  a1.a0.a1.a0.a1 = 4;
  a1.a0.a1.a1.a0 = -5.0;
  a1.a0.a2 = 6;
  a1.a0.a3.a0.a0 = -7.0;
  a1.a0.a3.a1 = 8.0;
  a1.a0.a4 = 9;
  a1.a0.a5.a0.a0 = 10.0;
  a1.a0.a5.a1.a0 = -11.0;
  a1.a0.a6 = 12;
  a1.a1.a0.a0 = -13;
  a1.a1.a0.a1 = 14;
  a1.a1.a1.a0 = -15.0;
  a1.a2 = 16.0;
  a1.a3 = -17.0;
  a2.a0.a0 = 18;
  a2.a0.a1.a0.a0 = -19;
  a2.a0.a1.a0.a1 = 20;
  a2.a0.a1.a1.a0 = -21.0;
  a2.a0.a2 = 22;
  a2.a0.a3.a0.a0 = -23.0;
  a2.a0.a3.a1 = 24.0;
  a2.a0.a4 = 25;
  a2.a0.a5.a0.a0 = 26.0;
  a2.a0.a5.a1.a0 = -27.0;
  a2.a0.a6 = 28;
  a2.a1.a0.a0 = -29;
  a2.a1.a0.a1 = 30;
  a2.a1.a1.a0 = -31.0;
  a2.a2 = 32.0;
  a2.a3 = -33.0;
  a3 = 34.0;
 
  std::cout << "Calling TestReturnStructNestedIrregularEvenBigger(" << "(" << a0
            << ", ((" << a1.a0.a0 << ", ((" << a1.a0.a1.a0.a0 << ", "
            << a1.a0.a1.a0.a1 << "), (" << a1.a0.a1.a1.a0 << ")), " << a1.a0.a2
            << ", ((" << a1.a0.a3.a0.a0 << "), " << a1.a0.a3.a1 << "), "
            << a1.a0.a4 << ", ((" << a1.a0.a5.a0.a0 << "), (" << a1.a0.a5.a1.a0
            << ")), " << a1.a0.a6 << "), ((" << a1.a1.a0.a0 << ", "
            << a1.a1.a0.a1 << "), (" << a1.a1.a1.a0 << ")), " << a1.a2 << ", "
            << a1.a3 << "), ((" << a2.a0.a0 << ", ((" << a2.a0.a1.a0.a0 << ", "
            << a2.a0.a1.a0.a1 << "), (" << a2.a0.a1.a1.a0 << ")), " << a2.a0.a2
            << ", ((" << a2.a0.a3.a0.a0 << "), " << a2.a0.a3.a1 << "), "
            << a2.a0.a4 << ", ((" << a2.a0.a5.a0.a0 << "), (" << a2.a0.a5.a1.a0
            << ")), " << a2.a0.a6 << "), ((" << a2.a1.a0.a0 << ", "
            << a2.a1.a0.a1 << "), (" << a2.a1.a1.a0 << ")), " << a2.a2 << ", "
            << a2.a3 << "), " << a3 << ")" << ")\n";
 
  StructNestedIrregularEvenBigger result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << "(" << result.a0 << ", ((" << result.a1.a0.a0
            << ", ((" << result.a1.a0.a1.a0.a0 << ", " << result.a1.a0.a1.a0.a1
            << "), (" << result.a1.a0.a1.a1.a0 << ")), " << result.a1.a0.a2
            << ", ((" << result.a1.a0.a3.a0.a0 << "), " << result.a1.a0.a3.a1
            << "), " << result.a1.a0.a4 << ", ((" << result.a1.a0.a5.a0.a0
            << "), (" << result.a1.a0.a5.a1.a0 << ")), " << result.a1.a0.a6
            << "), ((" << result.a1.a1.a0.a0 << ", " << result.a1.a1.a0.a1
            << "), (" << result.a1.a1.a1.a0 << ")), " << result.a1.a2 << ", "
            << result.a1.a3 << "), ((" << result.a2.a0.a0 << ", (("
            << result.a2.a0.a1.a0.a0 << ", " << result.a2.a0.a1.a0.a1 << "), ("
            << result.a2.a0.a1.a1.a0 << ")), " << result.a2.a0.a2 << ", (("
            << result.a2.a0.a3.a0.a0 << "), " << result.a2.a0.a3.a1 << "), "
            << result.a2.a0.a4 << ", ((" << result.a2.a0.a5.a0.a0 << "), ("
            << result.a2.a0.a5.a1.a0 << ")), " << result.a2.a0.a6 << "), (("
            << result.a2.a1.a0.a0 << ", " << result.a2.a1.a0.a1 << "), ("
            << result.a2.a1.a1.a0 << ")), " << result.a2.a2 << ", "
            << result.a2.a3 << "), " << result.a3 << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
  CHECK_EQ(a1.a0.a0, result.a1.a0.a0);
  CHECK_EQ(a1.a0.a1.a0.a0, result.a1.a0.a1.a0.a0);
  CHECK_EQ(a1.a0.a1.a0.a1, result.a1.a0.a1.a0.a1);
  CHECK_APPROX(a1.a0.a1.a1.a0, result.a1.a0.a1.a1.a0);
  CHECK_EQ(a1.a0.a2, result.a1.a0.a2);
  CHECK_APPROX(a1.a0.a3.a0.a0, result.a1.a0.a3.a0.a0);
  CHECK_APPROX(a1.a0.a3.a1, result.a1.a0.a3.a1);
  CHECK_EQ(a1.a0.a4, result.a1.a0.a4);
  CHECK_APPROX(a1.a0.a5.a0.a0, result.a1.a0.a5.a0.a0);
  CHECK_APPROX(a1.a0.a5.a1.a0, result.a1.a0.a5.a1.a0);
  CHECK_EQ(a1.a0.a6, result.a1.a0.a6);
  CHECK_EQ(a1.a1.a0.a0, result.a1.a1.a0.a0);
  CHECK_EQ(a1.a1.a0.a1, result.a1.a1.a0.a1);
  CHECK_APPROX(a1.a1.a1.a0, result.a1.a1.a1.a0);
  CHECK_APPROX(a1.a2, result.a1.a2);
  CHECK_APPROX(a1.a3, result.a1.a3);
  CHECK_EQ(a2.a0.a0, result.a2.a0.a0);
  CHECK_EQ(a2.a0.a1.a0.a0, result.a2.a0.a1.a0.a0);
  CHECK_EQ(a2.a0.a1.a0.a1, result.a2.a0.a1.a0.a1);
  CHECK_APPROX(a2.a0.a1.a1.a0, result.a2.a0.a1.a1.a0);
  CHECK_EQ(a2.a0.a2, result.a2.a0.a2);
  CHECK_APPROX(a2.a0.a3.a0.a0, result.a2.a0.a3.a0.a0);
  CHECK_APPROX(a2.a0.a3.a1, result.a2.a0.a3.a1);
  CHECK_EQ(a2.a0.a4, result.a2.a0.a4);
  CHECK_APPROX(a2.a0.a5.a0.a0, result.a2.a0.a5.a0.a0);
  CHECK_APPROX(a2.a0.a5.a1.a0, result.a2.a0.a5.a1.a0);
  CHECK_EQ(a2.a0.a6, result.a2.a0.a6);
  CHECK_EQ(a2.a1.a0.a0, result.a2.a1.a0.a0);
  CHECK_EQ(a2.a1.a0.a1, result.a2.a1.a0.a1);
  CHECK_APPROX(a2.a1.a1.a0, result.a2.a1.a1.a0);
  CHECK_APPROX(a2.a2, result.a2.a2);
  CHECK_APPROX(a2.a3, result.a2.a3);
  CHECK_APPROX(a3, result.a3);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1.a0.a0);
  CHECK_EQ(0, result.a1.a0.a1.a0.a0);
  CHECK_EQ(0, result.a1.a0.a1.a0.a1);
  CHECK_APPROX(0.0, result.a1.a0.a1.a1.a0);
  CHECK_EQ(0, result.a1.a0.a2);
  CHECK_APPROX(0.0, result.a1.a0.a3.a0.a0);
  CHECK_APPROX(0.0, result.a1.a0.a3.a1);
  CHECK_EQ(0, result.a1.a0.a4);
  CHECK_APPROX(0.0, result.a1.a0.a5.a0.a0);
  CHECK_APPROX(0.0, result.a1.a0.a5.a1.a0);
  CHECK_EQ(0, result.a1.a0.a6);
  CHECK_EQ(0, result.a1.a1.a0.a0);
  CHECK_EQ(0, result.a1.a1.a0.a1);
  CHECK_APPROX(0.0, result.a1.a1.a1.a0);
  CHECK_APPROX(0.0, result.a1.a2);
  CHECK_APPROX(0.0, result.a1.a3);
  CHECK_EQ(0, result.a2.a0.a0);
  CHECK_EQ(0, result.a2.a0.a1.a0.a0);
  CHECK_EQ(0, result.a2.a0.a1.a0.a1);
  CHECK_APPROX(0.0, result.a2.a0.a1.a1.a0);
  CHECK_EQ(0, result.a2.a0.a2);
  CHECK_APPROX(0.0, result.a2.a0.a3.a0.a0);
  CHECK_APPROX(0.0, result.a2.a0.a3.a1);
  CHECK_EQ(0, result.a2.a0.a4);
  CHECK_APPROX(0.0, result.a2.a0.a5.a0.a0);
  CHECK_APPROX(0.0, result.a2.a0.a5.a1.a0);
  CHECK_EQ(0, result.a2.a0.a6);
  CHECK_EQ(0, result.a2.a1.a0.a0);
  CHECK_EQ(0, result.a2.a1.a0.a1);
  CHECK_APPROX(0.0, result.a2.a1.a1.a0);
  CHECK_APPROX(0.0, result.a2.a2);
  CHECK_APPROX(0.0, result.a2.a3);
  CHECK_APPROX(0.0, result.a3);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_EQ(0, result.a0);
  CHECK_EQ(0, result.a1.a0.a0);
  CHECK_EQ(0, result.a1.a0.a1.a0.a0);
  CHECK_EQ(0, result.a1.a0.a1.a0.a1);
  CHECK_APPROX(0.0, result.a1.a0.a1.a1.a0);
  CHECK_EQ(0, result.a1.a0.a2);
  CHECK_APPROX(0.0, result.a1.a0.a3.a0.a0);
  CHECK_APPROX(0.0, result.a1.a0.a3.a1);
  CHECK_EQ(0, result.a1.a0.a4);
  CHECK_APPROX(0.0, result.a1.a0.a5.a0.a0);
  CHECK_APPROX(0.0, result.a1.a0.a5.a1.a0);
  CHECK_EQ(0, result.a1.a0.a6);
  CHECK_EQ(0, result.a1.a1.a0.a0);
  CHECK_EQ(0, result.a1.a1.a0.a1);
  CHECK_APPROX(0.0, result.a1.a1.a1.a0);
  CHECK_APPROX(0.0, result.a1.a2);
  CHECK_APPROX(0.0, result.a1.a3);
  CHECK_EQ(0, result.a2.a0.a0);
  CHECK_EQ(0, result.a2.a0.a1.a0.a0);
  CHECK_EQ(0, result.a2.a0.a1.a0.a1);
  CHECK_APPROX(0.0, result.a2.a0.a1.a1.a0);
  CHECK_EQ(0, result.a2.a0.a2);
  CHECK_APPROX(0.0, result.a2.a0.a3.a0.a0);
  CHECK_APPROX(0.0, result.a2.a0.a3.a1);
  CHECK_EQ(0, result.a2.a0.a4);
  CHECK_APPROX(0.0, result.a2.a0.a5.a0.a0);
  CHECK_APPROX(0.0, result.a2.a0.a5.a1.a0);
  CHECK_EQ(0, result.a2.a0.a6);
  CHECK_EQ(0, result.a2.a1.a0.a0);
  CHECK_EQ(0, result.a2.a1.a0.a1);
  CHECK_APPROX(0.0, result.a2.a1.a1.a0);
  CHECK_APPROX(0.0, result.a2.a2);
  CHECK_APPROX(0.0, result.a2.a3);
  CHECK_APPROX(0.0, result.a3);
 
  return 0;
}

TestReturnUnion16BytesNestedFloat()

DART_EXPORT intptr_t dart::TestReturnUnion16BytesNestedFloat

(

Union16BytesNestedFloat(*)(Struct8BytesHomogeneousFloat a0)

f

)

Definition at line 14684 of file ffi_test_functions_generated.cc.

                                                                   {
  Struct8BytesHomogeneousFloat a0 = {};
 
  a0.a0 = -1.0;
  a0.a1 = 2.0;
 
  std::cout << "Calling TestReturnUnion16BytesNestedFloat(" << "((" << a0.a0
            << ", " << a0.a1 << "))" << ")\n";
 
  Union16BytesNestedFloat result = f(a0);
 
  std::cout << "result = " << "((" << result.a0.a0 << ", " << result.a0.a1
            << "))" << "\n";
 
  CHECK_APPROX(a0.a0, result.a0.a0);
  CHECK_APPROX(a0.a1, result.a0.a1);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0.a0);
  CHECK_APPROX(0.0, result.a0.a1);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0.a0);
  CHECK_APPROX(0.0, result.a0.a1);
 
  return 0;
}

TestReturnUnion4BytesMixed()

DART_EXPORT intptr_t dart::TestReturnUnion4BytesMixed

(

Union4BytesMixed(*)(uint32_t a0)

f

)

Definition at line 14570 of file ffi_test_functions_generated.cc.

                                        {
  uint32_t a0;
 
  a0 = 1;
 
  std::cout << "Calling TestReturnUnion4BytesMixed(" << "(" << a0 << ")"
            << ")\n";
 
  Union4BytesMixed result = f(a0);
 
  std::cout << "result = " << "(" << result.a0 << ")" << "\n";
 
  CHECK_EQ(a0, result.a0);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0);
 
  return 0;
}

TestReturnUnion8BytesNestedFloat()

DART_EXPORT intptr_t dart::TestReturnUnion8BytesNestedFloat

(

Union8BytesNestedFloat(*)(double a0)

f

)

Definition at line 14605 of file ffi_test_functions_generated.cc.

                                            {
  double a0;
 
  a0 = -1.0;
 
  std::cout << "Calling TestReturnUnion8BytesNestedFloat(" << "(" << a0 << ")"
            << ")\n";
 
  Union8BytesNestedFloat result = f(a0);
 
  std::cout << "result = " << "(" << result.a0 << ")" << "\n";
 
  CHECK_APPROX(a0, result.a0);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0);
 
  CHECK_APPROX(0.0, result.a0);
 
  return 0;
}

TestReturnUnion9BytesNestedInt()

DART_EXPORT intptr_t dart::TestReturnUnion9BytesNestedInt

(

Union9BytesNestedInt(*)(Struct8BytesInt a0)

f

)

Definition at line 14640 of file ffi_test_functions_generated.cc.

                                                   {
  Struct8BytesInt a0 = {};
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
 
  std::cout << "Calling TestReturnUnion9BytesNestedInt(" << "((" << a0.a0
            << ", " << a0.a1 << ", " << a0.a2 << "))" << ")\n";
 
  Union9BytesNestedInt result = f(a0);
 
  std::cout << "result = " << "((" << result.a0.a0 << ", " << result.a0.a1
            << ", " << result.a0.a2 << "))" << "\n";
 
  CHECK_EQ(a0.a0, result.a0.a0);
  CHECK_EQ(a0.a1, result.a0.a1);
  CHECK_EQ(a0.a2, result.a0.a2);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a0.a2);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0);
 
  CHECK_EQ(0, result.a0.a0);
  CHECK_EQ(0, result.a0.a1);
  CHECK_EQ(0, result.a0.a2);
 
  return 0;
}

TestReturnVoid()

DART_EXPORT intptr_t dart::TestReturnVoid

(

intptr_t(*)()

return_void

)

Definition at line 1116 of file ffi_test_functions.cc.

                                                               {
  CHECK_EQ(return_void(), 0);
  return 0;
}

TestScriptJIT()

static void dart::TestScriptJIT ( const char *  script_chars, intptr_t  expected_before, intptr_t  expected_after  )

static

Definition at line 66 of file bce_test.cc.

                                                   {
  auto jit_result = ApplyBCE(script_chars, CompilerPass::kJIT);
  EXPECT_EQ(expected_before, jit_result.first);
  EXPECT_EQ(expected_after, jit_result.second);
}

TestSet() [1/2]

void dart::TestSet	(	IntKeyHash	hash,
		int	size
	)

Definition at line 81 of file hashmap_test.cc.

                                        {
  IntSet set(hash);
  EXPECT_EQ(0u, set.occupancy());
 
  set.Insert(1);
  set.Insert(2);
  set.Insert(3);
  set.Insert(4);
  EXPECT_EQ(4u, set.occupancy());
 
  set.Insert(2);
  set.Insert(3);
  EXPECT_EQ(4u, set.occupancy());
 
  EXPECT(set.Present(1));
  EXPECT(set.Present(2));
  EXPECT(set.Present(3));
  EXPECT(set.Present(4));
  EXPECT(!set.Present(5));
  EXPECT_EQ(4u, set.occupancy());
 
  set.Remove(1);
  EXPECT(!set.Present(1));
  EXPECT(set.Present(2));
  EXPECT(set.Present(3));
  EXPECT(set.Present(4));
  EXPECT_EQ(3u, set.occupancy());
 
  set.Remove(3);
  EXPECT(!set.Present(1));
  EXPECT(set.Present(2));
  EXPECT(!set.Present(3));
  EXPECT(set.Present(4));
  EXPECT_EQ(2u, set.occupancy());
 
  set.Remove(4);
  EXPECT(!set.Present(1));
  EXPECT(set.Present(2));
  EXPECT(!set.Present(3));
  EXPECT(!set.Present(4));
  EXPECT_EQ(1u, set.occupancy());
 
  set.Clear();
  EXPECT_EQ(0u, set.occupancy());
 
  // Insert a long series of values.
  const uint32_t start = 453;
  const uint32_t factor = 13;
  const uint32_t offset = 7;
  const uint32_t n = size;
 
  uint32_t x = start;
  for (uint32_t i = 0; i < n; i++) {
    EXPECT_EQ(i, set.occupancy());
    set.Insert(x);
    x = x * factor + offset;
  }
  EXPECT_EQ(n, set.occupancy());
 
  // Verify the same sequence of values.
  x = start;
  for (uint32_t i = 0; i < n; i++) {
    EXPECT(set.Present(x));
    x = x * factor + offset;
  }
  EXPECT_EQ(n, set.occupancy());
 
  // Remove all these values.
  x = start;
  for (uint32_t i = 0; i < n; i++) {
    EXPECT_EQ(n - i, set.occupancy());
    EXPECT(set.Present(x));
    set.Remove(x);
    EXPECT(!set.Present(x));
    x = x * factor + offset;
 
    // Verify the expected values are still there.
    int y = start;
    for (uint32_t j = 0; j < n; j++) {
      if (j <= i) {
        EXPECT(!set.Present(y));
      } else {
        EXPECT(set.Present(y));
      }
      y = y * factor + offset;
    }
  }
  EXPECT_EQ(0u, set.occupancy());
}

TestSet() [2/2]

template<typename Set >

void dart::TestSet	(	intptr_t	initial_capacity,
		bool	ordered
	)

Definition at line 192 of file hash_table_test.cc.

                                                      {
  std::set<std::string> expected;
  Set actual(HashTables::New<Set>(initial_capacity));
  // Insert the following strings twice:
  // aaa...aaa (length 26)
  // bbb..bbb
  // ...
  // yy
  // z
  for (int i = 0; i < 2; ++i) {
    for (char ch = 'a'; ch <= 'z'; ++ch) {
      std::string key('z' - ch + 1, ch);
      expected.insert(key);
      bool present = actual.Insert(String::Handle(String::New(key.c_str())));
      EXPECT_EQ((i != 0), present);
      Validate(actual);
      VerifyStringSetsEqual(expected, actual, ordered);
    }
  }
  actual.Clear();
  EXPECT_EQ(0, actual.NumOccupied());
  actual.Release();
}

TestSignExtendedBitField()

template<typename T >

static void dart::TestSignExtendedBitField ( )

static

Definition at line 27 of file bitfield_test.cc.

                                       {
  class F1 : public BitField<T, intptr_t, 0, 8, /*sign_extend=*/true> {};
  class F2
      : public BitField<T, uintptr_t, F1::kNextBit, 8, /*sign_extend=*/false> {
  };
  class F3
      : public BitField<T, intptr_t, F2::kNextBit, 8, /*sign_extend=*/true> {};
  class F4
      : public BitField<T, uintptr_t, F3::kNextBit, 8, /*sign_extend=*/false> {
  };
 
  const uint32_t value =
      F1::encode(-1) | F2::encode(1) | F3::encode(-2) | F4::encode(2);
  EXPECT_EQ(0x02fe01ffU, value);
  EXPECT_EQ(-1, F1::decode(value));
  EXPECT_EQ(1U, F2::decode(value));
  EXPECT_EQ(-2, F3::decode(value));
  EXPECT_EQ(2U, F4::decode(value));
}

TestSimpleAddition()

DART_EXPORT intptr_t dart::TestSimpleAddition

(

intptr_t(*)(int, int)

add

)

Definition at line 899 of file ffi_test_functions.cc.

                                                                   {
  const intptr_t result = add(10, 20);
  std::cout << "result " << result << "\n";
  CHECK_EQ(result, 30);
  return 0;
}

TestSimpleMultiply()

DART_EXPORT intptr_t dart::TestSimpleMultiply

(

double(*)(double)

fn

)

Definition at line 927 of file ffi_test_functions.cc.

                                                              {
  CHECK_EQ(fn(2.0), 2.0 * 1.337);
  return 0;
}

TestSimpleMultiplyFloat()

DART_EXPORT intptr_t dart::TestSimpleMultiplyFloat

(

float(*)(float)

fn

)

Definition at line 932 of file ffi_test_functions.cc.

                                                                 {
  CHECK(::std::abs(fn(2.0) - 2.0 * 1.337) < 0.001);
  return 0;
}

TestSmiSub()

void dart::TestSmiSub

(

Dart_NativeArguments

args

)

Definition at line 22 of file native_entry_test.cc.

                                           {
  Dart_Handle left = Dart_GetNativeArgument(args, 0);
  Dart_Handle right = Dart_GetNativeArgument(args, 1);
  int64_t left_value = -1;
  int64_t right_value = -1;
  EXPECT_VALID(Dart_IntegerToInt64(left, &left_value));
  EXPECT_VALID(Dart_IntegerToInt64(right, &right_value));
 
  // Ignoring overflow in the calculation below.
  int64_t result = left_value - right_value;
  Dart_SetReturnValue(args, Dart_NewInteger(result));
}

TestSmiSum()

void dart::TestSmiSum

(

Dart_NativeArguments

args

)

Definition at line 38 of file native_entry_test.cc.

                                           {
  int64_t result = 0;
  int arg_count = Dart_GetNativeArgumentCount(args);
  for (int i = 0; i < arg_count; i++) {
    Dart_Handle arg = Dart_GetNativeArgument(args, i);
    int64_t arg_value = -1;
    EXPECT_VALID(Dart_IntegerToInt64(arg, &arg_value));
 
    // Ignoring overflow in the addition below.
    result += arg_value;
  }
  Dart_SetReturnValue(args, Dart_NewInteger(result));
}

TestStartFunction()

MessageHandler::MessageStatus dart::TestStartFunction

(

uword

data

)

Definition at line 123 of file message_handler_test.cc.

                                                          {
  return (reinterpret_cast<TestMessageHandler*>(data))->Start();
}

TestStaticFieldForwarding()

void dart::TestStaticFieldForwarding	(	Thread *	thread,
		const Class &	test_cls,
		const Field &	field,
		intptr_t	num_stores,
		bool	expected_to_forward
	)

Definition at line 1424 of file il_test.cc.

                                                         {
  EXPECT(num_stores <= 2);
 
  using compiler::BlockBuilder;
  CompilerState S(thread, /*is_aot=*/false, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H;
 
  auto b1 = H.flow_graph()->graph_entry()->normal_entry();
 
  const auto constant_42 = H.IntConstant(42);
  const auto constant_24 = H.IntConstant(24);
  Definition* load;
  DartReturnInstr* ret;
 
  {
    BlockBuilder builder(H.flow_graph(), b1);
    // obj <- AllocateObject(TestClass)
    const auto obj = builder.AddDefinition(
        new AllocateObjectInstr(InstructionSource(), test_cls, DeoptId::kNone));
 
    if (num_stores >= 1) {
      // StoreField(o.field = 42)
      builder.AddInstruction(new StoreFieldInstr(
          field, new Value(obj), new Value(constant_42),
          StoreBarrierType::kNoStoreBarrier, InstructionSource(),
          &H.flow_graph()->parsed_function(),
          StoreFieldInstr::Kind::kInitializing));
    }
 
    if (num_stores >= 2) {
      // StoreField(o.field = 24)
      builder.AddInstruction(new StoreFieldInstr(
          field, new Value(obj), new Value(constant_24),
          StoreBarrierType::kNoStoreBarrier, InstructionSource(),
          &H.flow_graph()->parsed_function()));
    }
 
    // load <- LoadField(view.field)
    load = builder.AddDefinition(new LoadFieldInstr(
        new Value(obj), Slot::Get(field, &H.flow_graph()->parsed_function()),
        InstructionSource()));
 
    // Return(load)
    ret = builder.AddReturn(new Value(load));
  }
  H.FinishGraph();
  H.flow_graph()->Canonicalize();
 
  if (expected_to_forward) {
    EXPECT_PROPERTY(ret->value()->definition(), &it == constant_42);
  } else {
    EXPECT_PROPERTY(ret->value()->definition(), &it == load);
  }
}

TestStore()

DART_EXPORT intptr_t dart::TestStore

(

int64_t *(*)(int64_t *a)

fn

)

Definition at line 1095 of file ffi_test_functions.cc.

                                                           {
  int64_t p[2] = {42, 1000};
  int64_t* result = fn(p);
  CHECK_EQ(*result, 1337);
  CHECK_EQ(p[1], 1337);
  CHECK_EQ(result, p + 1);
  return 0;
}

TestString() [1/2]

void dart::TestString	(	BaseTextBuffer *	f,
		LoopInfo *	loop,
		const GrowableArray< BlockEntryInstr * > &	preorder
	)

Definition at line 27 of file loops_test.cc.

                                                                 {
  for (; loop != nullptr; loop = loop->next()) {
    intptr_t depth = loop->NestingDepth();
    f->Printf("%*c[%" Pd "\n", static_cast<int>(2 * depth), ' ', loop->id());
    for (BitVector::Iterator block_it(loop->blocks()); !block_it.Done();
         block_it.Advance()) {
      BlockEntryInstr* block = preorder[block_it.Current()];
      if (block->IsJoinEntry()) {
        for (PhiIterator it(block->AsJoinEntry()); !it.Done(); it.Advance()) {
          InductionVar* induc = loop->LookupInduction(it.Current());
          if (induc != nullptr) {
            // Obtain the debug string for induction and bounds.
            f->Printf("%*c%s", static_cast<int>(2 * depth), ' ',
                      induc->ToCString());
            for (auto bound : induc->bounds()) {
              f->Printf(" %s", bound.limit_->ToCString());
            }
            f->AddString("\n");
          }
        }
      }
      for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
        InductionVar* induc =
            loop->LookupInduction(it.Current()->AsDefinition());
        if (InductionVar::IsInduction(induc)) {
          f->Printf("%*c%s\n", static_cast<int>(2 * depth), ' ',
                    induc->ToCString());
        }
      }
    }
    TestString(f, loop->inner(), preorder);
    f->Printf("%*c]\n", static_cast<int>(2 * depth), ' ');
  }
}

TestString() [2/2]

static void dart::TestString ( const char *  cstr )

static

Definition at line 374 of file snapshot_test.cc.

                                         {
  Thread* thread = Thread::Current();
  EXPECT(Utf8::IsValid(reinterpret_cast<const uint8_t*>(cstr), strlen(cstr)));
  // Write snapshot with object content.
  String& str = String::Handle(String::New(cstr));
  std::unique_ptr<Message> message = WriteMessage(
      /* same_group */ false, str, ILLEGAL_PORT, Message::kNormalPriority);
 
  // Read object back from the snapshot.
  String& serialized_str = String::Handle();
  serialized_str ^= ReadMessage(thread, message.get());
  EXPECT(str.Equals(serialized_str));
 
  // Read object back from the snapshot into a C structure.
  ApiNativeScope scope;
  Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
  EXPECT_EQ(Dart_CObject_kString, root->type);
  EXPECT_STREQ(cstr, root->value.as_string);
  CheckEncodeDecodeMessage(scope.zone(), root);
}

TestSumFloatsAndDoubles()

DART_EXPORT intptr_t dart::TestSumFloatsAndDoubles

(

double(*)(float, double, float)

fn

)

Definition at line 991 of file ffi_test_functions.cc.

                                                                  {
  CHECK_EQ(6.0, fn(1.0, 2.0, 3.0));
  return 0;
}

TestSumVeryManyFloatsDoubles()

DART_EXPORT intptr_t dart::TestSumVeryManyFloatsDoubles

(

double(*)(float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double, float, double)

fn

)

Definition at line 1047 of file ffi_test_functions.cc.

                                                                        {
  CHECK_EQ(40 * 41 / 2,
           fn(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0,
              13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0,
              24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0,
              35.0, 36.0, 37.0, 38.0, 39.0, 40.0));
  return 0;
}

TestSumVeryManySmallInts()

DART_EXPORT intptr_t dart::TestSumVeryManySmallInts

(

int16_t(*)(int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t, int8_t, int16_t)

fn

)

Definition at line 999 of file ffi_test_functions.cc.

                                                                      {
  CHECK_EQ(40 * 41 / 2, fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                           16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
                           29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40));
  return 0;
}

TestTakeMaxUint8x10()

DART_EXPORT intptr_t dart::TestTakeMaxUint8x10

(

intptr_t(*)(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)

fn

)

Definition at line 1136 of file ffi_test_functions.cc.

                                                                  {
  CHECK_EQ(1, fn(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF));
  // Check the argument values are properly truncated.
  uint64_t v = 0xabcFF;
  CHECK_EQ(1, fn(v, v, v, v, v, v, v, v, v, v));
  return 0;
}

TestTestRangeCanonicalize()

static void dart::TestTestRangeCanonicalize ( const AbstractType &  type, uword  lower, uword  upper, bool  result  )

static

Definition at line 1381 of file il_test.cc.

                                                   {
  using compiler::BlockBuilder;
  CompilerState S(Thread::Current(), /*is_aot=*/true, /*is_optimizing=*/true);
  FlowGraphBuilderHelper H(/*num_parameters=*/1);
  H.AddVariable("v0", type);
 
  auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
 
  DartReturnInstr* ret;
  {
    BlockBuilder builder(H.flow_graph(), normal_entry);
    Definition* param = builder.AddParameter(0, kTagged);
    Definition* load_cid =
        builder.AddDefinition(new LoadClassIdInstr(new Value(param)));
    Definition* test_range = builder.AddDefinition(new TestRangeInstr(
        InstructionSource(), new Value(load_cid), lower, upper, kTagged));
    ret = builder.AddReturn(new Value(test_range));
  }
  H.FinishGraph();
  H.flow_graph()->Canonicalize();
 
  EXPECT_PROPERTY(ret, it.value()->BindsToConstant());
  EXPECT_PROPERTY(ret,
                  it.value()->BoundConstant().ptr() == Bool::Get(result).ptr());
}

TestThrowException()

DART_EXPORT intptr_t dart::TestThrowException

(

intptr_t(*)()

fn

)

Definition at line 1131 of file ffi_test_functions.cc.

                                                          {
  CHECK_EQ(fn(), 42);
  return 0;
}

TestThrowExceptionDouble()

DART_EXPORT intptr_t dart::TestThrowExceptionDouble

(

double(*)()

fn

)

Definition at line 1121 of file ffi_test_functions.cc.

                                                              {
  CHECK_EQ(fn(), 42.0);
  return 0;
}

TestThrowExceptionPointer()

DART_EXPORT intptr_t dart::TestThrowExceptionPointer

(

void *(*)()

fn

)

Definition at line 1126 of file ffi_test_functions.cc.

                                                              {
  CHECK_EQ(fn(), nullptr);
  return 0;
}

TestTypedDataDirectAccess()

static void dart::TestTypedDataDirectAccess ( )

static

Definition at line 2465 of file dart_api_impl_test.cc.

                                        {
  Dart_Handle str = Dart_NewStringFromCString("junk");
  Dart_Handle byte_array = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
  EXPECT_VALID(byte_array);
  Dart_Handle result;
  result = Dart_TypedDataAcquireData(byte_array, nullptr, nullptr, nullptr);
  EXPECT_ERROR(result,
               "Dart_TypedDataAcquireData expects argument 'type'"
               " to be non-null.");
  Dart_TypedData_Type type;
  result = Dart_TypedDataAcquireData(byte_array, &type, nullptr, nullptr);
  EXPECT_ERROR(result,
               "Dart_TypedDataAcquireData expects argument 'data'"
               " to be non-null.");
  void* data;
  result = Dart_TypedDataAcquireData(byte_array, &type, &data, nullptr);
  EXPECT_ERROR(result,
               "Dart_TypedDataAcquireData expects argument 'len'"
               " to be non-null.");
  intptr_t len;
  result = Dart_TypedDataAcquireData(Dart_Null(), &type, &data, &len);
  EXPECT_ERROR(result,
               "Dart_TypedDataAcquireData expects argument 'object'"
               " to be non-null.");
  result = Dart_TypedDataAcquireData(str, &type, &data, &len);
  EXPECT_ERROR(result,
               "Dart_TypedDataAcquireData expects argument 'object'"
               " to be of type 'TypedData'.");
 
  result = Dart_TypedDataReleaseData(Dart_Null());
  EXPECT_ERROR(result,
               "Dart_TypedDataReleaseData expects argument 'object'"
               " to be non-null.");
  result = Dart_TypedDataReleaseData(str);
  EXPECT_ERROR(result,
               "Dart_TypedDataReleaseData expects argument 'object'"
               " to be of type 'TypedData'.");
}

TestTypedDataDirectAccess1()

static void dart::TestTypedDataDirectAccess1 ( )

static

Definition at line 2587 of file dart_api_impl_test.cc.

                                         {
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "class Expect {\n"
      "  static equals(a, b) {\n"
      "    if (a != b) {\n"
      "      throw new Exception('not equal. expected: $a, got: $b');\n"
      "    }\n"
      "  }\n"
      "}\n"
      "void setMain(var a) {"
      "  for (var i = 0; i < 10; i++) {"
      "    a[i] = i;"
      "  }"
      "}\n"
      "bool testMain(var list) {"
      "  for (var i = 0; i < 10; i++) {"
      "    Expect.equals((10 + i), list[i]);"
      "  }\n"
      "  return true;"
      "}\n"
      "List main() {"
      "  var a = new Int8List(10);"
      "  return a;"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  Monitor monitor;
  bool done = false;
  Dart::thread_pool()->Run<BackgroundGCTask>(IsolateGroup::Current(), &monitor,
                                             &done);
 
  for (intptr_t i = 0; i < 10; i++) {
    // Test with an regular typed data object.
    Dart_Handle list_access_test_obj;
    list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, nullptr);
    EXPECT_VALID(list_access_test_obj);
    TestDirectAccess(lib, list_access_test_obj, Dart_TypedData_kInt8, false);
 
    // Test with an external typed data object.
    uint8_t data[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    intptr_t data_length = ARRAY_SIZE(data);
    Dart_Handle ext_list_access_test_obj;
    ext_list_access_test_obj =
        Dart_NewExternalTypedData(Dart_TypedData_kUint8, data, data_length);
    EXPECT_VALID(ext_list_access_test_obj);
    TestDirectAccess(lib, ext_list_access_test_obj, Dart_TypedData_kUint8,
                     true);
  }
 
  {
    MonitorLocker ml(&monitor);
    while (!done) {
      ml.Wait();
    }
  }
}

TestTypedDataViewDirectAccess()

static void dart::TestTypedDataViewDirectAccess ( )

static

Definition at line 2656 of file dart_api_impl_test.cc.

                                            {
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "class Expect {\n"
      "  static equals(a, b) {\n"
      "    if (a != b) {\n"
      "      throw 'not equal. expected: $a, got: $b';\n"
      "    }\n"
      "  }\n"
      "}\n"
      "void setMain(var list) {"
      "  Expect.equals(10, list.length);"
      "  for (var i = 0; i < 10; i++) {"
      "    list[i] = i;"
      "  }"
      "}\n"
      "bool testMain(var list) {"
      "  Expect.equals(10, list.length);"
      "  for (var i = 0; i < 10; i++) {"
      "    Expect.equals((10 + i), list[i]);"
      "  }"
      "  return true;"
      "}\n"
      "List main() {"
      "  var a = new Int8List(100);"
      "  var view = new Int8List.view(a.buffer, 50, 10);"
      "  return view;"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Test with a typed data view object.
  Dart_Handle list_access_test_obj;
  list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(list_access_test_obj);
  TestDirectAccess(lib, list_access_test_obj, Dart_TypedData_kInt8, false);
}

TestUintComputation()

DART_EXPORT intptr_t dart::TestUintComputation

(

uint64_t(*)(uint8_t, uint16_t, uint32_t, uint64_t)

fn

)

Definition at line 920 of file ffi_test_functions.cc.

                                                                           {
  CHECK_EQ(0x7FFFFFFFFFFFFFFFLL, fn(0, 0, 0, 0x7FFFFFFFFFFFFFFFLL));
  CHECK_EQ(0x8000000000000000LL, fn(0, 0, 0, 0x8000000000000000LL));
  CHECK_EQ(-1, (int64_t)fn(0, 0, 0, -1));
  return 0;
}

TestUnmodifiableTypedDataViewDirectAccess()

static void dart::TestUnmodifiableTypedDataViewDirectAccess ( )

static

Definition at line 2704 of file dart_api_impl_test.cc.

                                                        {
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "List main() {"
      "  var list = new Int8List(100);"
      "  for (var i = 0; i < 100; i++) {"
      "    list[i] = i;"
      "  }"
      "  return new UnmodifiableInt8ListView(list);"
      "}\n";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
 
  // Test with a typed data view object.
  Dart_Handle view_obj;
  view_obj = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(view_obj);
 
  const int kLength = 100;
  Dart_TypedData_Type type;
  void* data;
  intptr_t len;
  Dart_Handle result = Dart_TypedDataAcquireData(view_obj, &type, &data, &len);
  EXPECT(!Thread::Current()->IsAtSafepoint());
  EXPECT_VALID(result);
  EXPECT_EQ(Dart_TypedData_kInt8, type);
  EXPECT_EQ(kLength, len);
  int8_t* dataP = reinterpret_cast<int8_t*>(data);
  for (int i = 0; i < kLength; i++) {
    EXPECT_EQ(i, dataP[i]);
  }
 
  // Now try allocating a string with outstanding Acquires and it should
  // return an error.
  result = NewString("We expect an error here");
  EXPECT_ERROR(result, "Callbacks into the Dart VM are currently prohibited");
 
  // Release direct access to the typed data object.
  EXPECT(!Thread::Current()->IsAtSafepoint());
  result = Dart_TypedDataReleaseData(view_obj);
  EXPECT_VALID(result);
}

TestUnprotectCode()

DART_EXPORT void * dart::TestUnprotectCode

(

void(*)(void *)

fn

)

Definition at line 154 of file ffi_test_functions_vmspecific.cc.

                                                       {
  HelperThreadState* state = new HelperThreadState;
 
  {
    std::unique_lock<std::mutex> lock(state->mutex);  // locks the mutex
    state->helper.reset(new std::thread(UnprotectCodeOtherThread,
                                        Dart_CurrentIsolate(), &state->cvar,
                                        &state->mutex));
 
    state->cvar.wait(lock);
  }
 
  if (fn != nullptr) {
    fn(state);
    return nullptr;
  } else {
    return state;
  }
}

TestVariadicAt11Doublex8FloatStruct12BytesHomogeneousF()

DART_EXPORT intptr_t dart::TestVariadicAt11Doublex8FloatStruct12BytesHomogeneousF

(

double(*)(double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, float a8, Struct12BytesHomogeneousFloat a9, int64_t a10,...)

f

)

Definition at line 23700 of file ffi_test_functions_generated.cc.

                      {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;
  double a5;
  double a6;
  double a7;
  float a8;
  Struct12BytesHomogeneousFloat a9 = {};
  int64_t a10;
  int32_t a11;
  Struct12BytesHomogeneousFloat a12 = {};
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
  a5 = 6.0;
  a6 = -7.0;
  a7 = 8.0;
  a8 = -9.0;
  a9.a0 = 10.0;
  a9.a1 = -11.0;
  a9.a2 = 12.0;
  a10 = -13;
  a11 = 14;
  a12.a0 = -15.0;
  a12.a1 = 16.0;
  a12.a2 = -17.0;
 
  std::cout << "Calling TestVariadicAt11Doublex8FloatStruct12BytesHomogeneousF("
            << "(" << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", " << a7 << ", " << a8 << ", ("
            << a9.a0 << ", " << a9.a1 << ", " << a9.a2 << "), " << a10 << ", "
            << a11 << ", (" << a12.a0 << ", " << a12.a1 << ", " << a12.a2
            << "))" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-9.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1DoubleInt64Int32DoubleInt64Int32()

DART_EXPORT intptr_t dart::TestVariadicAt1DoubleInt64Int32DoubleInt64Int32

(

double(*)(double a0,...)

f

)

Definition at line 23612 of file ffi_test_functions_generated.cc.

                                 {
  double a0;
  int64_t a1;
  int32_t a2;
  double a3;
  int64_t a4;
  int32_t a5;
 
  a0 = -1.0;
  a1 = 2;
  a2 = -3;
  a3 = 4.0;
  a4 = -5;
  a5 = 6;
 
  std::cout << "Calling TestVariadicAt1DoubleInt64Int32DoubleInt64Int32(" << "("
            << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(3.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1DoubleInt64Int32Struct20BytesHomogeneou()

DART_EXPORT intptr_t dart::TestVariadicAt1DoubleInt64Int32Struct20BytesHomogeneou

(

double(*)(double a0,...)

f

)

Definition at line 23778 of file ffi_test_functions_generated.cc.

                                 {
  double a0;
  int64_t a1;
  int32_t a2;
  Struct20BytesHomogeneousInt32 a3 = {};
  double a4;
  int64_t a5;
  int32_t a6;
  Struct12BytesHomogeneousFloat a7 = {};
  int64_t a8;
 
  a0 = -1.0;
  a1 = 2;
  a2 = -3;
  a3.a0 = 4;
  a3.a1 = -5;
  a3.a2 = 6;
  a3.a3 = -7;
  a3.a4 = 8;
  a4 = -9.0;
  a5 = 10;
  a6 = -11;
  a7.a0 = 12.0;
  a7.a1 = -13.0;
  a7.a2 = 14.0;
  a8 = -15;
 
  std::cout << "Calling TestVariadicAt1DoubleInt64Int32Struct20BytesHomogeneou("
            << "(" << a0 << ", " << a1 << ", " << a2 << ", (" << a3.a0 << ", "
            << a3.a1 << ", " << a3.a2 << ", " << a3.a3 << ", " << a3.a4 << "), "
            << a4 << ", " << a5 << ", " << a6 << ", (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << "), " << a8 << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-8.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1DoubleStruct12BytesHomogeneousFloatDoub()

DART_EXPORT intptr_t dart::TestVariadicAt1DoubleStruct12BytesHomogeneousFloatDoub

(

double(*)(double a0,...)

f

)

Definition at line 23442 of file ffi_test_functions_generated.cc.

                                 {
  double a0;
  Struct12BytesHomogeneousFloat a1 = {};
  double a2;
 
  a0 = -1.0;
  a1.a0 = 2.0;
  a1.a1 = -3.0;
  a1.a2 = 4.0;
  a2 = -5.0;
 
  std::cout << "Calling TestVariadicAt1DoubleStruct12BytesHomogeneousFloatDoub("
            << "(" << a0 << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2
            << "), " << a2 << ")" << ")\n";
 
  double result = f(a0, a1, a2);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-3.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1DoubleStruct20BytesHomogeneousFloatDoub()

DART_EXPORT intptr_t dart::TestVariadicAt1DoubleStruct20BytesHomogeneousFloatDoub

(

double(*)(double a0,...)

f

)

Definition at line 23528 of file ffi_test_functions_generated.cc.

                                 {
  double a0;
  Struct20BytesHomogeneousFloat a1 = {};
  double a2;
 
  a0 = -1.0;
  a1.a0 = 2.0;
  a1.a1 = -3.0;
  a1.a2 = 4.0;
  a1.a3 = -5.0;
  a1.a4 = 6.0;
  a2 = -7.0;
 
  std::cout << "Calling TestVariadicAt1DoubleStruct20BytesHomogeneousFloatDoub("
            << "(" << a0 << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2
            << ", " << a1.a3 << ", " << a1.a4 << "), " << a2 << ")" << ")\n";
 
  double result = f(a0, a1, a2);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-4.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1Doublex2()

DART_EXPORT intptr_t dart::TestVariadicAt1Doublex2

(

double(*)(double a0,...)

f

)

Definition at line 23070 of file ffi_test_functions_generated.cc.

                                 {
  double a0;
  double a1;
 
  a0 = -1.0;
  a1 = 2.0;
 
  std::cout << "Calling TestVariadicAt1Doublex2(" << "(" << a0 << ", " << a1
            << ")" << ")\n";
 
  double result = f(a0, a1);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(1.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1Doublex20()

DART_EXPORT intptr_t dart::TestVariadicAt1Doublex20

(

double(*)(double a0,...)

f

)

Definition at line 23273 of file ffi_test_functions_generated.cc.

                                 {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;
  double a5;
  double a6;
  double a7;
  double a8;
  double a9;
  double a10;
  double a11;
  double a12;
  double a13;
  double a14;
  double a15;
  double a16;
  double a17;
  double a18;
  double a19;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
  a5 = 6.0;
  a6 = -7.0;
  a7 = 8.0;
  a8 = -9.0;
  a9 = 10.0;
  a10 = -11.0;
  a11 = 12.0;
  a12 = -13.0;
  a13 = 14.0;
  a14 = -15.0;
  a15 = 16.0;
  a16 = -17.0;
  a17 = 18.0;
  a18 = -19.0;
  a19 = 20.0;
 
  std::cout << "Calling TestVariadicAt1Doublex20(" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ", " << a5 << ", "
            << a6 << ", " << a7 << ", " << a8 << ", " << a9 << ", " << a10
            << ", " << a11 << ", " << a12 << ", " << a13 << ", " << a14 << ", "
            << a15 << ", " << a16 << ", " << a17 << ", " << a18 << ", " << a19
            << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
                    a14, a15, a16, a17, a18, a19);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(10.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
             a15, a16, a17, a18, a19);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
             a15, a16, a17, a18, a19);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1Doublex2Struct32BytesHomogeneousDoubleD()

DART_EXPORT intptr_t dart::TestVariadicAt1Doublex2Struct32BytesHomogeneousDoubleD

(

double(*)(double a0,...)

f

)

Definition at line 23397 of file ffi_test_functions_generated.cc.

                                 {
  double a0;
  double a1;
  Struct32BytesHomogeneousDouble a2 = {};
  double a3;
 
  a0 = -1.0;
  a1 = 2.0;
  a2.a0 = -3.0;
  a2.a1 = 4.0;
  a2.a2 = -5.0;
  a2.a3 = 6.0;
  a3 = -7.0;
 
  std::cout << "Calling TestVariadicAt1Doublex2Struct32BytesHomogeneousDoubleD("
            << "(" << a0 << ", " << a1 << ", (" << a2.a0 << ", " << a2.a1
            << ", " << a2.a2 << ", " << a2.a3 << "), " << a3 << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-4.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1Doublex5()

DART_EXPORT intptr_t dart::TestVariadicAt1Doublex5

(

double(*)(double a0,...)

f

)

Definition at line 23150 of file ffi_test_functions_generated.cc.

                                 {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
 
  std::cout << "Calling TestVariadicAt1Doublex5(" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-3.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1Int32Struct20BytesHomogeneousInt32Int32()

DART_EXPORT intptr_t dart::TestVariadicAt1Int32Struct20BytesHomogeneousInt32Int32

(

int32_t(*)(int32_t a0,...)

f

)

Definition at line 23484 of file ffi_test_functions_generated.cc.

                                   {
  int32_t a0;
  Struct20BytesHomogeneousInt32 a1 = {};
  int32_t a2;
 
  a0 = -1;
  a1.a0 = 2;
  a1.a1 = -3;
  a1.a2 = 4;
  a1.a3 = -5;
  a1.a4 = 6;
  a2 = -7;
 
  std::cout << "Calling TestVariadicAt1Int32Struct20BytesHomogeneousInt32Int32("
            << "(" << a0 << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2
            << ", " << a1.a3 << ", " << a1.a4 << "), " << a2 << ")" << ")\n";
 
  int32_t result = f(a0, a1, a2);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(-4, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestVariadicAt1Int64Int32Struct12BytesHomogeneousFloat()

DART_EXPORT intptr_t dart::TestVariadicAt1Int64Int32Struct12BytesHomogeneousFloat

(

double(*)(int64_t a0,...)

f

)

Definition at line 23658 of file ffi_test_functions_generated.cc.

                                  {
  int64_t a0;
  int32_t a1;
  Struct12BytesHomogeneousFloat a2 = {};
 
  a0 = -1;
  a1 = 2;
  a2.a0 = -3.0;
  a2.a1 = 4.0;
  a2.a2 = -5.0;
 
  std::cout << "Calling TestVariadicAt1Int64Int32Struct12BytesHomogeneousFloat("
            << "(" << a0 << ", " << a1 << ", (" << a2.a0 << ", " << a2.a1
            << ", " << a2.a2 << "))" << ")\n";
 
  double result = f(a0, a1, a2);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-3.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestVariadicAt1Int64x2()

DART_EXPORT intptr_t dart::TestVariadicAt1Int64x2

(

int64_t(*)(int64_t a0,...)

f

)

Definition at line 23033 of file ffi_test_functions_generated.cc.

                                   {
  int64_t a0;
  int64_t a1;
 
  a0 = -1;
  a1 = 2;
 
  std::cout << "Calling TestVariadicAt1Int64x2(" << "(" << a0 << ", " << a1
            << ")" << ")\n";
 
  int64_t result = f(a0, a1);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(1, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestVariadicAt1Int64x20()

DART_EXPORT intptr_t dart::TestVariadicAt1Int64x20

(

int64_t(*)(int64_t a0,...)

f

)

Definition at line 23193 of file ffi_test_functions_generated.cc.

                                   {
  int64_t a0;
  int64_t a1;
  int64_t a2;
  int64_t a3;
  int64_t a4;
  int64_t a5;
  int64_t a6;
  int64_t a7;
  int64_t a8;
  int64_t a9;
  int64_t a10;
  int64_t a11;
  int64_t a12;
  int64_t a13;
  int64_t a14;
  int64_t a15;
  int64_t a16;
  int64_t a17;
  int64_t a18;
  int64_t a19;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7 = 8;
  a8 = -9;
  a9 = 10;
  a10 = -11;
  a11 = 12;
  a12 = -13;
  a13 = 14;
  a14 = -15;
  a15 = 16;
  a16 = -17;
  a17 = 18;
  a18 = -19;
  a19 = 20;
 
  std::cout << "Calling TestVariadicAt1Int64x20(" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ", " << a5 << ", "
            << a6 << ", " << a7 << ", " << a8 << ", " << a9 << ", " << a10
            << ", " << a11 << ", " << a12 << ", " << a13 << ", " << a14 << ", "
            << a15 << ", " << a16 << ", " << a17 << ", " << a18 << ", " << a19
            << ")" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
                     a14, a15, a16, a17, a18, a19);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(10, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
             a15, a16, a17, a18, a19);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
             a15, a16, a17, a18, a19);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestVariadicAt1Int64x2Struct8BytesIntInt64()

DART_EXPORT intptr_t dart::TestVariadicAt1Int64x2Struct8BytesIntInt64

(

int64_t(*)(int64_t a0,...)

f

)

Definition at line 23353 of file ffi_test_functions_generated.cc.

                                   {
  int64_t a0;
  int64_t a1;
  Struct8BytesInt a2 = {};
  int64_t a3;
 
  a0 = -1;
  a1 = 2;
  a2.a0 = -3;
  a2.a1 = 4;
  a2.a2 = -5;
  a3 = 6;
 
  std::cout << "Calling TestVariadicAt1Int64x2Struct8BytesIntInt64(" << "("
            << a0 << ", " << a1 << ", (" << a2.a0 << ", " << a2.a1 << ", "
            << a2.a2 << "), " << a3 << ")" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(3, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestVariadicAt1Int64x5()

DART_EXPORT intptr_t dart::TestVariadicAt1Int64x5

(

int64_t(*)(int64_t a0,...)

f

)

Definition at line 23107 of file ffi_test_functions_generated.cc.

                                   {
  int64_t a0;
  int64_t a1;
  int64_t a2;
  int64_t a3;
  int64_t a4;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
 
  std::cout << "Calling TestVariadicAt1Int64x5(" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ")" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(-3, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestVariadicAt1Int64x7Struct12BytesHomogeneousInt32()

DART_EXPORT intptr_t dart::TestVariadicAt1Int64x7Struct12BytesHomogeneousInt32

(

int64_t(*)(int64_t a0,...)

f

)

Definition at line 23881 of file ffi_test_functions_generated.cc.

                                   {
  int64_t a0;
  int64_t a1;
  int64_t a2;
  int64_t a3;
  int64_t a4;
  int64_t a5;
  int64_t a6;
  Struct12BytesHomogeneousInt32 a7 = {};
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;
  a5 = 6;
  a6 = -7;
  a7.a0 = 8;
  a7.a1 = -9;
  a7.a2 = 10;
 
  std::cout << "Calling TestVariadicAt1Int64x7Struct12BytesHomogeneousInt32("
            << "(" << a0 << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4
            << ", " << a5 << ", " << a6 << ", (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << "))" << ")\n";
 
  int64_t result = f(a0, a1, a2, a3, a4, a5, a6, a7);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(5, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4, a5, a6, a7);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestVariadicAt1Struct12BytesHomogeneousInt32Int32x4()

DART_EXPORT intptr_t dart::TestVariadicAt1Struct12BytesHomogeneousInt32Int32x4

(

int32_t(*)(Struct12BytesHomogeneousInt32 a0,...)

f

)

Definition at line 23934 of file ffi_test_functions_generated.cc.

                                                         {
  Struct12BytesHomogeneousInt32 a0 = {};
  int32_t a1;
  int32_t a2;
  int32_t a3;
  int32_t a4;
 
  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;
  a1 = 4;
  a2 = -5;
  a3 = 6;
  a4 = -7;
 
  std::cout << "Calling TestVariadicAt1Struct12BytesHomogeneousInt32Int32x4("
            << "((" << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << "), " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ")" << ")\n";
 
  int32_t result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(-4, result);
 
  // Pass argument that will make the Dart callback throw.
  a0.a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0.a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestVariadicAt2Int32Int64IntPtr()

DART_EXPORT intptr_t dart::TestVariadicAt2Int32Int64IntPtr

(

int32_t(*)(int32_t a0, int64_t a1,...)

f

)

Definition at line 23573 of file ffi_test_functions_generated.cc.

                                               {
  int32_t a0;
  int64_t a1;
  intptr_t a2;
 
  a0 = -1;
  a1 = 2;
  a2 = -3;
 
  std::cout << "Calling TestVariadicAt2Int32Int64IntPtr(" << "(" << a0 << ", "
            << a1 << ", " << a2 << ")" << ")\n";
 
  int32_t result = f(a0, a1, a2);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_EQ(-2, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2);
 
  CHECK_EQ(0, result);
 
  return 0;
}

TestVariadicAt5Doublex5()

DART_EXPORT intptr_t dart::TestVariadicAt5Doublex5

(

double(*)(double a0, double a1, double a2, double a3, double a4,...)

f

)

Definition at line 23838 of file ffi_test_functions_generated.cc.

                                                                             {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;
 
  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;
 
  std::cout << "Calling TestVariadicAt5Doublex5(" << "(" << a0 << ", " << a1
            << ", " << a2 << ", " << a3 << ", " << a4 << ")" << ")\n";
 
  double result = f(a0, a1, a2, a3, a4);
 
  std::cout << "result = " << result << "\n";
 
  CHECK_APPROX(-3.0, result);
 
  // Pass argument that will make the Dart callback throw.
  a0 = 42;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  // Pass argument that will make the Dart callback return null.
  a0 = 84;
 
  result = f(a0, a1, a2, a3, a4);
 
  CHECK_APPROX(0.0, result);
 
  return 0;
}

TestWBEForArrays()

static void dart::TestWBEForArrays ( int  length )

static

Definition at line 122 of file write_barrier_elimination_test.cc.

                                 {
      kMoveGlob,
      kMatchAndMoveBranchFalse,
      kMoveGlob,
      kMatchAndMoveGoto,
      kMoveGlob,
      {kMatchAndMoveStoreField, &store},
  }));
 
  EXPECT(store->ShouldEmitStoreBarrier() == true);
}
 
static void TestWBEForArrays(int length) {
  DEBUG_ONLY(
      SetFlagScope<bool> sfs(&FLAG_trace_write_barrier_elimination, true));
  const char* nullable_tag = TestCase::NullableTag();
 
  // Test that array allocations are considered usable after a
  // may-trigger-GC instruction (in this case CheckStackOverflow) iff they
  // are small.
  // clang-format off
  auto kScript =
      Utils::CStringUniquePtr(OS::SCreate(nullptr, R"(
      class C {
        %s C next;
      }
 
      @pragma("vm:never-inline")
      fn() {}
 
      foo(int x) {
        C c = C();
        C n = C();
        List<C%s> array = List<C%s>.filled(%d, null);
        array[0] = c;
        while (x --> 0) {
          c.next = n;
          n = c;
          c = C();
        }
        array[0] = c;
        return array;
      }
 
      main() { foo(10); }
      )", TestCase::LateTag(), nullable_tag, nullable_tag, length), std::free);
  // clang-format on
 
  // Generate a length dependent test library uri.
  char lib_uri[256];
  snprintf(lib_uri, sizeof(lib_uri), "%s%d", RESOLVED_USER_TEST_URI, length);
 
  const auto& root_library = Library::Handle(
      LoadTestScript(kScript.get(), /*resolver=*/nullptr, lib_uri));
 
  Invoke(root_library, "main");
 
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* flow_graph = pipeline.RunPasses({});
 
  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);
 
  StoreFieldInstr* store_into_c = nullptr;
  StoreIndexedInstr* store_into_array_before_loop = nullptr;
  StoreIndexedInstr* store_into_array_after_loop = nullptr;
 
  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveStoreIndexed, &store_into_array_before_loop},

THREAD_POOL_UNIT_TEST_CASE() [1/6]

dart::THREAD_POOL_UNIT_TEST_CASE

(

ThreadPool_Create

)

Definition at line 31 of file thread_pool_test.cc.

                                              {
  ThreadPool thread_pool;
}

THREAD_POOL_UNIT_TEST_CASE() [2/6]

dart::THREAD_POOL_UNIT_TEST_CASE

(

ThreadPool_RecursiveSpawn

)

Definition at line 243 of file thread_pool_test.cc.

                                                      {
  ThreadPool thread_pool;
  Monitor sync;
  const int kTotalTasks = 500;
  int done = 0;
  thread_pool.Run<SpawnTask>(&thread_pool, &sync, kTotalTasks, kTotalTasks,
                             &done);
  {
    MonitorLocker ml(&sync);
    while (done < kTotalTasks) {
      ml.Wait();
    }
  }
  EXPECT_EQ(kTotalTasks, done);
}

THREAD_POOL_UNIT_TEST_CASE() [3/6]

dart::THREAD_POOL_UNIT_TEST_CASE

(

ThreadPool_RunMany

)

Definition at line 80 of file thread_pool_test.cc.

                                               {
  const int kTaskCount = 100;
  ThreadPool thread_pool;
  Monitor sync[kTaskCount];
  bool done[kTaskCount];
 
  for (int i = 0; i < kTaskCount; i++) {
    done[i] = true;
    thread_pool.Run<TestTask>(&sync[i], &done[i]);
  }
  for (int i = 0; i < kTaskCount; i++) {
    MonitorLocker ml(&sync[i]);
    done[i] = false;
    ml.Notify();
    while (!done[i]) {
      ml.Wait();
    }
    EXPECT(done[i]);
  }
}

THREAD_POOL_UNIT_TEST_CASE() [4/6]

dart::THREAD_POOL_UNIT_TEST_CASE

(

ThreadPool_RunOne

)

Definition at line 60 of file thread_pool_test.cc.

                                              {
  ThreadPool thread_pool;
  Monitor sync;
  bool done = true;
  thread_pool.Run<TestTask>(&sync, &done);
  {
    MonitorLocker ml(&sync);
    done = false;
    ml.Notify();
    while (!done) {
      ml.Wait();
    }
  }
  EXPECT(done);
 
  // Do a sanity test on the worker stats.
  EXPECT_EQ(1U, thread_pool.workers_started());
  EXPECT_EQ(0U, thread_pool.workers_stopped());
}

THREAD_POOL_UNIT_TEST_CASE() [5/6]

dart::THREAD_POOL_UNIT_TEST_CASE

(

ThreadPool_WorkerShutdown

)

Definition at line 133 of file thread_pool_test.cc.

                                                      {
  const int kTaskCount = 10;
  Monitor sync;
  int slept_count = 0;
  int started_count = 0;
 
  // Set up the ThreadPool so that workers notify before they exit.
  ThreadPool* thread_pool = new ThreadPool();
 
  // Run a single task.
  for (int i = 0; i < kTaskCount; i++) {
    thread_pool->Run<SleepTask>(&sync, &started_count, &slept_count, 2);
  }
 
  {
    // Wait for everybody to start.
    MonitorLocker ml(&sync);
    while (started_count < kTaskCount) {
      ml.Wait();
    }
  }
 
  // Kill the thread pool while the workers are sleeping.
  delete thread_pool;
  thread_pool = nullptr;
 
  int final_count = 0;
  {
    MonitorLocker ml(&sync);
    final_count = slept_count;
  }
 
  // We should have waited for all the workers to finish, so they all should
  // have had a chance to increment slept_count.
  EXPECT_EQ(kTaskCount, final_count);
}

THREAD_POOL_UNIT_TEST_CASE() [6/6]

dart::THREAD_POOL_UNIT_TEST_CASE

(

ThreadPool_WorkerTimeout

)

Definition at line 170 of file thread_pool_test.cc.

                                                     {
  // Adjust the worker timeout so that we timeout quickly.
  int saved_timeout = FLAG_worker_timeout_millis;
  FLAG_worker_timeout_millis = 1;
 
  {
    ThreadPool thread_pool;
    EXPECT_EQ(0U, thread_pool.workers_started());
    EXPECT_EQ(0U, thread_pool.workers_stopped());
 
    // Run a worker.
    Monitor sync;
    bool done = true;
    thread_pool.Run<TestTask>(&sync, &done);
    EXPECT_EQ(1U, thread_pool.workers_started());
    EXPECT_EQ(0U, thread_pool.workers_stopped());
    {
      MonitorLocker ml(&sync);
      done = false;
      ml.Notify();
      while (!done) {
        ml.Wait();
      }
    }
    EXPECT(done);
 
    // Wait up to 5 seconds to see if a worker times out.
    const int kMaxWait = 5000;
    int waited = 0;
    while (thread_pool.workers_stopped() == 0 && waited < kMaxWait) {
      OS::Sleep(1);
      waited += 1;
    }
    EXPECT_EQ(1U, thread_pool.workers_stopped());
  }
 
  FLAG_worker_timeout_millis = saved_timeout;
}

ThreadIteratorTestMain()

void dart::ThreadIteratorTestMain

(

uword

parameter

)

Definition at line 739 of file thread_test.cc.

                                             {
  ThreadIteratorTestParams* params =
      reinterpret_cast<ThreadIteratorTestParams*>(parameter);
  OSThread* thread = OSThread::Current();
  EXPECT(thread != nullptr);
 
  MonitorLocker ml(params->monitor);
  params->spawned_thread_id = thread->id();
  params->spawned_thread_join_id = OSThread::GetCurrentThreadJoinId(thread);
  EXPECT(params->spawned_thread_id != OSThread::kInvalidThreadId);
  EXPECT(OSThread::IsThreadInList(thread->id()));
  ml.Notify();
}

ThreadPoolTest_BarrierSync()

DART_EXPORT void dart::ThreadPoolTest_BarrierSync	(	Dart_Isolate(*)()	dart_current_isolate,
		void(*)(Dart_Isolate)	dart_enter_isolate,
		void(*)()	dart_exit_isolate,
		intptr_t	num_threads
	)

Definition at line 890 of file ffi_test_functions_vmspecific.cc.

                          {
  // Guaranteed to be initialized exactly once (no race between multiple
  // threads).
  static std::mutex mutex;
  static std::condition_variable cvar;
  static intptr_t thread_count = 0;
 
  const Dart_Isolate isolate = dart_current_isolate();
  dart_exit_isolate();
  {
    std::unique_lock<std::mutex> lock(mutex);
    ++thread_count;
    while (thread_count < num_threads) {
      cvar.wait(lock);
    }
    cvar.notify_all();
  }
  dart_enter_isolate(isolate);
}

ThrowArgumentError()

static ObjectPtr dart::ThrowArgumentError ( const char *  exception_message )

static

Definition at line 3332 of file dart_api_impl.cc.

                                                                   {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  // Lookup the class ArgumentError in dart:core.
  const String& lib_url = String::Handle(String::New("dart:core"));
  const String& class_name = String::Handle(String::New("ArgumentError"));
  const Library& lib =
      Library::Handle(zone, Library::LookupLibrary(thread, lib_url));
  if (lib.IsNull()) {
    const String& message = String::Handle(String::NewFormatted(
        "%s: library '%s' not found.", CURRENT_FUNC, lib_url.ToCString()));
    return ApiError::New(message);
  }
  const Class& cls =
      Class::Handle(zone, lib.LookupClassAllowPrivate(class_name));
  ASSERT(!cls.IsNull());
  Object& result = Object::Handle(zone);
  String& dot_name = String::Handle(String::New("."));
  String& constr_name = String::Handle(String::Concat(class_name, dot_name));
  result = ResolveConstructor(CURRENT_FUNC, cls, class_name, constr_name, 1);
  if (result.IsError()) return result.ptr();
  ASSERT(result.IsFunction());
  Function& constructor = Function::Handle(zone);
  constructor ^= result.ptr();
  if (!constructor.IsGenerativeConstructor()) {
    const String& message = String::Handle(
        String::NewFormatted("%s: class '%s' is not a constructor.",
                             CURRENT_FUNC, class_name.ToCString()));
    return ApiError::New(message);
  }
  Instance& exception = Instance::Handle(zone);
  exception = Instance::New(cls);
  const Array& args = Array::Handle(zone, Array::New(2));
  args.SetAt(0, exception);
  args.SetAt(1, String::Handle(String::New(exception_message)));
  result = DartEntry::InvokeFunction(constructor, args);
  if (result.IsError()) return result.ptr();
  ASSERT(result.IsNull());
 
  if (thread->top_exit_frame_info() == 0) {
    // There are no dart frames on the stack so it would be illegal to
    // throw an exception here.
    const String& message = String::Handle(
        String::New("No Dart frames on stack, cannot throw exception"));
    return ApiError::New(message);
  }
  // Unwind all the API scopes till the exit frame before throwing an
  // exception.
  const Instance* saved_exception;
  {
    NoSafepointScope no_safepoint;
    InstancePtr raw_exception = exception.ptr();
    thread->UnwindScopes(thread->top_exit_frame_info());
    saved_exception = &Instance::Handle(raw_exception);
  }
  Exceptions::Throw(thread, *saved_exception);
  const String& message =
      String::Handle(String::New("Exception was not thrown, internal error"));
  return ApiError::New(message);
}

ThrowExceptionHelper()

static DART_NORETURN void dart::ThrowExceptionHelper ( Thread *  thread, const Instance &  incoming_exception, const Instance &  existing_stacktrace, const bool  is_rethrow, const bool  bypass_debugger  )

static

Definition at line 731 of file exceptions.cc.

                                                             {
  // SuspendLongJumpScope during Dart entry ensures that if a longjmp base is
  // available, it is the innermost error handler. If one is available, so
  // should jump there instead.
  RELEASE_ASSERT(thread->long_jump_base() == nullptr);
  Zone* zone = thread->zone();
  auto object_store = thread->isolate_group()->object_store();
  Isolate* isolate = thread->isolate();
#if !defined(PRODUCT)
  if (!bypass_debugger) {
    // Do not notify debugger on stack overflow and out of memory exceptions.
    // The VM would crash when the debugger calls back into the VM to
    // get values of variables.
    if (incoming_exception.ptr() != object_store->out_of_memory() &&
        incoming_exception.ptr() != object_store->stack_overflow()) {
      isolate->debugger()->PauseException(incoming_exception);
    }
  }
#endif
  bool use_preallocated_stacktrace = false;
  Instance& exception = Instance::Handle(zone, incoming_exception.ptr());
  if (exception.IsNull()) {
    const Array& args = Array::Handle(zone, Array::New(4));
    const Smi& line_col = Smi::Handle(zone, Smi::New(-1));
    args.SetAt(0, Symbols::OptimizedOut());
    args.SetAt(1, line_col);
    args.SetAt(2, line_col);
    args.SetAt(3, String::Handle(String::New("Throw of null.")));
    exception ^= Exceptions::Create(Exceptions::kType, args);
  } else if (existing_stacktrace.IsNull() &&
             (exception.ptr() == object_store->out_of_memory() ||
              exception.ptr() == object_store->stack_overflow())) {
    use_preallocated_stacktrace = true;
  }
  // Find the exception handler and determine if the handler needs a
  // stacktrace.
  ExceptionHandlerFinder finder(thread);
  bool handler_exists = finder.Find();
  uword handler_pc = finder.handler_pc;
  uword handler_sp = finder.handler_sp;
  uword handler_fp = finder.handler_fp;
  bool handler_needs_stacktrace = finder.needs_stacktrace;
  Instance& stacktrace = Instance::Handle(zone);
  if (use_preallocated_stacktrace) {
    if (handler_pc == 0) {
      // No Dart frame.
      ASSERT(incoming_exception.ptr() == object_store->out_of_memory());
      const UnhandledException& error = UnhandledException::Handle(
          zone,
          isolate->isolate_object_store()->preallocated_unhandled_exception());
      thread->long_jump_base()->Jump(1, error);
      UNREACHABLE();
    }
    stacktrace = isolate->isolate_object_store()->preallocated_stack_trace();
    PreallocatedStackTraceBuilder frame_builder(stacktrace);
    ASSERT(existing_stacktrace.IsNull() ||
           (existing_stacktrace.ptr() == stacktrace.ptr()));
    ASSERT(existing_stacktrace.IsNull() || is_rethrow);
    if (handler_needs_stacktrace && existing_stacktrace.IsNull()) {
      BuildStackTrace(&frame_builder);
    }
  } else {
    if (!existing_stacktrace.IsNull()) {
      stacktrace = existing_stacktrace.ptr();
      // If this is not a rethrow, it's a "throw with stacktrace".
      // Set an Error object's stackTrace field if needed.
      if (!is_rethrow) {
        const Field& stacktrace_field =
            Field::Handle(zone, LookupStackTraceField(exception));
        if (!stacktrace_field.IsNull() &&
            (exception.GetField(stacktrace_field) == Object::null())) {
          exception.SetField(stacktrace_field, stacktrace);
        }
      }
    } else {
      // Get stacktrace field of class Error to determine whether we have a
      // subclass of Error which carries around its stack trace.
      const Field& stacktrace_field =
          Field::Handle(zone, LookupStackTraceField(exception));
      if (!stacktrace_field.IsNull() || handler_needs_stacktrace) {
        // Collect the stacktrace if needed.
        ASSERT(existing_stacktrace.IsNull());
        stacktrace = Exceptions::CurrentStackTrace();
        // If we have an Error object, then set its stackTrace field only if it
        // not yet initialized.
        if (!stacktrace_field.IsNull() &&
            (exception.GetField(stacktrace_field) == Object::null())) {
          exception.SetField(stacktrace_field, stacktrace);
        }
      }
    }
  }
  // We expect to find a handler_pc, if the exception is unhandled
  // then we expect to at least have the dart entry frame on the
  // stack as Exceptions::Throw should happen only after a dart
  // invocation has been done.
  ASSERT(handler_pc != 0);
 
  if (FLAG_print_stacktrace_at_throw) {
    THR_Print("Exception '%s' thrown:\n", exception.ToCString());
    THR_Print("%s\n", stacktrace.ToCString());
  }
  if (handler_exists) {
    finder.PrepareFrameForCatchEntry();
    // Found a dart handler for the exception, jump to it.
    JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp,
                           exception, stacktrace);
  } else {
    // No dart exception handler found in this invocation sequence,
    // so we create an unhandled exception object and return to the
    // invocation stub so that it returns this unhandled exception
    // object. The C++ code which invoked this dart sequence can check
    // and do the appropriate thing (rethrow the exception to the
    // dart invocation sequence above it, print diagnostics and terminate
    // the isolate etc.). This can happen in the compiler, which is not
    // allowed to allocate in new space, so we pass the kOld argument.
    const UnhandledException& unhandled_exception = UnhandledException::Handle(
        zone, exception.ptr() == object_store->out_of_memory()
                  ? isolate->isolate_object_store()
                        ->preallocated_unhandled_exception()
                  : UnhandledException::New(exception, stacktrace, Heap::kOld));
    stacktrace = StackTrace::null();
    JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp,
                           unhandled_exception, stacktrace);
  }
  UNREACHABLE();
}

ThrowFfiResolveError()

static void dart::ThrowFfiResolveError ( const String &  symbol, const String &  asset, char *  error  )

static

Definition at line 461 of file ffi_dynamic_library.cc.

                                              {
  const String& error_message = String::Handle(String::NewFormatted(
      "Couldn't resolve native function '%s' in '%s' : %s.\n",
      symbol.ToCString(), asset.ToCString(), error));
  free(error);
  Exceptions::ThrowArgumentError(error_message);
}

ThrowIfError()

static void dart::ThrowIfError ( const Object &  result )

static

Definition at line 524 of file runtime_entry.cc.

                                               {
  if (!result.IsNull() && result.IsError()) {
    Exceptions::PropagateError(Error::Cast(result));
  }
}

ThrowIsolateSpawnException()

static void dart::ThrowIsolateSpawnException ( const String &  message )

static

Definition at line 553 of file isolate.cc.

                                                              {
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, message);
  Exceptions::ThrowByType(Exceptions::kIsolateSpawn, args);
}

ThrowLanguageError()

static void dart::ThrowLanguageError ( const char *  message )

static

Definition at line 670 of file mirrors.cc.

                                                    {
  const Error& error =
      Error::Handle(LanguageError::New(String::Handle(String::New(message))));
  Exceptions::PropagateError(error);
}

ThrowMaskRangeException()

static void dart::ThrowMaskRangeException ( int64_t  m )

static

Definition at line 14 of file simd128.cc.

                                               {
  if ((m < 0) || (m > 255)) {
    Exceptions::ThrowRangeError("mask", Integer::Handle(Integer::New(m)), 0,
                                255);
  }
}

ThrowNoSuchMethod() [1/2]

static void dart::ThrowNoSuchMethod ( const Instance &  receiver, const String &  function_name, const Array &  arguments, const Array &  argument_names, const InvocationMirror::Level  level, const InvocationMirror::Kind  kind  )

static

Definition at line 49 of file mirrors.cc.

                                                               {
  const Smi& invocation_type =
      Smi::Handle(Smi::New(InvocationMirror::EncodeType(level, kind)));
 
  const Array& args = Array::Handle(Array::New(7));
  args.SetAt(0, receiver);
  args.SetAt(1, function_name);
  args.SetAt(2, invocation_type);
  args.SetAt(3, Object::smi_zero());  // Type arguments length.
  args.SetAt(4, Object::null_type_arguments());
  args.SetAt(5, arguments);
  args.SetAt(6, argument_names);
 
  const Library& libcore = Library::Handle(Library::CoreLibrary());
  const Class& cls =
      Class::Handle(libcore.LookupClass(Symbols::NoSuchMethodError()));
  const auto& error = cls.EnsureIsFinalized(Thread::Current());
  ASSERT(error == Error::null());
  const Function& throwNew =
      Function::Handle(cls.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
  const Object& result =
      Object::Handle(DartEntry::InvokeFunction(throwNew, args));
  ASSERT(result.IsError());
  Exceptions::PropagateError(Error::Cast(result));
  UNREACHABLE();
}

ThrowNoSuchMethod() [2/2]

static ObjectPtr dart::ThrowNoSuchMethod ( const Instance &  receiver, const String &  function_name, const Array &  arguments, const Array &  argument_names, const InvocationMirror::Level  level, const InvocationMirror::Kind  kind  )

static

Definition at line 4520 of file object.cc.

                                                                    {
  const Smi& invocation_type =
      Smi::Handle(Smi::New(InvocationMirror::EncodeType(level, kind)));
 
  ASSERT(!receiver.IsNull() || level == InvocationMirror::Level::kTopLevel);
  ASSERT(level != InvocationMirror::Level::kTopLevel || receiver.IsString());
  const Array& args = Array::Handle(Array::New(7));
  args.SetAt(0, receiver);
  args.SetAt(1, function_name);
  args.SetAt(2, invocation_type);
  args.SetAt(3, Object::smi_zero());  // Type arguments length.
  args.SetAt(4, Object::null_type_arguments());
  args.SetAt(5, arguments);
  args.SetAt(6, argument_names);
 
  const Library& libcore = Library::Handle(Library::CoreLibrary());
  const Class& cls =
      Class::Handle(libcore.LookupClass(Symbols::NoSuchMethodError()));
  ASSERT(!cls.IsNull());
  const auto& error = cls.EnsureIsFinalized(Thread::Current());
  ASSERT(error == Error::null());
  const Function& throwNew =
      Function::Handle(cls.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
  return DartEntry::InvokeFunction(throwNew, args);
}

ThrowOnReturnOfError()

DART_EXPORT Dart_Handle dart::ThrowOnReturnOfError

(

Dart_Handle(*)()

callback

)

Definition at line 1071 of file ffi_test_functions_vmspecific.cc.

                                                                        {
  Dart_Handle result = callback();
  const bool is_error = Dart_IsError(result);
  printf("ThrowOnReturnOfError is_error %s\n", is_error ? "true" : "false");
  return result;
}

ThrowTypeError()

static ObjectPtr dart::ThrowTypeError ( const TokenPosition  token_pos, const Instance &  src_value, const AbstractType &  dst_type, const String &  dst_name  )

static

Definition at line 4551 of file object.cc.

                                                        {
  const Array& args = Array::Handle(Array::New(4));
  const Smi& pos = Smi::Handle(Smi::New(token_pos.Serialize()));
  args.SetAt(0, pos);
  args.SetAt(1, src_value);
  args.SetAt(2, dst_type);
  args.SetAt(3, dst_name);
 
  const Library& libcore = Library::Handle(Library::CoreLibrary());
  const Class& cls =
      Class::Handle(libcore.LookupClassAllowPrivate(Symbols::TypeError()));
  const auto& error = cls.EnsureIsFinalized(Thread::Current());
  ASSERT(error == Error::null());
  const Function& throwNew =
      Function::Handle(cls.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
  return DartEntry::InvokeFunction(throwNew, args);
}

Times1_337Double()

DART_EXPORT double dart::Times1_337Double

(

double

a

)

Definition at line 255 of file ffi_test_functions.cc.

                                              {
  std::cout << "Times1_337Double(" << a << ")\n";
  const double retval = a * 1.337;
  std::cout << "returning " << retval << "\n";
  return retval;
}

Times1_337Float()

DART_EXPORT float dart::Times1_337Float

(

float

a

)

Definition at line 264 of file ffi_test_functions.cc.

                                           {
  std::cout << "Times1_337Float(" << a << ")\n";
  const float retval = a * 1.337f;
  std::cout << "returning " << retval << "\n";
  return retval;
}

Times3()

DART_EXPORT intptr_t dart::Times3

(

intptr_t

a

)

Definition at line 244 of file ffi_test_functions.cc.

                                        {
  std::cout << "Times3(" << a << ")\n";
  const intptr_t retval = a * 3;
  std::cout << "returning " << retval << "\n";
  return retval;
}

ToContextIndex()

static intptr_t dart::ToContextIndex ( intptr_t  offset_in_bytes )

static

Definition at line 285 of file deferred_objects.cc.

                                                         {
  intptr_t result = (offset_in_bytes - Context::variable_offset(0)) /
                    Context::kBytesPerElement;
  ASSERT(result >= 0);
  return result;
}

ToDouble()

static double dart::ToDouble ( const Object &  value )

static

Definition at line 1288 of file constant_propagator.cc.

                                            {
  return value.IsInteger() ? Integer::Cast(value).AsDoubleValue()
                           : Double::Cast(value).value();
}

ToInstructionEnd()

static intptr_t dart::ToInstructionEnd ( intptr_t  pos )

static

Definition at line 54 of file linearscan.cc.

                                               {
  return (pos | 1);
}

ToInstructionStart()

static intptr_t dart::ToInstructionStart ( intptr_t  pos )

static

Definition at line 50 of file linearscan.cc.

                                                 {
  return (pos & ~1);
}

TopDartFrame()

static ActivationFrame * dart::TopDartFrame ( )

static

Definition at line 1779 of file debugger.cc.

                                       {
  StackFrameIterator iterator(ValidationPolicy::kDontValidateFrames,
                              Thread::Current(),
                              StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame;
  while (true) {
    frame = iterator.NextFrame();
    RELEASE_ASSERT(frame != nullptr);
    if (!frame->IsDartFrame()) {
      continue;
    }
    Code& code = Code::Handle(frame->LookupDartCode());
    ActivationFrame* activation = new ActivationFrame(
        frame->pc(), frame->fp(), frame->sp(), code, Object::null_array(), 0);
    return activation;
  }
}

ToScaleFactor()

static ScaleFactor dart::ToScaleFactor ( intptr_t  index_scale, bool  index_unboxed  )

inlinestatic

Definition at line 95 of file constants.h.

                                                            {
  RELEASE_ASSERT(index_scale >= 0);
  const intptr_t shift = Utils::ShiftForPowerOfTwo(index_scale) -
                         (index_unboxed ? 0 : kSmiTagShift);
  // index_scale < kSmiTagShift for boxed indexes must be handled by the caller,
  // and ScaleFactor is currently only defined up to TIMES_16 == 4.
  RELEASE_ASSERT(shift >= 0 && shift <= 4);
  return static_cast<ScaleFactor>(shift);
}

ToStdString()

std::string dart::ToStdString

(

const String &

str

)

Definition at line 116 of file hash_table_test.cc.

                                         {
  EXPECT(str.IsOneByteString());
  std::string result;
  for (intptr_t i = 0; i < str.Length(); ++i) {
    result += static_cast<char>(str.CharAt(i));
  }
  return result;
}

TracePolyInlining()

static void dart::TracePolyInlining ( const CallTargets &  targets, intptr_t  idx, intptr_t  total, const char *  message  )

static

Definition at line 2302 of file inliner.cc.

                                                   {
  String& name =
      String::Handle(targets.TargetAt(idx)->target->QualifiedUserVisibleName());
  int percent = total == 0 ? 0 : (100 * targets.TargetAt(idx)->count) / total;
  THR_Print("%s cid %" Pd "-%" Pd ": %" Pd "/%" Pd " %d%% %s\n",
            name.ToCString(), targets[idx].cid_start, targets[idx].cid_end,
            targets.TargetAt(idx)->count, total, percent, message);
}

TraceStrongModeType() [1/2]

static void dart::TraceStrongModeType ( const Instruction *  instr, CompileType *  compileType  )

static

Definition at line 31 of file type_propagator.cc.

                                                          {
  if (FLAG_trace_strong_mode_types) {
    const AbstractType* type = compileType->ToAbstractType();
    if ((type != nullptr) && !type->IsDynamicType()) {
      TraceStrongModeType(instr, *type);
    }
  }
}

TraceStrongModeType() [2/2]

static void dart::TraceStrongModeType ( const Instruction *  instr, const AbstractType &  type  )

static

Definition at line 23 of file type_propagator.cc.

                                                          {
  if (FLAG_trace_strong_mode_types) {
    THR_Print("[Strong mode] Type of %s - %s\n", instr->ToCString(),
              type.ToCString());
  }
}

TransferableTypedDataFinalizer()

static void dart::TransferableTypedDataFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 25909 of file object.cc.

                                                       {
  delete (reinterpret_cast<TransferableTypedDataPeer*>(peer));
}

TransposeCoordinate()

DART_EXPORT Coord * dart::TransposeCoordinate

(

Coord *

coord

)

Definition at line 552 of file ffi_test_functions.cc.

                                                     {
  std::cout << "TransposeCoordinate(" << coord << " {" << coord->x << ", "
            << coord->y << ", " << coord->next << "})\n";
  coord->x = coord->x + 10.0;
  coord->y = coord->y + 10.0;
  std::cout << "returning " << coord->next << "\n";
  return coord->next;
}

TriggerEchoEvent()

static void dart::TriggerEchoEvent ( Thread *  thread, JSONStream *  js  )

static

Definition at line 1777 of file service.cc.

                                                             {
  if (Service::echo_stream.enabled()) {
    Service::SendEchoEvent(thread->isolate(), js->LookupParam("text"));
  }
  JSONObject jsobj(js);
  HandleCommonEcho(&jsobj, js);
}

TriggerGC()

DART_EXPORT void dart::TriggerGC

(

uint64_t

count

)

Definition at line 90 of file ffi_test_functions_vmspecific.cc.

                                           {
  Dart_ExecuteInternalCommand("gc-now", nullptr);
}

TrivialTypeExactnessFor()

static StaticTypeExactnessState dart::TrivialTypeExactnessFor ( const Class &  cls )

static

Definition at line 12831 of file object.cc.

                                                                          {
  const intptr_t type_arguments_offset = cls.host_type_arguments_field_offset();
  ASSERT(type_arguments_offset != Class::kNoTypeArguments);
  if (StaticTypeExactnessState::CanRepresentAsTriviallyExact(
          type_arguments_offset / kCompressedWordSize)) {
    return StaticTypeExactnessState::TriviallyExact(type_arguments_offset /
                                                    kCompressedWordSize);
  } else {
    return StaticTypeExactnessState::NotExact();
  }
}

TrueHandle()

DART_EXPORT Dart_Handle dart::TrueHandle

(

)

Definition at line 1078 of file ffi_test_functions_vmspecific.cc.

                                     {
  return Dart_True();
}

TryAddTest()

static void dart::TryAddTest ( ZoneGrowableArray< intptr_t > *  results, intptr_t  test_cid, bool  result  )

static

Definition at line 1370 of file call_specializer.cc.

                                    {
  if (!CidTestResultsContains(*results, test_cid)) {
    results->Add(test_cid);
    results->Add(static_cast<intptr_t>(result));
  }
}

TryCatchOptimizerTest()

static void dart::TryCatchOptimizerTest ( Thread *  thread, const char *  script_chars, std::initializer_list< const char * >  synchronized  )

static

Definition at line 66 of file redundancy_elimination_test.cc.

                                                   {
  // Load the script and exercise the code once.
  const auto& root_library =
      Library::Handle(LoadTestScript(script_chars, &NoopNativeLookup));
  Invoke(root_library, "main");
 
  // Build the flow graph.
  std::initializer_list<CompilerPass::Id> passes = {
      CompilerPass::kComputeSSA,      CompilerPass::kTypePropagation,
      CompilerPass::kApplyICData,     CompilerPass::kSelectRepresentations,
      CompilerPass::kTypePropagation, CompilerPass::kCanonicalize,
  };
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kJIT);
  FlowGraph* graph = pipeline.RunPasses(passes);
 
  // Finally run TryCatchAnalyzer on the graph (in AOT mode).
  OptimizeCatchEntryStates(graph, /*is_aot=*/true);
 
  EXPECT_EQ(1, graph->graph_entry()->catch_entries().length());
  auto scope = graph->parsed_function().scope();
 
  GrowableArray<LocalVariable*> env;
  FlattenScopeIntoEnvironment(graph, scope, &env);
 
  for (intptr_t i = 0; i < env.length(); i++) {
    bool found = false;
    for (auto name : synchronized) {
      if (env[i]->name().Equals(name)) {
        found = true;
        break;
      }
    }
    if (!found) {
      env[i] = nullptr;
    }
  }
 
  CatchBlockEntryInstr* catch_entry = graph->graph_entry()->catch_entries()[0];
 
  // We should only synchronize state for variables from the synchronized list.
  for (auto defn : *catch_entry->initial_definitions()) {
    if (ParameterInstr* param = defn->AsParameter()) {
      if (param->location().IsRegister()) {
        EXPECT(param->location().Equals(LocationExceptionLocation()) ||
               param->location().Equals(LocationStackTraceLocation()));
        continue;
      }
 
      EXPECT(0 <= param->env_index() && param->env_index() < env.length());
      EXPECT(env[param->env_index()] != nullptr);
      if (env[param->env_index()] == nullptr) {
        OS::PrintErr("something is wrong with %s\n", param->ToCString());
      }
    }
  }
}

TrySwitchInstanceCall()

static void dart::TrySwitchInstanceCall ( Thread *  thread, StackFrame *  caller_frame, const Code &  caller_code, const Function &  caller_function, const ICData &  ic_data, const Function &  target_function  )

static

Definition at line 1634 of file runtime_entry.cc.

                                                                   {
  auto zone = thread->zone();
 
  // Monomorphic/megamorphic calls only check the receiver CID.
  if (ic_data.NumArgsTested() != 1) return;
 
  ASSERT(ic_data.rebind_rule() == ICData::kInstance);
 
  // Monomorphic/megamorphic calls don't record exactness.
  if (ic_data.is_tracking_exactness()) return;
 
#if !defined(PRODUCT)
  // Monomorphic/megamorphic do not check the isolate's stepping flag.
  if (thread->isolate()->has_attempted_stepping()) return;
#endif
 
  // Monomorphic/megamorphic calls are only for unoptimized code.
  ASSERT(!caller_code.is_optimized());
 
  // Code is detached from its function. This will prevent us from resetting
  // the switchable call later because resets are function based and because
  // the ic_data_array belongs to the function instead of the code. This should
  // only happen because of reload, but it sometimes happens with KBC mixed mode
  // probably through a race between foreground and background compilation.
  if (caller_function.unoptimized_code() != caller_code.ptr()) {
    return;
  }
#if !defined(PRODUCT)
  // Skip functions that contain breakpoints or when debugger is in single
  // stepping mode.
  if (thread->isolate_group()->debugger()->IsDebugging(thread,
                                                       caller_function)) {
    return;
  }
#endif
 
  const intptr_t num_checks = ic_data.NumberOfChecks();
 
  // Monomorphic call.
  if (FLAG_unopt_monomorphic_calls && (num_checks == 1)) {
    // A call site in the monomorphic state does not load the arguments
    // descriptor, so do not allow transition to this state if the callee
    // needs it.
    if (target_function.PrologueNeedsArgumentsDescriptor()) {
      return;
    }
 
    const Array& data = Array::Handle(zone, ic_data.entries());
    const Code& target = Code::Handle(zone, target_function.EnsureHasCode());
    CodePatcher::PatchInstanceCallAt(caller_frame->pc(), caller_code, data,
                                     target);
    if (FLAG_trace_ic) {
      OS::PrintErr("Instance call at %" Px
                   " switching to monomorphic dispatch, %s\n",
                   caller_frame->pc(), ic_data.ToCString());
    }
    return;  // Success.
  }
 
  // Megamorphic call.
  if (FLAG_unopt_megamorphic_calls &&
      (num_checks > FLAG_max_polymorphic_checks)) {
    const String& name = String::Handle(zone, ic_data.target_name());
    const Array& descriptor =
        Array::Handle(zone, ic_data.arguments_descriptor());
    const MegamorphicCache& cache = MegamorphicCache::Handle(
        zone, MegamorphicCacheTable::Lookup(thread, name, descriptor));
    ic_data.set_is_megamorphic(true);
    CodePatcher::PatchInstanceCallAt(caller_frame->pc(), caller_code, cache,
                                     StubCode::MegamorphicCall());
    if (FLAG_trace_ic) {
      OS::PrintErr("Instance call at %" Px
                   " switching to megamorphic dispatch, %s\n",
                   caller_frame->pc(), ic_data.ToCString());
    }
    return;  // Success.
  }
}

TwoArgsSmiOpInlineCacheEntry()

static CodePtr dart::TwoArgsSmiOpInlineCacheEntry ( Token::Kind  kind )

static

Definition at line 5158 of file il.cc.

                                                            {
  if (!FLAG_two_args_smi_icd) {
    return Code::null();
  }
  switch (kind) {
    case Token::kADD:
      return StubCode::SmiAddInlineCache().ptr();
    case Token::kLT:
      return StubCode::SmiLessInlineCache().ptr();
    case Token::kEQ:
      return StubCode::SmiEqualInlineCache().ptr();
    default:
      return Code::null();
  }
}

TypeArgumentsForElementType()

static TypeArgumentsPtr dart::TypeArgumentsForElementType ( ObjectStore *  store, Dart_CoreType_Id  element_type_id  )

static

Definition at line 3054 of file dart_api_impl.cc.

                                      {
  switch (element_type_id) {
    case Dart_CoreType_Dynamic:
      return TypeArguments::null();
    case Dart_CoreType_Int:
      return store->type_argument_legacy_int();
    case Dart_CoreType_String:
      return store->type_argument_legacy_string();
  }
  UNREACHABLE();
  return TypeArguments::null();
}

TypeArgumentsHashCacheTest()

static void dart::TypeArgumentsHashCacheTest ( Thread *  thread, intptr_t  num_classes  )

static

Definition at line 8016 of file object_test.cc.

                                                                             {
  TextBuffer buffer(MB);
  buffer.AddString("class D<T> {}\n");
  for (intptr_t i = 0; i < num_classes; i++) {
    buffer.Printf("class C%" Pd " { String toString() => 'C%" Pd "'; }\n", i,
                  i);
  }
  buffer.AddString("main() {\n");
  for (intptr_t i = 0; i < num_classes; i++) {
    buffer.Printf("  C%" Pd "().toString();\n", i);
  }
  buffer.AddString("}\n");
 
  Dart_Handle api_lib = TestCase::LoadTestScript(buffer.buffer(), nullptr);
  EXPECT_VALID(api_lib);
  Dart_Handle result = Dart_Invoke(api_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
 
  // D + C0...CN, where N = kNumClasses - 1
  EXPECT(IsolateGroup::Current()->class_table()->NumCids() > num_classes);
 
  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();
 
  const auto& root_lib =
      Library::CheckedHandle(zone, Api::UnwrapHandle(api_lib));
  EXPECT(!root_lib.IsNull());
 
  const auto& class_d = Class::Handle(zone, GetClass(root_lib, "D"));
  ASSERT(!class_d.IsNull());
  const auto& decl_type_d = Type::Handle(zone, class_d.DeclarationType());
  const auto& decl_type_d_type_args =
      TypeArguments::Handle(zone, decl_type_d.arguments());
 
  EXPECT(!decl_type_d_type_args.HasInstantiations());
 
  auto& class_c = Class::Handle(zone);
  auto& decl_type_c = Type::Handle(zone);
  auto& instantiator_type_args = TypeArguments::Handle(zone);
  const auto& function_type_args = Object::null_type_arguments();
  auto& result_type_args = TypeArguments::Handle(zone);
  auto& result_type = AbstractType::Handle(zone);
  // Cache the first computed set of instantiator type arguments to check that
  // no entries from the cache have been lost when the cache grows.
  auto& first_instantiator_type_args = TypeArguments::Handle(zone);
  // Used for the cache hit in stub check.
  const auto& invoke_instantiate_tav =
      Code::Handle(zone, CreateInvokeInstantiateTypeArgumentsStub(thread));
  const auto& invoke_instantiate_tav_arguments =
      Array::Handle(zone, Array::New(3));
  const auto& invoke_instantiate_tav_args_descriptor =
      Array::Handle(zone, ArgumentsDescriptor::NewBoxed(0, 3));
  for (intptr_t i = 0; i < num_classes; ++i) {
    const bool updated_cache_is_linear =
        i < TypeArguments::Cache::kMaxLinearCacheEntries;
    auto const name = OS::SCreate(zone, "C%" Pd "", i);
    class_c = GetClass(root_lib, name);
    ASSERT(!class_c.IsNull());
    decl_type_c = class_c.DeclarationType();
    instantiator_type_args = TypeArguments::New(1);
    instantiator_type_args.SetTypeAt(0, decl_type_c);
    instantiator_type_args = instantiator_type_args.Canonicalize(thread);
 
#if !defined(PRODUCT)
    // The first call to InstantiateAndCanonicalizeFrom shouldn't have a cache
    // hit since the instantiator type arguments should be unique for each
    // iteration, and after that we do a check that the InstantiateTypeArguments
    // stub finds the entry (unless the cache is hash-based on IA32).
    TESTING_runtime_fail_on_existing_cache_entry = true;
#endif
 
    // Check that the key does not currently exist in the cache.
    intptr_t old_capacity;
    {
      SafepointMutexLocker ml(
          thread->isolate_group()->type_arguments_canonicalization_mutex());
      TypeArguments::Cache cache(zone, decl_type_d_type_args);
      EXPECT_EQ(i, cache.NumOccupied());
      auto loc =
          cache.FindKeyOrUnused(instantiator_type_args, function_type_args);
      EXPECT(!loc.present);
      old_capacity = cache.NumEntries();
    }
 
    decl_type_d_type_args.InstantiateAndCanonicalizeFrom(instantiator_type_args,
                                                         function_type_args);
 
    // Check that the key now does exist in the cache.
    TypeArguments::Cache::KeyLocation loc;
    bool storage_changed;
    {
      SafepointMutexLocker ml(
          thread->isolate_group()->type_arguments_canonicalization_mutex());
      TypeArguments::Cache cache(zone, decl_type_d_type_args);
      EXPECT_EQ(i + 1, cache.NumOccupied());
      // Double-check that we got the expected type of cache.
      EXPECT(updated_cache_is_linear ? cache.IsLinear() : cache.IsHash());
      loc = cache.FindKeyOrUnused(instantiator_type_args, function_type_args);
      EXPECT(loc.present);
      storage_changed = cache.NumEntries() != old_capacity;
    }
 
#if defined(TARGET_ARCH_IA32)
    const bool stub_checks_hash_caches = false;
#else
    const bool stub_checks_hash_caches = true;
#endif
    // Now check that we get the expected result from calling the stub if it
    // checks the cache (e.g., in all cases but hash-based caches on IA32).
    if (updated_cache_is_linear || stub_checks_hash_caches) {
      invoke_instantiate_tav_arguments.SetAt(0, decl_type_d_type_args);
      invoke_instantiate_tav_arguments.SetAt(1, instantiator_type_args);
      invoke_instantiate_tav_arguments.SetAt(2, function_type_args);
      result_type_args ^= DartEntry::InvokeCode(
          invoke_instantiate_tav, invoke_instantiate_tav_args_descriptor,
          invoke_instantiate_tav_arguments, thread);
      EXPECT_EQ(1, result_type_args.Length());
      result_type = result_type_args.TypeAt(0);
      EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(decl_type_c, result_type);
    }
 
#if !defined(PRODUCT)
    // Setting to false prior to re-calling InstantiateAndCanonicalizeFrom with
    // the same keys, as now we want a runtime check of an existing cache entry.
    TESTING_runtime_fail_on_existing_cache_entry = false;
#endif
 
    result_type_args = decl_type_d_type_args.InstantiateAndCanonicalizeFrom(
        instantiator_type_args, function_type_args);
    result_type = result_type_args.TypeAt(0);
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(decl_type_c, result_type);
 
    // Check that no new entries were added to the cache.
    {
      SafepointMutexLocker ml(
          thread->isolate_group()->type_arguments_canonicalization_mutex());
      TypeArguments::Cache cache(zone, decl_type_d_type_args);
      EXPECT_EQ(i + 1, cache.NumOccupied());
      auto const loc2 =
          cache.FindKeyOrUnused(instantiator_type_args, function_type_args);
      EXPECT(loc2.present);
      EXPECT_EQ(loc.entry, loc2.entry);
    }
 
    if (i == 0) {
      first_instantiator_type_args = instantiator_type_args.ptr();
    } else if (storage_changed) {
      // Check that the first instantiator TAV still exists in the new cache.
      SafepointMutexLocker ml(
          thread->isolate_group()->type_arguments_canonicalization_mutex());

TypedDataCidForElementSize()

static classid_t dart::TypedDataCidForElementSize ( intptr_t  elem_size )

static

Definition at line 26 of file memory_copy_test.cc.

                                                                {
  switch (elem_size) {
    case 1:
      return kTypedDataUint8ArrayCid;
    case 2:
      return kTypedDataUint16ArrayCid;
    case 4:
      return kTypedDataUint32ArrayCid;
    case 8:
      return kTypedDataUint64ArrayCid;
    case 16:
      return kTypedDataInt32x4ArrayCid;
    default:
      break;
  }
  UNIMPLEMENTED();
}

TypeToHelper()

static Dart_Handle dart::TypeToHelper ( Dart_Handle  type, Nullability  nullability  )

static

Definition at line 5626 of file dart_api_impl.cc.

                                                                           {
  DARTSCOPE(Thread::Current());
  const Type& ty = Api::UnwrapTypeHandle(Z, type);
  if (ty.IsNull()) {
    RETURN_TYPE_ERROR(Z, type, Type);
  }
  if (ty.nullability() == nullability) {
    return type;
  }
  return Api::NewHandle(T, ty.ToNullability(nullability, Heap::kOld));
}

UintComputation()

DART_EXPORT int64_t dart::UintComputation	(	uint8_t	a,
		uint16_t	b,
		uint32_t	c,
		uint64_t	d
	)

Definition at line 231 of file ffi_test_functions.cc.

                                                {
  std::cout << "UintComputation(" << static_cast<int>(a) << ", " << b << ", "
            << c << ", " << d << ")\n";
  const uint64_t retval = d - c + b - a;
  std::cout << "returning " << retval << "\n";
  return retval;
}

UnanchoredAdvance()

RegExpNode * dart::UnanchoredAdvance	(	RegExpCompiler *	compiler,
		RegExpNode *	on_success
	)

Definition at line 4121 of file regexp.cc.

                                                      {
  // This implements ES2015 21.2.5.2.3, AdvanceStringIndex.
  ASSERT(!compiler->read_backward());
  // Advance any character. If the character happens to be a lead surrogate and
  // we advanced into the middle of a surrogate pair, it will work out, as
  // nothing will match from there. We will have to advance again, consuming
  // the associated trail surrogate.
  auto range = CharacterRange::List(
      on_success->zone(), CharacterRange::Range(0, Utf16::kMaxCodeUnit));
  return TextNode::CreateForCharacterRanges(range, false, on_success,
                                            RegExpFlags());
}

UnaryIntegerEvaluateRaw()

static IntegerPtr dart::UnaryIntegerEvaluateRaw ( const Integer &  value, Token::Kind  token_kind, Zone *  zone  )

static

Definition at line 51 of file evaluator.cc.

                                                      {
  switch (token_kind) {
    case Token::kNEGATE:
      return value.ArithmeticOp(Token::kMUL, Smi::Handle(zone, Smi::New(-1)),
                                Heap::kOld);
    case Token::kBIT_NOT:
      if (value.IsSmi()) {
        return Integer::New(~Smi::Cast(value).Value(), Heap::kOld);
      } else if (value.IsMint()) {
        return Integer::New(~Mint::Cast(value).value(), Heap::kOld);
      }
      break;
    default:
      UNREACHABLE();
  }
  return Integer::null();
}

Unhandled_equals()

void FUNCTION_NAME() dart::Unhandled_equals

(

Dart_NativeArguments

args

)

Definition at line 15 of file exceptions_test.cc.

                                                                {
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  TransitionNativeToVM transition(arguments->thread());
  Zone* zone = arguments->thread()->zone();
  const Instance& expected =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
  const Instance& actual =
      Instance::CheckedHandle(zone, arguments->NativeArgAt(1));
  if (!expected.CanonicalizeEquals(actual)) {
    OS::PrintErr("expected: '%s' actual: '%s'\n", expected.ToCString(),
                 actual.ToCString());
    FATAL("Unhandled_equals fails.\n");
  }
}

Unhandled_invoke()

void FUNCTION_NAME() dart::Unhandled_invoke

(

Dart_NativeArguments

args

)

Definition at line 30 of file exceptions_test.cc.

                                                                {
  // Invoke the specified entry point.
  Dart_Handle cls = Dart_GetClass(TestCase::lib(), NewString("Second"));
  Dart_Handle result = Dart_Invoke(cls, NewString("method2"), 0, nullptr);
  ASSERT(Dart_IsError(result));
  ASSERT(Dart_ErrorHasException(result));
  return;
}

Unhandled_invoke2()

void FUNCTION_NAME() dart::Unhandled_invoke2

(

Dart_NativeArguments

args

)

Definition at line 39 of file exceptions_test.cc.

                                                                 {
  // Invoke the specified entry point.
  Dart_Handle cls = Dart_GetClass(TestCase::lib(), NewString("Second"));
  Dart_Handle result = Dart_Invoke(cls, NewString("method2"), 0, nullptr);
  ASSERT(Dart_IsError(result));
  ASSERT(Dart_ErrorHasException(result));
  Dart_Handle exception = Dart_ErrorGetException(result);
  ASSERT(!Dart_IsError(exception));
  Dart_ThrowException(exception);
  UNREACHABLE();
  return;
}

Union()

static void dart::Union ( GrowableArray< Chain * > *  chains, Chain *  source_chain, Chain *  target_chain  )

static

Definition at line 136 of file block_scheduler.cc.

                                       {
  if (source_chain->length < target_chain->length) {
    for (Link* link = source_chain->first; link != nullptr; link = link->next) {
      (*chains)[link->block->postorder_number()] = target_chain;
    }
    // Link the chains.
    source_chain->last->next = target_chain->first;
    // Update the state of the longer chain.
    target_chain->first = source_chain->first;
    target_chain->length += source_chain->length;
  } else {
    for (Link* link = target_chain->first; link != nullptr; link = link->next) {
      (*chains)[link->block->postorder_number()] = source_chain;
    }
    source_chain->last->next = target_chain->first;
    source_chain->last = target_chain->last;
    source_chain->length += target_chain->length;
  }
}

UNIT_TEST_CASE() [1/19]

dart::UNIT_TEST_CASE

(

DartAPI_DartInitializeAfterCleanup

)

Definition at line 31 of file dart_api_impl_test.cc.

                                                   {
  EXPECT(Dart_SetVMFlags(TesterState::argc, TesterState::argv) == nullptr);
  Dart_InitializeParams params;
  memset(&params, 0, sizeof(Dart_InitializeParams));
  params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
  params.vm_snapshot_data = TesterState::vm_snapshot_data;
  params.create_group = TesterState::create_callback;
  params.shutdown_isolate = TesterState::shutdown_callback;
  params.cleanup_group = TesterState::group_cleanup_callback;
  params.start_kernel_isolate = true;
 
  // Reinitialize and ensure we can execute Dart code.
  EXPECT(Dart_Initialize(&params) == nullptr);
  {
    TestIsolateScope scope;
    const char* kScriptChars =
        "int testMain() {\n"
        "  return 42;\n"
        "}\n";
    Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
    EXPECT_VALID(lib);
    Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, nullptr);
    EXPECT_VALID(result);
    int64_t value = 0;
    EXPECT_VALID(Dart_IntegerToInt64(result, &value));
    EXPECT_EQ(42, value);
  }
  EXPECT(Dart_Cleanup() == nullptr);
}

UNIT_TEST_CASE() [2/19]

dart::UNIT_TEST_CASE

(

DartAPI_DartInitializeCallsCodeObserver

)

Definition at line 61 of file dart_api_impl_test.cc.

                                                        {
  EXPECT(Dart_SetVMFlags(TesterState::argc, TesterState::argv) == nullptr);
  Dart_InitializeParams params;
  memset(&params, 0, sizeof(Dart_InitializeParams));
  params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
  params.vm_snapshot_data = TesterState::vm_snapshot_data;
  params.create_group = TesterState::create_callback;
  params.shutdown_isolate = TesterState::shutdown_callback;
  params.cleanup_group = TesterState::group_cleanup_callback;
  params.start_kernel_isolate = true;
 
  bool was_called = false;
  Dart_CodeObserver code_observer;
  code_observer.data = &was_called;
  code_observer.on_new_code = [](Dart_CodeObserver* observer, const char* name,
                                 uintptr_t base, uintptr_t size) {
    *static_cast<bool*>(observer->data) = true;
  };
  params.code_observer = &code_observer;
 
  // Reinitialize and ensure we can execute Dart code.
  EXPECT(Dart_Initialize(&params) == nullptr);
 
  // Wait for 5 seconds to let the kernel service load the snapshot,
  // which should trigger calls to the code observer.
  OS::Sleep(5);
 
  EXPECT(was_called);
  EXPECT(Dart_Cleanup() == nullptr);
}

UNIT_TEST_CASE() [3/19]

dart::UNIT_TEST_CASE

(

DartAPI_DartInitializeHeapSizes

)

Definition at line 92 of file dart_api_impl_test.cc.

                                                {
  Dart_InitializeParams params;
  memset(&params, 0, sizeof(Dart_InitializeParams));
  params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
  params.vm_snapshot_data = TesterState::vm_snapshot_data;
  params.create_group = TesterState::create_callback;
  params.shutdown_isolate = TesterState::shutdown_callback;
  params.cleanup_group = TesterState::group_cleanup_callback;
  params.start_kernel_isolate = true;
 
  // Initialize with a normal heap size specification.
  const char* options_1[] = {"--old-gen-heap-size=3192",
                             "--new-gen-semi-max-size=32"};
  EXPECT(Dart_SetVMFlags(2, options_1) == nullptr);
  EXPECT(Dart_Initialize(&params) == nullptr);
  EXPECT(FLAG_old_gen_heap_size == 3192);
  EXPECT(FLAG_new_gen_semi_max_size == 32);
  EXPECT(Dart_Cleanup() == nullptr);
 
  const char* options_2[] = {"--old-gen-heap-size=16384",
                             "--new-gen-semi-max-size=16384"};
  EXPECT(Dart_SetVMFlags(2, options_2) == nullptr);
  EXPECT(Dart_Initialize(&params) == nullptr);
  if (kMaxAddrSpaceMB == 4096) {
    EXPECT(FLAG_old_gen_heap_size == 0);
    EXPECT(FLAG_new_gen_semi_max_size == kDefaultNewGenSemiMaxSize);
  } else {
    EXPECT(FLAG_old_gen_heap_size == 16384);
    EXPECT(FLAG_new_gen_semi_max_size == 16384);
  }
  EXPECT(Dart_Cleanup() == nullptr);
 
  const char* options_3[] = {"--old-gen-heap-size=30720",
                             "--new-gen-semi-max-size=30720"};
  EXPECT(Dart_SetVMFlags(2, options_3) == nullptr);
  EXPECT(Dart_Initialize(&params) == nullptr);
  if (kMaxAddrSpaceMB == 4096) {
    EXPECT(FLAG_old_gen_heap_size == 0);
    EXPECT(FLAG_new_gen_semi_max_size == kDefaultNewGenSemiMaxSize);
  } else {
    EXPECT(FLAG_old_gen_heap_size == 30720);
    EXPECT(FLAG_new_gen_semi_max_size == 30720);
  }
  EXPECT(Dart_Cleanup() == nullptr);
}

UNIT_TEST_CASE() [4/19]

dart::UNIT_TEST_CASE

(

DartAPI_TimelineEvents_Loop

)

Definition at line 10072 of file dart_api_impl_test.cc.

     {
    error = nullptr;
    response_json = nullptr;
    response_json_length = 0;
    const bool success = Dart_InvokeVMServiceMethod(
        reinterpret_cast<uint8_t*>(buffer), strlen(buffer), &response_json,
        &response_json_length, &error);
    if (success) {
      MonitorLocker ml(loop_test_lock);
      EXPECT(error == nullptr);
      free(response_json);
      if (count == 10) {
        loop_test_exit = true;
        ml.Notify();
      }
      count++;
    } else {
      free(error);
    }
  } while (count < 100);
}
 
TEST_CASE(DartAPI_InvokeVMServiceMethod_Loop) {
  MonitorLocker ml(loop_test_lock);
  loop_test_exit = false;
  loop_reset_count = false;
  OSThread::Start("InvokeServiceMessages", InvokeServiceMessages, 0);
  while (!loop_test_exit) {
    ml.Wait();
  }
}
#endif  // !defined(PRODUCT)
 
static void HandleResponse(Dart_Port dest_port_id, Dart_CObject* message) {
  printf("Response received\n");
}

UNIT_TEST_CASE() [5/19]

dart::UNIT_TEST_CASE

(

DartAPI_TimelineEvents_NullFlowIdsHandledGracefully

)

Definition at line 10109 of file dart_api_impl_test.cc.

                                           {
  uint32_t count = 0;
  do {
    const Dart_Port port_id = Dart_NewNativePort("tst", &HandleResponse, false);
    if (port_id != ILLEGAL_PORT) {

UNIT_TEST_CASE() [6/19]

dart::UNIT_TEST_CASE

(

FixedCacheEmpty

)

Definition at line 12 of file fixed_cache_test.cc.

                                {
  FixedCache<int, int, 2> cache;
  EXPECT(cache.Lookup(0) == nullptr);
  EXPECT(cache.Lookup(1) == nullptr);
  cache.Insert(1, 2);
  EXPECT(*cache.Lookup(1) == 2);
  EXPECT(cache.Lookup(0) == nullptr);
}

UNIT_TEST_CASE() [7/19]

dart::UNIT_TEST_CASE

(

FixedCacheFullResource

)

Definition at line 66 of file fixed_cache_test.cc.

                                       {
  {
    FixedCache<int, Resource, 6> cache;
    cache.Insert(10, Resource(2));
    cache.Insert(20, Resource(4));
    cache.Insert(40, Resource(16));
    cache.Insert(30, Resource(8));
    EXPECT(cache.Lookup(40)->id == 16);
    EXPECT(cache.Lookup(5) == nullptr);
    EXPECT(cache.Lookup(0) == nullptr);
    // Insert in the front, middle.
    cache.Insert(5, Resource(1));
    cache.Insert(15, Resource(3));
    cache.Insert(25, Resource(6));
    // 40 got removed by shifting.
    EXPECT(cache.Lookup(40) == nullptr);
    EXPECT(cache.Lookup(5)->id == 1);
    EXPECT(cache.Lookup(15)->id == 3);
    EXPECT(cache.Lookup(25)->id == 6);
 
    // Insert at end top - 30 gets replaced by 40.
    cache.Insert(40, Resource(16));
    EXPECT(cache.Lookup(40)->id == 16);
    EXPECT(cache.Lookup(30) == nullptr);
  }
  EXPECT(Resource::copies == 0);
}

UNIT_TEST_CASE() [8/19]

dart::UNIT_TEST_CASE

(

FixedCacheHalfFull

)

Definition at line 21 of file fixed_cache_test.cc.

                                   {
  FixedCache<int, const char*, 8> cache;
  // Insert at end.
  cache.Insert(10, "a");
  cache.Insert(20, "b");
  cache.Insert(40, "c");
  // Insert in the middle.
  cache.Insert(15, "ab");
  cache.Insert(25, "bc");
  // Insert in front.
  cache.Insert(5, "_");
  // Check all items.
  EXPECT(strcmp(*cache.Lookup(5), "_") == 0);
  EXPECT(strcmp(*cache.Lookup(10), "a") == 0);
  EXPECT(strcmp(*cache.Lookup(20), "b") == 0);
  EXPECT(strcmp(*cache.Lookup(40), "c") == 0);
  EXPECT(strcmp(*cache.Lookup(25), "bc") == 0);
  // Nonexistent - front, middle, end.
  EXPECT(cache.Lookup(1) == nullptr);
  EXPECT(cache.Lookup(35) == nullptr);
  EXPECT(cache.Lookup(50) == nullptr);
}

UNIT_TEST_CASE() [9/19]

dart::UNIT_TEST_CASE

(

IntrusiveDListAppendListTest

)

Definition at line 155 of file intrusive_dlist_test.cc.

                                             {
  // Append to empty list.
  {
    IntrusiveDList<Item> all;
    IntrusiveDList<Item> other;
 
    Item a1(1, 11), a2(2, 12);
    all.Append(&a1);
    all.Append(&a2);
 
    other.AppendList(&all);
 
    EXPECT(all.IsEmpty());
    EXPECT(!other.IsEmpty());
    EXPECT_EQ(&a1, other.First());
    EXPECT_EQ(&a2, other.Last());
 
    auto it = other.Begin();
    EXPECT_EQ(&a1, *it);
    it = other.Erase(it);
    EXPECT_EQ(&a2, *it);
    it = other.Erase(it);
    EXPECT(it == other.end());
  }
  // Append to non-empty list.
  {
    IntrusiveDList<Item> all;
    IntrusiveDList<Item> other;
 
    Item a1(1, 11), a2(2, 12);
    all.Append(&a1);
    all.Append(&a2);
 
    Item o1(1, 11);
    other.Append(&o1);
 
    other.AppendList(&all);
 
    EXPECT(all.IsEmpty());
    EXPECT(!other.IsEmpty());
    EXPECT_EQ(&o1, other.First());
    EXPECT_EQ(&a2, other.Last());
 
    auto it = other.Begin();
    EXPECT_EQ(&o1, *it);
    it = other.Erase(it);
    EXPECT_EQ(&a1, *it);
    it = other.Erase(it);
    EXPECT_EQ(&a2, *it);
    it = other.Erase(it);
    EXPECT(it == other.end());
  }
}

UNIT_TEST_CASE() [10/19]

dart::UNIT_TEST_CASE

(

IntrusiveDListEraseIterator

)

Definition at line 131 of file intrusive_dlist_test.cc.

                                            {
  Item a1(1, 11), a2(2, 12), a3(3, 13);
 
  IntrusiveDList<Item> all;
 
  all.Append(&a2);
  all.Append(&a3);
  all.Prepend(&a1);
 
  auto it = all.Begin();
  it = all.Erase(++it);
  EXPECT_EQ(*it, &a3);
  EXPECT_EQ(*it, all.Last());
 
  it = all.Erase(all.Begin());
  EXPECT_EQ(*it, &a3);
  EXPECT_EQ(*it, all.First());
  EXPECT_EQ(*it, all.Last());
 
  it = all.Erase(all.Begin());
  EXPECT(it == all.End());
  EXPECT(all.IsEmpty());
}

UNIT_TEST_CASE() [11/19]

dart::UNIT_TEST_CASE

(

IntrusiveDListIsInList

)

Definition at line 108 of file intrusive_dlist_test.cc.

                                       {
  Item a1(1, 11), a2(2, 12), a3(3, 13);
 
  IntrusiveDList<Item> all;
 
  all.Append(&a2);
  all.Append(&a3);
  all.Prepend(&a1);
 
  ASSERT(all.IsInList(&a1));
  ASSERT(all.IsInList(&a2));
  ASSERT(all.IsInList(&a3));
 
  EXPECT_EQ(&a1, all.RemoveFirst());
  EXPECT(!all.IsInList(&a1));
  EXPECT_EQ(&a3, all.RemoveLast());
  EXPECT(!all.IsInList(&a3));
  EXPECT_EQ(&a2, all.RemoveFirst());
  EXPECT(!all.IsInList(&a2));
 
  EXPECT(all.IsEmpty());
}

UNIT_TEST_CASE() [12/19]

dart::UNIT_TEST_CASE

(

IntrusiveDListMultiEntryTest

)

Definition at line 26 of file intrusive_dlist_test.cc.

                                             {
  Item a1(1, 11), a2(2, 12), a3(3, 13);
 
  IntrusiveDList<Item> all;
  IntrusiveDList<Item, 2> ready;
 
  EXPECT(all.IsEmpty());
  EXPECT(ready.IsEmpty());
 
  all.Append(&a2);
  all.Append(&a3);
  all.Prepend(&a1);
  EXPECT_EQ(all.First()->item, 11);
  EXPECT_EQ(all.Last()->item, 13);
 
  ready.Append(&a1);
  ready.Append(&a2);
  EXPECT_EQ(ready.First()->item, 11);
  EXPECT_EQ(ready.Last()->item, 12);
 
  int i = 0;
  for (auto it = all.Begin(); it != all.End(); ++it) {
    i++;
    EXPECT_EQ(it->base, i);
    EXPECT_EQ((*it)->base, i);
    EXPECT_EQ(it->item, 10 + i);
    EXPECT_EQ((*it)->item, 10 + i);
  }
  EXPECT_EQ(i, 3);
 
  i = 0;
  for (auto it = ready.Begin(); it != ready.End(); ++it) {
    i++;
    EXPECT_EQ(it->base, i);
    EXPECT_EQ((*it)->base, i);
    EXPECT_EQ(it->item, 10 + i);
    EXPECT_EQ((*it)->item, 10 + i);
  }
  EXPECT_EQ(i, 2);
 
  ready.Remove(&a1);
  ready.Remove(&a2);
 
  all.Remove(&a1);
  all.Remove(&a2);
  all.Remove(&a3);
 
  EXPECT(all.IsEmpty());
  EXPECT(ready.IsEmpty());
}

UNIT_TEST_CASE() [13/19]

dart::UNIT_TEST_CASE

(

IntrusiveDListRemoveFirstTest

)

Definition at line 77 of file intrusive_dlist_test.cc.

                                              {
  Item a1(1, 11), a2(2, 12), a3(3, 13);
 
  IntrusiveDList<Item> all;
 
  all.Append(&a2);
  all.Append(&a3);
  all.Prepend(&a1);
 
  EXPECT_EQ(&a1, all.RemoveFirst());
  EXPECT_EQ(&a2, all.RemoveFirst());
  EXPECT_EQ(&a3, all.RemoveFirst());
 
  EXPECT(all.IsEmpty());
}

UNIT_TEST_CASE() [14/19]

dart::UNIT_TEST_CASE

(

IntrusiveDListRemoveLastTest

)

Definition at line 93 of file intrusive_dlist_test.cc.

                                             {
  Item a1(1, 11), a2(2, 12), a3(3, 13);
 
  IntrusiveDList<Item> all;
 
  all.Append(&a2);
  all.Append(&a3);
  all.Prepend(&a1);
 
  EXPECT_EQ(&a3, all.RemoveLast());
  EXPECT_EQ(&a2, all.RemoveLast());
  EXPECT_EQ(&a1, all.RemoveLast());
  EXPECT(all.IsEmpty());
}

UNIT_TEST_CASE() [15/19]

dart::UNIT_TEST_CASE

(

PRIORITY_HEAP_WITH_INDEX__CHANGE_PRIORITY

)

Definition at line 122 of file priority_heap_test.cc.

                                                          {
  const word kSize = PriorityQueue<word, word>::kMinimumSize;
 
  PriorityQueue<word, word> heap;
  for (word i = 0; i < kSize; i++) {
    if (i % 2 == 0) {
      heap.Insert(i, 10 + i);
    }
  }
  ASSERT(heap.min_heap_size() == kSize);
  for (word i = 0; i < kSize; i++) {
    bool was_inserted = i % 2 == 0;
    bool increase = i % 3 == 0;
    word new_priority = i + (increase ? 100 : -100);
 
    EXPECT(was_inserted != heap.InsertOrChangePriority(new_priority, 10 + i));
  }
 
  for (word i = 0; i < kSize; i++) {
    bool increase = i % 3 == 0;
    if (!increase) {
      word expected_priority = i + (increase ? 100 : -100);
      EXPECT(!heap.IsEmpty());
      EXPECT_EQ(expected_priority, heap.Minimum().priority);
      EXPECT_EQ(10 + i, heap.Minimum().value);
      EXPECT(heap.ContainsValue(10 + i));
      heap.RemoveMinimum();
      EXPECT(!heap.ContainsValue(10 + i));
    }
  }
  for (word i = 0; i < kSize; i++) {
    bool increase = i % 3 == 0;
    if (increase) {
      word expected_priority = i + (increase ? 100 : -100);
      EXPECT(!heap.IsEmpty());
      EXPECT_EQ(expected_priority, heap.Minimum().priority);
      EXPECT_EQ(10 + i, heap.Minimum().value);
      EXPECT(heap.ContainsValue(10 + i));
      heap.RemoveMinimum();
      EXPECT(!heap.ContainsValue(10 + i));
    }
  }
  EXPECT(heap.IsEmpty());
}

UNIT_TEST_CASE() [16/19]

dart::UNIT_TEST_CASE

(

PRIORITY_HEAP_WITH_INDEX__DECREASING

)

Definition at line 30 of file priority_heap_test.cc.

                                                     {
  const word kSize = PriorityQueue<word, word>::kMinimumSize;
 
  PriorityQueue<word, word> heap;
  for (word i = kSize - 1; i >= 0; i--) {
    heap.Insert(i, 10 + i);
  }
  ASSERT(heap.min_heap_size() == kSize);
  for (word i = 0; i < kSize; i++) {
    EXPECT(!heap.IsEmpty());
    EXPECT_EQ(i, heap.Minimum().priority);
    EXPECT_EQ(10 + i, heap.Minimum().value);
    EXPECT(heap.ContainsValue(10 + i));
    heap.RemoveMinimum();
    EXPECT(!heap.ContainsValue(10 + i));
  }
  EXPECT(heap.IsEmpty());
}

UNIT_TEST_CASE() [17/19]

dart::UNIT_TEST_CASE

(

PRIORITY_HEAP_WITH_INDEX__DELETE_BY_VALUES

)

Definition at line 49 of file priority_heap_test.cc.

                                                           {
  const word kSize = PriorityQueue<word, word>::kMinimumSize;
 
  PriorityQueue<word, word> heap;
  for (word i = kSize - 1; i >= 0; i--) {
    heap.Insert(i, 10 + i);
  }
 
  ASSERT(heap.min_heap_size() == kSize);
 
  EXPECT(heap.RemoveByValue(10 + 0));
  EXPECT(!heap.RemoveByValue(10 + 0));
 
  EXPECT(heap.RemoveByValue(10 + 5));
  EXPECT(!heap.RemoveByValue(10 + 5));
 
  EXPECT(heap.RemoveByValue(10 + kSize - 1));
  EXPECT(!heap.RemoveByValue(10 + kSize - 1));
 
  for (word i = 0; i < kSize; i++) {
    // Jump over the removed [i]s in the loop.
    if (i != 0 && i != 5 && i != (kSize - 1)) {
      EXPECT(!heap.IsEmpty());
      EXPECT_EQ(i, heap.Minimum().priority);
      EXPECT_EQ(10 + i, heap.Minimum().value);
      EXPECT(heap.ContainsValue(10 + i));
      heap.RemoveMinimum();
      EXPECT(!heap.ContainsValue(10 + i));
    }
  }
  EXPECT(heap.IsEmpty());
}

UNIT_TEST_CASE() [18/19]

dart::UNIT_TEST_CASE

(

PRIORITY_HEAP_WITH_INDEX__GROW_SHRINK

)

Definition at line 82 of file priority_heap_test.cc.

                                                      {
  const word kSize = 1024;
  const word kMinimumSize = PriorityQueue<word, word>::kMinimumSize;
 
  PriorityQueue<word, word> heap;
  for (word i = 0; i < kSize; i++) {
    heap.Insert(i, 10 + i);
  }
 
  ASSERT(heap.min_heap_size() == kSize);
 
  for (word i = 0; i < kSize; i++) {
    EXPECT(!heap.IsEmpty());
    EXPECT_EQ(i, heap.Minimum().priority);
    EXPECT_EQ(10 + i, heap.Minimum().value);
    EXPECT(heap.ContainsValue(10 + i));
    heap.RemoveMinimum();
    EXPECT(!heap.ContainsValue(10 + i));
  }
 
  EXPECT(heap.IsEmpty());
  ASSERT(heap.min_heap_size() == kMinimumSize);
 
  for (word i = 0; i < kSize; i++) {
    heap.Insert(i, 10 + i);
  }
 
  for (word i = 0; i < kSize; i++) {
    EXPECT(!heap.IsEmpty());
    EXPECT_EQ(i, heap.Minimum().priority);
    EXPECT_EQ(10 + i, heap.Minimum().value);
    EXPECT(heap.ContainsValue(10 + i));
    heap.RemoveMinimum();
    EXPECT(!heap.ContainsValue(10 + i));
  }
 
  EXPECT(heap.IsEmpty());
  ASSERT(heap.min_heap_size() == kMinimumSize);
}

UNIT_TEST_CASE() [19/19]

dart::UNIT_TEST_CASE

(

PRIORITY_HEAP_WITH_INDEX__INCREASING

)

Definition at line 11 of file priority_heap_test.cc.

                                                     {
  const word kSize = PriorityQueue<word, word>::kMinimumSize;
 
  PriorityQueue<word, word> heap;
  for (word i = 0; i < kSize; i++) {
    heap.Insert(i, 10 + i);
  }
  ASSERT(heap.min_heap_size() == kSize);
  for (word i = 0; i < kSize; i++) {
    EXPECT(!heap.IsEmpty());
    EXPECT_EQ(i, heap.Minimum().priority);
    EXPECT_EQ(10 + i, heap.Minimum().value);
    EXPECT(heap.ContainsValue(10 + i));
    heap.RemoveMinimum();
    EXPECT(!heap.ContainsValue(10 + i));
  }
  EXPECT(heap.IsEmpty());
}

UnitString()

static const char * dart::UnitString ( intptr_t  unit )

static

Definition at line 61 of file metrics.cc.

                                             {
  switch (unit) {
    case Metric::kCounter:
      return "counter";
    case Metric::kByte:
      return "byte";
    case Metric::kMicrosecond:
      return "us";
    default:
      UNREACHABLE();
  }
  UNREACHABLE();
  return nullptr;
}

UnmarkClasses()

static void dart::UnmarkClasses ( )

static

Definition at line 3493 of file service.cc.

                            {
  ClassTable* table = IsolateGroup::Current()->class_table();
  for (intptr_t i = 1; i < table->NumCids(); i++) {
    table->SetCollectInstancesFor(i, false);
  }
}

UnprotectCodeOtherThread()

DART_EXPORT void * dart::UnprotectCodeOtherThread	(	void *	isolate,
		std::condition_variable *	var,
		std::mutex *	mut
	)

Definition at line 123 of file ffi_test_functions_vmspecific.cc.

                                                          {
  std::function<void()> callback = [&]() {
    mut->lock();
    var->notify_all();
    mut->unlock();
 
    // Wait for mutator thread to continue (and block) before leaving the
    // safepoint.
    while (Dart_ExecuteInternalCommand("is-mutator-in-native", isolate) !=
           nullptr) {
      usleep(10 * 1000 /*10 ms*/);
    }
  };
 
  struct {
    void* isolate;
    std::function<void()>* callback;
  } args = {.isolate = isolate, .callback = &callback};
 
  Dart_ExecuteInternalCommand("run-in-safepoint-and-rw-code", &args);
  return nullptr;
}

UnreachableFinalizer()

static void dart::UnreachableFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 8002 of file dart_api_impl_test.cc.

                                      {

UnreachableMessageHandler()

static void dart::UnreachableMessageHandler ( Dart_Port  dest_port_id, Dart_CObject *  message  )

static

Definition at line 8283 of file dart_api_impl_test.cc.

UnreachedCallback()

static void dart::UnreachedCallback ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3146 of file dart_api_impl_test.cc.

                                                                       {
  UNREACHABLE();
}

untag()

raw_obj dart::untag

(

)

-> num_entries()) VARIABLE_COMPRESSED_VISITOR(Array, Smi::Value(raw_obj->untag()->length())) VARIABLE_COMPRESSED_VISITOR( TypedData, TypedData::ElementSizeInBytes(raw_obj->GetClassId()) * Smi::Value(raw_obj->untag()->length())) VARIABLE_COMPRESSED_VISITOR(Record, RecordShape(raw_obj->untag()->shape()).num_fields()) VARIABLE_NULL_VISITOR(CompressedStackMaps, CompressedStackMaps::PayloadSizeOf(raw_obj)) VARIABLE_NULL_VISITOR(OneByteString, Smi::Value(raw_obj->untag()->length())) VARIABLE_NULL_VISITOR(TwoByteString, Smi::Value(raw_obj->untag()->length())) intptr_t UntaggedField::VisitFieldPointers(FieldPtr raw_obj, ObjectPointerVisitor* visitor)

Definition at line 562 of file raw_object.cc.

                                                                          {
  ASSERT(raw_obj->IsHeapObject());
  ASSERT_COMPRESSED(Field);
  visitor->VisitCompressedPointers(
      raw_obj->heap_base(), raw_obj->untag()->from(), raw_obj->untag()->to());
 
  if (visitor->trace_values_through_fields()) {
    if (Field::StaticBit::decode(raw_obj->untag()->kind_bits_)) {
      visitor->isolate_group()->ForEachIsolate(
          [&](Isolate* isolate) {
            intptr_t index =
                Smi::Value(raw_obj->untag()->host_offset_or_field_id());
            visitor->VisitPointer(&isolate->field_table()->table()[index]);
          },
          /*at_safepoint=*/true);
    }
  }
  return Field::InstanceSize();
}

UnwrapConstraint()

static Definition * dart::UnwrapConstraint ( Definition *  defn )

static

Definition at line 73 of file range_analysis.cc.

                                                      {
  while (defn->IsConstraint()) {
    defn = defn->AsConstraint()->value()->definition();
  }
  return defn;
}

UpdateBestFit()

static void dart::UpdateBestFit ( Function *  best_fit, const Function &  func  )

static

Definition at line 2354 of file debugger.cc.

                                                                    {
  if (best_fit->IsNull()) {
    *best_fit = func.ptr();
  } else if ((best_fit->token_pos().IsSynthetic() ||
              func.token_pos().IsSynthetic() ||
              (best_fit->token_pos() < func.token_pos())) &&
             (func.end_token_pos() <= best_fit->end_token_pos())) {
    *best_fit = func.ptr();
  }
}

UpdateBoundsCheck()

static void dart::UpdateBoundsCheck ( intptr_t  index, intptr_t *  checked_up_to  )

static

Definition at line 2357 of file regexp.cc.

                                                                       {
  if (index > *checked_up_to) {
    *checked_up_to = index;
  }
}

UpdateLengthField()

DART_FORCE_INLINE void dart::UpdateLengthField	(	intptr_t	cid,
		ObjectPtr	from,
		ObjectPtr	to
	)

Definition at line 280 of file object_graph_copy.cc.

                                                                   {
  // We share these objects - never copy them.
  ASSERT(!IsStringClassId(cid));
 
  // We update any in-heap variable sized object with the length to keep the
  // length and the size in the object header in-sync for the GC.
  if (cid == kArrayCid || cid == kImmutableArrayCid) {
    static_cast<UntaggedArray*>(to.untag())->length_ =
        static_cast<UntaggedArray*>(from.untag())->length_;
  } else if (cid == kContextCid) {
    static_cast<UntaggedContext*>(to.untag())->num_variables_ =
        static_cast<UntaggedContext*>(from.untag())->num_variables_;
  } else if (IsTypedDataClassId(cid)) {
    static_cast<UntaggedTypedDataBase*>(to.untag())->length_ =
        static_cast<UntaggedTypedDataBase*>(from.untag())->length_;
  } else if (cid == kRecordCid) {
    static_cast<UntaggedRecord*>(to.untag())->shape_ =
        static_cast<UntaggedRecord*>(from.untag())->shape_;
  }
}

UpdateTypeTestCache()

static void dart::UpdateTypeTestCache ( Zone *  zone, Thread *  thread, const Instance &  instance, const AbstractType &  destination_type, const TypeArguments &  instantiator_type_arguments, const TypeArguments &  function_type_arguments, const Bool &  result, const SubtypeTestCache &  new_cache  )

static

Definition at line 973 of file runtime_entry.cc.

                                       {
  ASSERT(!new_cache.IsNull());
  ASSERT(destination_type.IsCanonical());
  ASSERT(instantiator_type_arguments.IsCanonical());
  ASSERT(function_type_arguments.IsCanonical());
  if (instance.IsRecord()) {
    // Do not add record instances to cache as they don't have a valid
    // key (type of a record depends on types of all its fields).
    if (FLAG_trace_type_checks) {
      THR_Print("Not updating subtype test cache for the record instance.\n");
    }
    return;
  }
  Class& instance_class = Class::Handle(zone);
  if (instance.IsSmi()) {
    instance_class = Smi::Class();
  } else {
    instance_class = instance.clazz();
  }
  // If the type is uninstantiated and refers to parent function type
  // parameters, the function_type_arguments have been canonicalized
  // when concatenated.
  auto& instance_class_id_or_signature = Object::Handle(zone);
  auto& instance_type_arguments = TypeArguments::Handle(zone);
  auto& instance_parent_function_type_arguments = TypeArguments::Handle(zone);
  auto& instance_delayed_type_arguments = TypeArguments::Handle(zone);
  if (instance_class.IsClosureClass()) {
    const auto& closure = Closure::Cast(instance);
    const auto& function = Function::Handle(zone, closure.function());
    instance_class_id_or_signature = function.signature();
    ASSERT(instance_class_id_or_signature.IsFunctionType());
    instance_type_arguments = closure.instantiator_type_arguments();
    instance_parent_function_type_arguments = closure.function_type_arguments();
    instance_delayed_type_arguments = closure.delayed_type_arguments();
    ASSERT(instance_class_id_or_signature.IsCanonical());
    ASSERT(instance_type_arguments.IsCanonical());
    ASSERT(instance_parent_function_type_arguments.IsCanonical());
    ASSERT(instance_delayed_type_arguments.IsCanonical());
  } else {
    instance_class_id_or_signature = Smi::New(instance_class.id());
    if (instance_class.NumTypeArguments() > 0) {
      instance_type_arguments = instance.GetTypeArguments();
      ASSERT(instance_type_arguments.IsCanonical());
    }
  }
  if (FLAG_trace_type_checks) {
    const auto& instance_class_name =
        String::Handle(zone, instance_class.Name());
    TextBuffer buffer(256);
    buffer.Printf("  Updating test cache %#" Px " with result %s for:\n",
                  static_cast<uword>(new_cache.ptr()), result.ToCString());
    if (instance.IsString()) {
      buffer.Printf("    instance: '%s'\n", instance.ToCString());
    } else {
      buffer.Printf("    instance: %s\n", instance.ToCString());
    }
    buffer.Printf("    class: %s (%" Pd ")\n", instance_class_name.ToCString(),
                  instance_class.id());
    buffer.Printf(
        "    raw entry: [ %#" Px ", %#" Px ", %#" Px ", %#" Px ", %#" Px
        ", %#" Px ", %#" Px ", %#" Px " ]\n",
        static_cast<uword>(instance_class_id_or_signature.ptr()),
        static_cast<uword>(instance_type_arguments.ptr()),
        static_cast<uword>(instantiator_type_arguments.ptr()),
        static_cast<uword>(function_type_arguments.ptr()),
        static_cast<uword>(instance_parent_function_type_arguments.ptr()),
        static_cast<uword>(instance_delayed_type_arguments.ptr()),
        static_cast<uword>(destination_type.ptr()),
        static_cast<uword>(result.ptr()));
    THR_Print("%s", buffer.buffer());
  }
  {
    SafepointMutexLocker ml(
        thread->isolate_group()->subtype_test_cache_mutex());
    const intptr_t len = new_cache.NumberOfChecks();
    if (len >= FLAG_max_subtype_cache_entries) {
      if (FLAG_trace_type_checks) {
        THR_Print("Not updating subtype test cache as its length reached %d\n",
                  FLAG_max_subtype_cache_entries);
      }
      return;
    }
    intptr_t colliding_index = -1;
    auto& old_result = Bool::Handle(zone);
    if (new_cache.HasCheck(
            instance_class_id_or_signature, destination_type,
            instance_type_arguments, instantiator_type_arguments,
            function_type_arguments, instance_parent_function_type_arguments,
            instance_delayed_type_arguments, &colliding_index, &old_result)) {
      if (FLAG_trace_type_checks) {
        TextBuffer buffer(256);
        buffer.Printf("  Collision for test cache %#" Px " at index %" Pd ":\n",
                      static_cast<uword>(new_cache.ptr()), colliding_index);
        buffer.Printf("    entry: ");
        new_cache.WriteEntryToBuffer(zone, &buffer, colliding_index, "      ");
        THR_Print("%s\n", buffer.buffer());
      }
      if (old_result.ptr() != result.ptr()) {
        FATAL("Existing subtype test cache entry has result %s, not %s",
              old_result.ToCString(), result.ToCString());
      }
      // Some other isolate might have updated the cache between entry was
      // found missing and now.
      return;
    }
    const intptr_t new_index = new_cache.AddCheck(
        instance_class_id_or_signature, destination_type,
        instance_type_arguments, instantiator_type_arguments,
        function_type_arguments, instance_parent_function_type_arguments,
        instance_delayed_type_arguments, result);
    if (FLAG_trace_type_checks) {
      TextBuffer buffer(256);
      buffer.Printf("  Added new entry to test cache %#" Px " at index %" Pd
                    ":\n",
                    static_cast<uword>(new_cache.ptr()), new_index);
      buffer.Printf("    new entry: ");
      new_cache.WriteEntryToBuffer(zone, &buffer, new_index, "      ");
      THR_Print("%s\n", buffer.buffer());
    }
  }
}

Usage()

static intptr_t dart::Usage ( Thread *  thread, const Function &  function  )

static

Definition at line 727 of file il.cc.

                                                                {
  intptr_t count = function.usage_counter();
  if (count < 0) {
    if (function.HasCode()) {
      // 'function' is queued for optimized compilation
      count = thread->isolate_group()->optimization_counter_threshold();
    } else {
      count = 0;
    }
  } else if (Code::IsOptimized(function.CurrentCode())) {
    // 'function' was optimized and stopped counting
    count = thread->isolate_group()->optimization_counter_threshold();
  }
  return count;
}

USE()

template<typename T >

static void dart::USE ( T &&  )

inlinestatic

Definition at line 618 of file globals.h.

{}

UseDartApi()

static void dart::UseDartApi ( Dart_NativeArguments  args )

static

Definition at line 124 of file benchmark_test.cc.

                                                  {
  int count = Dart_GetNativeArgumentCount(args);
  EXPECT_EQ(3, count);
 
  // Get native field from receiver.
  intptr_t receiver_value;
  Dart_Handle result = Dart_GetNativeReceiver(args, &receiver_value);
  EXPECT_VALID(result);
  EXPECT_EQ(7, receiver_value);
 
  // Get param1.
  Dart_Handle param1 = Dart_GetNativeArgument(args, 1);
  EXPECT_VALID(param1);
  EXPECT(Dart_IsInteger(param1));
  bool fits = false;
  result = Dart_IntegerFitsIntoInt64(param1, &fits);
  EXPECT_VALID(result);
  EXPECT(fits);
  int64_t value1;
  result = Dart_IntegerToInt64(param1, &value1);
  EXPECT_VALID(result);
  EXPECT_LE(0, value1);
  EXPECT_LE(value1, 1000000);
 
  // Return param + receiver.field.
  Dart_SetReturnValue(args, Dart_NewInteger(value1 * receiver_value));
}

Validate()

template<typename Table >

void dart::Validate

(

const Table &

table

)

Definition at line 39 of file hash_table_test.cc.

                                  {
  // Verify consistency of entry state tracking.
  intptr_t num_entries = table.NumEntries();
  intptr_t num_unused = table.NumUnused();
  intptr_t num_occupied = table.NumOccupied();
  intptr_t num_deleted = table.NumDeleted();
  for (intptr_t i = 0; i < num_entries; ++i) {
    EXPECT_EQ(1, table.IsUnused(i) + table.IsOccupied(i) + table.IsDeleted(i));
    num_unused -= table.IsUnused(i);
    num_occupied -= table.IsOccupied(i);
    num_deleted -= table.IsDeleted(i);
  }
  EXPECT_EQ(0, num_unused);
  EXPECT_EQ(0, num_occupied);
  EXPECT_EQ(0, num_deleted);
}

ValidateMessageObject()

static ObjectPtr dart::ValidateMessageObject ( Zone *  zone, Isolate *  isolate, const Object &  obj  )

static

Definition at line 142 of file isolate.cc.

                                                          {
  TIMELINE_DURATION(Thread::Current(), Isolate, "ValidateMessageObject");
 
  class SendMessageValidator : public ObjectPointerVisitor {
   public:
    SendMessageValidator(IsolateGroup* isolate_group,
                         WeakTable* visited,
                         MallocGrowableArray<ObjectPtr>* const working_set)
        : ObjectPointerVisitor(isolate_group),
          visited_(visited),
          working_set_(working_set) {}
 
    void VisitObject(ObjectPtr obj) {
      if (!obj->IsHeapObject() || obj->untag()->IsCanonical()) {
        return;
      }
      if (visited_->GetValueExclusive(obj) == 1) {
        return;
      }
      visited_->SetValueExclusive(obj, 1);
      working_set_->Add(obj);
    }
 
   private:
    void VisitPointers(ObjectPtr* from, ObjectPtr* to) override {
      for (ObjectPtr* ptr = from; ptr <= to; ptr++) {
        VisitObject(*ptr);
      }
    }
 
#if defined(DART_COMPRESSED_POINTERS)
    void VisitCompressedPointers(uword heap_base,
                                 CompressedObjectPtr* from,
                                 CompressedObjectPtr* to) override {
      for (CompressedObjectPtr* ptr = from; ptr <= to; ptr++) {
        VisitObject(ptr->Decompress(heap_base));
      }
    }
#endif
 
    WeakTable* visited_;
    MallocGrowableArray<ObjectPtr>* const working_set_;
  };
  if (!obj.ptr()->IsHeapObject() || obj.ptr()->untag()->IsCanonical()) {
    return obj.ptr();
  }
  ClassTable* class_table = isolate->group()->class_table();
 
  Class& klass = Class::Handle(zone);
  Closure& closure = Closure::Handle(zone);
  Array& array = Array::Handle(zone);
  Object& illegal_object = Object::Handle(zone);
  const char* exception_message = nullptr;
  Thread* thread = Thread::Current();
 
  // working_set contains only elements that have not been visited yet that
  // need to be processed.
  // So before adding elements to working_set ensure to check visited flag,
  // set visited flag at the same time as the element is added.
 
  // This working set of raw pointers is visited by GC, only one for a given
  // isolate should be in use.
  MallocGrowableArray<ObjectPtr>* const working_set =
      isolate->pointers_to_verify_at_exit();
  ASSERT(working_set->length() == 0);
  std::unique_ptr<WeakTable> visited(new WeakTable());
 
  SendMessageValidator visitor(isolate->group(), visited.get(), working_set);
 
  visited->SetValueExclusive(obj.ptr(), 1);
  working_set->Add(obj.ptr());
 
  while (!working_set->is_empty() && (exception_message == nullptr)) {
    thread->CheckForSafepoint();
 
    ObjectPtr raw = working_set->RemoveLast();
    if (CanShareObjectAcrossIsolates(raw)) {
      continue;
    }
    const intptr_t cid = raw->GetClassId();
    switch (cid) {
      case kArrayCid: {
        array ^= Array::RawCast(raw);
        visitor.VisitObject(array.GetTypeArguments());
        const intptr_t batch_size = (2 << 14) - 1;
        for (intptr_t i = 0; i < array.Length(); ++i) {
          ObjectPtr ptr = array.At(i);
          visitor.VisitObject(ptr);
          if ((i & batch_size) == batch_size) {
            thread->CheckForSafepoint();
          }
        }
        continue;
      }
      case kClosureCid:
        closure ^= raw;
        // Only context has to be checked.
        working_set->Add(closure.RawContext());
        continue;
 
#define MESSAGE_SNAPSHOT_ILLEGAL(type)                                         \
  case k##type##Cid:                                                           \
    illegal_object = raw;                                                      \
    exception_message = "is a " #type;                                         \
    break;
 
        MESSAGE_SNAPSHOT_ILLEGAL(DynamicLibrary);
        // TODO(http://dartbug.com/47777): Send and exit support: remove this.
        MESSAGE_SNAPSHOT_ILLEGAL(Finalizer);
        MESSAGE_SNAPSHOT_ILLEGAL(NativeFinalizer);
        MESSAGE_SNAPSHOT_ILLEGAL(MirrorReference);
        MESSAGE_SNAPSHOT_ILLEGAL(Pointer);
        MESSAGE_SNAPSHOT_ILLEGAL(ReceivePort);
        MESSAGE_SNAPSHOT_ILLEGAL(UserTag);
        MESSAGE_SNAPSHOT_ILLEGAL(SuspendState);
 
      default:
        klass = class_table->At(cid);
        if (klass.is_isolate_unsendable()) {
          illegal_object = raw;
          exception_message =
              "is unsendable object (see restrictions listed at"
              "`SendPort.send()` documentation for more information)";
          break;
        }
    }
    raw->untag()->VisitPointers(&visitor);
  }
 
  ASSERT((exception_message == nullptr) == illegal_object.IsNull());
  if (exception_message != nullptr) {
    working_set->Clear();
 
    const Array& args = Array::Handle(zone, Array::New(3));
    args.SetAt(0, illegal_object);
    args.SetAt(2, String::Handle(
                      zone, String::NewFormatted(
                                "%s%s",
                                FindRetainingPath(
                                    zone, isolate, obj, illegal_object,
                                    TraversalRules::kInternalToIsolateGroup),
                                exception_message)));
    const Object& exception = Object::Handle(
        zone, Exceptions::Create(Exceptions::kArgumentValue, args));
    return UnhandledException::New(Instance::Cast(exception),
                                   StackTrace::Handle(zone));
  }
 
  ASSERT(working_set->length() == 0);
  isolate->set_forward_table_new(nullptr);
  return obj.ptr();
}

ValidateParameters()

static bool dart::ValidateParameters ( const MethodParameter *const *  parameters, JSONStream *  js  )

static

Definition at line 895 of file service.cc.

                                               {
  if (parameters == nullptr) {
    return true;
  }
  if (js->NumObjectParameters() > 0) {
    Object& value = Object::Handle();
    for (intptr_t i = 0; parameters[i] != nullptr; i++) {
      const MethodParameter* parameter = parameters[i];
      const char* name = parameter->name();
      const bool required = parameter->required();
      value = js->LookupObjectParam(name);
      const bool has_parameter = !value.IsNull();
      if (required && !has_parameter) {
        PrintMissingParamError(js, name);
        return false;
      }
      if (has_parameter && !parameter->ValidateObject(value)) {
        parameter->PrintErrorObject(name, value, js);
        return false;
      }
    }
  } else {
    for (intptr_t i = 0; parameters[i] != nullptr; i++) {
      const MethodParameter* parameter = parameters[i];
      const char* name = parameter->name();
      const bool required = parameter->required();
      const char* value = js->LookupParam(name);
      const bool has_parameter = (value != nullptr);
      if (required && !has_parameter) {
        PrintMissingParamError(js, name);
        return false;
      }
      if (has_parameter && !parameter->Validate(value)) {
        parameter->PrintError(name, value, js);
        return false;
      }
    }
  }
  return true;
}

ValidateSummary()

static void dart::ValidateSummary ( LocationSummary *  locs, Location  expected_output, const LocationArray *  expected_inputs, const LocationArray *  expected_temps  )

static

Definition at line 40 of file locations_helpers_test.cc.

                                                                 {
  EXPECT(locs->out(0).Equals(expected_output));
  EXPECT_EQ(expected_inputs->length(), locs->input_count());
  for (intptr_t i = 0; i < expected_inputs->length(); i++) {
    EXPECT(locs->in(i).Equals(expected_inputs->At(i)));
  }
  EXPECT_EQ(expected_temps->length(), locs->temp_count());
  for (intptr_t i = 0; i < expected_temps->length(); i++) {
    EXPECT(locs->temp(i).Equals(expected_temps->At(i)));
  }
}

ValidateThreadStackBounds()

static bool dart::ValidateThreadStackBounds ( uintptr_t  fp, uintptr_t  sp, uword  stack_lower, uword  stack_upper  )

static

Definition at line 344 of file profiler.cc.

                                                         {
  if (stack_lower >= stack_upper) {
    // Stack boundary is invalid.
    return false;
  }
 
  if ((sp < stack_lower) || (sp >= stack_upper)) {
    // Stack pointer is outside thread's stack boundary.
    return false;
  }
 
  if ((fp < stack_lower) || (fp >= stack_upper)) {
    // Frame pointer is outside threads's stack boundary.
    return false;
  }
 
  return true;
}

ValidOutputForAlwaysCalls()

static bool dart::ValidOutputForAlwaysCalls ( const Location &  loc )

static

Definition at line 201 of file locations.cc.

                                                           {
  return loc.IsMachineRegister() || loc.IsInvalid() || loc.IsPairLocation();
}

VARIABLE_COMPRESSED_VISITOR()

dart::VARIABLE_COMPRESSED_VISITOR	(	WeakArray	,
		Smi::Value(raw_obj->untag() ->length())
	)

VariadicAt11Doublex8FloatStruct12BytesHomogeneousF()

DART_EXPORT double dart::VariadicAt11Doublex8FloatStruct12BytesHomogeneousF	(	double	a0,
		double	a1,
		double	a2,
		double	a3,
		double	a4,
		double	a5,
		double	a6,
		double	a7,
		float	a8,
		Struct12BytesHomogeneousFloat	a9,
		int64_t	a10,
			...
	)

Definition at line 22832 of file ffi_test_functions_generated.cc.

         {
  va_list var_args;
  va_start(var_args, a10);
  int32_t a11 = va_arg(var_args, int32_t);
  Struct12BytesHomogeneousFloat a12 =
      va_arg(var_args, Struct12BytesHomogeneousFloat);
  va_end(var_args);
 
  std::cout << "VariadicAt11Doublex8FloatStruct12BytesHomogeneousF" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", "
            << a5 << ", " << a6 << ", " << a7 << ", " << a8 << ", (" << a9.a0
            << ", " << a9.a1 << ", " << a9.a2 << "), " << a10 << ", " << a11
            << ", (" << a12.a0 << ", " << a12.a1 << ", " << a12.a2 << "))"
            << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
  result += a5;
  result += a6;
  result += a7;
  result += a8;
  result += a9.a0;
  result += a9.a1;
  result += a9.a2;
  result += a10;
  result += a11;
  result += a12.a0;
  result += a12.a1;
  result += a12.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1DoubleInt64Int32DoubleInt64Int32()

DART_EXPORT double dart::VariadicAt1DoubleInt64Int32DoubleInt64Int32	(	double	a0,
			...
	)

Definition at line 22773 of file ffi_test_functions_generated.cc.

                                                                               {
  va_list var_args;
  va_start(var_args, a0);
  int64_t a1 = va_arg(var_args, int64_t);
  int32_t a2 = va_arg(var_args, int32_t);
  double a3 = va_arg(var_args, double);
  int64_t a4 = va_arg(var_args, int64_t);
  int32_t a5 = va_arg(var_args, int32_t);
  va_end(var_args);
 
  std::cout << "VariadicAt1DoubleInt64Int32DoubleInt64Int32" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", "
            << a5 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
  result += a5;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1DoubleInt64Int32Struct20BytesHomogeneou()

DART_EXPORT double dart::VariadicAt1DoubleInt64Int32Struct20BytesHomogeneou	(	double	a0,
			...
	)

Definition at line 22886 of file ffi_test_functions_generated.cc.

                                                                           {
  va_list var_args;
  va_start(var_args, a0);
  int64_t a1 = va_arg(var_args, int64_t);
  int32_t a2 = va_arg(var_args, int32_t);
  Struct20BytesHomogeneousInt32 a3 =
      va_arg(var_args, Struct20BytesHomogeneousInt32);
  double a4 = va_arg(var_args, double);
  int64_t a5 = va_arg(var_args, int64_t);
  int32_t a6 = va_arg(var_args, int32_t);
  Struct12BytesHomogeneousFloat a7 =
      va_arg(var_args, Struct12BytesHomogeneousFloat);
  int64_t a8 = va_arg(var_args, int64_t);
  va_end(var_args);
 
  std::cout << "VariadicAt1DoubleInt64Int32Struct20BytesHomogeneou" << "(" << a0
            << ", " << a1 << ", " << a2 << ", (" << a3.a0 << ", " << a3.a1
            << ", " << a3.a2 << ", " << a3.a3 << ", " << a3.a4 << "), " << a4
            << ", " << a5 << ", " << a6 << ", (" << a7.a0 << ", " << a7.a1
            << ", " << a7.a2 << "), " << a8 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3.a0;
  result += a3.a1;
  result += a3.a2;
  result += a3.a3;
  result += a3.a4;
  result += a4;
  result += a5;
  result += a6;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
  result += a8;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1DoubleStruct12BytesHomogeneousFloatDoub()

DART_EXPORT double dart::VariadicAt1DoubleStruct12BytesHomogeneousFloatDoub	(	double	a0,
			...
	)

Definition at line 22662 of file ffi_test_functions_generated.cc.

                                                                           {
  va_list var_args;
  va_start(var_args, a0);
  Struct12BytesHomogeneousFloat a1 =
      va_arg(var_args, Struct12BytesHomogeneousFloat);
  double a2 = va_arg(var_args, double);
  va_end(var_args);
 
  std::cout << "VariadicAt1DoubleStruct12BytesHomogeneousFloatDoub" << "(" << a0
            << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << "), " << a2
            << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1DoubleStruct20BytesHomogeneousFloatDoub()

DART_EXPORT double dart::VariadicAt1DoubleStruct20BytesHomogeneousFloatDoub	(	double	a0,
			...
	)

Definition at line 22720 of file ffi_test_functions_generated.cc.

                                                                           {
  va_list var_args;
  va_start(var_args, a0);
  Struct20BytesHomogeneousFloat a1 =
      va_arg(var_args, Struct20BytesHomogeneousFloat);
  double a2 = va_arg(var_args, double);
  va_end(var_args);
 
  std::cout << "VariadicAt1DoubleStruct20BytesHomogeneousFloatDoub" << "(" << a0
            << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", " << a1.a3
            << ", " << a1.a4 << "), " << a2 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a1.a4;
  result += a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Doublex2()

DART_EXPORT double dart::VariadicAt1Doublex2	(	double	a0,
			...
	)

Definition at line 22409 of file ffi_test_functions_generated.cc.

                                                       {
  va_list var_args;
  va_start(var_args, a0);
  double a1 = va_arg(var_args, double);
  va_end(var_args);
 
  std::cout << "VariadicAt1Doublex2" << "(" << a0 << ", " << a1 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Doublex20()

DART_EXPORT double dart::VariadicAt1Doublex20	(	double	a0,
			...
	)

Definition at line 22543 of file ffi_test_functions_generated.cc.

                                                        {
  va_list var_args;
  va_start(var_args, a0);
  double a1 = va_arg(var_args, double);
  double a2 = va_arg(var_args, double);
  double a3 = va_arg(var_args, double);
  double a4 = va_arg(var_args, double);
  double a5 = va_arg(var_args, double);
  double a6 = va_arg(var_args, double);
  double a7 = va_arg(var_args, double);
  double a8 = va_arg(var_args, double);
  double a9 = va_arg(var_args, double);
  double a10 = va_arg(var_args, double);
  double a11 = va_arg(var_args, double);
  double a12 = va_arg(var_args, double);
  double a13 = va_arg(var_args, double);
  double a14 = va_arg(var_args, double);
  double a15 = va_arg(var_args, double);
  double a16 = va_arg(var_args, double);
  double a17 = va_arg(var_args, double);
  double a18 = va_arg(var_args, double);
  double a19 = va_arg(var_args, double);
  va_end(var_args);
 
  std::cout << "VariadicAt1Doublex20" << "(" << a0 << ", " << a1 << ", " << a2
            << ", " << a3 << ", " << a4 << ", " << a5 << ", " << a6 << ", "
            << a7 << ", " << a8 << ", " << a9 << ", " << a10 << ", " << a11
            << ", " << a12 << ", " << a13 << ", " << a14 << ", " << a15 << ", "
            << a16 << ", " << a17 << ", " << a18 << ", " << a19 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
  result += a5;
  result += a6;
  result += a7;
  result += a8;
  result += a9;
  result += a10;
  result += a11;
  result += a12;
  result += a13;
  result += a14;
  result += a15;
  result += a16;
  result += a17;
  result += a18;
  result += a19;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Doublex2Struct32BytesHomogeneousDoubleD()

DART_EXPORT double dart::VariadicAt1Doublex2Struct32BytesHomogeneousDoubleD	(	double	a0,
			...
	)

Definition at line 22631 of file ffi_test_functions_generated.cc.

                                                                           {
  va_list var_args;
  va_start(var_args, a0);
  double a1 = va_arg(var_args, double);
  Struct32BytesHomogeneousDouble a2 =
      va_arg(var_args, Struct32BytesHomogeneousDouble);
  double a3 = va_arg(var_args, double);
  va_end(var_args);
 
  std::cout << "VariadicAt1Doublex2Struct32BytesHomogeneousDoubleD" << "(" << a0
            << ", " << a1 << ", (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2
            << ", " << a2.a3 << "), " << a3 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a2.a3;
  result += a3;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Doublex5()

DART_EXPORT double dart::VariadicAt1Doublex5	(	double	a0,
			...
	)

Definition at line 22456 of file ffi_test_functions_generated.cc.

                                                       {
  va_list var_args;
  va_start(var_args, a0);
  double a1 = va_arg(var_args, double);
  double a2 = va_arg(var_args, double);
  double a3 = va_arg(var_args, double);
  double a4 = va_arg(var_args, double);
  va_end(var_args);
 
  std::cout << "VariadicAt1Doublex5" << "(" << a0 << ", " << a1 << ", " << a2
            << ", " << a3 << ", " << a4 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Int32Struct20BytesHomogeneousInt32Int32()

DART_EXPORT int32_t dart::VariadicAt1Int32Struct20BytesHomogeneousInt32Int32	(	int32_t	a0,
			...
	)

Definition at line 22691 of file ffi_test_functions_generated.cc.

                                                                    {
  va_list var_args;
  va_start(var_args, a0);
  Struct20BytesHomogeneousInt32 a1 =
      va_arg(var_args, Struct20BytesHomogeneousInt32);
  int32_t a2 = va_arg(var_args, int32_t);
  va_end(var_args);
 
  std::cout << "VariadicAt1Int32Struct20BytesHomogeneousInt32Int32" << "(" << a0
            << ", (" << a1.a0 << ", " << a1.a1 << ", " << a1.a2 << ", " << a1.a3
            << ", " << a1.a4 << "), " << a2 << ")" << "\n";
 
  int32_t result = 0;
 
  result += a0;
  result += a1.a0;
  result += a1.a1;
  result += a1.a2;
  result += a1.a3;
  result += a1.a4;
  result += a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Int64Int32Struct12BytesHomogeneousFloat()

DART_EXPORT double dart::VariadicAt1Int64Int32Struct12BytesHomogeneousFloat	(	int64_t	a0,
			...
	)

Definition at line 22803 of file ffi_test_functions_generated.cc.

         {
  va_list var_args;
  va_start(var_args, a0);
  int32_t a1 = va_arg(var_args, int32_t);
  Struct12BytesHomogeneousFloat a2 =
      va_arg(var_args, Struct12BytesHomogeneousFloat);
  va_end(var_args);
 
  std::cout << "VariadicAt1Int64Int32Struct12BytesHomogeneousFloat" << "(" << a0
            << ", " << a1 << ", (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2
            << "))" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Int64x2()

DART_EXPORT int64_t dart::VariadicAt1Int64x2	(	int64_t	a0,
			...
	)

Definition at line 22389 of file ffi_test_functions_generated.cc.

                                                        {
  va_list var_args;
  va_start(var_args, a0);
  int64_t a1 = va_arg(var_args, int64_t);
  va_end(var_args);
 
  std::cout << "VariadicAt1Int64x2" << "(" << a0 << ", " << a1 << ")" << "\n";
 
  int64_t result = 0;
 
  result += a0;
  result += a1;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Int64x20()

DART_EXPORT int64_t dart::VariadicAt1Int64x20	(	int64_t	a0,
			...
	)

Definition at line 22483 of file ffi_test_functions_generated.cc.

                                                         {
  va_list var_args;
  va_start(var_args, a0);
  int64_t a1 = va_arg(var_args, int64_t);
  int64_t a2 = va_arg(var_args, int64_t);
  int64_t a3 = va_arg(var_args, int64_t);
  int64_t a4 = va_arg(var_args, int64_t);
  int64_t a5 = va_arg(var_args, int64_t);
  int64_t a6 = va_arg(var_args, int64_t);
  int64_t a7 = va_arg(var_args, int64_t);
  int64_t a8 = va_arg(var_args, int64_t);
  int64_t a9 = va_arg(var_args, int64_t);
  int64_t a10 = va_arg(var_args, int64_t);
  int64_t a11 = va_arg(var_args, int64_t);
  int64_t a12 = va_arg(var_args, int64_t);
  int64_t a13 = va_arg(var_args, int64_t);
  int64_t a14 = va_arg(var_args, int64_t);
  int64_t a15 = va_arg(var_args, int64_t);
  int64_t a16 = va_arg(var_args, int64_t);
  int64_t a17 = va_arg(var_args, int64_t);
  int64_t a18 = va_arg(var_args, int64_t);
  int64_t a19 = va_arg(var_args, int64_t);
  va_end(var_args);
 
  std::cout << "VariadicAt1Int64x20" << "(" << a0 << ", " << a1 << ", " << a2
            << ", " << a3 << ", " << a4 << ", " << a5 << ", " << a6 << ", "
            << a7 << ", " << a8 << ", " << a9 << ", " << a10 << ", " << a11
            << ", " << a12 << ", " << a13 << ", " << a14 << ", " << a15 << ", "
            << a16 << ", " << a17 << ", " << a18 << ", " << a19 << ")" << "\n";
 
  int64_t result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
  result += a5;
  result += a6;
  result += a7;
  result += a8;
  result += a9;
  result += a10;
  result += a11;
  result += a12;
  result += a13;
  result += a14;
  result += a15;
  result += a16;
  result += a17;
  result += a18;
  result += a19;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Int64x2Struct8BytesIntInt64()

DART_EXPORT int64_t dart::VariadicAt1Int64x2Struct8BytesIntInt64	(	int64_t	a0,
			...
	)

Definition at line 22603 of file ffi_test_functions_generated.cc.

                                                                            {
  va_list var_args;
  va_start(var_args, a0);
  int64_t a1 = va_arg(var_args, int64_t);
  Struct8BytesInt a2 = va_arg(var_args, Struct8BytesInt);
  int64_t a3 = va_arg(var_args, int64_t);
  va_end(var_args);
 
  std::cout << "VariadicAt1Int64x2Struct8BytesIntInt64" << "(" << a0 << ", "
            << a1 << ", (" << a2.a0 << ", " << a2.a1 << ", " << a2.a2 << "), "
            << a3 << ")" << "\n";
 
  int64_t result = 0;
 
  result += a0;
  result += a1;
  result += a2.a0;
  result += a2.a1;
  result += a2.a2;
  result += a3;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Int64x5()

DART_EXPORT int64_t dart::VariadicAt1Int64x5	(	int64_t	a0,
			...
	)

Definition at line 22429 of file ffi_test_functions_generated.cc.

                                                        {
  va_list var_args;
  va_start(var_args, a0);
  int64_t a1 = va_arg(var_args, int64_t);
  int64_t a2 = va_arg(var_args, int64_t);
  int64_t a3 = va_arg(var_args, int64_t);
  int64_t a4 = va_arg(var_args, int64_t);
  va_end(var_args);
 
  std::cout << "VariadicAt1Int64x5" << "(" << a0 << ", " << a1 << ", " << a2
            << ", " << a3 << ", " << a4 << ")" << "\n";
 
  int64_t result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Int64x7Struct12BytesHomogeneousInt32()

DART_EXPORT int64_t dart::VariadicAt1Int64x7Struct12BytesHomogeneousInt32	(	int64_t	a0,
			...
	)

Definition at line 22962 of file ffi_test_functions_generated.cc.

                                                                         {
  va_list var_args;
  va_start(var_args, a0);
  int64_t a1 = va_arg(var_args, int64_t);
  int64_t a2 = va_arg(var_args, int64_t);
  int64_t a3 = va_arg(var_args, int64_t);
  int64_t a4 = va_arg(var_args, int64_t);
  int64_t a5 = va_arg(var_args, int64_t);
  int64_t a6 = va_arg(var_args, int64_t);
  Struct12BytesHomogeneousInt32 a7 =
      va_arg(var_args, Struct12BytesHomogeneousInt32);
  va_end(var_args);
 
  std::cout << "VariadicAt1Int64x7Struct12BytesHomogeneousInt32" << "(" << a0
            << ", " << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", "
            << a5 << ", " << a6 << ", (" << a7.a0 << ", " << a7.a1 << ", "
            << a7.a2 << "))" << "\n";
 
  int64_t result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
  result += a5;
  result += a6;
  result += a7.a0;
  result += a7.a1;
  result += a7.a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt1Struct12BytesHomogeneousInt32Int32x4()

DART_EXPORT int32_t dart::VariadicAt1Struct12BytesHomogeneousInt32Int32x4	(	Struct12BytesHomogeneousInt32	a0,
			...
	)

Definition at line 23001 of file ffi_test_functions_generated.cc.

         {
  va_list var_args;
  va_start(var_args, a0);
  int32_t a1 = va_arg(var_args, int32_t);
  int32_t a2 = va_arg(var_args, int32_t);
  int32_t a3 = va_arg(var_args, int32_t);
  int32_t a4 = va_arg(var_args, int32_t);
  va_end(var_args);
 
  std::cout << "VariadicAt1Struct12BytesHomogeneousInt32Int32x4" << "(("
            << a0.a0 << ", " << a0.a1 << ", " << a0.a2 << "), " << a1 << ", "
            << a2 << ", " << a3 << ", " << a4 << ")" << "\n";
 
  int32_t result = 0;
 
  result += a0.a0;
  result += a0.a1;
  result += a0.a2;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt2Int32Int64IntPtr()

DART_EXPORT int32_t dart::VariadicAt2Int32Int64IntPtr	(	int32_t	a0,
		int64_t	a1,
			...
	)

Definition at line 22751 of file ffi_test_functions_generated.cc.

                                                                             {
  va_list var_args;
  va_start(var_args, a1);
  intptr_t a2 = va_arg(var_args, intptr_t);
  va_end(var_args);
 
  std::cout << "VariadicAt2Int32Int64IntPtr" << "(" << a0 << ", " << a1 << ", "
            << a2 << ")" << "\n";
 
  int32_t result = 0;
 
  result += a0;
  result += a1;
  result += a2;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicAt5Doublex5()

DART_EXPORT double dart::VariadicAt5Doublex5	(	double	a0,
		double	a1,
		double	a2,
		double	a3,
		double	a4,
			...
	)

Definition at line 22933 of file ffi_test_functions_generated.cc.

                                            {
  va_list var_args;
  va_start(var_args, a4);
 
  va_end(var_args);
 
  std::cout << "VariadicAt5Doublex5" << "(" << a0 << ", " << a1 << ", " << a2
            << ", " << a3 << ", " << a4 << ")" << "\n";
 
  double result = 0;
 
  result += a0;
  result += a1;
  result += a2;
  result += a3;
  result += a4;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VariadicStructVarArgs()

DART_EXPORT int64_t dart::VariadicStructVarArgs	(	VarArgs	a0,
			...
	)

Definition at line 1267 of file ffi_test_functions.cc.

                                                           {
  va_list var_args;
  va_start(var_args, a0);
  VarArgs a1 = va_arg(var_args, VarArgs);
  va_end(var_args);
 
  std::cout << "VariadicStructVarArgs" << "(" << a0.a << ", " << a1.a << ")"
            << "\n";
 
  int64_t result = 0;
 
  result += a0.a;
  result += a1.a;
 
  std::cout << "result = " << result << "\n";
 
  return result;
}

VerifyEntryPoint()

DART_WARN_UNUSED_RESULT ErrorPtr dart::VerifyEntryPoint	(	const Library &	lib,
		const Object &	member,
		const Object &	annotated,
		std::initializer_list< EntryPointPragma >	allowed_kinds
	)

Definition at line 27227 of file object.cc.

                                                         {
#if defined(DART_PRECOMPILED_RUNTIME)
  // Annotations are discarded in the AOT snapshot, so we can't determine
  // precisely if this member was marked as an entry-point. Instead, we use
  // "has_pragma()" as a proxy, since that bit is usually retained.
  bool is_marked_entrypoint = true;
  if (annotated.IsClass() && !Class::Cast(annotated).has_pragma()) {
    is_marked_entrypoint = false;
  } else if (annotated.IsField() && !Field::Cast(annotated).has_pragma()) {
    is_marked_entrypoint = false;
  } else if (annotated.IsFunction() &&
             !Function::Cast(annotated).has_pragma()) {
    is_marked_entrypoint = false;
  }
#else
  Object& metadata = Object::Handle(Object::empty_array().ptr());
  if (!annotated.IsNull()) {
    metadata = lib.GetMetadata(annotated);
  }
  if (metadata.IsError()) return Error::RawCast(metadata.ptr());
  ASSERT(!metadata.IsNull() && metadata.IsArray());
  EntryPointPragma pragma =
      FindEntryPointPragma(IsolateGroup::Current(), Array::Cast(metadata),
                           &Field::Handle(), &Object::Handle());
  bool is_marked_entrypoint = pragma == EntryPointPragma::kAlways;
  if (!is_marked_entrypoint) {
    for (const auto allowed_kind : allowed_kinds) {
      if (pragma == allowed_kind) {
        is_marked_entrypoint = true;
        break;
      }
    }
  }
#endif
  if (!is_marked_entrypoint) {
    return EntryPointMemberInvocationError(member);
  }
  return Error::null();
}

VerifyMethodKindShifts()

static void dart::VerifyMethodKindShifts ( )

static

Definition at line 584 of file mirrors.cc.

                                     {
#ifdef DEBUG
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const Library& lib = Library::Handle(zone, Library::MirrorsLibrary());
  const Class& cls = Class::Handle(
      zone, lib.LookupClassAllowPrivate(Symbols::_MethodMirror()));
  Error& error = Error::Handle(zone);
  error ^= cls.EnsureIsFinalized(thread);
  ASSERT(error.IsNull());
 
  Field& field = Field::Handle(zone);
  Smi& value = Smi::Handle(zone);
  String& fname = String::Handle(zone);
 
#define CHECK_KIND_SHIFT(name)                                                 \
  fname ^= String::New(#name);                                                 \
  field = cls.LookupField(fname);                                              \
  ASSERT(!field.IsNull());                                                     \
  if (field.IsUninitialized()) {                                               \
    error ^= field.InitializeStatic();                                         \
    ASSERT(error.IsNull());                                                    \
  }                                                                            \
  value ^= field.StaticValue();                                                \
  ASSERT(value.Value() == Mirrors::name);
  MIRRORS_KIND_SHIFT_LIST(CHECK_KIND_SHIFT)
#undef CHECK_KIND_SHIFT
#endif
}

VerifyStackOverflowStackTraceInfo()

void dart::VerifyStackOverflowStackTraceInfo	(	const char *	script,
		const char *	top_frame_func_name,
		const char *	entry_func_name,
		int	expected_line_number,
		int	expected_column_number
	)

Definition at line 396 of file dart_api_impl_test.cc.

                                                                   {
  Dart_Handle lib = TestCase::LoadTestScript(script, nullptr);
  Dart_Handle error = Dart_Invoke(lib, NewString(entry_func_name), 0, nullptr);
 
  EXPECT(Dart_IsError(error));
 
  Dart_StackTrace stacktrace;
  Dart_Handle result = Dart_GetStackTraceFromError(error, &stacktrace);
  EXPECT_VALID(result);
 
  intptr_t frame_count = 0;
  result = Dart_StackTraceLength(stacktrace, &frame_count);
  EXPECT_VALID(result);
  EXPECT_EQ(StackTrace::kPreallocatedStackdepth - 1, frame_count);
 
  Dart_Handle function_name;
  Dart_Handle script_url;
  intptr_t line_number = 0;
  intptr_t column_number = 0;
  const char* cstr = "";
 
  // Top frame at recursive call.
  Dart_ActivationFrame frame;
  result = Dart_GetActivationFrame(stacktrace, 0, &frame);
  EXPECT_VALID(result);
  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
                                    &line_number, &column_number);
  EXPECT_VALID(result);
  Dart_StringToCString(function_name, &cstr);
  EXPECT_STREQ(top_frame_func_name, cstr);
  Dart_StringToCString(script_url, &cstr);
  EXPECT_STREQ(TestCase::url(), cstr);
  EXPECT_EQ(expected_line_number, line_number);
  EXPECT_EQ(expected_column_number, column_number);
 
  // Out-of-bounds frames.
  result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
  EXPECT(Dart_IsError(result));
  result = Dart_GetActivationFrame(stacktrace, -1, &frame);
  EXPECT(Dart_IsError(result));
}

VerifyStringMapsEqual()

template<typename Map >

void dart::VerifyStringMapsEqual	(	const std::map< std::string, int > &	expected,
		const Map &	actual,
		bool	ordered
	)

Definition at line 159 of file hash_table_test.cc.

                                         {
  intptr_t expected_size = expected.size();
  // Get actual concatenated (key, value) pairs in iteration order.
  Array& entries = Array::Handle(HashTables::ToArray(actual, true));
  // Cardinality must match.
  EXPECT_EQ(expected_size * 2, entries.Length());
  std::vector<std::pair<std::string, int> > expected_vec(expected.begin(),
                                                         expected.end());
  // Check containment.
  Smi& value = Smi::Handle();
  for (uintptr_t i = 0; i < expected_vec.size(); ++i) {
    std::string key = expected_vec[i].first;
    EXPECT(actual.ContainsKey(key.c_str()));
    value ^= actual.GetOrNull(key.c_str());
    EXPECT_EQ(expected_vec[i].second, value.Value());
  }
  if (!ordered) {
    return;
  }
  // Equality including order.
  std::vector<std::string> actual_vec;
  String& key = String::Handle();
  for (int i = 0; i < expected_size; ++i) {
    key ^= entries.At(2 * i);
    value ^= entries.At(2 * i + 1);
    EXPECT(expected_vec[i].first == ToStdString(key));
    EXPECT_EQ(expected_vec[i].second, value.Value());
  }
}

VerifyStringSetsEqual()

template<typename Set >

void dart::VerifyStringSetsEqual	(	const std::set< std::string > &	expected,
		const Set &	actual,
		bool	ordered
	)

Definition at line 129 of file hash_table_test.cc.

                                         {
  // Get actual keys in iteration order.
  Array& keys = Array::Handle(HashTables::ToArray(actual, true));
  // Cardinality must match.
  EXPECT_EQ(static_cast<intptr_t>(expected.size()), keys.Length());
  std::vector<std::string> expected_vec(expected.begin(), expected.end());
  // Check containment.
  for (uintptr_t i = 0; i < expected_vec.size(); ++i) {
    EXPECT(actual.ContainsKey(expected_vec[i].c_str()));
  }
  // Equality, including order, if requested.
  std::vector<std::string> actual_vec;
  String& key = String::Handle();
  for (int i = 0; i < keys.Length(); ++i) {
    key ^= keys.At(i);
    actual_vec.push_back(ToStdString(key));
  }
  if (!ordered) {
    std::sort(actual_vec.begin(), actual_vec.end());
  }
  EXPECT(
      std::equal(actual_vec.begin(), actual_vec.end(), expected_vec.begin()));
}

VisitSamples()

static void dart::VisitSamples ( SampleBlockBuffer *  buffer, SampleVisitor *  visitor  )

static

Definition at line 83 of file profiler_test.cc.

                                                                            {
  visitor->Reset();
  buffer->VisitSamples(visitor);
}

VM_UNIT_TEST_CASE() [1/107]

dart::VM_UNIT_TEST_CASE

(

AllocateAlignedVirtualMemory

)

Definition at line 54 of file virtual_memory_test.cc.

                                                {
  intptr_t kHeapPageSize = kPageSize;
  intptr_t kVirtualPageSize = 4096;
 
  intptr_t kIterations = kHeapPageSize / kVirtualPageSize;
  for (intptr_t i = 0; i < kIterations; i++) {
    VirtualMemory* vm = VirtualMemory::AllocateAligned(
        kHeapPageSize, kHeapPageSize, false, false, "test");
    EXPECT(Utils::IsAligned(vm->start(), kHeapPageSize));
    EXPECT_EQ(kHeapPageSize, vm->size());
    delete vm;
  }
}

VM_UNIT_TEST_CASE() [2/107]

dart::VM_UNIT_TEST_CASE

(

AllocateVirtualMemory

)

Definition at line 22 of file virtual_memory_test.cc.

                                         {
  const intptr_t kVirtualMemoryBlockSize = 64 * KB;
  VirtualMemory* vm =
      VirtualMemory::Allocate(kVirtualMemoryBlockSize, false, false, "test");
  EXPECT(vm != nullptr);
  EXPECT(vm->address() != nullptr);
  EXPECT_EQ(vm->start(), reinterpret_cast<uword>(vm->address()));
  EXPECT_EQ(kVirtualMemoryBlockSize, vm->size());
  EXPECT_EQ(vm->start() + kVirtualMemoryBlockSize, vm->end());
  EXPECT(vm->Contains(vm->start()));
  EXPECT(vm->Contains(vm->start() + 1));
  EXPECT(vm->Contains(vm->start() + kVirtualMemoryBlockSize - 1));
  EXPECT(vm->Contains(vm->start() + (kVirtualMemoryBlockSize / 2)));
  EXPECT(!vm->Contains(vm->start() - 1));
  EXPECT(!vm->Contains(vm->end()));
  EXPECT(!vm->Contains(vm->end() + 1));
  EXPECT(!vm->Contains(0));
  EXPECT(!vm->Contains(static_cast<uword>(-1)));
 
  char* buf = reinterpret_cast<char*>(vm->address());
  EXPECT(IsZero(buf, buf + vm->size()));
  buf[0] = 'a';
  buf[1] = 'c';
  buf[2] = '/';
  buf[3] = 'd';
  buf[4] = 'c';
  buf[5] = 0;
  EXPECT_STREQ("ac/dc", buf);
 
  delete vm;
}

VM_UNIT_TEST_CASE() [3/107]

dart::VM_UNIT_TEST_CASE

(

AllocateZone

)

Definition at line 15 of file zone_test.cc.

                                {
#if defined(DEBUG)
  FLAG_trace_zones = true;
#endif
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->zone() == nullptr);
  {
    TransitionNativeToVM transition(thread);
    StackZone stack_zone(thread);
    EXPECT(thread->zone() != nullptr);
    Zone* zone = stack_zone.GetZone();
    uintptr_t allocated_size = 0;
 
    // The loop is to make sure we overflow one segment and go on
    // to the next segment.
    for (int i = 0; i < 1000; i++) {
      uword first = zone->AllocUnsafe(2 * kWordSize);
      uword second = zone->AllocUnsafe(3 * kWordSize);
      EXPECT(first != second);
      allocated_size = ((2 + 3) * kWordSize);
    }
    EXPECT_LE(allocated_size, zone->SizeInBytes());
 
    // Test for allocation of large segments.
    const uword kLargeSize = 1 * MB;
    const uword kSegmentSize = 64 * KB;
    ASSERT(kLargeSize > kSegmentSize);
    for (int i = 0; i < 10; i++) {
      EXPECT(zone->AllocUnsafe(kLargeSize) != 0);
      allocated_size += kLargeSize;
    }
    EXPECT_LE(allocated_size, zone->SizeInBytes());
 
    // Test corner cases of kSegmentSize.
    uint8_t* buffer = nullptr;
    buffer =
        reinterpret_cast<uint8_t*>(zone->AllocUnsafe(kSegmentSize - kWordSize));
    EXPECT(buffer != nullptr);
    buffer[(kSegmentSize - kWordSize) - 1] = 0;
    allocated_size += (kSegmentSize - kWordSize);
    EXPECT_LE(allocated_size, zone->SizeInBytes());
 
    buffer = reinterpret_cast<uint8_t*>(
        zone->AllocUnsafe(kSegmentSize - (2 * kWordSize)));
    EXPECT(buffer != nullptr);
    buffer[(kSegmentSize - (2 * kWordSize)) - 1] = 0;
    allocated_size += (kSegmentSize - (2 * kWordSize));
    EXPECT_LE(allocated_size, zone->SizeInBytes());
 
    buffer =
        reinterpret_cast<uint8_t*>(zone->AllocUnsafe(kSegmentSize + kWordSize));
    EXPECT(buffer != nullptr);
    buffer[(kSegmentSize + kWordSize) - 1] = 0;
    allocated_size += (kSegmentSize + kWordSize);
    EXPECT_LE(allocated_size, zone->SizeInBytes());
  }
  EXPECT(thread->zone() == nullptr);
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [4/107]

dart::VM_UNIT_TEST_CASE

(

AllocGeneric_Success

)

Definition at line 76 of file zone_test.cc.

                                        {
#if defined(DEBUG)
  FLAG_trace_zones = true;
#endif
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->zone() == nullptr);
  {
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
    EXPECT(thread->zone() != nullptr);
    uintptr_t allocated_size = 0;
 
    const intptr_t kNumElements = 1000;
    zone.GetZone()->Alloc<uint32_t>(kNumElements);
    allocated_size += sizeof(uint32_t) * kNumElements;
    EXPECT_LE(allocated_size, zone.SizeInBytes());
  }
  EXPECT(thread->zone() == nullptr);
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [5/107]

dart::VM_UNIT_TEST_CASE

(

BasicFlags

)

Definition at line 16 of file flags_test.cc.

                              {
  EXPECT_EQ(true, FLAG_basic_flag);
  EXPECT_EQ(false, FLAG_verbose_gc);
  EXPECT_EQ(false, FLAG_print_flags);
}

VM_UNIT_TEST_CASE() [6/107]

dart::VM_UNIT_TEST_CASE

(

BitFields

)

Definition at line 13 of file bitfield_test.cc.

                             {
  class TestBitFields : public BitField<uword, int32_t, 1, 8> {};
  EXPECT(TestBitFields::is_valid(16));
  EXPECT(!TestBitFields::is_valid(256));
  EXPECT_EQ(0x00ffU, TestBitFields::mask());
  EXPECT_EQ(0x001feU, TestBitFields::mask_in_place());
  EXPECT_EQ(1, TestBitFields::shift());
  EXPECT_EQ(8, TestBitFields::bitsize());
  EXPECT_EQ(32U, TestBitFields::encode(16));
  EXPECT_EQ(16, TestBitFields::decode(32));
  EXPECT_EQ(2U, TestBitFields::update(1, 16));
}

VM_UNIT_TEST_CASE() [7/107]

dart::VM_UNIT_TEST_CASE

(

BitFields_SignedField

)

Definition at line 68 of file bitfield_test.cc.

                                         {
  TestSignExtendedBitField<uint32_t>();
  TestSignExtendedBitField<int32_t>();
}

VM_UNIT_TEST_CASE() [8/107]

dart::VM_UNIT_TEST_CASE

(

BoolField

)

Definition at line 12 of file boolfield_test.cc.

                             {
  class TestBoolField : public BoolField<1> {};
  EXPECT(TestBoolField::decode(2));
  EXPECT(!TestBoolField::decode(1));
  EXPECT_EQ(2U, TestBoolField::encode(true));
  EXPECT_EQ(0U, TestBoolField::encode(false));
  EXPECT_EQ(3U, TestBoolField::update(true, 1));
  EXPECT_EQ(1U, TestBoolField::update(false, 1));
}

VM_UNIT_TEST_CASE() [9/107]

dart::VM_UNIT_TEST_CASE

(

CleanupBequestNeverReceived

)

Definition at line 537 of file heap_test.cc.

                                               {
  const char* TEST_MESSAGE = "hello, world";
  Dart_Isolate parent = TestCase::CreateTestIsolate("parent");
  EXPECT_EQ(parent, Dart_CurrentIsolate());
  {
    SendAndExitMessagesHandler handler(Isolate::Current());
    Dart_Port port_id = PortMap::CreatePort(&handler);
    EXPECT_EQ(PortMap::GetIsolate(port_id), Isolate::Current());
    Dart_ExitIsolate();
 
    Dart_Isolate worker = TestCase::CreateTestIsolateInGroup("worker", parent);
    EXPECT_EQ(worker, Dart_CurrentIsolate());
    {
      Thread* thread = Thread::Current();
      TransitionNativeToVM transition(thread);
      StackZone zone(thread);
 
      String& string = String::Handle(String::New(TEST_MESSAGE));
      PersistentHandle* handle =
          Isolate::Current()->group()->api_state()->AllocatePersistentHandle();
      handle->set_ptr(string.ptr());
 
      reinterpret_cast<Isolate*>(worker)->bequeath(
          std::unique_ptr<Bequest>(new Bequest(handle, port_id)));
    }
  }
  Dart_ShutdownIsolate();
  Dart_EnterIsolate(parent);
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [10/107]

dart::VM_UNIT_TEST_CASE

(

CountLeadingZeros32

)

Definition at line 220 of file utils_test.cc.

                                       {
  EXPECT_EQ(32, Utils::CountLeadingZeros32(0x0));
  EXPECT_EQ(31, Utils::CountLeadingZeros32(0x1));
  EXPECT_EQ(4, Utils::CountLeadingZeros32(0x0F0F0000));
  EXPECT_EQ(1, Utils::CountLeadingZeros32(0x7FFFFFFF));
  EXPECT_EQ(0, Utils::CountLeadingZeros32(0xFFFFFFFF));
}

VM_UNIT_TEST_CASE() [11/107]

dart::VM_UNIT_TEST_CASE

(

CountLeadingZeros64

)

Definition at line 228 of file utils_test.cc.

                                       {
  EXPECT_EQ(64, Utils::CountLeadingZeros64(0x0));
  EXPECT_EQ(63, Utils::CountLeadingZeros64(0x1));
  EXPECT_EQ(4, Utils::CountLeadingZeros64(0x0F0F000000000000LLU));
  EXPECT_EQ(1, Utils::CountLeadingZeros64(0x7FFFFFFFFFFFFFFFLLU));
  EXPECT_EQ(0, Utils::CountLeadingZeros64(0xFFFFFFFFFFFFFFFFLLU));
}

VM_UNIT_TEST_CASE() [12/107]

dart::VM_UNIT_TEST_CASE

(

CountOneBits32

)

Definition at line 160 of file utils_test.cc.

                                  {
  EXPECT_EQ(0, Utils::CountOneBits32(0));
  EXPECT_EQ(1, Utils::CountOneBits32(0x00000010));
  EXPECT_EQ(1, Utils::CountOneBits32(0x00010000));
  EXPECT_EQ(1, Utils::CountOneBits32(0x10000000));
  EXPECT_EQ(4, Utils::CountOneBits32(0x10101010));
  EXPECT_EQ(8, Utils::CountOneBits32(0x03030303));
  EXPECT_EQ(32, Utils::CountOneBits32(0xFFFFFFFF));
}

VM_UNIT_TEST_CASE() [13/107]

dart::VM_UNIT_TEST_CASE

(

CountOneBits64

)

Definition at line 170 of file utils_test.cc.

                                  {
  EXPECT_EQ(0, Utils::CountOneBits64(DART_UINT64_C(0)));
  EXPECT_EQ(1, Utils::CountOneBits64(DART_UINT64_C(0x00000010)));
  EXPECT_EQ(1, Utils::CountOneBits64(DART_UINT64_C(0x00010000)));
  EXPECT_EQ(1, Utils::CountOneBits64(DART_UINT64_C(0x10000000)));
  EXPECT_EQ(4, Utils::CountOneBits64(DART_UINT64_C(0x10101010)));
  EXPECT_EQ(8, Utils::CountOneBits64(DART_UINT64_C(0x03030303)));
  EXPECT_EQ(32, Utils::CountOneBits64(DART_UINT64_C(0xFFFFFFFF)));
  EXPECT_EQ(2, Utils::CountOneBits64(DART_UINT64_C(0x0000001000000010)));
  EXPECT_EQ(2, Utils::CountOneBits64(DART_UINT64_C(0x0001000000010000)));
  EXPECT_EQ(2, Utils::CountOneBits64(DART_UINT64_C(0x1000000010000000)));
  EXPECT_EQ(8, Utils::CountOneBits64(DART_UINT64_C(0x1010101010101010)));
  EXPECT_EQ(16, Utils::CountOneBits64(DART_UINT64_C(0x0303030303030303)));
  EXPECT_EQ(64, Utils::CountOneBits64(DART_UINT64_C(0xFFFFFFFFFFFFFFFF)));
}

VM_UNIT_TEST_CASE() [14/107]

dart::VM_UNIT_TEST_CASE

(

CountOneBitsWord

)

Definition at line 186 of file utils_test.cc.

                                    {
  EXPECT_EQ(0, Utils::CountOneBitsWord(0));
  EXPECT_EQ(1, Utils::CountOneBitsWord(0x00000010));
  EXPECT_EQ(1, Utils::CountOneBitsWord(0x00010000));
  EXPECT_EQ(1, Utils::CountOneBitsWord(0x10000000));
  EXPECT_EQ(4, Utils::CountOneBitsWord(0x10101010));
  EXPECT_EQ(8, Utils::CountOneBitsWord(0x03030303));
  EXPECT_EQ(32, Utils::CountOneBitsWord(0xFFFFFFFF));
#if defined(ARCH_IS_64_BIT)
  EXPECT_EQ(2, Utils::CountOneBitsWord(0x0000001000000010));
  EXPECT_EQ(2, Utils::CountOneBitsWord(0x0001000000010000));
  EXPECT_EQ(2, Utils::CountOneBitsWord(0x1000000010000000));
  EXPECT_EQ(8, Utils::CountOneBitsWord(0x1010101010101010));
  EXPECT_EQ(16, Utils::CountOneBitsWord(0x0303030303030303));
  EXPECT_EQ(64, Utils::CountOneBitsWord(0xFFFFFFFFFFFFFFFF));
#endif
}

VM_UNIT_TEST_CASE() [15/107]

dart::VM_UNIT_TEST_CASE

(

CountTrailingZeros32

)

Definition at line 204 of file utils_test.cc.

                                        {
  EXPECT_EQ(0, Utils::CountTrailingZeros32(0x1));
  EXPECT_EQ(1, Utils::CountTrailingZeros32(0x2));
  EXPECT_EQ(4, Utils::CountTrailingZeros32(0x0f0f0));
  EXPECT_EQ(31, Utils::CountTrailingZeros32(0x80000000));
  EXPECT_EQ(32, Utils::CountTrailingZeros32(0x0));
}

VM_UNIT_TEST_CASE() [16/107]

dart::VM_UNIT_TEST_CASE

(

CountTrailingZeros64

)

Definition at line 212 of file utils_test.cc.

                                        {
  EXPECT_EQ(0, Utils::CountTrailingZeros64(0x1));
  EXPECT_EQ(1, Utils::CountTrailingZeros64(0x2));
  EXPECT_EQ(4, Utils::CountTrailingZeros64(0x0f0f0));
  EXPECT_EQ(63, Utils::CountTrailingZeros64(0x8000000000000000LLU));
  EXPECT_EQ(64, Utils::CountTrailingZeros64(0x0));
}

VM_UNIT_TEST_CASE() [17/107]

dart::VM_UNIT_TEST_CASE

(

CountZerosWord

)

Definition at line 236 of file utils_test.cc.

                                  {
  EXPECT_EQ(kBitsPerWord, Utils::CountTrailingZerosWord(0x0));
  EXPECT_EQ(kBitsPerWord, Utils::CountLeadingZerosWord(0x0));
  EXPECT_EQ(0, Utils::CountTrailingZerosWord(0x1));
  EXPECT_EQ(kBitsPerWord - 1, Utils::CountLeadingZerosWord(0x1));
  EXPECT_EQ(1, Utils::CountTrailingZerosWord(0x2));
  EXPECT_EQ(kBitsPerWord - 2, Utils::CountLeadingZerosWord(0x2));
  EXPECT_EQ(0, Utils::CountTrailingZerosWord(0x3));
  EXPECT_EQ(kBitsPerWord - 2, Utils::CountLeadingZerosWord(0x3));
  EXPECT_EQ(2, Utils::CountTrailingZerosWord(0x4));
  EXPECT_EQ(kBitsPerWord - 3, Utils::CountLeadingZerosWord(0x4));
  EXPECT_EQ(0, Utils::CountTrailingZerosWord(kUwordMax));
  EXPECT_EQ(0, Utils::CountLeadingZerosWord(kUwordMax));
  const uword kTopBit = static_cast<uword>(1) << (kBitsPerWord - 1);
  EXPECT_EQ(kBitsPerWord - 1, Utils::CountTrailingZerosWord(kTopBit));
  EXPECT_EQ(0, Utils::CountLeadingZerosWord(kTopBit));
}

VM_UNIT_TEST_CASE() [18/107]

dart::VM_UNIT_TEST_CASE

(

CustomIsolates

)

Definition at line 309 of file custom_isolate_test.cc.

                                  {
  bool saved_flag = FLAG_trace_shutdown;
  FLAG_trace_shutdown = true;
  event_queue = new EventQueue();
 
  Dart_Isolate dart_isolate = TestCase::CreateTestIsolate();
  EXPECT(dart_isolate != nullptr);
  Dart_SetMessageNotifyCallback(&NotifyMessage);
  Dart_EnterScope();
  Dart_Handle result;
 
  // Create a test library.
  Dart_Handle lib =
      TestCase::LoadTestScript(kCustomIsolateScriptChars, NativeLookup);
  EXPECT_VALID(lib);
 
  // Run main.
  result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  EXPECT(Dart_IsString(result));
  const char* result_str = nullptr;
  EXPECT_VALID(Dart_StringToCString(result, &result_str));
  EXPECT_STREQ("success", result_str);
 
  Dart_ExitScope();
  Dart_ExitIsolate();
 
  OS::PrintErr("-- Starting event loop --\n");
  Event* event = event_queue->Get();
  while (event != nullptr) {
    event->Process();
    delete event;
    event = event_queue->Get();
  }
  OS::PrintErr("-- Finished event loop --\n");
  EXPECT_STREQ("Received: 43", saved_echo);
  free(saved_echo);
 
  delete event_queue;
  event_queue = nullptr;
  FLAG_trace_shutdown = saved_flag;
}

VM_UNIT_TEST_CASE() [19/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_AssignToPersistentHandle

)

Definition at line 3408 of file dart_api_impl_test.cc.

                                                    {
  const char* kTestString1 = "Test String1";
  const char* kTestString2 = "Test String2";
  TestIsolateScope __test_isolate__;
 
  Thread* T = Thread::Current();
  CHECK_API_SCOPE(T);
  Isolate* isolate = T->isolate();
  EXPECT(isolate != nullptr);
  ApiState* state = isolate->group()->api_state();
  EXPECT(state != nullptr);
 
  // Start with a known persistent handle.
  Dart_Handle ref1 = Dart_NewStringFromCString(kTestString1);
  Dart_PersistentHandle obj = Dart_NewPersistentHandle(ref1);
  EXPECT(state->IsValidPersistentHandle(obj));
  {
    TransitionNativeToVM transition(T);
    HANDLESCOPE(T);
    String& str = String::Handle();
    str ^= PersistentHandle::Cast(obj)->ptr();
    EXPECT(str.Equals(kTestString1));
  }
 
  // Now create another local handle and assign it to the persistent handle.
  Dart_Handle ref2 = Dart_NewStringFromCString(kTestString2);
  Dart_SetPersistentHandle(obj, ref2);
  {
    TransitionNativeToVM transition(T);
    HANDLESCOPE(T);
    String& str = String::Handle();
    str ^= PersistentHandle::Cast(obj)->ptr();
    EXPECT(str.Equals(kTestString2));
  }
 
  // Now assign Null to the persistent handle and check.
  Dart_SetPersistentHandle(obj, Dart_Null());
  EXPECT(Dart_IsNull(obj));
}

VM_UNIT_TEST_CASE() [20/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_CurrentIsolateData

)

Definition at line 4809 of file dart_api_impl_test.cc.

                                              {
  Dart_IsolateShutdownCallback saved_shutdown = Isolate::ShutdownCallback();
  Dart_IsolateGroupCleanupCallback saved_cleanup =
      Isolate::GroupCleanupCallback();
  Isolate::SetShutdownCallback(nullptr);
  Isolate::SetGroupCleanupCallback(nullptr);
 
  intptr_t mydata = 12345;
  Dart_Isolate isolate =
      TestCase::CreateTestIsolate(nullptr, reinterpret_cast<void*>(mydata));
  EXPECT(isolate != nullptr);
  EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_CurrentIsolateGroupData()));
  EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_IsolateGroupData(isolate)));
  Dart_ShutdownIsolate();
 
  Isolate::SetShutdownCallback(saved_shutdown);
  Isolate::SetGroupCleanupCallback(saved_cleanup);
}

VM_UNIT_TEST_CASE() [21/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_EnterExitScope

)

Definition at line 3287 of file dart_api_impl_test.cc.

                                          {
  TestIsolateScope __test_isolate__;
 
  Thread* thread = Thread::Current();
  EXPECT(thread != nullptr);
  ApiLocalScope* scope = thread->api_top_scope();
  Dart_EnterScope();
  {
    EXPECT(thread->api_top_scope() != nullptr);
    TransitionNativeToVM transition(thread);
    HANDLESCOPE(thread);
    String& str1 = String::Handle();
    str1 = String::New("Test String");
    Dart_Handle ref = Api::NewHandle(thread, str1.ptr());
    String& str2 = String::Handle();
    str2 ^= Api::UnwrapHandle(ref);
    EXPECT(str1.Equals(str2));
  }
  Dart_ExitScope();
  EXPECT(scope == thread->api_top_scope());
}

VM_UNIT_TEST_CASE() [22/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_FinalizableHandlesCallbackShutdown

)

Definition at line 4077 of file dart_api_impl_test.cc.

                                                              {
  TestCase::CreateTestIsolate();
  Dart_EnterScope();
  Dart_Handle ref = Dart_True();
  int peer = 1234;
  Dart_NewFinalizableHandle(ref, &peer, 0, FinalizableHandlePeerFinalizer);
  Dart_ExitScope();
  Dart_ShutdownIsolate();
  EXPECT(peer == 42);
}

VM_UNIT_TEST_CASE() [23/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_HeapSampling_CorrectSamplingIntervalForOldSpaceAllocations

)

Definition at line 10467 of file dart_api_impl_test.cc.

VM_UNIT_TEST_CASE() [24/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_IsolateGroups

)

Definition at line 4790 of file dart_api_impl_test.cc.

                                         {
  Dart_Isolate iso_1 = TestCase::CreateTestIsolate();
  EXPECT_NOTNULL(Dart_CurrentIsolateGroup());
  Dart_ExitIsolate();
  EXPECT_NULLPTR(Dart_CurrentIsolateGroup());
  Dart_Isolate iso_2 = TestCase::CreateTestIsolate();
  EXPECT_NOTNULL(Dart_CurrentIsolateGroup());
  Dart_ExitIsolate();
  EXPECT_NULLPTR(Dart_CurrentIsolateGroup());
  Dart_EnterIsolate(iso_2);
  EXPECT_NOTNULL(Dart_CurrentIsolateGroup());
  Dart_ShutdownIsolate();
  EXPECT_NULLPTR(Dart_CurrentIsolateGroup());
  Dart_EnterIsolate(iso_1);
  EXPECT_NOTNULL(Dart_CurrentIsolateGroup());
  Dart_ShutdownIsolate();
  EXPECT_NULLPTR(Dart_CurrentIsolateGroup());
}

VM_UNIT_TEST_CASE() [25/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_Isolates

)

Definition at line 4767 of file dart_api_impl_test.cc.

                                    {
  // This test currently assumes that the Dart_Isolate type is an opaque
  // representation of Isolate*.
  Dart_Isolate iso_1 = TestCase::CreateTestIsolate();
  EXPECT_EQ(iso_1, Api::CastIsolate(Isolate::Current()));
  Dart_Isolate isolate = Dart_CurrentIsolate();
  EXPECT_EQ(iso_1, isolate);
  Dart_ExitIsolate();
  EXPECT_NULLPTR(Dart_CurrentIsolate());
  Dart_Isolate iso_2 = TestCase::CreateTestIsolate();
  EXPECT_EQ(iso_2, Dart_CurrentIsolate());
  Dart_ExitIsolate();
  EXPECT_NULLPTR(Dart_CurrentIsolate());
  Dart_EnterIsolate(iso_2);
  EXPECT_EQ(iso_2, Dart_CurrentIsolate());
  Dart_ShutdownIsolate();
  EXPECT_NULLPTR(Dart_CurrentIsolate());
  Dart_EnterIsolate(iso_1);
  EXPECT_EQ(iso_1, Dart_CurrentIsolate());
  Dart_ShutdownIsolate();
  EXPECT_NULLPTR(Dart_CurrentIsolate());
}

VM_UNIT_TEST_CASE() [26/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_IsolateShutdownAndCleanup

)

Definition at line 8547 of file dart_api_impl_test.cc.

                                                                 {
  cleanup_group_callback_data = callback_data;
}
 
VM_UNIT_TEST_CASE(DartAPI_IsolateShutdownAndCleanup) {
  Dart_IsolateShutdownCallback saved_shutdown = Isolate::ShutdownCallback();
  Dart_IsolateGroupCleanupCallback saved_cleanup =
      Isolate::GroupCleanupCallback();
  Isolate::SetShutdownCallback(IsolateShutdownTestCallback);
  Isolate::SetCleanupCallback(IsolateCleanupTestCallback);
  Isolate::SetGroupCleanupCallback(IsolateGroupCleanupTestCallback);
 
  shutdown_isolate_group_data = nullptr;
  shutdown_isolate_data = nullptr;
  cleanup_group_callback_data = nullptr;
  void* my_group_data = reinterpret_cast<void*>(123);
  void* my_data = reinterpret_cast<void*>(456);
 
  // Create an isolate.
  Dart_Isolate isolate =
      TestCase::CreateTestIsolate(nullptr, my_group_data, my_data);
  EXPECT(isolate != nullptr);
 
  // The shutdown callback has not been called.
  EXPECT(nullptr == shutdown_isolate_data);
  EXPECT(nullptr == shutdown_isolate_group_data);
  EXPECT(nullptr == cleanup_group_callback_data);
 
  // The isolate is the active isolate which allows us to access the isolate
  // specific and isolate-group specific data.
  EXPECT(Dart_CurrentIsolateData() == my_data);
  EXPECT(Dart_CurrentIsolateGroupData() == my_group_data);

VM_UNIT_TEST_CASE() [27/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_IsolateShutdownRunDartCode

)

Definition at line 8614 of file dart_api_impl_test.cc.

                             {arg1, arg2};
  Dart_Handle result = Dart_Invoke(lib, NewString("add"), 2, dart_args);
  EXPECT_VALID(result);
  result = Dart_IntegerToInt64(result, &add_result);
  EXPECT_VALID(result);
  Dart_ExitScope();
}
 
VM_UNIT_TEST_CASE(DartAPI_IsolateShutdownRunDartCode) {
  const char* kScriptChars =
      "int add(int a, int b) {\n"
      "  return a + b;\n"
      "}\n"
      "\n"
      "void main() {\n"
      "  add(4, 5);\n"
      "}\n";
 
  // Create an isolate.
  auto isolate = reinterpret_cast<Isolate*>(TestCase::CreateTestIsolate());
  EXPECT(isolate != nullptr);
 
  isolate->set_on_shutdown_callback(IsolateShutdownRunDartCodeTestCallback);
 
  {
    Dart_EnterScope();
    Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
    EXPECT_VALID(lib);
    Dart_Handle result = Dart_SetLibraryTagHandler(TestCase::library_handler);
    EXPECT_VALID(result);
    result = Dart_FinalizeLoading(false);
    EXPECT_VALID(result);

VM_UNIT_TEST_CASE() [28/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_LocalHandles

)

Definition at line 4652 of file dart_api_impl_test.cc.

                                        {
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  EXPECT(isolate != nullptr);
  ApiLocalScope* scope = thread->api_top_scope();
  Dart_Handle handles[300];
  {
    TransitionNativeToVM transition1(thread);
    StackZone zone(thread);
    Smi& val = Smi::Handle();
    TransitionVMToNative transition2(thread);
 
    // Start a new scope and allocate some local handles.
    Dart_EnterScope();
    {
      TransitionNativeToVM transition3(thread);
      for (int i = 0; i < 100; i++) {
        handles[i] = Api::NewHandle(thread, Smi::New(i));
      }
      EXPECT_EQ(100, thread->CountLocalHandles());
      for (int i = 0; i < 100; i++) {
        val ^= Api::UnwrapHandle(handles[i]);
        EXPECT_EQ(i, val.Value());
      }
    }
    // Start another scope and allocate some more local handles.
    {
      Dart_EnterScope();
      {
        TransitionNativeToVM transition3(thread);
        for (int i = 100; i < 200; i++) {
          handles[i] = Api::NewHandle(thread, Smi::New(i));
        }
        EXPECT_EQ(200, thread->CountLocalHandles());
        for (int i = 100; i < 200; i++) {
          val ^= Api::UnwrapHandle(handles[i]);
          EXPECT_EQ(i, val.Value());
        }
      }
 
      // Start another scope and allocate some more local handles.
      {
        Dart_EnterScope();
        {
          TransitionNativeToVM transition3(thread);
          for (int i = 200; i < 300; i++) {
            handles[i] = Api::NewHandle(thread, Smi::New(i));
          }
          EXPECT_EQ(300, thread->CountLocalHandles());
          for (int i = 200; i < 300; i++) {
            val ^= Api::UnwrapHandle(handles[i]);
            EXPECT_EQ(i, val.Value());
          }
          EXPECT_EQ(300, thread->CountLocalHandles());
        }
        Dart_ExitScope();
      }
      EXPECT_EQ(200, thread->CountLocalHandles());
      Dart_ExitScope();
    }
    EXPECT_EQ(100, thread->CountLocalHandles());
    Dart_ExitScope();
  }
  EXPECT_EQ(0, thread->CountLocalHandles());
  EXPECT(scope == thread->api_top_scope());
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [29/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_LocalZoneMemory

)

Definition at line 4724 of file dart_api_impl_test.cc.

                                           {
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread != nullptr);
  ApiLocalScope* scope = thread->api_top_scope();
  EXPECT_EQ(0, thread->ZoneSizeInBytes());
  {
    // Start a new scope and allocate some memory.
    Dart_EnterScope();
    EXPECT_EQ(0, thread->ZoneSizeInBytes());
    for (int i = 0; i < 100; i++) {
      Dart_ScopeAllocate(16);
    }
    EXPECT_EQ(1600, thread->ZoneSizeInBytes());
    // Start another scope and allocate some more memory.
    {
      Dart_EnterScope();
      for (int i = 0; i < 100; i++) {
        Dart_ScopeAllocate(16);
      }
      EXPECT_EQ(3200, thread->ZoneSizeInBytes());
      {
        // Start another scope and allocate some more memory.
        {
          Dart_EnterScope();
          for (int i = 0; i < 200; i++) {
            Dart_ScopeAllocate(16);
          }
          EXPECT_EQ(6400, thread->ZoneSizeInBytes());
          Dart_ExitScope();
        }
      }
      EXPECT_EQ(3200, thread->ZoneSizeInBytes());
      Dart_ExitScope();
    }
    EXPECT_EQ(1600, thread->ZoneSizeInBytes());
    Dart_ExitScope();
  }
  EXPECT_EQ(0, thread->ZoneSizeInBytes());
  EXPECT(scope == thread->api_top_scope());
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [30/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_NewNativePort

)

Definition at line 8025 of file dart_api_impl_test.cc.

                                         {
  // Create a port with a bogus handler.
  Dart_Port error_port = Dart_NewNativePort("Foo", nullptr, true);
  EXPECT_EQ(ILLEGAL_PORT, error_port);
 
  // Create the port w/o a current isolate, just to make sure that works.
  Dart_Port port_id1 =
      Dart_NewNativePort("Port123", NewNativePort_send123, true);
 
  TestIsolateScope __test_isolate__;
  const char* kScriptChars =
      "import 'dart:isolate';\n"
      "void callPort(SendPort port) {\n"
      "  var receivePort = new RawReceivePort();\n"
      "  var replyPort = receivePort.sendPort;\n"
      "  port.send(<dynamic>[replyPort]);\n"
      "  receivePort.handler = (message) {\n"
      "    receivePort.close();\n"
      "    throw new Exception(message);\n"
      "  };\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
 
  // Create a port w/ a current isolate, to make sure that works too.
  Dart_Port port_id2 =
      Dart_NewNativePort("Port321", NewNativePort_send321, true);
 
  Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
  EXPECT_VALID(send_port1);
  Dart_Handle send_port2 = Dart_NewSendPort(port_id2);
  EXPECT_VALID(send_port2);
 
  // Test first port.
  Dart_Handle dart_args[1];
  dart_args[0] = send_port1;
  Dart_Handle result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
  EXPECT_VALID(result);
  result = Dart_RunLoop();
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
  EXPECT_SUBSTRING("Exception: 123\n", Dart_GetError(result));
 
  // result second port.

VM_UNIT_TEST_CASE() [31/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_NewPersistentHandle_FromPersistentHandle

)

Definition at line 3379 of file dart_api_impl_test.cc.

                                                                    {
  TestIsolateScope __test_isolate__;
 
  Isolate* isolate = Isolate::Current();
  EXPECT(isolate != nullptr);
  ApiState* state = isolate->group()->api_state();
  EXPECT(state != nullptr);
  Thread* thread = Thread::Current();
  CHECK_API_SCOPE(thread);
 
  // Start with a known persistent handle.
  Dart_PersistentHandle obj1 = Dart_NewPersistentHandle(Dart_True());
  EXPECT(state->IsValidPersistentHandle(obj1));
 
  // And use it to allocate a second persistent handle.
  Dart_Handle obj2 = Dart_HandleFromPersistent(obj1);
  Dart_PersistentHandle obj3 = Dart_NewPersistentHandle(obj2);
  EXPECT(state->IsValidPersistentHandle(obj3));
 
  // Make sure that the value transferred.
  Dart_Handle obj4 = Dart_HandleFromPersistent(obj3);
  EXPECT(Dart_IsBoolean(obj4));
  bool value = false;
  Dart_Handle result = Dart_BooleanValue(obj4, &value);
  EXPECT_VALID(result);
  EXPECT(value);
}

VM_UNIT_TEST_CASE() [32/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_PersistentHandles

)

Definition at line 3310 of file dart_api_impl_test.cc.

                                             {
  const char* kTestString1 = "Test String1";
  const char* kTestString2 = "Test String2";
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  EXPECT(isolate != nullptr);
  ApiState* state = isolate->group()->api_state();
  EXPECT(state != nullptr);
  ApiLocalScope* scope = thread->api_top_scope();
 
  const intptr_t handle_count_start = state->CountPersistentHandles();
 
  Dart_PersistentHandle handles[2000];
  Dart_EnterScope();
  {
    CHECK_API_SCOPE(thread);
    Dart_Handle ref1 = Dart_NewStringFromCString(kTestString1);
    for (int i = 0; i < 1000; i++) {
      handles[i] = Dart_NewPersistentHandle(ref1);
    }
    Dart_EnterScope();
    Dart_Handle ref2 = Dart_NewStringFromCString(kTestString2);
    for (int i = 1000; i < 2000; i++) {
      handles[i] = Dart_NewPersistentHandle(ref2);
    }
    for (int i = 500; i < 1500; i++) {
      Dart_DeletePersistentHandle(handles[i]);
    }
    for (int i = 500; i < 1000; i++) {
      handles[i] = Dart_NewPersistentHandle(ref2);
    }
    for (int i = 1000; i < 1500; i++) {
      handles[i] = Dart_NewPersistentHandle(ref1);
    }
    Dart_ExitScope();
  }
  Dart_ExitScope();
  {
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
    for (int i = 0; i < 500; i++) {
      String& str = String::Handle();
      str ^= PersistentHandle::Cast(handles[i])->ptr();
      EXPECT(str.Equals(kTestString1));
    }
    for (int i = 500; i < 1000; i++) {
      String& str = String::Handle();
      str ^= PersistentHandle::Cast(handles[i])->ptr();
      EXPECT(str.Equals(kTestString2));
    }
    for (int i = 1000; i < 1500; i++) {
      String& str = String::Handle();
      str ^= PersistentHandle::Cast(handles[i])->ptr();
      EXPECT(str.Equals(kTestString1));
    }
    for (int i = 1500; i < 2000; i++) {
      String& str = String::Handle();
      str ^= PersistentHandle::Cast(handles[i])->ptr();
      EXPECT(str.Equals(kTestString2));
    }
  }
  EXPECT(scope == thread->api_top_scope());
  EXPECT_EQ(handle_count_start + 2000, state->CountPersistentHandles());
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [33/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_RunLoop_Exception

)

Definition at line 8502 of file dart_api_impl_test.cc.

         {
    EXPECT_VALID(result);
  }

VM_UNIT_TEST_CASE() [34/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_RunLoop_Success

)

Definition at line 8498 of file dart_api_impl_test.cc.

                       {

VM_UNIT_TEST_CASE() [35/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_SetMessageCallbacks

)

Definition at line 4857 of file dart_api_impl_test.cc.

                                               {
  Dart_Isolate dart_isolate = TestCase::CreateTestIsolate();
  Dart_SetMessageNotifyCallback(&MyMessageNotifyCallback);
  Isolate* isolate = reinterpret_cast<Isolate*>(dart_isolate);
  EXPECT_EQ(&MyMessageNotifyCallback, isolate->message_notify_callback());
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [36/107]

dart::VM_UNIT_TEST_CASE

(

DartAPI_WeakPersistentHandlesCallbackShutdown

)

Definition at line 4065 of file dart_api_impl_test.cc.

                                                                 {
  TestCase::CreateTestIsolate();
  Dart_EnterScope();
  Dart_Handle ref = Dart_True();
  int peer = 1234;
  delete_on_finalization = Dart_NewWeakPersistentHandle(
      ref, &peer, 0, DontDeleteWeakHandleOnFinalization);
  Dart_ExitScope();
  Dart_ShutdownIsolate();
  EXPECT(peer == 42);
}

VM_UNIT_TEST_CASE() [37/107]

dart::VM_UNIT_TEST_CASE

(

DartGeneratedArrayLiteralMessages

)

Definition at line 1074 of file snapshot_test.cc.

                                                     {
  const int kArrayLength = 10;
  const char* kScriptChars =
      "final int kArrayLength = 10;\n"
      "getList() {\n"
      "  return [null, null, null, null, null, null, null, null, null, null];\n"
      "}\n"
      "getIntList() {\n"
      "  return [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n"
      "}\n"
      "getStringList() {\n"
      "  return ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];\n"
      "}\n"
      "getListList() {\n"
      "  return <dynamic>[[],"
      "                   [0],"
      "                   [0, 1],"
      "                   [0, 1, 2],"
      "                   [0, 1, 2, 3],"
      "                   [0, 1, 2, 3, 4],"
      "                   [0, 1, 2, 3, 4, 5],"
      "                   [0, 1, 2, 3, 4, 5, 6],"
      "                   [0, 1, 2, 3, 4, 5, 6, 7],"
      "                   [0, 1, 2, 3, 4, 5, 6, 7, 8]];\n"
      "}\n"
      "getMixedList() {\n"
      "  var list = [];\n"
      "  list.add(0);\n"
      "  list.add('1');\n"
      "  list.add(2.2);\n"
      "  list.add(true);\n"
      "  list.add([]);\n"
      "  list.add(<dynamic>[[]]);\n"
      "  list.add(<dynamic>[<dynamic>[[]]]);\n"
      "  list.add(<dynamic>[1, <dynamic>[2, [3]]]);\n"
      "  list.add(<dynamic>[1, <dynamic>[1, 2, [1, 2, 3]]]);\n"
      "  list.add([1, 2, 3]);\n"
      "  return list;\n"
      "}\n";
 
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->isolate() != nullptr);
  Dart_EnterScope();
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  {
    CHECK_API_SCOPE(thread);
    TransitionNativeToVM transition(thread);
    HANDLESCOPE(thread);
    StackZone zone(thread);
    {
      // Generate a list of nulls from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        EXPECT_EQ(Dart_CObject_kNull, root->value.as_array.values[i]->type);
      }
      CheckEncodeDecodeMessage(scope.zone(), root);
    }
    {
      // Generate a list of ints from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getIntList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        EXPECT_EQ(Dart_CObject_kInt32, root->value.as_array.values[i]->type);
        EXPECT_EQ(i, root->value.as_array.values[i]->value.as_int32);
      }
      CheckEncodeDecodeMessage(scope.zone(), root);
    }
    {
      // Generate a list of strings from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getStringList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        EXPECT_EQ(Dart_CObject_kString, root->value.as_array.values[i]->type);
        char buffer[3];
        snprintf(buffer, sizeof(buffer), "%d", i);
        EXPECT_STREQ(buffer, root->value.as_array.values[i]->value.as_string);
      }
    }
    {
      // Generate a list of lists from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getListList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(Dart_CObject_kArray, element->type);
        EXPECT_EQ(i, element->value.as_array.length);
        for (int j = 0; j < i; j++) {
          EXPECT_EQ(Dart_CObject_kInt32,
                    element->value.as_array.values[j]->type);
          EXPECT_EQ(j, element->value.as_array.values[j]->value.as_int32);
        }
      }
    }
    {
      // Generate a list of objects of different types from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getMixedList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
 
      EXPECT_EQ(Dart_CObject_kInt32, root->value.as_array.values[0]->type);
      EXPECT_EQ(0, root->value.as_array.values[0]->value.as_int32);
      EXPECT_EQ(Dart_CObject_kString, root->value.as_array.values[1]->type);
      EXPECT_STREQ("1", root->value.as_array.values[1]->value.as_string);
      EXPECT_EQ(Dart_CObject_kDouble, root->value.as_array.values[2]->type);
      EXPECT_EQ(2.2, root->value.as_array.values[2]->value.as_double);
      EXPECT_EQ(Dart_CObject_kBool, root->value.as_array.values[3]->type);
      EXPECT_EQ(true, root->value.as_array.values[3]->value.as_bool);
 
      for (int i = 0; i < kArrayLength; i++) {
        if (i > 3) {
          EXPECT_EQ(Dart_CObject_kArray, root->value.as_array.values[i]->type);
        }
      }
 
      Dart_CObject* element;
      Dart_CObject* e;
 
      // []
      element = root->value.as_array.values[4];
      EXPECT_EQ(0, element->value.as_array.length);
 
      // [[]]
      element = root->value.as_array.values[5];
      EXPECT_EQ(1, element->value.as_array.length);
      element = element->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kArray, element->type);
      EXPECT_EQ(0, element->value.as_array.length);
 
      // [[[]]]"
      element = root->value.as_array.values[6];
      EXPECT_EQ(1, element->value.as_array.length);
      element = element->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kArray, element->type);
      EXPECT_EQ(1, element->value.as_array.length);
      element = element->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kArray, element->type);
      EXPECT_EQ(0, element->value.as_array.length);
 
      // [1, [2, [3]]]
      element = root->value.as_array.values[7];
      EXPECT_EQ(2, element->value.as_array.length);
      e = element->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kInt32, e->type);
      EXPECT_EQ(1, e->value.as_int32);
      element = element->value.as_array.values[1];
      EXPECT_EQ(Dart_CObject_kArray, element->type);
      EXPECT_EQ(2, element->value.as_array.length);
      e = element->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kInt32, e->type);
      EXPECT_EQ(2, e->value.as_int32);
      element = element->value.as_array.values[1];
      EXPECT_EQ(Dart_CObject_kArray, element->type);
      EXPECT_EQ(1, element->value.as_array.length);
      e = element->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kInt32, e->type);
      EXPECT_EQ(3, e->value.as_int32);
 
      // [1, [1, 2, [1, 2, 3]]]
      element = root->value.as_array.values[8];
      EXPECT_EQ(2, element->value.as_array.length);
      e = element->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kInt32, e->type);
      e = element->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kInt32, e->type);
      EXPECT_EQ(1, e->value.as_int32);
      element = element->value.as_array.values[1];
      EXPECT_EQ(Dart_CObject_kArray, element->type);
      EXPECT_EQ(3, element->value.as_array.length);
      for (int i = 0; i < 2; i++) {
        e = element->value.as_array.values[i];
        EXPECT_EQ(Dart_CObject_kInt32, e->type);
        EXPECT_EQ(i + 1, e->value.as_int32);
      }
      element = element->value.as_array.values[2];
      EXPECT_EQ(Dart_CObject_kArray, element->type);
      EXPECT_EQ(3, element->value.as_array.length);
      for (int i = 0; i < 3; i++) {
        e = element->value.as_array.values[i];
        EXPECT_EQ(Dart_CObject_kInt32, e->type);
        EXPECT_EQ(i + 1, e->value.as_int32);
      }
 
      // [1, 2, 3]
      element = root->value.as_array.values[9];
      EXPECT_EQ(3, element->value.as_array.length);
      for (int i = 0; i < 3; i++) {
        e = element->value.as_array.values[i];
        EXPECT_EQ(Dart_CObject_kInt32, e->type);
        EXPECT_EQ(i + 1, e->value.as_int32);
      }
    }
  }
  Dart_ExitScope();
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [38/107]

dart::VM_UNIT_TEST_CASE

(

DartGeneratedArrayLiteralMessagesWithBackref

)

Definition at line 1487 of file snapshot_test.cc.

                                                                {
  const int kArrayLength = 10;
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "final int kArrayLength = 10;\n"
      "getStringList() {\n"
      "  var s = 'Hello, world!';\n"
      "  var list = [s, s, s, s, s, s, s, s, s, s];\n"
      "  return list;\n"
      "}\n"
      "getMintList() {\n"
      "  var mint = 0x7FFFFFFFFFFFFFFF;\n"
      "  var list = [mint, mint, mint, mint, mint,\n"
      "              mint, mint, mint, mint, mint];\n"
      "  return list;\n"
      "}\n"
      "getDoubleList() {\n"
      "  var d = 3.14;\n"
      "  var list = [3.14, 3.14, 3.14, 3.14, 3.14, 3.14];\n"
      "  list.add(3.14);\n"
      "  list.add(3.14);\n"
      "  list.add(3.14);\n"
      "  list.add(3.14);\n"
      "  return list;\n"
      "}\n"
      "getTypedDataList() {\n"
      "  var byte_array = new Uint8List(256);\n"
      "  var list = [];\n"
      "  for (var i = 0; i < kArrayLength; i++) {\n"
      "    list.add(byte_array);\n"
      "  }\n"
      "  return list;\n"
      "}\n"
      "getTypedDataViewList() {\n"
      "  var uint8_list = new Uint8List(256);\n"
      "  uint8_list[64] = 1;\n"
      "  var uint8_list_view =\n"
      "      new Uint8List.view(uint8_list.buffer, 64, 128);\n"
      "  var list = [];\n"
      "  for (var i = 0; i < kArrayLength; i++) {\n"
      "    list.add(uint8_list_view);\n"
      "  }\n"
      "  return list;\n"
      "}\n"
      "getMixedList() {\n"
      "  var list = [];\n"
      "  for (var i = 0; i < kArrayLength; i++) {\n"
      "    list.add(((i % 2) == 0) ? '.' : 2.72);\n"
      "  }\n"
      "  return list;\n"
      "}\n"
      "getSelfRefList() {\n"
      "  var list = [];\n"
      "  for (var i = 0; i < kArrayLength; i++) {\n"
      "    list.add(list);\n"
      "  }\n"
      "  return list;\n"
      "}\n";
 
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->isolate() != nullptr);
  Dart_EnterScope();
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  {
    CHECK_API_SCOPE(thread);
    TransitionNativeToVM transition(thread);
    HANDLESCOPE(thread);
    StackZone zone(thread);
    {
      // Generate a list of strings from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getStringList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(root->value.as_array.values[0], element);
        EXPECT_EQ(Dart_CObject_kString, element->type);
        EXPECT_STREQ("Hello, world!", element->value.as_string);
      }
    }
    {
      // Generate a list of medium ints from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getMintList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(root->value.as_array.values[0], element);
        EXPECT_EQ(Dart_CObject_kInt64, element->type);
        EXPECT_EQ(DART_INT64_C(0x7FFFFFFFFFFFFFFF), element->value.as_int64);
      }
    }
    {
      // Generate a list of doubles from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getDoubleList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      Dart_CObject* element = root->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kDouble, element->type);
      EXPECT_EQ(3.14, element->value.as_double);
      for (int i = 1; i < kArrayLength; i++) {
        element = root->value.as_array.values[i];
        EXPECT_EQ(Dart_CObject_kDouble, element->type);
        EXPECT_EQ(3.14, element->value.as_double);
      }
    }
    {
      // Generate a list of Uint8Lists from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getTypedDataList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(root->value.as_array.values[0], element);
        EXPECT_EQ(Dart_CObject_kTypedData, element->type);
        EXPECT_EQ(Dart_TypedData_kUint8, element->value.as_typed_data.type);
        EXPECT_EQ(256, element->value.as_typed_data.length);
      }
    }
    {
      // Generate a list of Uint8List views from Dart code.
      std::unique_ptr<Message> message =
          GetSerialized(lib, "getTypedDataViewList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(root->value.as_array.values[0], element);
        EXPECT_EQ(Dart_CObject_kTypedData, element->type);
        EXPECT_EQ(Dart_TypedData_kUint8, element->value.as_typed_data.type);
        EXPECT_EQ(128, element->value.as_typed_data.length);
        EXPECT_EQ(1, element->value.as_typed_data.values[0]);
        EXPECT_EQ(0, element->value.as_typed_data.values[1]);
      }
    }
    {
      // Generate a list of objects of different types from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getMixedList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      Dart_CObject* element = root->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kString, element->type);
      EXPECT_STREQ(".", element->value.as_string);
      element = root->value.as_array.values[1];
      EXPECT_EQ(Dart_CObject_kDouble, element->type);
      EXPECT_EQ(2.72, element->value.as_double);
      for (int i = 2; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        if ((i % 2) == 0) {
          EXPECT_EQ(root->value.as_array.values[0], element);
          EXPECT_EQ(Dart_CObject_kString, element->type);
          EXPECT_STREQ(".", element->value.as_string);
        } else {
          EXPECT_EQ(Dart_CObject_kDouble, element->type);
          EXPECT_EQ(2.72, element->value.as_double);
        }
      }
    }
    {
      // Generate a list of objects of different types from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getSelfRefList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(Dart_CObject_kArray, element->type);
        EXPECT_EQ(root, element);
      }
    }
  }
  Dart_ExitScope();
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [39/107]

dart::VM_UNIT_TEST_CASE

(

DartGeneratedListMessages

)

Definition at line 964 of file snapshot_test.cc.

                                             {
  const int kArrayLength = 10;
  const char* kScriptChars =
      "final int kArrayLength = 10;\n"
      "getList() {\n"
      "  return List.filled(kArrayLength, null);\n"
      "}\n"
      "getIntList() {\n"
      "  var list = List<int>.filled(kArrayLength, 0);\n"
      "  for (var i = 0; i < kArrayLength; i++) list[i] = i;\n"
      "  return list;\n"
      "}\n"
      "getStringList() {\n"
      "  var list = List<String>.filled(kArrayLength, '');\n"
      "  for (var i = 0; i < kArrayLength; i++) list[i] = i.toString();\n"
      "  return list;\n"
      "}\n"
      "getMixedList() {\n"
      "  var list = List<dynamic>.filled(kArrayLength, null);\n"
      "  list[0] = 0;\n"
      "  list[1] = '1';\n"
      "  list[2] = 2.2;\n"
      "  list[3] = true;\n"
      "  return list;\n"
      "}\n";
 
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->isolate() != nullptr);
  Dart_EnterScope();
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  {
    CHECK_API_SCOPE(thread);
    TransitionNativeToVM transition(thread);
    HANDLESCOPE(thread);
    StackZone zone(thread);
    {
      // Generate a list of nulls from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        EXPECT_EQ(Dart_CObject_kNull, root->value.as_array.values[i]->type);
      }
      CheckEncodeDecodeMessage(scope.zone(), root);
    }
    {
      // Generate a list of ints from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getIntList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        EXPECT_EQ(Dart_CObject_kInt32, root->value.as_array.values[i]->type);
        EXPECT_EQ(i, root->value.as_array.values[i]->value.as_int32);
      }
      CheckEncodeDecodeMessage(scope.zone(), root);
    }
    {
      // Generate a list of strings from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getStringList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        EXPECT_EQ(Dart_CObject_kString, root->value.as_array.values[i]->type);
        char buffer[3];
        snprintf(buffer, sizeof(buffer), "%d", i);
        EXPECT_STREQ(buffer, root->value.as_array.values[i]->value.as_string);
      }
    }
    {
      // Generate a list of objects of different types from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getMixedList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
 
      EXPECT_EQ(Dart_CObject_kInt32, root->value.as_array.values[0]->type);
      EXPECT_EQ(0, root->value.as_array.values[0]->value.as_int32);
      EXPECT_EQ(Dart_CObject_kString, root->value.as_array.values[1]->type);
      EXPECT_STREQ("1", root->value.as_array.values[1]->value.as_string);
      EXPECT_EQ(Dart_CObject_kDouble, root->value.as_array.values[2]->type);
      EXPECT_EQ(2.2, root->value.as_array.values[2]->value.as_double);
      EXPECT_EQ(Dart_CObject_kBool, root->value.as_array.values[3]->type);
      EXPECT_EQ(true, root->value.as_array.values[3]->value.as_bool);
 
      for (int i = 0; i < kArrayLength; i++) {
        if (i > 3) {
          EXPECT_EQ(Dart_CObject_kNull, root->value.as_array.values[i]->type);
        }
      }
    }
  }
  Dart_ExitScope();
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [40/107]

dart::VM_UNIT_TEST_CASE

(

DartGeneratedListMessagesWithBackref

)

Definition at line 1294 of file snapshot_test.cc.

                                                        {
  const int kArrayLength = 10;
  const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "final int kArrayLength = 10;\n"
      "getStringList() {\n"
      "  var s = 'Hello, world!';\n"
      "  var list = List<String>.filled(kArrayLength, '');\n"
      "  for (var i = 0; i < kArrayLength; i++) list[i] = s;\n"
      "  return list;\n"
      "}\n"
      "getMintList() {\n"
      "  var mint = 0x7FFFFFFFFFFFFFFF;\n"
      "  var list = List.filled(kArrayLength, 0);\n"
      "  for (var i = 0; i < kArrayLength; i++) list[i] = mint;\n"
      "  return list;\n"
      "}\n"
      "getDoubleList() {\n"
      "  var d = 3.14;\n"
      "  var list = List<double>.filled(kArrayLength, 0.0);\n"
      "  for (var i = 0; i < kArrayLength; i++) list[i] = d;\n"
      "  return list;\n"
      "}\n"
      "getTypedDataList() {\n"
      "  var byte_array = Uint8List(256);\n"
      "  var list = List<dynamic>.filled(kArrayLength, null);\n"
      "  for (var i = 0; i < kArrayLength; i++) list[i] = byte_array;\n"
      "  return list;\n"
      "}\n"
      "getTypedDataViewList() {\n"
      "  var uint8_list = Uint8List(256);\n"
      "  uint8_list[64] = 1;\n"
      "  var uint8_list_view =\n"
      "      Uint8List.view(uint8_list.buffer, 64, 128);\n"
      "  var list = List<dynamic>.filled(kArrayLength, null);\n"
      "  for (var i = 0; i < kArrayLength; i++) list[i] = uint8_list_view;\n"
      "  return list;\n"
      "}\n"
      "getMixedList() {\n"
      "  var list = List<dynamic>.filled(kArrayLength, null);\n"
      "  for (var i = 0; i < kArrayLength; i++) {\n"
      "    list[i] = ((i % 2) == 0) ? 'A' : 2.72;\n"
      "  }\n"
      "  return list;\n"
      "}\n"
      "getSelfRefList() {\n"
      "  var list = List<dynamic>.filled(kArrayLength, null, growable: true);\n"
      "  for (var i = 0; i < kArrayLength; i++) {\n"
      "    list[i] = list;\n"
      "  }\n"
      "  return list;\n"
      "}\n";
 
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->isolate() != nullptr);
  Dart_EnterScope();
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  {
    CHECK_API_SCOPE(thread);
    TransitionNativeToVM transition(thread);
    HANDLESCOPE(thread);
    StackZone zone(thread);
    {
      // Generate a list of strings from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getStringList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(root->value.as_array.values[0], element);
        EXPECT_EQ(Dart_CObject_kString, element->type);
        EXPECT_STREQ("Hello, world!", element->value.as_string);
      }
    }
    {
      // Generate a list of medium ints from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getMintList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(root->value.as_array.values[0], element);
        EXPECT_EQ(Dart_CObject_kInt64, element->type);
        EXPECT_EQ(DART_INT64_C(0x7FFFFFFFFFFFFFFF), element->value.as_int64);
      }
    }
    {
      // Generate a list of doubles from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getDoubleList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      Dart_CObject* element = root->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kDouble, element->type);
      EXPECT_EQ(3.14, element->value.as_double);
      for (int i = 1; i < kArrayLength; i++) {
        element = root->value.as_array.values[i];
        EXPECT_EQ(Dart_CObject_kDouble, element->type);
        EXPECT_EQ(3.14, element->value.as_double);
      }
    }
    {
      // Generate a list of Uint8Lists from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getTypedDataList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(root->value.as_array.values[0], element);
        EXPECT_EQ(Dart_CObject_kTypedData, element->type);
        EXPECT_EQ(Dart_TypedData_kUint8, element->value.as_typed_data.type);
        EXPECT_EQ(256, element->value.as_typed_data.length);
      }
    }
    {
      // Generate a list of Uint8List views from Dart code.
      std::unique_ptr<Message> message =
          GetSerialized(lib, "getTypedDataViewList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(root->value.as_array.values[0], element);
        EXPECT_EQ(Dart_CObject_kTypedData, element->type);
        EXPECT_EQ(Dart_TypedData_kUint8, element->value.as_typed_data.type);
        EXPECT_EQ(128, element->value.as_typed_data.length);
        EXPECT_EQ(1, element->value.as_typed_data.values[0]);
        EXPECT_EQ(0, element->value.as_typed_data.values[1]);
      }
    }
    {
      // Generate a list of objects of different types from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getMixedList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      Dart_CObject* element = root->value.as_array.values[0];
      EXPECT_EQ(Dart_CObject_kString, element->type);
      EXPECT_STREQ("A", element->value.as_string);
      element = root->value.as_array.values[1];
      EXPECT_EQ(Dart_CObject_kDouble, element->type);
      EXPECT_EQ(2.72, element->value.as_double);
      for (int i = 2; i < kArrayLength; i++) {
        element = root->value.as_array.values[i];
        if ((i % 2) == 0) {
          EXPECT_EQ(root->value.as_array.values[0], element);
          EXPECT_EQ(Dart_CObject_kString, element->type);
          EXPECT_STREQ("A", element->value.as_string);
        } else {
          EXPECT_EQ(Dart_CObject_kDouble, element->type);
          EXPECT_EQ(2.72, element->value.as_double);
        }
      }
    }
    {
      // Generate a list of objects of different types from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getSelfRefList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      EXPECT_EQ(kArrayLength, root->value.as_array.length);
      for (int i = 0; i < kArrayLength; i++) {
        Dart_CObject* element = root->value.as_array.values[i];
        EXPECT_EQ(Dart_CObject_kArray, element->type);
        EXPECT_EQ(root, element);
      }
    }
  }
  Dart_ExitScope();
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [41/107]

dart::VM_UNIT_TEST_CASE

(

DartGeneratedListMessagesWithTypedData

)

Definition at line 1694 of file snapshot_test.cc.

                                                          {
  static const char* kScriptChars =
      "import 'dart:typed_data';\n"
      "getTypedDataList() {\n"
      "  var list = List<dynamic>.filled(13, null);\n"
      "  var index = 0;\n"
      "  list[index++] = Int8List(256);\n"
      "  list[index++] = Uint8List(256);\n"
      "  list[index++] = Int16List(256);\n"
      "  list[index++] = Uint16List(256);\n"
      "  list[index++] = Int32List(256);\n"
      "  list[index++] = Uint32List(256);\n"
      "  list[index++] = Int64List(256);\n"
      "  list[index++] = Uint64List(256);\n"
      "  list[index++] = Float32List(256);\n"
      "  list[index++] = Float64List(256);\n"
      "  list[index++] = Int32x4List(256);\n"
      "  list[index++] = Float32x4List(256);\n"
      "  list[index++] = Float64x2List(256);\n"
      "  return list;\n"
      "}\n"
      "getTypedDataViewList() {\n"
      "  var list = List<dynamic>.filled(45, null);\n"
      "  var index = 0;\n"
      "  list[index++] = Int8List.view(Int8List(256).buffer);\n"
      "  list[index++] = Uint8List.view(Uint8List(256).buffer);\n"
      "  list[index++] = Int16List.view(new Int16List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Uint16List(256).buffer);\n"
      "  list[index++] = Int32List.view(new Int32List(256).buffer);\n"
      "  list[index++] = Uint32List.view(new Uint32List(256).buffer);\n"
      "  list[index++] = Int64List.view(new Int64List(256).buffer);\n"
      "  list[index++] = Uint64List.view(new Uint64List(256).buffer);\n"
      "  list[index++] = Float32List.view(new Float32List(256).buffer);\n"
      "  list[index++] = Float64List.view(new Float64List(256).buffer);\n"
      "  list[index++] = Int32x4List.view(new Int32x4List(256).buffer);\n"
      "  list[index++] = Float32x4List.view(new Float32x4List(256).buffer);\n"
      "  list[index++] = Float64x2List.view(new Float64x2List(256).buffer);\n"
 
      "  list[index++] = Int8List.view(new Int16List(256).buffer);\n"
      "  list[index++] = Uint8List.view(new Uint16List(256).buffer);\n"
      "  list[index++] = Int8List.view(new Int32List(256).buffer);\n"
      "  list[index++] = Uint8List.view(new Uint32List(256).buffer);\n"
      "  list[index++] = Int8List.view(new Int64List(256).buffer);\n"
      "  list[index++] = Uint8List.view(new Uint64List(256).buffer);\n"
      "  list[index++] = Int8List.view(new Float32List(256).buffer);\n"
      "  list[index++] = Uint8List.view(new Float32List(256).buffer);\n"
      "  list[index++] = Int8List.view(new Float64List(256).buffer);\n"
      "  list[index++] = Uint8List.view(new Float64List(256).buffer);\n"
      "  list[index++] = Int8List.view(new Int32x4List(256).buffer);\n"
      "  list[index++] = Uint8List.view(new Int32x4List(256).buffer);\n"
      "  list[index++] = Int8List.view(new Float32x4List(256).buffer);\n"
      "  list[index++] = Uint8List.view(new Float32x4List(256).buffer);\n"
      "  list[index++] = Int8List.view(new Float64x2List(256).buffer);\n"
      "  list[index++] = Uint8List.view(new Float64x2List(256).buffer);\n"
 
      "  list[index++] = Int16List.view(new Int8List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Uint8List(256).buffer);\n"
      "  list[index++] = Int16List.view(new Int32List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Uint32List(256).buffer);\n"
      "  list[index++] = Int16List.view(new Int64List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Uint64List(256).buffer);\n"
      "  list[index++] = Int16List.view(new Float32List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Float32List(256).buffer);\n"
      "  list[index++] = Int16List.view(new Float64List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Float64List(256).buffer);\n"
      "  list[index++] = Int16List.view(new Int32x4List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Int32x4List(256).buffer);\n"
      "  list[index++] = Int16List.view(new Float32x4List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Float32x4List(256).buffer);\n"
      "  list[index++] = Int16List.view(new Float64x2List(256).buffer);\n"
      "  list[index++] = Uint16List.view(new Float64x2List(256).buffer);\n"
      "  return list;\n"
      "}\n"
      "getMultipleTypedDataViewList() {\n"
      "  var list = List<dynamic>.filled(13, null);\n"
      "  var index = 0;\n"
      "  var data = Uint8List(256).buffer;\n"
      "  list[index++] = Int8List.view(data);\n"
      "  list[index++] = Uint8List.view(data);\n"
      "  list[index++] = Int16List.view(data);\n"
      "  list[index++] = Uint16List.view(data);\n"
      "  list[index++] = Int32List.view(data);\n"
      "  list[index++] = Uint32List.view(data);\n"
      "  list[index++] = Int64List.view(data);\n"
      "  list[index++] = Uint64List.view(data);\n"
      "  list[index++] = Float32List.view(data);\n"
      "  list[index++] = Float64List.view(data);\n"
      "  list[index++] = Int32x4List.view(data);\n"
      "  list[index++] = Float32x4List.view(data);\n"
      "  list[index++] = Float64x2List.view(data);\n"
      "  return list;\n"
      "}\n";
 
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->isolate() != nullptr);
  Dart_EnterScope();
 
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
 
  {
    CHECK_API_SCOPE(thread);
    TransitionNativeToVM transition(thread);
    HANDLESCOPE(thread);
    StackZone zone(thread);
    {
      // Generate a list of Uint8Lists from Dart code.
      std::unique_ptr<Message> message = GetSerialized(lib, "getTypedDataList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      struct {
        Dart_TypedData_Type type;
        int size;
      } expected[] = {
          {Dart_TypedData_kInt8, 256},      {Dart_TypedData_kUint8, 256},
          {Dart_TypedData_kInt16, 256},     {Dart_TypedData_kUint16, 256},
          {Dart_TypedData_kInt32, 256},     {Dart_TypedData_kUint32, 256},
          {Dart_TypedData_kInt64, 256},     {Dart_TypedData_kUint64, 256},
          {Dart_TypedData_kFloat32, 256},   {Dart_TypedData_kFloat64, 256},
          {Dart_TypedData_kInt32x4, 256},   {Dart_TypedData_kFloat32x4, 256},
          {Dart_TypedData_kFloat64x2, 256}, {Dart_TypedData_kInvalid, -1}};
 
      int i = 0;
      while (expected[i].type != Dart_TypedData_kInvalid) {
        CheckTypedData(root->value.as_array.values[i], expected[i].type,
                       expected[i].size);
        i++;
      }
      EXPECT_EQ(i, root->value.as_array.length);
    }
    {
      // Generate a list of Uint8List views from Dart code.
      std::unique_ptr<Message> message =
          GetSerialized(lib, "getTypedDataViewList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      struct {
        Dart_TypedData_Type type;
        int size;
      } expected[] = {
          {Dart_TypedData_kInt8, 256},      {Dart_TypedData_kUint8, 256},
          {Dart_TypedData_kInt16, 256},     {Dart_TypedData_kUint16, 256},
          {Dart_TypedData_kInt32, 256},     {Dart_TypedData_kUint32, 256},
          {Dart_TypedData_kInt64, 256},     {Dart_TypedData_kUint64, 256},
          {Dart_TypedData_kFloat32, 256},   {Dart_TypedData_kFloat64, 256},
          {Dart_TypedData_kInt32x4, 256},   {Dart_TypedData_kFloat32x4, 256},
          {Dart_TypedData_kFloat64x2, 256},
 
          {Dart_TypedData_kInt8, 512},      {Dart_TypedData_kUint8, 512},
          {Dart_TypedData_kInt8, 1024},     {Dart_TypedData_kUint8, 1024},
          {Dart_TypedData_kInt8, 2048},     {Dart_TypedData_kUint8, 2048},
          {Dart_TypedData_kInt8, 1024},     {Dart_TypedData_kUint8, 1024},
          {Dart_TypedData_kInt8, 2048},     {Dart_TypedData_kUint8, 2048},
          {Dart_TypedData_kInt8, 4096},     {Dart_TypedData_kUint8, 4096},
          {Dart_TypedData_kInt8, 4096},     {Dart_TypedData_kUint8, 4096},
          {Dart_TypedData_kInt8, 4096},     {Dart_TypedData_kUint8, 4096},
 
          {Dart_TypedData_kInt16, 128},     {Dart_TypedData_kUint16, 128},
          {Dart_TypedData_kInt16, 512},     {Dart_TypedData_kUint16, 512},
          {Dart_TypedData_kInt16, 1024},    {Dart_TypedData_kUint16, 1024},
          {Dart_TypedData_kInt16, 512},     {Dart_TypedData_kUint16, 512},
          {Dart_TypedData_kInt16, 1024},    {Dart_TypedData_kUint16, 1024},
          {Dart_TypedData_kInt16, 2048},    {Dart_TypedData_kUint16, 2048},
          {Dart_TypedData_kInt16, 2048},    {Dart_TypedData_kUint16, 2048},
          {Dart_TypedData_kInt16, 2048},    {Dart_TypedData_kUint16, 2048},
 
          {Dart_TypedData_kInvalid, -1}};
 
      int i = 0;
      while (expected[i].type != Dart_TypedData_kInvalid) {
        CheckTypedData(root->value.as_array.values[i], expected[i].type,
                       expected[i].size);
        i++;
      }
      EXPECT_EQ(i, root->value.as_array.length);
    }
    {
      // Generate a list of Uint8Lists from Dart code.
      std::unique_ptr<Message> message =
          GetSerialized(lib, "getMultipleTypedDataViewList");
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kArray, root->type);
      struct {
        Dart_TypedData_Type type;
        int size;
      } expected[] = {
          {Dart_TypedData_kInt8, 256},     {Dart_TypedData_kUint8, 256},
          {Dart_TypedData_kInt16, 128},    {Dart_TypedData_kUint16, 128},
          {Dart_TypedData_kInt32, 64},     {Dart_TypedData_kUint32, 64},
          {Dart_TypedData_kInt64, 32},     {Dart_TypedData_kUint64, 32},
          {Dart_TypedData_kFloat32, 64},   {Dart_TypedData_kFloat64, 32},
          {Dart_TypedData_kInt32x4, 16},   {Dart_TypedData_kFloat32x4, 16},
          {Dart_TypedData_kFloat64x2, 16}, {Dart_TypedData_kInvalid, -1}};
 
      int i = 0;
      while (expected[i].type != Dart_TypedData_kInvalid) {
        CheckTypedData(root->value.as_array.values[i], expected[i].type,
                       expected[i].size);
 
        // All views point to the same data.
        EXPECT_EQ(root->value.as_array.values[0]->value.as_typed_data.values,
                  root->value.as_array.values[i]->value.as_typed_data.values);
        i++;
      }
      EXPECT_EQ(i, root->value.as_array.length);
    }
  }
  Dart_ExitScope();
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [42/107]

dart::VM_UNIT_TEST_CASE

(

DartGeneratedMessages

)

Definition at line 842 of file snapshot_test.cc.

                                         {
  static const char* kCustomIsolateScriptChars =
      "final int kArrayLength = 10;\n"
      "getSmi() {\n"
      "  return 42;\n"
      "}\n"
      "getAsciiString() {\n"
      "  return \"Hello, world!\";\n"
      "}\n"
      "getNonAsciiString() {\n"
      "  return \"Blåbærgrød\";\n"
      "}\n"
      "getNonBMPString() {\n"
      "  return \"\\u{10000}\\u{1F601}\\u{1F637}\\u{20000}\";\n"
      "}\n"
      "getLeadSurrogateString() {\n"
      "  return String.fromCharCodes([0xd800]);\n"
      "}\n"
      "getTrailSurrogateString() {\n"
      "  return \"\\u{10000}\".substring(1);\n"
      "}\n"
      "getSurrogatesString() {\n"
      "  return String.fromCharCodes([0xdc00, 0xdc00, 0xd800, 0xd800]);\n"
      "}\n"
      "getCrappyString() {\n"
      "  return String.fromCharCodes([0xd800, 32, 0xdc00, 32]);\n"
      "}\n"
      "getList() {\n"
      "  return List.filled(kArrayLength, null);\n"
      "}\n";
 
  TestCase::CreateTestIsolate();
  Isolate* isolate = Isolate::Current();
  EXPECT(isolate != nullptr);
  Dart_EnterScope();
 
  Dart_Handle lib =
      TestCase::LoadTestScript(kCustomIsolateScriptChars, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle smi_result;
  smi_result = Dart_Invoke(lib, NewString("getSmi"), 0, nullptr);
  EXPECT_VALID(smi_result);
 
  Dart_Handle ascii_string_result;
  ascii_string_result =
      Dart_Invoke(lib, NewString("getAsciiString"), 0, nullptr);
  EXPECT_VALID(ascii_string_result);
  EXPECT(Dart_IsString(ascii_string_result));
 
  Dart_Handle non_ascii_string_result;
  non_ascii_string_result =
      Dart_Invoke(lib, NewString("getNonAsciiString"), 0, nullptr);
  EXPECT_VALID(non_ascii_string_result);
  EXPECT(Dart_IsString(non_ascii_string_result));
 
  Dart_Handle non_bmp_string_result;
  non_bmp_string_result =
      Dart_Invoke(lib, NewString("getNonBMPString"), 0, nullptr);
  EXPECT_VALID(non_bmp_string_result);
  EXPECT(Dart_IsString(non_bmp_string_result));
 
  Dart_Handle lead_surrogate_string_result;
  lead_surrogate_string_result =
      Dart_Invoke(lib, NewString("getLeadSurrogateString"), 0, nullptr);
  EXPECT_VALID(lead_surrogate_string_result);
  EXPECT(Dart_IsString(lead_surrogate_string_result));
 
  Dart_Handle trail_surrogate_string_result;
  trail_surrogate_string_result =
      Dart_Invoke(lib, NewString("getTrailSurrogateString"), 0, nullptr);
  EXPECT_VALID(trail_surrogate_string_result);
  EXPECT(Dart_IsString(trail_surrogate_string_result));
 
  Dart_Handle surrogates_string_result;
  surrogates_string_result =
      Dart_Invoke(lib, NewString("getSurrogatesString"), 0, nullptr);
  EXPECT_VALID(surrogates_string_result);
  EXPECT(Dart_IsString(surrogates_string_result));
 
  Dart_Handle crappy_string_result;
  crappy_string_result =
      Dart_Invoke(lib, NewString("getCrappyString"), 0, nullptr);
  EXPECT_VALID(crappy_string_result);
  EXPECT(Dart_IsString(crappy_string_result));
 
  {
    Thread* thread = Thread::Current();
    CHECK_API_SCOPE(thread);
    TransitionNativeToVM transition(thread);
    HANDLESCOPE(thread);
 
    {
      StackZone zone(thread);
      Smi& smi = Smi::Handle();
      smi ^= Api::UnwrapHandle(smi_result);
      std::unique_ptr<Message> message = WriteMessage(
          /* same_group */ false, smi, ILLEGAL_PORT, Message::kNormalPriority);
 
      // Read object back from the snapshot into a C structure.
      ApiNativeScope scope;
      Dart_CObject* root = ReadApiMessage(scope.zone(), message.get());
      EXPECT_NOTNULL(root);
      EXPECT_EQ(Dart_CObject_kInt32, root->type);
      EXPECT_EQ(42, root->value.as_int32);
      CheckEncodeDecodeMessage(scope.zone(), root);
    }
    CheckString(ascii_string_result, "Hello, world!");
    CheckString(non_ascii_string_result, "Blåbærgrød");
    CheckString(non_bmp_string_result,
                "\xf0\x90\x80\x80"
                "\xf0\x9f\x98\x81"
                "\xf0\x9f\x98\xb7"
                "\xf0\xa0\x80\x80");
    CheckStringInvalid(lead_surrogate_string_result);
    CheckStringInvalid(trail_surrogate_string_result);
    CheckStringInvalid(crappy_string_result);
    CheckStringInvalid(surrogates_string_result);
  }
  Dart_ExitScope();
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [43/107]

dart::VM_UNIT_TEST_CASE

(

DecrementBy

)

Definition at line 43 of file atomic_test.cc.

                               {
  RelaxedAtomic<intptr_t> v = 42;
  v.fetch_sub(41);
  EXPECT_EQ(static_cast<intptr_t>(1), v);
}

VM_UNIT_TEST_CASE() [44/107]

dart::VM_UNIT_TEST_CASE

(

DirectoryCurrentNoScope

)

Definition at line 12 of file directory_test.cc.

                                           {
  char* current_dir = dart::bin::Directory::CurrentNoScope();
  EXPECT_NOTNULL(current_dir);
  free(current_dir);
}

VM_UNIT_TEST_CASE() [45/107]

dart::VM_UNIT_TEST_CASE

(

DoublesBitEqual

)

Definition at line 424 of file utils_test.cc.

                                   {
  EXPECT(Utils::DoublesBitEqual(1.0, 1.0));
  EXPECT(!Utils::DoublesBitEqual(1.0, -1.0));
  EXPECT(Utils::DoublesBitEqual(0.0, 0.0));
  EXPECT(!Utils::DoublesBitEqual(0.0, -0.0));
  EXPECT(Utils::DoublesBitEqual(NAN, NAN));
}

VM_UNIT_TEST_CASE() [46/107]

dart::VM_UNIT_TEST_CASE

(

DuplicateRXVirtualMemory

)

Definition at line 100 of file virtual_memory_test.cc.

                                            {
  const uword page_size = VirtualMemory::PageSize();
  const uword pointer = reinterpret_cast<uword>(&testFunction);
  const uword page_start = Utils::RoundDown(pointer, page_size);
  const uword offset = pointer - page_start;
 
  // Grab 2 * page_size, in case testFunction happens to land near the end of
  // the page.
  VirtualMemory* vm = VirtualMemory::ForImagePage(
      reinterpret_cast<void*>(page_start), 2 * page_size);
  EXPECT_NE(nullptr, vm);
 
#if defined(DART_HOST_OS_MACOS) && !defined(DART_PRECOMPILED_RUNTIME)
  // If we are not going to use vm_remap then we need to pass
  // is_executable=true so that pages get allocated with MAP_JIT flag if
  // necessary. Otherwise OS will kill us with a codesigning violation if
  // hardened runtime is enabled.
  const bool is_executable = true;
#else
  const bool is_executable = false;
#endif
 
  VirtualMemory* vm2 = VirtualMemory::AllocateAligned(
      vm->size(), kPageSize, is_executable,
      /*is_compressed=*/false, "FfiCallbackMetadata::TrampolinePage");
  bool ok = vm->DuplicateRX(vm2);
  EXPECT_EQ(true, ok);
 
  auto testFunction2 = reinterpret_cast<int (*)(int)>(vm2->start() + offset);
  EXPECT_NE(&testFunction, testFunction2);
 
  EXPECT_EQ(246, testFunction2(123));
 
  delete vm;
  delete vm2;
}

VM_UNIT_TEST_CASE() [47/107]

dart::VM_UNIT_TEST_CASE

(

Endianity

)

Definition at line 380 of file utils_test.cc.

                             {
  uint16_t value16be = Utils::HostToBigEndian16(0xf1);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value16be)[0]);
  EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value16be)[1]);
 
  uint16_t value16le = Utils::HostToLittleEndian16(0xf1);
  EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value16le)[0]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value16le)[1]);
 
  uint32_t value32be = Utils::HostToBigEndian32(0xf1f2);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value32be)[0]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value32be)[1]);
  EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value32be)[2]);
  EXPECT_EQ(0xf2, reinterpret_cast<uint8_t*>(&value32be)[3]);
  EXPECT_EQ(0xf1f2u, Utils::BigEndianToHost32(value32be));
 
  uint32_t value32le = Utils::HostToLittleEndian32(0xf1f2);
  EXPECT_EQ(0xf2, reinterpret_cast<uint8_t*>(&value32le)[0]);
  EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value32le)[1]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value32le)[2]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value32le)[3]);
 
  uint64_t value64be = Utils::HostToBigEndian64(0xf1f2f3f4);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64be)[0]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64be)[1]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64be)[2]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64be)[3]);
  EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value64be)[4]);
  EXPECT_EQ(0xf2, reinterpret_cast<uint8_t*>(&value64be)[5]);
  EXPECT_EQ(0xf3, reinterpret_cast<uint8_t*>(&value64be)[6]);
  EXPECT_EQ(0xf4, reinterpret_cast<uint8_t*>(&value64be)[7]);
 
  uint64_t value64le = Utils::HostToLittleEndian64(0xf1f2f3f4);
  EXPECT_EQ(0xf4, reinterpret_cast<uint8_t*>(&value64le)[0]);
  EXPECT_EQ(0xf3, reinterpret_cast<uint8_t*>(&value64le)[1]);
  EXPECT_EQ(0xf2, reinterpret_cast<uint8_t*>(&value64le)[2]);
  EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value64le)[3]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[4]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[5]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[6]);
  EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[7]);
  EXPECT_EQ(0xf1f2f3f4ul, Utils::LittleEndianToHost64(value64le));
}

VM_UNIT_TEST_CASE() [48/107]

dart::VM_UNIT_TEST_CASE

(

ExtendedRegion

)

Definition at line 58 of file memory_region_test.cc.

                                  {
  const uword kSize = 1024;
  const uword kSubSize = 512;
  const uword kExtendSize = 512;
  MemoryRegion region(NewRegion(kSize), kSize);
  MemoryRegion sub_region;
  sub_region.Subregion(region, 0, kSubSize);
  MemoryRegion extended_region;
  extended_region.Extend(sub_region, kExtendSize);
  EXPECT_EQ(kSize, extended_region.size());
  EXPECT(extended_region.pointer() == region.pointer());
  EXPECT(extended_region.pointer() == sub_region.pointer());
 
  extended_region.Store<int32_t>(0, 42);
  EXPECT_EQ(42, extended_region.Load<int32_t>(0));
 
  DeleteRegion(region);
}

VM_UNIT_TEST_CASE() [49/107]

dart::VM_UNIT_TEST_CASE

(

FetchAndDecrement

)

Definition at line 19 of file atomic_test.cc.

                                     {
  RelaxedAtomic<uintptr_t> v = 42;
  EXPECT_EQ(static_cast<uintptr_t>(42), v.fetch_sub(1));
  EXPECT_EQ(static_cast<uintptr_t>(41), v);
}

VM_UNIT_TEST_CASE() [50/107]

dart::VM_UNIT_TEST_CASE

(

FetchAndDecrementSigned

)

Definition at line 31 of file atomic_test.cc.

                                           {
  RelaxedAtomic<intptr_t> v = -42;
  EXPECT_EQ(static_cast<intptr_t>(-42), v.fetch_sub(1));
  EXPECT_EQ(static_cast<intptr_t>(-43), v);
}

VM_UNIT_TEST_CASE() [51/107]

dart::VM_UNIT_TEST_CASE

(

FetchAndIncrement

)

Definition at line 13 of file atomic_test.cc.

                                     {
  RelaxedAtomic<uintptr_t> v = 42;
  EXPECT_EQ(static_cast<uintptr_t>(42), v.fetch_add(1));
  EXPECT_EQ(static_cast<uintptr_t>(43), v);
}

VM_UNIT_TEST_CASE() [52/107]

dart::VM_UNIT_TEST_CASE

(

FetchAndIncrementSigned

)

Definition at line 25 of file atomic_test.cc.

                                           {
  RelaxedAtomic<intptr_t> v = -42;
  EXPECT_EQ(static_cast<intptr_t>(-42), v.fetch_add(1));
  EXPECT_EQ(static_cast<intptr_t>(-41), v);
}

VM_UNIT_TEST_CASE() [53/107]

dart::VM_UNIT_TEST_CASE

(

FetchAndRelaxed

)

Definition at line 56 of file atomic_test.cc.

                                   {
  RelaxedAtomic<uint32_t> v = 42;
  uint32_t previous = v.fetch_and(3);
  EXPECT_EQ(static_cast<uint32_t>(42), previous);
  EXPECT_EQ(static_cast<uint32_t>(2), v);
}

VM_UNIT_TEST_CASE() [54/107]

dart::VM_UNIT_TEST_CASE

(

FetchOrRelaxed

)

Definition at line 49 of file atomic_test.cc.

                                  {
  RelaxedAtomic<uint32_t> v = 42;
  uint32_t previous = v.fetch_or(3);
  EXPECT_EQ(static_cast<uint32_t>(42), previous);
  EXPECT_EQ(static_cast<uint32_t>(43), v);
}

VM_UNIT_TEST_CASE() [55/107]

dart::VM_UNIT_TEST_CASE

(

FfiCallbackMetadata_CreateAsyncFfiCallback

)

Definition at line 168 of file ffi_callback_metadata_test.cc.

                                                              {
  auto* fcm = FfiCallbackMetadata::Instance();
  FfiCallbackMetadata::Trampoline tramp1 = 0;
  FfiCallbackMetadata::Trampoline tramp2 = 0;
 
  {
    TestIsolateScope isolate_scope;
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    ASSERT(thread->isolate() == isolate_scope.isolate());
    TransitionNativeToVM transition(thread);
    StackZone stack_zone(thread);
    HandleScope handle_scope(thread);
 
    auto* zone = thread->zone();
 
    const Function& func =
        Function::Handle(CreateTestFunction(FfiCallbackKind::kAsyncCallback));
    const Code& code = Code::Handle(func.EnsureHasCode());
    EXPECT(!code.IsNull());
 
    EXPECT_EQ(isolate->ffi_callback_list_head(), nullptr);
 
    auto port1 = PortMap::CreatePort(new FakeMessageHandler());
    tramp1 = isolate->CreateAsyncFfiCallback(zone, func, port1);
    EXPECT_NE(tramp1, 0u);
 
    {
      FfiCallbackMetadata::Metadata m1 =
          fcm->LookupMetadataForTrampoline(tramp1);
      EXPECT(m1.IsLive());
      EXPECT_EQ(m1.target_isolate(), isolate);
      EXPECT_EQ(m1.target_entry_point(), code.EntryPoint());
      EXPECT_EQ(m1.send_port(), port1);
      EXPECT_EQ(static_cast<int>(m1.trampoline_type()),
                static_cast<int>(FfiCallbackMetadata::TrampolineType::kAsync));
 
      // head -> tramp1
      auto* e1 = fcm->MetadataOfTrampoline(tramp1);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e1);
      EXPECT_EQ(e1->list_prev(), nullptr);
      EXPECT_EQ(e1->list_next(), nullptr);
    }
 
    auto port2 = PortMap::CreatePort(new FakeMessageHandler());
    tramp2 = isolate->CreateAsyncFfiCallback(zone, func, port2);
    EXPECT_NE(tramp2, 0u);
    EXPECT_NE(tramp2, tramp1);
 
    {
      FfiCallbackMetadata::Metadata m2 =
          fcm->LookupMetadataForTrampoline(tramp2);
      EXPECT(m2.IsLive());
      EXPECT_EQ(m2.target_isolate(), isolate);
      EXPECT_EQ(m2.target_entry_point(), code.EntryPoint());
      EXPECT_EQ(m2.send_port(), port2);
      EXPECT_EQ(static_cast<int>(m2.trampoline_type()),
                static_cast<int>(FfiCallbackMetadata::TrampolineType::kAsync));
    }
 
    {
      // head -> tramp2 -> tramp1
      auto* e1 = fcm->MetadataOfTrampoline(tramp1);
      auto* e2 = fcm->MetadataOfTrampoline(tramp2);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e2);
      EXPECT_EQ(e2->list_prev(), nullptr);
      EXPECT_EQ(e2->list_next(), e1);
      EXPECT_EQ(e1->list_prev(), e2);
      EXPECT_EQ(e1->list_next(), nullptr);
    }
 
    {
      isolate->DeleteFfiCallback(tramp2);
      FfiCallbackMetadata::Metadata m2 =
          fcm->LookupMetadataForTrampoline(tramp2);
      EXPECT(!m2.IsLive());
 
      // head -> tramp1
      auto* e1 = fcm->MetadataOfTrampoline(tramp1);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e1);
      EXPECT_EQ(e1->list_prev(), nullptr);
      EXPECT_EQ(e1->list_next(), nullptr);
    }
  }
 
  {
    // Isolate has shut down, so all callbacks should be deleted.
    FfiCallbackMetadata::Metadata m1 = fcm->LookupMetadataForTrampoline(tramp1);
    EXPECT(!m1.IsLive());
 
    FfiCallbackMetadata::Metadata m2 = fcm->LookupMetadataForTrampoline(tramp2);

VM_UNIT_TEST_CASE() [56/107]

dart::VM_UNIT_TEST_CASE

(

FfiCallbackMetadata_CreateIsolateLocalFfiCallback

)

Definition at line 263 of file ffi_callback_metadata_test.cc.

                                                                     {
  auto* fcm = FfiCallbackMetadata::Instance();
  FfiCallbackMetadata::Trampoline tramp1 = 0;
  FfiCallbackMetadata::Trampoline tramp2 = 0;
 
  {
    TestIsolateScope isolate_scope;
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    ASSERT(thread->isolate() == isolate_scope.isolate());
    TransitionNativeToVM transition(thread);
    StackZone stack_zone(thread);
    HandleScope handle_scope(thread);
 
    auto* zone = thread->zone();
 
    const Function& func = Function::Handle(
        CreateTestFunction(FfiCallbackKind::kIsolateLocalClosureCallback));
    const Code& code = Code::Handle(func.EnsureHasCode());
    EXPECT(!code.IsNull());
 
    // Using a FfiCallbackKind::kSync function as a dummy closure.
    const Function& closure_func = Function::Handle(
        CreateTestFunction(FfiCallbackKind::kIsolateLocalStaticCallback));
    const Context& context = Context::Handle(Context::null());
    const Closure& closure1 = Closure::Handle(
        Closure::New(Object::null_type_arguments(),
                     Object::null_type_arguments(), closure_func, context));
 
    EXPECT_EQ(isolate->ffi_callback_list_head(), nullptr);
 
    tramp1 = isolate->CreateIsolateLocalFfiCallback(zone, func, closure1, true);
    EXPECT_NE(tramp1, 0u);
 
    {
      FfiCallbackMetadata::Metadata m1 =
          fcm->LookupMetadataForTrampoline(tramp1);
      EXPECT(m1.IsLive());
      EXPECT_EQ(m1.target_isolate(), isolate);
      EXPECT_EQ(m1.target_entry_point(), code.EntryPoint());
      EXPECT_EQ(m1.closure_handle()->ptr(), closure1.ptr());
      EXPECT_EQ(static_cast<int>(m1.trampoline_type()),
                static_cast<int>(FfiCallbackMetadata::TrampolineType::kSync));
 
      // head -> tramp1
      auto* e1 = fcm->MetadataOfTrampoline(tramp1);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e1);
      EXPECT_EQ(e1->list_prev(), nullptr);
      EXPECT_EQ(e1->list_next(), nullptr);
    }
 
    const Closure& closure2 = Closure::Handle(
        Closure::New(Object::null_type_arguments(),
                     Object::null_type_arguments(), closure_func, context));
    tramp2 = isolate->CreateIsolateLocalFfiCallback(zone, func, closure2, true);
    EXPECT_NE(tramp2, 0u);
    EXPECT_NE(tramp2, tramp1);
 
    {
      FfiCallbackMetadata::Metadata m2 =
          fcm->LookupMetadataForTrampoline(tramp2);
      EXPECT(m2.IsLive());
      EXPECT_EQ(m2.target_isolate(), isolate);
      EXPECT_EQ(m2.target_entry_point(), code.EntryPoint());
      EXPECT_EQ(m2.closure_handle()->ptr(), closure2.ptr());
      EXPECT_EQ(static_cast<int>(m2.trampoline_type()),
                static_cast<int>(FfiCallbackMetadata::TrampolineType::kSync));
    }
 
    {
      // head -> tramp2 -> tramp1
      auto* e1 = fcm->MetadataOfTrampoline(tramp1);
      auto* e2 = fcm->MetadataOfTrampoline(tramp2);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e2);
      EXPECT_EQ(e2->list_prev(), nullptr);
      EXPECT_EQ(e2->list_next(), e1);
      EXPECT_EQ(e1->list_prev(), e2);
      EXPECT_EQ(e1->list_next(), nullptr);
    }
 
    {
      isolate->DeleteFfiCallback(tramp2);
      FfiCallbackMetadata::Metadata m2 =
          fcm->LookupMetadataForTrampoline(tramp2);
      EXPECT(!m2.IsLive());
 
      // head -> tramp1
      auto* e1 = fcm->MetadataOfTrampoline(tramp1);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e1);
      EXPECT_EQ(e1->list_prev(), nullptr);
      EXPECT_EQ(e1->list_next(), nullptr);
    }
  }
 
  {
    // Isolate has shut down, so all callbacks should be deleted.
    FfiCallbackMetadata::Metadata m1 = fcm->LookupMetadataForTrampoline(tramp1);
    EXPECT(!m1.IsLive());
 
    FfiCallbackMetadata::Metadata m2 = fcm->LookupMetadataForTrampoline(tramp2);

VM_UNIT_TEST_CASE() [57/107]

dart::VM_UNIT_TEST_CASE

(

FfiCallbackMetadata_CreateSyncFfiCallback

)

Definition at line 75 of file ffi_callback_metadata_test.cc.

                                                             {
  auto* fcm = FfiCallbackMetadata::Instance();
  FfiCallbackMetadata::Trampoline tramp1 = 0;
  FfiCallbackMetadata::Trampoline tramp2 = 0;
 
  {
    TestIsolateScope isolate_scope;
    Thread* thread = Thread::Current();
    Isolate* isolate = thread->isolate();
    ASSERT(isolate == isolate_scope.isolate());
    TransitionNativeToVM transition(thread);
    StackZone stack_zone(thread);
    HandleScope handle_scope(thread);
 
    auto* zone = thread->zone();
 
    const auto& func = Function::Handle(
        CreateTestFunction(FfiCallbackKind::kIsolateLocalStaticCallback));
    const auto& code = Code::Handle(func.EnsureHasCode());
    EXPECT(!code.IsNull());
 
    tramp1 = isolate->CreateIsolateLocalFfiCallback(
        zone, func, Closure::Handle(Closure::null()), false);
    EXPECT_NE(tramp1, 0u);
 
    {
      FfiCallbackMetadata::Metadata m1 =
          fcm->LookupMetadataForTrampoline(tramp1);
      EXPECT(m1.IsLive());
      EXPECT_EQ(m1.target_isolate(), isolate);
      EXPECT_EQ(m1.target_entry_point(), code.EntryPoint());
      EXPECT_EQ(m1.closure_handle(), nullptr);
      EXPECT_EQ(static_cast<int>(m1.trampoline_type()),
                static_cast<int>(FfiCallbackMetadata::TrampolineType::kSync));
 
      // head -> tramp1
      auto* e1 = fcm->MetadataOfTrampoline(tramp1);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e1);
      EXPECT_EQ(e1->list_prev(), nullptr);
      EXPECT_EQ(e1->list_next(), nullptr);
    }
 
    tramp2 = isolate->CreateIsolateLocalFfiCallback(
        zone, func, Closure::Handle(Closure::null()), false);
    EXPECT_NE(tramp2, 0u);
    EXPECT_NE(tramp2, tramp1);
 
    {
      FfiCallbackMetadata::Metadata m2 =
          fcm->LookupMetadataForTrampoline(tramp2);
      EXPECT(m2.IsLive());
      EXPECT_EQ(m2.target_isolate(), isolate);
      EXPECT_EQ(m2.target_entry_point(), code.EntryPoint());
      EXPECT_EQ(m2.closure_handle(), nullptr);
      EXPECT_EQ(static_cast<int>(m2.trampoline_type()),
                static_cast<int>(FfiCallbackMetadata::TrampolineType::kSync));
    }
 
    {
      // head -> tramp2 -> tramp1
      auto* e1 = fcm->MetadataOfTrampoline(tramp1);
      auto* e2 = fcm->MetadataOfTrampoline(tramp2);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e2);
      EXPECT_EQ(e2->list_prev(), nullptr);
      EXPECT_EQ(e2->list_next(), e1);
      EXPECT_EQ(e1->list_prev(), e2);
      EXPECT_EQ(e1->list_next(), nullptr);
    }
 
    {
      isolate->DeleteFfiCallback(tramp1);
      FfiCallbackMetadata::Metadata m1 =
          fcm->LookupMetadataForTrampoline(tramp1);
      EXPECT(!m1.IsLive());
 
      // head -> tramp2
      auto* e2 = fcm->MetadataOfTrampoline(tramp2);
      EXPECT_EQ(isolate->ffi_callback_list_head(), e2);
      EXPECT_EQ(e2->list_prev(), nullptr);
      EXPECT_EQ(e2->list_next(), nullptr);
    }
  }
 
  {
    // Isolate has shut down, so all callbacks should be deleted.
    FfiCallbackMetadata::Metadata m1 = fcm->LookupMetadataForTrampoline(tramp1);
    EXPECT(!m1.IsLive());
 
    FfiCallbackMetadata::Metadata m2 = fcm->LookupMetadataForTrampoline(tramp2);

VM_UNIT_TEST_CASE() [58/107]

dart::VM_UNIT_TEST_CASE

(

FfiCallbackMetadata_DeleteTrampolines

)

Definition at line 423 of file ffi_callback_metadata_test.cc.

                                                         {
  static constexpr int kCreations = 1000;
  static constexpr int kDeletions = 100;
 
  TestIsolateScope isolate_scope;
  Thread* thread = Thread::Current();
  Isolate* isolate = thread->isolate();
  ASSERT(isolate == isolate_scope.isolate());
  TransitionNativeToVM transition(thread);
  StackZone stack_zone(thread);
  HandleScope handle_scope(thread);
 
  auto* fcm = FfiCallbackMetadata::Instance();
  std::unordered_set<FfiCallbackMetadata::Trampoline> tramps;
  FfiCallbackMetadata::Metadata* list_head = nullptr;
 
  const auto& sync_func = Function::Handle(
      CreateTestFunction(FfiCallbackKind::kIsolateLocalStaticCallback));
  const auto& sync_code = Code::Handle(sync_func.EnsureHasCode());
  EXPECT(!sync_code.IsNull());
 
  // Create some callbacks.
  for (int itr = 0; itr < kCreations; ++itr) {
    tramps.insert(fcm->CreateIsolateLocalFfiCallback(
        isolate, thread->zone(), sync_func, Closure::Handle(Closure::null()),
        &list_head));
  }
 
  // Delete some of the callbacks.
  for (int itr = 0; itr < kDeletions; ++itr) {
    auto tramp = *tramps.begin();
    fcm->DeleteCallback(tramp, &list_head);
    tramps.erase(tramp);
  }
 
  // Verify all the callbacks.
  for (FfiCallbackMetadata::Trampoline tramp : tramps) {
    auto metadata = fcm->LookupMetadataForTrampoline(tramp);
    EXPECT(metadata.IsLive());
    EXPECT_EQ(metadata.target_isolate(), isolate);
    EXPECT_EQ(static_cast<int>(metadata.trampoline_type()),
              static_cast<int>(FfiCallbackMetadata::TrampolineType::kSync));
    EXPECT_EQ(metadata.target_entry_point(), sync_code.EntryPoint());
  }
 
  // Verify the list of callbacks.
  uword list_length = 0;
  for (FfiCallbackMetadata::Metadata* m = list_head; m != nullptr;) {
    ++list_length;
    auto tramp = fcm->TrampolineOfMetadata(m);
    EXPECT(m->IsLive());
    EXPECT_EQ(m->target_isolate(), isolate);
    EXPECT_EQ(tramps.count(tramp), 1u);
    auto* next = m->list_next();
    auto* prev = m->list_prev();
    if (prev != nullptr) {
      EXPECT_EQ(prev->list_next(), m);
    } else {
      EXPECT_EQ(list_head, m);
    }
    if (next != nullptr) {
      EXPECT_EQ(next->list_prev(), m);
    }
    m = m->list_next();
  }
  EXPECT_EQ(list_length, tramps.size());
 
  // Delete all callbacks and verify they're destroyed.
  fcm->DeleteAllCallbacks(&list_head);
  EXPECT_EQ(list_head, nullptr);
  for (FfiCallbackMetadata::Trampoline tramp : tramps) {

VM_UNIT_TEST_CASE() [59/107]

dart::VM_UNIT_TEST_CASE

(

FreeVirtualMemory

)

Definition at line 68 of file virtual_memory_test.cc.

                                     {
  // Reservations should always be handed back to OS upon destruction.
  const intptr_t kVirtualMemoryBlockSize = 10 * MB;
  const intptr_t kIterations = 900;  // Enough to exhaust 32-bit address space.
  for (intptr_t i = 0; i < kIterations; ++i) {
    VirtualMemory* vm =
        VirtualMemory::Allocate(kVirtualMemoryBlockSize, false, false, "test");
    delete vm;
  }
  // Check that truncation does not introduce leaks.
  for (intptr_t i = 0; i < kIterations; ++i) {
    VirtualMemory* vm =
        VirtualMemory::Allocate(kVirtualMemoryBlockSize, false, false, "test");
    vm->Truncate(kVirtualMemoryBlockSize / 2);
    delete vm;
  }
  for (intptr_t i = 0; i < kIterations; ++i) {
    VirtualMemory* vm =
        VirtualMemory::Allocate(kVirtualMemoryBlockSize, true, false, "test");
    vm->Truncate(0);
    delete vm;
  }
}

VM_UNIT_TEST_CASE() [60/107]

dart::VM_UNIT_TEST_CASE

(

FullSnapshot

)

Definition at line 709 of file snapshot_test.cc.

                                {
  // clang-format off
  auto kScriptChars = Utils::CStringUniquePtr(
      OS::SCreate(
          nullptr,
          "class Fields  {\n"
          "  Fields(int i, int j) : fld1 = i, fld2 = j {}\n"
          "  int fld1;\n"
          "  final int fld2;\n"
          "  final int bigint_fld = 0xfffffffffff;\n"
          "  static int%s fld3;\n"
          "  static const int smi_sfld = 10;\n"
          "  static const int bigint_sfld = 0xfffffffffff;\n"
          "}\n"
          "class Expect {\n"
          "  static void equals(x, y) {\n"
          "    if (x != y) throw new ArgumentError('not equal');\n"
          "  }\n"
          "}\n"
          "class FieldsTest {\n"
          "  static Fields testMain() {\n"
          "    Expect.equals(true, Fields.bigint_sfld == 0xfffffffffff);\n"
          "    Fields obj = new Fields(10, 20);\n"
          "    Expect.equals(true, obj.bigint_fld == 0xfffffffffff);\n"
          "    return obj;\n"
          "  }\n"
          "}\n",
          TestCase::NullableTag()),
      std::free);
  // clang-format on
  Dart_Handle result;
 
  uint8_t* isolate_snapshot_data_buffer;
 
  // Start an Isolate, load a script and create a full snapshot.
  Timer timer1;
  timer1.Start();
  {
    TestIsolateScope __test_isolate__;
 
    // Create a test library and Load up a test script in it.
    TestCase::LoadTestScript(kScriptChars.get(), nullptr);
 
    Thread* thread = Thread::Current();
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
    HandleScope scope(thread);
 
    Dart_Handle result = Api::CheckAndFinalizePendingClasses(thread);
    {
      TransitionVMToNative to_native(thread);
      EXPECT_VALID(result);
    }
    timer1.Stop();
    OS::PrintErr("Without Snapshot: %" Pd64 "us\n", timer1.TotalElapsedTime());
 
    // Write snapshot with object content.
    MallocWriteStream isolate_snapshot_data(FullSnapshotWriter::kInitialSize);
    FullSnapshotWriter writer(
        Snapshot::kFull, /*vm_snapshot_data=*/nullptr, &isolate_snapshot_data,
        /*vm_image_writer=*/nullptr, /*iso_image_writer=*/nullptr);
    writer.WriteFullSnapshot();
    // Take ownership so it doesn't get freed by the stream destructor.
    intptr_t unused;
    isolate_snapshot_data_buffer = isolate_snapshot_data.Steal(&unused);
  }
 
  // Now Create another isolate using the snapshot and execute a method
  // from the script.
  Timer timer2;
  timer2.Start();
  TestCase::CreateTestIsolateFromSnapshot(isolate_snapshot_data_buffer);
  {
    Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
    timer2.Stop();
    OS::PrintErr("From Snapshot: %" Pd64 "us\n", timer2.TotalElapsedTime());
 
    // Invoke a function which returns an object.
    Dart_Handle cls = Dart_GetClass(TestCase::lib(), NewString("FieldsTest"));
    result = Dart_Invoke(cls, NewString("testMain"), 0, nullptr);
    EXPECT_VALID(result);
    Dart_ExitScope();
  }
  Dart_ShutdownIsolate();
  free(isolate_snapshot_data_buffer);
}

VM_UNIT_TEST_CASE() [61/107]

dart::VM_UNIT_TEST_CASE

(

GetCpuModelTest

)

Definition at line 12 of file cpuinfo_test.cc.

                                   {
  const char* cpumodel = CpuInfo::GetCpuModel();
  EXPECT_NE(strlen(cpumodel), 0UL);
  // caller is responsible for deleting the returned cpumodel string.
  free(const_cast<char*>(cpumodel));
}

VM_UNIT_TEST_CASE() [62/107]

dart::VM_UNIT_TEST_CASE

(

Id

)

Definition at line 12 of file cpu_test.cc.

                      {
#if defined(TARGET_ARCH_IA32)
  EXPECT_STREQ("ia32", CPU::Id());
#elif defined(TARGET_ARCH_X64)
  EXPECT_STREQ("x64", CPU::Id());
#elif defined(TARGET_ARCH_ARM)
#if defined(HOST_ARCH_ARM)
  EXPECT_STREQ("arm", CPU::Id());
#else   // defined(HOST_ARCH_ARM)
  EXPECT_STREQ("simarm", CPU::Id());
#endif  // defined(HOST_ARCH_ARM)
#elif defined(TARGET_ARCH_ARM64)
#if defined(HOST_ARCH_ARM64)
  EXPECT_STREQ("arm64", CPU::Id());
#else   // defined(HOST_ARCH_ARM64)
  EXPECT_STREQ("simarm64", CPU::Id());
#endif  // defined(HOST_ARCH_ARM64)
#elif defined(TARGET_ARCH_RISCV32)
#if defined(HOST_ARCH_RISCV32)
  EXPECT_STREQ("riscv32", CPU::Id());
#else   // defined(HOST_ARCH_RISCV32)
  EXPECT_STREQ("simriscv32", CPU::Id());
#endif  // defined(HOST_ARCH_RISCV32)
#elif defined(TARGET_ARCH_RISCV64)
#if defined(HOST_ARCH_RISCV64)
  EXPECT_STREQ("riscv64", CPU::Id());
#else   // defined(HOST_ARCH_RISCV64)
  EXPECT_STREQ("simriscv64", CPU::Id());
#endif  // defined(HOST_ARCH_RISCV64)
#else
#error Architecture was not detected as supported by Dart.
#endif
}

VM_UNIT_TEST_CASE() [63/107]

dart::VM_UNIT_TEST_CASE

(

IncrementBy

)

Definition at line 37 of file atomic_test.cc.

                               {
  RelaxedAtomic<intptr_t> v = 42;
  v.fetch_add(100);
  EXPECT_EQ(static_cast<intptr_t>(142), v);
}

VM_UNIT_TEST_CASE() [64/107]

dart::VM_UNIT_TEST_CASE

(

IsAligned

)

Definition at line 102 of file utils_test.cc.

                             {
  EXPECT(Utils::IsAligned(0, 1));
  EXPECT(Utils::IsAligned(1, 1));
 
  EXPECT(Utils::IsAligned(0, 2));
  EXPECT(!Utils::IsAligned(1, 2));
  EXPECT(Utils::IsAligned(2, 2));
 
  EXPECT(Utils::IsAligned(32, 8));
  EXPECT(!Utils::IsAligned(33, 8));
  EXPECT(Utils::IsAligned(40, 8));
 
  EXPECT(!Utils::IsAligned(0, 8, 4));
  EXPECT(!Utils::IsAligned(1, 8, 4));
  EXPECT(Utils::IsAligned(4, 8, 4));
  EXPECT(!Utils::IsAligned(8, 8, 4));
  EXPECT(!Utils::IsAligned(9, 8, 4));
  EXPECT(Utils::IsAligned(12, 8, 4));
}

VM_UNIT_TEST_CASE() [65/107]

dart::VM_UNIT_TEST_CASE

(

IsInt

)

Definition at line 277 of file utils_test.cc.

                         {
  EXPECT(Utils::IsInt(8, 16));
  EXPECT(Utils::IsInt(8, 16U));
  EXPECT(Utils::IsInt(8, 127));
  EXPECT(Utils::IsInt(8, 127U));
  EXPECT(Utils::IsInt(8, -128));
  EXPECT(!Utils::IsInt(8, static_cast<unsigned int>(-128)));
  EXPECT(!Utils::IsInt(8, 255));
  EXPECT(!Utils::IsInt(8, 255U));
  EXPECT(Utils::IsInt(16, 16));
  EXPECT(Utils::IsInt(16, 16U));
  EXPECT(!Utils::IsInt(16, 65535));
  EXPECT(!Utils::IsInt(16, 65535U));
  EXPECT(Utils::IsInt(16, 32767));
  EXPECT(Utils::IsInt(16, 32767U));
  EXPECT(Utils::IsInt(16, -32768));
  EXPECT(!Utils::IsInt(16, static_cast<unsigned int>(-32768)));
  EXPECT(Utils::IsInt(32, 16LL));
  EXPECT(Utils::IsInt(32, 16ULL));
  EXPECT(Utils::IsInt(32, 2147483647LL));
  EXPECT(Utils::IsInt(32, 2147483647ULL));
  EXPECT(Utils::IsInt(32, -2147483648LL));
  EXPECT(!Utils::IsInt(32, static_cast<uint64_t>(-2147483648LL)));
  EXPECT(!Utils::IsInt(32, 4294967295LL));
  EXPECT(!Utils::IsInt(32, 4294967295ULL));
}

VM_UNIT_TEST_CASE() [66/107]

dart::VM_UNIT_TEST_CASE

(

IsolateCurrent

)

Definition at line 19 of file isolate_test.cc.

                                  {
  Dart_Isolate isolate = TestCase::CreateTestIsolate();
  EXPECT_EQ(isolate, Dart_CurrentIsolate());
  Dart_ShutdownIsolate();
  EXPECT_EQ(static_cast<Dart_Isolate>(nullptr), Dart_CurrentIsolate());
}

VM_UNIT_TEST_CASE() [67/107]

dart::VM_UNIT_TEST_CASE

(

IsPowerOfTwo

)

Definition at line 84 of file utils_test.cc.

                                {
  EXPECT(!Utils::IsPowerOfTwo(0));
  EXPECT(Utils::IsPowerOfTwo(1));
  EXPECT(Utils::IsPowerOfTwo(2));
  EXPECT(!Utils::IsPowerOfTwo(3));
  EXPECT(Utils::IsPowerOfTwo(4));
  EXPECT(Utils::IsPowerOfTwo(256));
 
  EXPECT(!Utils::IsPowerOfTwo(-1));
  EXPECT(!Utils::IsPowerOfTwo(-2));
}

VM_UNIT_TEST_CASE() [68/107]

dart::VM_UNIT_TEST_CASE

(

IsUint

)

Definition at line 304 of file utils_test.cc.

                          {
  EXPECT(Utils::IsUint(8, 16));
  EXPECT(Utils::IsUint(8, 16U));
  EXPECT(Utils::IsUint(8, 0));
  EXPECT(Utils::IsUint(8, 0U));
  EXPECT(Utils::IsUint(8, 255));
  EXPECT(Utils::IsUint(8, 255U));
  EXPECT(!Utils::IsUint(8, 256));
  EXPECT(!Utils::IsUint(8, 256U));
  EXPECT(Utils::IsUint(16, 16));
  EXPECT(Utils::IsUint(16, 16U));
  EXPECT(Utils::IsUint(16, 0));
  EXPECT(Utils::IsUint(16, 0U));
  EXPECT(Utils::IsUint(16, 65535));
  EXPECT(Utils::IsUint(16, 65535U));
  EXPECT(!Utils::IsUint(16, 65536));
  EXPECT(!Utils::IsUint(16, 65536U));
  EXPECT(Utils::IsUint(32, 16LL));
  EXPECT(Utils::IsUint(32, 16ULL));
  EXPECT(Utils::IsUint(32, 0LL));
  EXPECT(Utils::IsUint(32, 0ULL));
  EXPECT(Utils::IsUint(32, 4294967295LL));
  EXPECT(Utils::IsUint(32, 4294967295ULL));
  EXPECT(!Utils::IsUint(32, 4294967296LL));
  EXPECT(!Utils::IsUint(32, 4294967296ULL));
}

VM_UNIT_TEST_CASE() [69/107]

dart::VM_UNIT_TEST_CASE

(

LoadRelaxed

)

Definition at line 63 of file atomic_test.cc.

                               {
  RelaxedAtomic<uword> v = 42;
  EXPECT_EQ(static_cast<uword>(42), v.load());
}

VM_UNIT_TEST_CASE() [70/107]

dart::VM_UNIT_TEST_CASE

(

LowBits

)

Definition at line 372 of file utils_test.cc.

                           {
  EXPECT_EQ(0xff00, Utils::Low16Bits(0xffff00));
  EXPECT_EQ(0xff, Utils::High16Bits(0xffff00));
  EXPECT_EQ(0xff00, Utils::Low32Bits(0xff0000ff00LL));
  EXPECT_EQ(0xff, Utils::High32Bits(0xff0000ff00LL));
  EXPECT_EQ(0x00ff0000ff00LL, Utils::LowHighTo64Bits(0xff00, 0x00ff));
}

VM_UNIT_TEST_CASE() [71/107]

dart::VM_UNIT_TEST_CASE

(

MagnitudeIsUint

)

Definition at line 331 of file utils_test.cc.

                                   {
  EXPECT(Utils::MagnitudeIsUint(8, 16));
  EXPECT(Utils::MagnitudeIsUint(8, 16U));
  EXPECT(Utils::MagnitudeIsUint(8, 0));
  EXPECT(Utils::MagnitudeIsUint(8, 0U));
  EXPECT(Utils::MagnitudeIsUint(8, -128));
  EXPECT(!Utils::MagnitudeIsUint(8, static_cast<unsigned int>(-128)));
  EXPECT(Utils::MagnitudeIsUint(8, 255));
  EXPECT(Utils::MagnitudeIsUint(8, 255U));
  EXPECT(!Utils::MagnitudeIsUint(8, 256));
  EXPECT(!Utils::MagnitudeIsUint(8, 256U));
  EXPECT(Utils::MagnitudeIsUint(12, 4095));
  EXPECT(Utils::MagnitudeIsUint(12, 4095U));
  EXPECT(Utils::MagnitudeIsUint(12, -4095));
  EXPECT(!Utils::MagnitudeIsUint(12, static_cast<unsigned int>(-4095)));
  EXPECT(!Utils::MagnitudeIsUint(12, 4096));
  EXPECT(!Utils::MagnitudeIsUint(12, 4096U));
  EXPECT(!Utils::MagnitudeIsUint(12, -4096));
  EXPECT(!Utils::MagnitudeIsUint(12, static_cast<unsigned int>(-4096)));
  EXPECT(Utils::MagnitudeIsUint(16, 16));
  EXPECT(Utils::MagnitudeIsUint(16, 16U));
  EXPECT(Utils::MagnitudeIsUint(16, 0));
  EXPECT(Utils::MagnitudeIsUint(16, 0U));
  EXPECT(Utils::MagnitudeIsUint(16, 65535));
  EXPECT(Utils::MagnitudeIsUint(16, 65535U));
  EXPECT(Utils::MagnitudeIsUint(16, -32768));
  EXPECT(!Utils::MagnitudeIsUint(16, static_cast<unsigned int>(-32768)));
  EXPECT(!Utils::MagnitudeIsUint(16, 65536));
  EXPECT(!Utils::MagnitudeIsUint(16, 65536U));
  EXPECT(Utils::MagnitudeIsUint(32, 16LL));
  EXPECT(Utils::MagnitudeIsUint(32, 16ULL));
  EXPECT(Utils::MagnitudeIsUint(32, 0LL));
  EXPECT(Utils::MagnitudeIsUint(32, 0ULL));
  EXPECT(Utils::MagnitudeIsUint(32, -2147483648LL));
  EXPECT(!Utils::MagnitudeIsUint(32, static_cast<uint64_t>(-2147483648LL)));
  EXPECT(Utils::MagnitudeIsUint(32, 4294967295LL));
  EXPECT(Utils::MagnitudeIsUint(32, 4294967295ULL));
  EXPECT(!Utils::MagnitudeIsUint(32, 4294967296LL));
  EXPECT(!Utils::MagnitudeIsUint(32, 4294967296ULL));
}

VM_UNIT_TEST_CASE() [72/107]

dart::VM_UNIT_TEST_CASE

(

Maximum

)

Definition at line 70 of file utils_test.cc.

                           {
  EXPECT_EQ(1, Utils::Maximum(0, 1));
  EXPECT_EQ(1, Utils::Maximum(1, 0));
 
  EXPECT_EQ(2, Utils::Maximum(1, 2));
  EXPECT_EQ(2, Utils::Maximum(2, 1));
 
  EXPECT_EQ(1, Utils::Maximum(-1, 1));
  EXPECT_EQ(1, Utils::Maximum(1, -1));
 
  EXPECT_EQ(-1, Utils::Maximum(-1, -2));
  EXPECT_EQ(-1, Utils::Maximum(-2, -1));
}

VM_UNIT_TEST_CASE() [73/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_CloseAllPorts

)

Definition at line 217 of file message_handler_test.cc.

                                                {
  TestMessageHandler handler;
  MessageHandlerTestPeer handler_peer(&handler);
  handler_peer.PostMessage(BlankMessage(1, Message::kNormalPriority));
  handler_peer.PostMessage(BlankMessage(2, Message::kNormalPriority));
 
  handler_peer.CloseAllPorts();
 
  // All messages are dropped from the queue.
  EXPECT(nullptr == handler_peer.queue()->Dequeue());
}

VM_UNIT_TEST_CASE() [74/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_ClosePort

)

Definition at line 199 of file message_handler_test.cc.

                                            {
  TestMessageHandler handler;
  MessageHandlerTestPeer handler_peer(&handler);
  std::unique_ptr<Message> message;
  message = BlankMessage(1, Message::kNormalPriority);
  Message* raw_message1 = message.get();
  handler_peer.PostMessage(std::move(message));
  message = BlankMessage(2, Message::kNormalPriority);
  Message* raw_message2 = message.get();
  handler_peer.PostMessage(std::move(message));
 
  handler_peer.ClosePort(1);
 
  // Closing the port does not drop the messages from the queue.
  EXPECT(raw_message1 == handler_peer.queue()->Dequeue().get());
  EXPECT(raw_message2 == handler_peer.queue()->Dequeue().get());
}

VM_UNIT_TEST_CASE() [75/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_HandleNextMessage

)

Definition at line 229 of file message_handler_test.cc.

                                                    {
  TestMessageHandler handler;
  MessageHandlerTestPeer handler_peer(&handler);
  Dart_Port port1 = PortMap::CreatePort(&handler);
  Dart_Port port2 = PortMap::CreatePort(&handler);
  Dart_Port port3 = PortMap::CreatePort(&handler);
  handler_peer.PostMessage(BlankMessage(port1, Message::kNormalPriority));
  handler_peer.PostMessage(BlankMessage(port2, Message::kOOBPriority));
  handler_peer.PostMessage(BlankMessage(port2, Message::kNormalPriority));
  handler_peer.PostMessage(BlankMessage(port3, Message::kOOBPriority));
 
  // We handle both oob messages and a single normal message.
  EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  EXPECT_EQ(3, handler.message_count());
  Dart_Port* ports = handler.port_buffer();
  EXPECT_EQ(port2, ports[0]);
  EXPECT_EQ(port3, ports[1]);
  EXPECT_EQ(port1, ports[2]);
}

VM_UNIT_TEST_CASE() [76/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_HandleNextMessage_ProcessOOBAfterError

)

Definition at line 249 of file message_handler_test.cc.

                                                                         {
  TestMessageHandler handler;
  MessageHandler::MessageStatus results[] = {
      MessageHandler::kError,  // oob_message1
      MessageHandler::kOK,     // oob_message2
      MessageHandler::kOK,     // unused
  };
  handler.set_results(results);
  MessageHandlerTestPeer handler_peer(&handler);
  Dart_Port port1 = PortMap::CreatePort(&handler);
  Dart_Port port2 = PortMap::CreatePort(&handler);
  Dart_Port port3 = PortMap::CreatePort(&handler);
  handler_peer.PostMessage(BlankMessage(port1, Message::kNormalPriority));
  handler_peer.PostMessage(BlankMessage(port2, Message::kOOBPriority));
  handler_peer.PostMessage(BlankMessage(port3, Message::kOOBPriority));
 
  // When we get an error, we continue processing oob messages but
  // stop handling normal messages.
  EXPECT_EQ(MessageHandler::kError, handler.HandleNextMessage());
  EXPECT_EQ(2, handler.message_count());
  Dart_Port* ports = handler.port_buffer();
  EXPECT_EQ(port2, ports[0]);  // oob_message1, error
  EXPECT_EQ(port3, ports[1]);  // oob_message2, ok
  handler_peer.CloseAllPorts();
}

VM_UNIT_TEST_CASE() [77/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_HandleNextMessage_Shutdown

)

Definition at line 275 of file message_handler_test.cc.

                                                             {
  TestMessageHandler handler;
  MessageHandler::MessageStatus results[] = {
      MessageHandler::kOK,        // oob_message1
      MessageHandler::kShutdown,  // oob_message2
      MessageHandler::kOK,        // unused
      MessageHandler::kOK,        // unused
  };
  handler.set_results(results);
  MessageHandlerTestPeer handler_peer(&handler);
  Dart_Port port1 = PortMap::CreatePort(&handler);
  Dart_Port port2 = PortMap::CreatePort(&handler);
  Dart_Port port3 = PortMap::CreatePort(&handler);
  Dart_Port port4 = PortMap::CreatePort(&handler);
  handler_peer.PostMessage(BlankMessage(port1, Message::kNormalPriority));
  handler_peer.PostMessage(BlankMessage(port2, Message::kOOBPriority));
  handler_peer.PostMessage(BlankMessage(port3, Message::kOOBPriority));
  handler_peer.PostMessage(BlankMessage(port4, Message::kOOBPriority));
 
  // When we get a shutdown message, we stop processing all messages.
  EXPECT_EQ(MessageHandler::kShutdown, handler.HandleNextMessage());
  EXPECT_EQ(2, handler.message_count());
  Dart_Port* ports = handler.port_buffer();
  EXPECT_EQ(port2, ports[0]);  // oob_message1, ok
  EXPECT_EQ(port3, ports[1]);  // oob_message2, shutdown
  {
    // The oob queue has been cleared.  oob_message3 is gone.
    MessageHandler::AcquiredQueues aq(&handler);
    EXPECT(aq.oob_queue()->Length() == 0);
  }
  handler_peer.CloseAllPorts();
}

VM_UNIT_TEST_CASE() [78/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_HandleOOBMessages

)

Definition at line 308 of file message_handler_test.cc.

                                                    {
  TestMessageHandler handler;
  MessageHandlerTestPeer handler_peer(&handler);
  Dart_Port port1 = PortMap::CreatePort(&handler);
  Dart_Port port2 = PortMap::CreatePort(&handler);
  Dart_Port port3 = PortMap::CreatePort(&handler);
  Dart_Port port4 = PortMap::CreatePort(&handler);
  handler_peer.PostMessage(BlankMessage(port1, Message::kNormalPriority));
  handler_peer.PostMessage(BlankMessage(port2, Message::kNormalPriority));
  handler_peer.PostMessage(BlankMessage(port3, Message::kOOBPriority));
  handler_peer.PostMessage(BlankMessage(port4, Message::kOOBPriority));
 
  // We handle both oob messages but no normal messages.
  EXPECT_EQ(MessageHandler::kOK, handler.HandleOOBMessages());
  EXPECT_EQ(2, handler.message_count());
  Dart_Port* ports = handler.port_buffer();
  EXPECT_EQ(port3, ports[0]);
  EXPECT_EQ(port4, ports[1]);
  handler_peer.CloseAllPorts();
}

VM_UNIT_TEST_CASE() [79/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_HasOOBMessages

)

Definition at line 167 of file message_handler_test.cc.

                                                 {
  TestMessageHandler handler;
  MessageHandlerTestPeer handler_peer(&handler);
 
  EXPECT(!handler.HasOOBMessages());
 
  // Post a normal message.
  std::unique_ptr<Message> message = BlankMessage(1, Message::kNormalPriority);
  handler_peer.PostMessage(std::move(message));
  EXPECT(!handler.HasOOBMessages());
  {
    // Acquire ownership of message handler queues, verify one regular message.
    MessageHandler::AcquiredQueues aq(&handler);
    EXPECT(aq.queue()->Length() == 1);
  }
 
  // Post an oob message.
  message = BlankMessage(1, Message::kOOBPriority);
  handler_peer.PostMessage(std::move(message));
  EXPECT(handler.HasOOBMessages());
  {
    // Acquire ownership of message handler queues, verify one regular and one
    // OOB message.
    MessageHandler::AcquiredQueues aq(&handler);
    EXPECT(aq.queue()->Length() == 1);
    EXPECT(aq.oob_queue()->Length() == 1);
  }
 
  // Delete all pending messages.
  handler_peer.CloseAllPorts();
}

VM_UNIT_TEST_CASE() [80/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_PostMessage

)

Definition at line 137 of file message_handler_test.cc.

                                              {
  TestMessageHandler handler;
  MessageHandlerTestPeer handler_peer(&handler);
  EXPECT_EQ(0, handler.notify_count());
 
  // Post a message.
  std::unique_ptr<Message> message = BlankMessage(1, Message::kNormalPriority);
  Message* raw_message = message.get();
  handler_peer.PostMessage(std::move(message));
 
  // The notify callback is called.
  EXPECT_EQ(1, handler.notify_count());
 
  // The message has been added to the correct queue.
  EXPECT(raw_message == handler_peer.queue()->Dequeue().get());
  EXPECT(nullptr == handler_peer.oob_queue()->Dequeue());
 
  // Post an oob message.
  message = BlankMessage(1, Message::kOOBPriority);
  raw_message = message.get();
  handler_peer.PostMessage(std::move(message));
 
  // The notify callback is called.
  EXPECT_EQ(2, handler.notify_count());
 
  // The message has been added to the correct queue.
  EXPECT(raw_message == handler_peer.oob_queue()->Dequeue().get());
  EXPECT(nullptr == handler_peer.queue()->Dequeue());
}

VM_UNIT_TEST_CASE() [81/107]

dart::VM_UNIT_TEST_CASE

(

MessageHandler_Run

)

Definition at line 347 of file message_handler_test.cc.

                                      {
  TestMessageHandler handler;
  ThreadPool pool;
  MessageHandlerTestPeer handler_peer(&handler);
 
  handler.Run(&pool, TestStartFunction, TestEndFunction,
              reinterpret_cast<uword>(&handler));
 
  EXPECT(!PortMap::HasPorts(&handler));
  Dart_Port port = PortMap::CreatePort(&handler);
  EXPECT(PortMap::HasPorts(&handler));
 
  handler_peer.PostMessage(BlankMessage(port, Message::kNormalPriority));
 
  // Wait for the first message to be handled.
  {
    MonitorLocker ml(handler.monitor());
    while (handler.message_count() < 1) {
      ml.Wait();
    }
    EXPECT_EQ(1, handler.message_count());
    EXPECT(handler.start_called());
    EXPECT(!handler.end_called());
    Dart_Port* handler_ports = handler.port_buffer();
    EXPECT_EQ(port, handler_ports[0]);
  }
 
  // Start a thread which sends more messages.
  Dart_Port ports[10];
  for (int i = 0; i < 10; i++) {
    ports[i] = PortMap::CreatePort(&handler);
  }
  ThreadStartInfo info;
  info.handler = &handler;
  info.ports = ports;
  info.count = 10;
  info.join_id = OSThread::kInvalidThreadJoinId;
  OSThread::Start("SendMessages", SendMessages, reinterpret_cast<uword>(&info));
 
  // Wait for the messages to be handled.
  {
    MonitorLocker ml(handler.monitor());
    while (handler.message_count() < 11) {
      ml.Wait();
    }
    Dart_Port* handler_ports = handler.port_buffer();
    EXPECT_EQ(11, handler.message_count());
    EXPECT(handler.start_called());
    EXPECT(!handler.end_called());
    EXPECT_EQ(port, handler_ports[0]);
    for (int i = 1; i < 11; i++) {
      EXPECT_EQ(ports[i - 1], handler_ports[i]);
    }
  }
 
  for (int i = 0; i < 10; i++) {
    PortMap::ClosePort(ports[i]);
  }
  PortMap::ClosePort(port);
  EXPECT(!PortMap::HasPorts(&handler));
 
  // Must join the thread or the VM shutdown is racing with any VM state the
  // thread touched.
  ASSERT(info.join_id != OSThread::kInvalidThreadJoinId);
  OSThread::Join(info.join_id);
}

VM_UNIT_TEST_CASE() [82/107]

dart::VM_UNIT_TEST_CASE

(

Metric_OnDemand

)

Definition at line 50 of file metrics_test.cc.

                                   {
  TestCase::CreateTestIsolate();
  {
    Thread* thread = Thread::Current();
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
    MyMetric metric;
 
    metric.InitInstance(Isolate::Current(), "a.b.c", "foobar", Metric::kByte);
    // value is still the default value.
    EXPECT_EQ(0, metric.value());
    // Call LeakyValue to confirm that Value returns constant 99.
    EXPECT_EQ(99, metric.LeakyValue());
 
    // Serialize to JSON.
    JSONStream js;
    metric.PrintJSON(&js);
    const char* json = js.ToCString();
    EXPECT_STREQ(
        "{\"type\":\"Counter\",\"name\":\"a.b.c\",\"description\":"
        "\"foobar\",\"unit\":\"byte\","
        "\"fixedId\":true,\"id\":\"metrics\\/native\\/a.b.c\""
        ",\"value\":99.0}",
        json);
  }
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [83/107]

dart::VM_UNIT_TEST_CASE

(

Metric_Simple

)

Definition at line 21 of file metrics_test.cc.

                                 {
  TestCase::CreateTestIsolate();
  {
    Metric metric;
 
    // Initialize metric.
    metric.InitInstance(Isolate::Current(), "a.b.c", "foobar",
                        Metric::kCounter);
    EXPECT_EQ(0, metric.value());
    metric.increment();
    EXPECT_EQ(1, metric.value());
    metric.set_value(44);
    EXPECT_EQ(44, metric.value());
  }
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [84/107]

dart::VM_UNIT_TEST_CASE

(

Minimum

)

Definition at line 56 of file utils_test.cc.

                           {
  EXPECT_EQ(0, Utils::Minimum(0, 1));
  EXPECT_EQ(0, Utils::Minimum(1, 0));
 
  EXPECT_EQ(1, Utils::Minimum(1, 2));
  EXPECT_EQ(1, Utils::Minimum(2, 1));
 
  EXPECT_EQ(-1, Utils::Minimum(-1, 1));
  EXPECT_EQ(-1, Utils::Minimum(1, -1));
 
  EXPECT_EQ(-2, Utils::Minimum(-1, -2));
  EXPECT_EQ(-2, Utils::Minimum(-2, -1));
}

VM_UNIT_TEST_CASE() [85/107]

dart::VM_UNIT_TEST_CASE

(

Monitor

)

Definition at line 37 of file thread_test.cc.

                           {
  // This unit test case needs a running isolate.
  TestCase::CreateTestIsolate();
  OSThread* thread = OSThread::Current();
  // Thread interrupter interferes with this test, disable interrupts.
  thread->DisableThreadInterrupts();
  Monitor* monitor = new Monitor();
  monitor->Enter();
  monitor->Exit();
  EXPECT_EQ(true, monitor->TryEnter());
  monitor->Exit();
 
  const int kNumAttempts = 5;
  int attempts = 0;
  while (attempts < kNumAttempts) {
    MonitorLocker ml(monitor);
    int64_t start = OS::GetCurrentMonotonicMicros();
    int64_t wait_time = 2017;
    Monitor::WaitResult wait_result = ml.Wait(wait_time);
    int64_t stop = OS::GetCurrentMonotonicMicros();
 
    // We expect to be timing out here.
    EXPECT_EQ(Monitor::kTimedOut, wait_result);
 
    // Check whether this attempt falls within the expected time limits.
    int64_t wakeup_time = (stop - start) / kMicrosecondsPerMillisecond;
    OS::PrintErr("wakeup_time: %" Pd64 "\n", wakeup_time);
    const int kAcceptableTimeJitter = 20;    // Measured in milliseconds.
    const int kAcceptableWakeupDelay = 150;  // Measured in milliseconds.
    if (((wait_time - kAcceptableTimeJitter) <= wakeup_time) &&
        (wakeup_time <= (wait_time + kAcceptableWakeupDelay))) {
      break;
    }
 
    // Record the attempt.
    attempts++;
  }
  EXPECT_LT(attempts, kNumAttempts);
 
  // The isolate shutdown and the destruction of the mutex are out-of-order on
  // purpose.
  Dart_ShutdownIsolate();
  delete monitor;
}

VM_UNIT_TEST_CASE() [86/107]

dart::VM_UNIT_TEST_CASE

(

Mutex

)

Definition at line 17 of file thread_test.cc.

                         {
  // This unit test case needs a running isolate.
  TestCase::CreateTestIsolate();
  Mutex* mutex = new Mutex();
  mutex->Lock();
  EXPECT_EQ(false, mutex->TryLock());
  mutex->Unlock();
  EXPECT_EQ(true, mutex->TryLock());
  mutex->Unlock();
  {
    MutexLocker ml(mutex);
    EXPECT_EQ(false, mutex->TryLock());
  }
  // The isolate shutdown and the destruction of the mutex are out-of-order on
  // purpose.
  Dart_ShutdownIsolate();
  delete mutex;
}

VM_UNIT_TEST_CASE() [87/107]

dart::VM_UNIT_TEST_CASE

(

NBitMask

)

Definition at line 432 of file utils_test.cc.

                            {
#if defined(ARCH_IS_64_BIT)
  EXPECT_EQ(0ull, Utils::NBitMask(0));
  EXPECT_EQ(0x1ull, Utils::NBitMask(1));
  EXPECT_EQ(0x3ull, Utils::NBitMask(2));
  EXPECT_EQ(0xfull, Utils::NBitMask(4));
  EXPECT_EQ(0xffull, Utils::NBitMask(8));
  EXPECT_EQ(0xffffull, Utils::NBitMask(16));
  EXPECT_EQ(0x1ffffull, Utils::NBitMask(17));
  EXPECT_EQ(0x7fffffffull, Utils::NBitMask(31));
  EXPECT_EQ(0xffffffffull, Utils::NBitMask(32));
  EXPECT_EQ(0x1ffffffffull, Utils::NBitMask(33));
  EXPECT_EQ(0x7fffffffffffffffull, Utils::NBitMask(kBitsPerWord - 1));
  EXPECT_EQ(0xffffffffffffffffull, Utils::NBitMask(kBitsPerWord));
#else
  EXPECT_EQ(0u, Utils::NBitMask(0));
  EXPECT_EQ(0x1u, Utils::NBitMask(1));
  EXPECT_EQ(0x3u, Utils::NBitMask(2));
  EXPECT_EQ(0xfu, Utils::NBitMask(4));
  EXPECT_EQ(0xffu, Utils::NBitMask(8));
  EXPECT_EQ(0xffffu, Utils::NBitMask(16));
  EXPECT_EQ(0x1ffffu, Utils::NBitMask(17));
  EXPECT_EQ(0x7fffffffu, Utils::NBitMask(kBitsPerWord - 1));
  EXPECT_EQ(0xffffffffu, Utils::NBitMask(kBitsPerWord));
#endif
}

VM_UNIT_TEST_CASE() [88/107]

dart::VM_UNIT_TEST_CASE

(

NewRegion

)

Definition at line 27 of file memory_region_test.cc.

                             {
  const uword kSize = 1024;
  MemoryRegion region(NewRegion(kSize), kSize);
  EXPECT_EQ(kSize, region.size());
  EXPECT(region.pointer() != nullptr);
 
  region.Store<int32_t>(0, 42);
  EXPECT_EQ(42, region.Load<int32_t>(0));
 
  DeleteRegion(region);
}

VM_UNIT_TEST_CASE() [89/107]

dart::VM_UNIT_TEST_CASE

(

NullRegion

)

Definition at line 20 of file memory_region_test.cc.

                              {
  const uword kSize = 512;
  MemoryRegion region(nullptr, kSize);
  EXPECT(region.pointer() == nullptr);
  EXPECT_EQ(kSize, region.size());
}

VM_UNIT_TEST_CASE() [90/107]

dart::VM_UNIT_TEST_CASE

(

OsFuncs

)

Definition at line 29 of file os_test.cc.

                           {
  EXPECT(Utils::IsPowerOfTwo(OS::ActivationFrameAlignment()));
  int procs = OS::NumberOfAvailableProcessors();
  EXPECT_LE(1, procs);
}

VM_UNIT_TEST_CASE() [91/107]

dart::VM_UNIT_TEST_CASE

(

ParseFlags

)

Definition at line 27 of file flags_test.cc.

                              {
  EXPECT_EQ(true, FLAG_parse_flag_bool_test);
  Flags::Parse("no_parse_flag_bool_test");
  EXPECT_EQ(false, FLAG_parse_flag_bool_test);
  Flags::Parse("parse_flag_bool_test");
  EXPECT_EQ(true, FLAG_parse_flag_bool_test);
  Flags::Parse("parse_flag_bool_test=false");
  EXPECT_EQ(false, FLAG_parse_flag_bool_test);
  Flags::Parse("parse_flag_bool_test=true");
  EXPECT_EQ(true, FLAG_parse_flag_bool_test);
 
  EXPECT_EQ(true, FLAG_string_opt_test == nullptr);
  Flags::Parse("string_opt_test=doobidoo");
  EXPECT_EQ(true, FLAG_string_opt_test != nullptr);
  EXPECT_EQ(0, strcmp(FLAG_string_opt_test, "doobidoo"));
  FLAG_string_opt_test = reinterpret_cast<charp>(0xDEADBEEF);
  Flags::Parse("string_opt_test=foofoo");
  EXPECT_EQ(true, FLAG_string_opt_test != nullptr);
  EXPECT_EQ(0, strcmp(FLAG_string_opt_test, "foofoo"));
 
  EXPECT_EQ(true, FLAG_entrypoint_test != nullptr);
  EXPECT_EQ(0, strcmp(FLAG_entrypoint_test, "main"));
 
  EXPECT_EQ(100, FLAG_counter);
  Flags::Parse("counter=-300");
  EXPECT_EQ(-300, FLAG_counter);
  Flags::Parse("counter=$300");
  EXPECT_EQ(-300, FLAG_counter);
}

VM_UNIT_TEST_CASE() [92/107]

dart::VM_UNIT_TEST_CASE

(

PostCObject

)

Definition at line 1917 of file snapshot_test.cc.

                               {
  // Create a native port for posting from C to Dart
  TestIsolateScope __test_isolate__;
  const char* kScriptChars =
      "import 'dart:isolate';\n"
      "main() {\n"
      "  var messageCount = 0;\n"
      "  var exception = '';\n"
      "  var port = new RawReceivePort();\n"
      "  var sendPort = port.sendPort;\n"
      "  port.handler = (message) {\n"
      "    if (messageCount < 9) {\n"
      "      exception = '$exception${message}';\n"
      "    } else {\n"
      "      exception = '$exception${message.length}';\n"
      "      for (int i = 0; i < message.length; i++) {\n"
      "        exception = '$exception${message[i]}';\n"
      "      }\n"
      "    }\n"
      "    messageCount++;\n"
      "    if (messageCount == 13) throw new Exception(exception);\n"
      "  };\n"
      "  return sendPort;\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  Dart_EnterScope();
 
  Dart_Handle send_port = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(send_port);
  Dart_Port port_id;
  Dart_Handle result = Dart_SendPortGetId(send_port, &port_id);
  ASSERT(!Dart_IsError(result));
 
  // Setup single object message.
  Dart_CObject object;
 
  object.type = Dart_CObject_kNull;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kBool;
  object.value.as_bool = true;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kBool;
  object.value.as_bool = false;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kInt32;
  object.value.as_int32 = 123;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kString;
  object.value.as_string = const_cast<char*>("456");
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kString;
  object.value.as_string = const_cast<char*>("æøå");
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kString;
  object.value.as_string = const_cast<char*>("");
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kDouble;
  object.value.as_double = 3.14;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kArray;
  object.value.as_array.length = 0;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  const int kArrayLength = 10;
  Dart_CObject* array = reinterpret_cast<Dart_CObject*>(Dart_ScopeAllocate(
      sizeof(Dart_CObject) + sizeof(Dart_CObject*) * kArrayLength));  // NOLINT
  array->type = Dart_CObject_kArray;
  array->value.as_array.length = kArrayLength;
  array->value.as_array.values = reinterpret_cast<Dart_CObject**>(array + 1);
  for (int i = 0; i < kArrayLength; i++) {
    Dart_CObject* element = reinterpret_cast<Dart_CObject*>(
        Dart_ScopeAllocate(sizeof(Dart_CObject)));
    element->type = Dart_CObject_kInt32;
    element->value.as_int32 = i;
    array->value.as_array.values[i] = element;
  }
  EXPECT(Dart_PostCObject(port_id, array));
 
  object.type = Dart_CObject_kTypedData;
  object.value.as_typed_data.type = Dart_TypedData_kUint8;
  uint8_t data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
  object.value.as_typed_data.length = ARRAY_SIZE(data);
  object.value.as_typed_data.values = data;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kExternalTypedData;
  object.value.as_typed_data.type = Dart_TypedData_kUint8;
  uint8_t* external_data = reinterpret_cast<uint8_t*>(malloc(sizeof(data)));
  memmove(external_data, data, sizeof(data));
  object.value.as_external_typed_data.length = ARRAY_SIZE(data);
  object.value.as_external_typed_data.data = external_data;
  object.value.as_external_typed_data.peer = external_data;
  object.value.as_external_typed_data.callback = MallocFinalizer;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  object.type = Dart_CObject_kUnmodifiableExternalTypedData;
  object.value.as_typed_data.type = Dart_TypedData_kUint8;
  static const uint8_t unmodifiable_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
  object.value.as_external_typed_data.length = ARRAY_SIZE(unmodifiable_data);
  object.value.as_external_typed_data.data =
      const_cast<uint8_t*>(unmodifiable_data);
  object.value.as_external_typed_data.peer = nullptr;
  object.value.as_external_typed_data.callback = NoopFinalizer;
  EXPECT(Dart_PostCObject(port_id, &object));
 
  result = Dart_RunLoop();
  EXPECT(Dart_IsError(result));
  EXPECT(Dart_ErrorHasException(result));
  EXPECT_SUBSTRING(
      "Exception: "
      "nulltruefalse123456æøå3.14[]"
      "100123456789901234567890123456789012345678\n",
      Dart_GetError(result));
 
  Dart_ExitScope();
}

VM_UNIT_TEST_CASE() [93/107]

dart::VM_UNIT_TEST_CASE

(

ReceivesSendAndExitMessage

)

Definition at line 568 of file heap_test.cc.

                                              {
  const char* TEST_MESSAGE = "hello, world";
  Dart_Isolate parent = TestCase::CreateTestIsolate("parent");
  EXPECT_EQ(parent, Dart_CurrentIsolate());
  SendAndExitMessagesHandler handler(Isolate::Current());
  Dart_Port port_id = PortMap::CreatePort(&handler);
  EXPECT_EQ(PortMap::GetIsolate(port_id), Isolate::Current());
  Dart_ExitIsolate();
 
  Dart_Isolate worker = TestCase::CreateTestIsolateInGroup("worker", parent);
  EXPECT_EQ(worker, Dart_CurrentIsolate());
  {
    Thread* thread = Thread::Current();
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
 
    String& string = String::Handle(String::New(TEST_MESSAGE));
 
    PersistentHandle* handle =
        Isolate::Current()->group()->api_state()->AllocatePersistentHandle();
    handle->set_ptr(string.ptr());
 
    reinterpret_cast<Isolate*>(worker)->bequeath(
        std::unique_ptr<Bequest>(new Bequest(handle, port_id)));
  }
 
  Dart_ShutdownIsolate();
  Dart_EnterIsolate(parent);
  {
    Thread* thread = Thread::Current();
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
 
    EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
  }
  EXPECT_STREQ(handler.msg(), TEST_MESSAGE);
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [94/107]

dart::VM_UNIT_TEST_CASE

(

ReverseBits32

)

Definition at line 254 of file utils_test.cc.

                                 {
  EXPECT_EQ(0xffffffffU, Utils::ReverseBits32(0xffffffffU));
  EXPECT_EQ(0xf0000000U, Utils::ReverseBits32(0x0000000fU));
  EXPECT_EQ(0x00000001U, Utils::ReverseBits32(0x80000000U));
  EXPECT_EQ(0x22222222U, Utils::ReverseBits32(0x44444444U));
  EXPECT_EQ(0x1E6A2C48U, Utils::ReverseBits32(0x12345678U));
}

VM_UNIT_TEST_CASE() [95/107]

dart::VM_UNIT_TEST_CASE

(

ReverseBits64

)

Definition at line 262 of file utils_test.cc.

                                 {
  EXPECT_EQ(0xffffffffffffffffLLU, Utils::ReverseBits64(0xffffffffffffffffLLU));
  EXPECT_EQ(0xf000000000000000LLU, Utils::ReverseBits64(0x000000000000000fLLU));
  EXPECT_EQ(0x0000000000000001LLU, Utils::ReverseBits64(0x8000000000000000LLU));
  EXPECT_EQ(0x2222222222222222LLU, Utils::ReverseBits64(0x4444444444444444LLU));
  EXPECT_EQ(0x8f7b3d591e6a2c48LLU, Utils::ReverseBits64(0x123456789abcdef1LLU));
}

VM_UNIT_TEST_CASE() [96/107]

dart::VM_UNIT_TEST_CASE

(

ReverseBitsWord

)

Definition at line 270 of file utils_test.cc.

                                   {
  const uword kOne = static_cast<uword>(1);
  const uword kTopBit = kOne << (kBitsPerWord - 1);
  EXPECT_EQ(kTopBit, Utils::ReverseBitsWord(kOne));
  EXPECT_EQ(kOne, Utils::ReverseBitsWord(kTopBit));
}

VM_UNIT_TEST_CASE() [97/107]

dart::VM_UNIT_TEST_CASE

(

RoundDown

)

Definition at line 122 of file utils_test.cc.

                             {
  EXPECT_EQ(0, Utils::RoundDown(22, 32));
  EXPECT_EQ(32, Utils::RoundDown(33, 32));
  EXPECT_EQ(32, Utils::RoundDown(63, 32));
  uword* address = reinterpret_cast<uword*>(63);
  uword* rounddown_address = reinterpret_cast<uword*>(32);
  EXPECT_EQ(rounddown_address, Utils::RoundDown(address, 32));
}

VM_UNIT_TEST_CASE() [98/107]

dart::VM_UNIT_TEST_CASE

(

RoundUp

)

Definition at line 131 of file utils_test.cc.

                           {
  EXPECT_EQ(32, Utils::RoundUp(22, 32));
  EXPECT_EQ(64, Utils::RoundUp(33, 32));
  EXPECT_EQ(64, Utils::RoundUp(63, 32));
  uword* address = reinterpret_cast<uword*>(63);
  uword* roundup_address = reinterpret_cast<uword*>(64);
  EXPECT_EQ(roundup_address, Utils::RoundUp(address, 32));
 
  EXPECT_EQ(4, Utils::RoundUp(0, 8, 4));
  EXPECT_EQ(4, Utils::RoundUp(1, 8, 4));
  EXPECT_EQ(4, Utils::RoundUp(4, 8, 4));
  EXPECT_EQ(12, Utils::RoundUp(8, 8, 4));
  EXPECT_EQ(12, Utils::RoundUp(9, 8, 4));
  EXPECT_EQ(12, Utils::RoundUp(12, 8, 4));
}

VM_UNIT_TEST_CASE() [99/107]

dart::VM_UNIT_TEST_CASE

(

RoundUpToPowerOfTwo

)

Definition at line 147 of file utils_test.cc.

                                       {
  EXPECT_EQ(0U, Utils::RoundUpToPowerOfTwo(0));
  EXPECT_EQ(1U, Utils::RoundUpToPowerOfTwo(1));
  EXPECT_EQ(2U, Utils::RoundUpToPowerOfTwo(2));
  EXPECT_EQ(4U, Utils::RoundUpToPowerOfTwo(3));
  EXPECT_EQ(4U, Utils::RoundUpToPowerOfTwo(4));
  EXPECT_EQ(8U, Utils::RoundUpToPowerOfTwo(5));
  EXPECT_EQ(8U, Utils::RoundUpToPowerOfTwo(7));
  EXPECT_EQ(16U, Utils::RoundUpToPowerOfTwo(9));
  EXPECT_EQ(16U, Utils::RoundUpToPowerOfTwo(16));
  EXPECT_EQ(0x10000000U, Utils::RoundUpToPowerOfTwo(0x08765432));
}

VM_UNIT_TEST_CASE() [100/107]

dart::VM_UNIT_TEST_CASE

(

ShiftForPowerOfTwo

)

Definition at line 96 of file utils_test.cc.

                                      {
  EXPECT_EQ(1, Utils::ShiftForPowerOfTwo(2));
  EXPECT_EQ(2, Utils::ShiftForPowerOfTwo(4));
  EXPECT_EQ(8, Utils::ShiftForPowerOfTwo(256));
}

VM_UNIT_TEST_CASE() [101/107]

dart::VM_UNIT_TEST_CASE

(

SimpleHashMap_Basic

)

Definition at line 171 of file hashmap_test.cc.

                                       {
  TestSet(WordHash, 100);
  TestSet(Hash, 100);
  TestSet(CollisionHash1, 50);
  TestSet(CollisionHash2, 50);
  TestSet(CollisionHash3, 50);
  TestSet(CollisionHash4, 50);
}

VM_UNIT_TEST_CASE() [102/107]

dart::VM_UNIT_TEST_CASE

(

SNPrint

)

Definition at line 13 of file os_test.cc.

                           {
  char buffer[256];
  int length;
  length = Utils::SNPrint(buffer, 10, "%s", "foo");
  EXPECT_EQ(3, length);
  EXPECT_STREQ("foo", buffer);
  length = Utils::SNPrint(buffer, 3, "%s", "foo");
  EXPECT_EQ(3, length);
  EXPECT_STREQ("fo", buffer);
  length = Utils::SNPrint(buffer, 256, "%s%c%d", "foo", 'Z', 42);
  EXPECT_EQ(6, length);
  EXPECT_STREQ("fooZ42", buffer);
  length = Utils::SNPrint(nullptr, 0, "foo");
  EXPECT_EQ(3, length);
}

VM_UNIT_TEST_CASE() [103/107]

dart::VM_UNIT_TEST_CASE

(

StringHash

)

Definition at line 12 of file utils_test.cc.

                              {
  auto hash_created_string = [](intptr_t length,
                                intptr_t misalignment) -> uint32_t {
    const intptr_t capacity = length + misalignment + kInt32Size;
    char* str = new char[capacity];
    const intptr_t alloc_misalignment =
        reinterpret_cast<intptr_t>(str) % kInt32Size;
    const intptr_t first_aligned_position =
        alloc_misalignment > 0 ? kInt32Size - alloc_misalignment : 0;
    const intptr_t start = first_aligned_position + misalignment;
    for (intptr_t n = 0; n < start; n++) {
      str[n] = 0xFF;
    }
    for (intptr_t n = 0; n < length; n++) {
      // Fill the important string positions with uppercase letters.
      str[start + n] = 0x40 + (n % 26);
    }
    for (intptr_t n = start + length; n < capacity; n++) {
      str[n] = 0xFF;
    }
    const uint32_t hash = Utils::StringHash(str + start, length);
    delete[] str;
    return hash;
  };
 
  const intptr_t kMaxLength = 100;
  ASSERT(kMaxLength >= kInt64Size);
  uint32_t last_hash = hash_created_string(0, 0);
  bool identical_hashes = true;
  // Check the same string at different (mis)alignments has the same hash.
  for (intptr_t len = 0; len < kMaxLength; len++) {
    const uint32_t hash = hash_created_string(len, 0);
    for (intptr_t misalignment = 1; misalignment < kInt64Size; misalignment++) {
      EXPECT_EQ(hash, hash_created_string(len, misalignment));
    }
    if (hash != last_hash) {
      identical_hashes = false;
    }
    last_hash = hash;
  }
  // Make sure at least some of the hashes were different from each other.
  EXPECT(!identical_hashes);
}

VM_UNIT_TEST_CASE() [104/107]

dart::VM_UNIT_TEST_CASE

(

Subregion

)

Definition at line 39 of file memory_region_test.cc.

                             {
  const uword kSize = 1024;
  const uword kSubOffset = 128;
  const uword kSubSize = 512;
  MemoryRegion region(NewRegion(kSize), kSize);
  MemoryRegion sub_region;
  sub_region.Subregion(region, kSubOffset, kSubSize);
  EXPECT_EQ(kSubSize, sub_region.size());
  EXPECT(sub_region.pointer() != nullptr);
  EXPECT(sub_region.start() == region.start() + kSubOffset);
 
  region.Store<int32_t>(0, 42);
  sub_region.Store<int32_t>(0, 100);
  EXPECT_EQ(42, region.Load<int32_t>(0));
  EXPECT_EQ(100, region.Load<int32_t>(kSubOffset));
 
  DeleteRegion(region);
}

VM_UNIT_TEST_CASE() [105/107]

dart::VM_UNIT_TEST_CASE

(

ThreadBarrier

)

Definition at line 39 of file thread_barrier_test.cc.

                                 {
  const intptr_t kNumTasks = 5;
  const intptr_t kNumRounds = 500;
 
  ThreadBarrier* barrier = new ThreadBarrier(kNumTasks + 1, kNumTasks + 1);
  for (intptr_t i = 0; i < kNumTasks; ++i) {
    Dart::thread_pool()->Run<FuzzTask>(kNumRounds, barrier, i + 1);
  }
  for (intptr_t i = 0; i < kNumRounds; ++i) {
    barrier->Sync();
  }
  barrier->Release();
}

VM_UNIT_TEST_CASE() [106/107]

dart::VM_UNIT_TEST_CASE

(

ZoneAllocated

)

Definition at line 138 of file zone_test.cc.

                                 {
#if defined(DEBUG)
  FLAG_trace_zones = true;
#endif
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->zone() == nullptr);
  static int marker;
 
  class SimpleZoneObject : public ZoneAllocated {
   public:
    SimpleZoneObject() : slot(marker++) {}
    virtual ~SimpleZoneObject() {}
    virtual int GetSlot() { return slot; }
    int slot;
  };
 
  // Reset the marker.
  marker = 0;
 
  // Create a few zone allocated objects.
  {
    TransitionNativeToVM transition(thread);
    StackZone zone(thread);
    EXPECT_EQ(0UL, zone.SizeInBytes());
    SimpleZoneObject* first = new SimpleZoneObject();
    EXPECT(first != nullptr);
    SimpleZoneObject* second = new SimpleZoneObject();
    EXPECT(second != nullptr);
    EXPECT(first != second);
    uintptr_t expected_size = (2 * sizeof(SimpleZoneObject));
    EXPECT_LE(expected_size, zone.SizeInBytes());
 
    // Make sure the constructors were invoked.
    EXPECT_EQ(0, first->slot);
    EXPECT_EQ(1, second->slot);
 
    // Make sure we can write to the members of the zone objects.
    first->slot = 42;
    second->slot = 87;
    EXPECT_EQ(42, first->slot);
    EXPECT_EQ(87, second->slot);
  }
  EXPECT(thread->zone() == nullptr);
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE() [107/107]

dart::VM_UNIT_TEST_CASE

(

ZoneRealloc

)

Definition at line 116 of file zone_test.cc.

                               {
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  {
    TransitionNativeToVM transition(thread);
    StackZone stack_zone(thread);
    auto zone = thread->zone();
 
    const intptr_t kOldLen = 32;
    const intptr_t kNewLen = 16;
    const intptr_t kNewLen2 = 16;
 
    auto data_old = zone->Alloc<uint8_t>(kOldLen);
    auto data_new = zone->Realloc<uint8_t>(data_old, kOldLen, kNewLen);
    RELEASE_ASSERT(data_old == data_new);
 
    auto data_new2 = zone->Realloc<uint8_t>(data_old, kNewLen, kNewLen2);
    RELEASE_ASSERT(data_old == data_new2);
  }
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE_WITH_EXPECTATION() [1/2]

dart::VM_UNIT_TEST_CASE_WITH_EXPECTATION	(	AllocGeneric_Overflow	,
		"Crash"
	)

Definition at line 99 of file zone_test.cc.

                                                                   {
#if defined(DEBUG)
  FLAG_trace_zones = true;
#endif
  TestCase::CreateTestIsolate();
  Thread* thread = Thread::Current();
  EXPECT(thread->zone() == nullptr);
  {
    StackZone zone(thread);
    EXPECT(thread->zone() != nullptr);
 
    const intptr_t kNumElements = (kIntptrMax / sizeof(uint32_t)) + 1;
    zone.GetZone()->Alloc<uint32_t>(kNumElements);
  }
  Dart_ShutdownIsolate();
}

VM_UNIT_TEST_CASE_WITH_EXPECTATION() [2/2]

dart::VM_UNIT_TEST_CASE_WITH_EXPECTATION	(	BitFields_Assert	,
		DEBUG_CRASH
	)

Definition at line 79 of file bitfield_test.cc.

                                                                  {
  class F : public BitField<uint32_t, uint32_t, 0, 8, /*sign_extend=*/false> {};
  const uint32_t value = F::encode(kMaxUint32);
  EXPECT_EQ(kMaxUint8, value);
}

vmservice_resolver()

static void dart::vmservice_resolver ( Dart_NativeArguments  args )

static

Definition at line 208 of file benchmark_test.cc.

{}

WaitForHelper()

DART_EXPORT void dart::WaitForHelper

(

HelperThreadState *

helper

)

Definition at line 174 of file ffi_test_functions_vmspecific.cc.

                                                          {
  helper->helper->join();
  delete helper;
}

WaitUntilNThreadsEnterBarrier()

DART_EXPORT void dart::WaitUntilNThreadsEnterBarrier

(

intptr_t

num_threads

)

Definition at line 1288 of file ffi_test_functions_vmspecific.cc.

                                                                     {
  ThreadPoolTest_BarrierSync(Dart_CurrentIsolate_DL, Dart_EnterIsolate_DL,
                             Dart_ExitIsolate_DL, num_threads);
}

WCharMaxValue()

DART_EXPORT int64_t dart::WCharMaxValue

(

)

Definition at line 1259 of file ffi_test_functions.cc.

                                    {
  return WCHAR_MAX;
}

WCharMinValue()

DART_EXPORT int64_t dart::WCharMinValue

(

)

Definition at line 1256 of file ffi_test_functions.cc.

                                    {
  return WCHAR_MIN;
}

WeakArray_Generations()

static void dart::WeakArray_Generations ( intptr_t  length, Generation  array_space, Generation  element_space, bool  cleared_after_minor, bool  cleared_after_major, bool  cleared_after_all  )

static

Definition at line 1071 of file heap_test.cc.

                                                          {
  WeakArray& array = WeakArray::Handle();
  GCTestHelper::CollectAllGarbage();
  {
    HANDLESCOPE(Thread::Current());
    switch (array_space) {
      case kNew:
        array = WeakArray::New(length, Heap::kNew);
        break;
      case kOld:
        array = WeakArray::New(length, Heap::kOld);
        break;
      case kImm:
        UNREACHABLE();
    }
 
    Object& element = Object::Handle();
    switch (element_space) {
      case kNew:
        element = OneByteString::New("element", Heap::kNew);
        break;
      case kOld:
        element = OneByteString::New("element", Heap::kOld);
        break;
      case kImm:
        element = Smi::New(42);
        break;
    }
 
    array.SetAt(length - 1, element);
  }
 
  OS::PrintErr("%d %d\n", array_space, element_space);
 
  GCTestHelper::CollectNewSpace();
  if (cleared_after_minor) {
    EXPECT(array.At(length - 1) == Object::null());
  } else {
    EXPECT(array.At(length - 1) != Object::null());
  }
 
  GCTestHelper::CollectOldSpace();
  if (cleared_after_major) {
    EXPECT(array.At(length - 1) == Object::null());
  } else {
    EXPECT(array.At(length - 1) != Object::null());
  }
 
  GCTestHelper::CollectAllGarbage();
  if (cleared_after_all) {
    EXPECT(array.At(length - 1) == Object::null());
  } else {
    EXPECT(array.At(length - 1) != Object::null());
  }
}

WeakHandleFinalizer() [1/2]

static void dart::WeakHandleFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 144 of file object_graph_test.cc.

{}

WeakHandleFinalizer() [2/2]

static void dart::WeakHandleFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 488 of file service_test.cc.

{}

WeakPersistentHandlePeerCleanupEnsuresIGFinalizer()

static void dart::WeakPersistentHandlePeerCleanupEnsuresIGFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3832 of file dart_api_impl_test.cc.

                {
  ASSERT(IsolateGroup::Current() != nullptr);
}

WeakPersistentHandlePeerCleanupFinalizer()

static void dart::WeakPersistentHandlePeerCleanupFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3849 of file dart_api_impl_test.cc.

                {
  Dart_DeletePersistentHandle(persistent_handle1);
  Dart_DeleteWeakPersistentHandle(weak_persistent_handle2);
  *static_cast<int*>(peer) = 42;
}

WeakPersistentHandlePeerFinalizer()

static void dart::WeakPersistentHandlePeerFinalizer ( void *  isolate_callback_data, void *  peer  )

static

Definition at line 3926 of file dart_api_impl_test.cc.

                                                          {
  *static_cast<int*>(peer) = 42;
}

WeakProperty_Generations()

static void dart::WeakProperty_Generations ( Generation  property_space, Generation  key_space, Generation  value_space, bool  cleared_after_minor, bool  cleared_after_major, bool  cleared_after_all  )

static

Definition at line 896 of file heap_test.cc.

                                                             {
  WeakProperty& property = WeakProperty::Handle();
  GCTestHelper::CollectAllGarbage();
  {
    HANDLESCOPE(Thread::Current());
    switch (property_space) {
      case kNew:
        property = WeakProperty::New(Heap::kNew);
        break;
      case kOld:
        property = WeakProperty::New(Heap::kOld);
        break;
      case kImm:
        UNREACHABLE();
    }
 
    Object& key = Object::Handle();
    switch (key_space) {
      case kNew:
        key = OneByteString::New("key", Heap::kNew);
        break;
      case kOld:
        key = OneByteString::New("key", Heap::kOld);
        break;
      case kImm:
        key = Smi::New(42);
        break;
    }
 
    Object& value = Object::Handle();
    switch (value_space) {
      case kNew:
        value = OneByteString::New("value", Heap::kNew);
        break;
      case kOld:
        value = OneByteString::New("value", Heap::kOld);
        break;
      case kImm:
        value = Smi::New(84);
        break;
    }
 
    property.set_key(key);
    property.set_value(value);
  }
 
  OS::PrintErr("%d %d %d\n", property_space, key_space, value_space);
 
  GCTestHelper::CollectNewSpace();
  if (cleared_after_minor) {
    EXPECT(property.key() == Object::null());
    EXPECT(property.value() == Object::null());
  } else {
    EXPECT(property.key() != Object::null());
    EXPECT(property.value() != Object::null());
  }
 
  GCTestHelper::CollectOldSpace();
  if (cleared_after_major) {
    EXPECT(property.key() == Object::null());
    EXPECT(property.value() == Object::null());
  } else {
    EXPECT(property.key() != Object::null());
    EXPECT(property.value() != Object::null());
  }
 
  GCTestHelper::CollectAllGarbage();
  if (cleared_after_all) {
    EXPECT(property.key() == Object::null());
    EXPECT(property.value() == Object::null());
  } else {
    EXPECT(property.key() != Object::null());
    EXPECT(property.value() != Object::null());
  }
}

WeakReference_Clear_ReachableThroughWeakProperty()

static void dart::WeakReference_Clear_ReachableThroughWeakProperty ( Thread *  thread, Heap::Space  space  )

static

Definition at line 3713 of file object_test.cc.

                     {
  auto& weak_property = WeakProperty::Handle();
  const auto& key = String::Handle(OneByteString::New("key", space));
  {
    HANDLESCOPE(thread);
    ObjectStore* object_store = thread->isolate_group()->object_store();
    const auto& type_arguments =
        TypeArguments::Handle(object_store->type_argument_double());
    const auto& weak_reference =
        WeakReference::Handle(WeakReference::New(space));
    const auto& target = String::Handle(OneByteString::New("target", space));
    weak_reference.set_target(target);
    weak_reference.SetTypeArguments(type_arguments);
 
    weak_property ^= WeakProperty::New(space);
    weak_property.set_key(key);
    weak_property.set_value(weak_reference);
  }
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  const auto& weak_reference =
      WeakReference::CheckedHandle(Z, weak_property.value());
  EXPECT(weak_reference.target() == Object::null());
  EXPECT(weak_reference.GetTypeArguments() != Object::null());
}

WeakReference_ClearOne()

static void dart::WeakReference_ClearOne ( Thread *  thread, Heap::Space  space  )

static

Definition at line 3682 of file object_test.cc.

                                                                    {
  auto& weak = WeakReference::Handle();
  {
    HANDLESCOPE(thread);
    const auto& target = String::Handle(OneByteString::New("target", space));
    ObjectStore* object_store = thread->isolate_group()->object_store();
    const auto& type_arguments =
        TypeArguments::Handle(object_store->type_argument_double());
    weak ^= WeakReference::New(space);
    weak.set_target(target);
    weak.SetTypeArguments(type_arguments);
  }
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  EXPECT(weak.target() == Object::null());
  EXPECT(weak.GetTypeArguments() != Object::null());
}

WeakReference_Generations()

static void dart::WeakReference_Generations ( Generation  reference_space, Generation  target_space, bool  cleared_after_minor, bool  cleared_after_major, bool  cleared_after_all  )

static

Definition at line 1000 of file heap_test.cc.

                                                              {
  WeakReference& reference = WeakReference::Handle();
  GCTestHelper::CollectAllGarbage();
  {
    HANDLESCOPE(Thread::Current());
    switch (reference_space) {
      case kNew:
        reference = WeakReference::New(Heap::kNew);
        break;
      case kOld:
        reference = WeakReference::New(Heap::kOld);
        break;
      case kImm:
        UNREACHABLE();
    }
 
    Object& target = Object::Handle();
    switch (target_space) {
      case kNew:
        target = OneByteString::New("target", Heap::kNew);
        break;
      case kOld:
        target = OneByteString::New("target", Heap::kOld);
        break;
      case kImm:
        target = Smi::New(42);
        break;
    }
 
    reference.set_target(target);
  }
 
  OS::PrintErr("%d %d\n", reference_space, target_space);
 
  GCTestHelper::CollectNewSpace();
  if (cleared_after_minor) {
    EXPECT(reference.target() == Object::null());
  } else {
    EXPECT(reference.target() != Object::null());
  }
 
  GCTestHelper::CollectOldSpace();
  if (cleared_after_major) {
    EXPECT(reference.target() == Object::null());
  } else {
    EXPECT(reference.target() != Object::null());
  }
 
  GCTestHelper::CollectAllGarbage();
  if (cleared_after_all) {
    EXPECT(reference.target() == Object::null());
  } else {
    EXPECT(reference.target() != Object::null());
  }
}

WeakReference_Preserve_ReachableThroughWeakProperty()

static void dart::WeakReference_Preserve_ReachableThroughWeakProperty ( Thread *  thread, Heap::Space  space  )

static

Definition at line 3756 of file object_test.cc.

                     {
  auto& weak_property = WeakProperty::Handle();
  const auto& key = String::Handle(OneByteString::New("key", space));
  const auto& target = String::Handle(OneByteString::New("target", space));
  {
    HANDLESCOPE(thread);
    ObjectStore* object_store = thread->isolate_group()->object_store();
    const auto& type_arguments =
        TypeArguments::Handle(object_store->type_argument_double());
    const auto& weak_reference =
        WeakReference::Handle(WeakReference::New(space));
    weak_reference.set_target(target);
    weak_reference.SetTypeArguments(type_arguments);
 
    weak_property ^= WeakProperty::New(space);
    weak_property.set_key(key);
    weak_property.set_value(weak_reference);
  }
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  const auto& weak_reference =
      WeakReference::CheckedHandle(Z, weak_property.value());
  EXPECT(weak_reference.target() != Object::null());
  EXPECT(weak_reference.GetTypeArguments() != Object::null());
}

WeakReference_PreserveOne()

static void dart::WeakReference_PreserveOne ( Thread *  thread, Heap::Space  space  )

static

Definition at line 3651 of file object_test.cc.

                                                                       {
  auto& weak = WeakReference::Handle();
  const auto& target = String::Handle(OneByteString::New("target", space));
  {
    HANDLESCOPE(thread);
    ObjectStore* object_store = thread->isolate_group()->object_store();
    const auto& type_arguments =
        TypeArguments::Handle(object_store->type_argument_double());
    weak ^= WeakReference::New(space);
    weak.set_target(target);
    weak.SetTypeArguments(type_arguments);
  }
 
  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }
 
  EXPECT(weak.target() != Object::null());
  EXPECT(weak.GetTypeArguments() != Object::null());
}

WidenMax()

static RangeBoundary dart::WidenMax ( const Range *  range, const Range *  new_range, RangeBoundary::RangeSize  size  )

static

Definition at line 363 of file range_analysis.cc.

                                                           {
  RangeBoundary max = range->max();
  RangeBoundary new_max = new_range->max();
 
  if (max.IsSymbol()) {
    if (max.UpperBound().Overflowed(size)) {
      return RangeBoundary::MaxConstant(size);
    } else if (DependOnSameSymbol(max, new_max)) {
      return max.offset() >= new_max.offset()
                 ? max
                 : RangeBoundary::MaxConstant(size);
    } else if (max.LowerBound(size) >= new_max.UpperBound(size)) {
      return max;
    }
  }
 
  max = Range::ConstantMax(range, size);
  new_max = Range::ConstantMax(new_range, size);
 
  return (max.ConstantValue() >= new_max.ConstantValue())
             ? max
             : RangeBoundary::MaxConstant(size);
}

WidenMin()

static RangeBoundary dart::WidenMin ( const Range *  range, const Range *  new_range, RangeBoundary::RangeSize  size  )

static

Definition at line 334 of file range_analysis.cc.

                                                           {
  RangeBoundary min = range->min();
  RangeBoundary new_min = new_range->min();
 
  if (min.IsSymbol()) {
    if (min.LowerBound().Overflowed(size)) {
      return RangeBoundary::MinConstant(size);
    } else if (DependOnSameSymbol(min, new_min)) {
      return min.offset() <= new_min.offset()
                 ? min
                 : RangeBoundary::MinConstant(size);
    } else if (min.UpperBound(size) <= new_min.LowerBound(size)) {
      return min;
    }
  }
 
  min = Range::ConstantMin(range, size);
  new_min = Range::ConstantMin(new_range, size);
 
  return (min.ConstantValue() <= new_min.ConstantValue())
             ? min
             : RangeBoundary::MinConstant(size);
}

WordHash()

static uint32_t dart::WordHash ( uint32_t  key )

static

Definition at line 62 of file hashmap_test.cc.

                                       {
  return dart::Utils::WordHash(key);
}

WordsToMB()

constexpr double dart::WordsToMB ( intptr_t  size_in_words )

constexpr

Definition at line 551 of file globals.h.

                                                   {
  return static_cast<double>(size_in_words) / MBInWords;
}

Work1()

void dart::Work1

(

)

Definition at line 513 of file ffi_test_functions_vmspecific.cc.

             {
  printf("C T1: Work1 Start.\n");
  SleepOnAnyOS(1);
  const intptr_t val1 = 3;
  printf("C T1: MyCallbackBlocking(%" Pd ").\n", val1);
  const intptr_t val2 = MyCallbackBlocking(val1);  // val2 = 6.
  printf("C T1: MyCallbackBlocking returned %" Pd ".\n", val2);
  SleepOnAnyOS(1);
  const intptr_t val3 = val2 - 1;  // val3 = 5.
  printf("C T1: MyCallbackNonBlocking(%" Pd ").\n", val3);
  MyCallbackNonBlocking(val3);  // Post 5 to Dart.
  printf("C T1: Work1 Done.\n");
}

Work1_2()

void dart::Work1_2

(

)

Definition at line 803 of file ffi_test_functions_vmspecific.cc.

               {
  printf("C T1: Work1 Start.\n");
  SleepOnAnyOS(1);
  const intptr_t val1 = 3;
  printf("C T1: MyCallback1(%" Pd ").\n", val1);
  const intptr_t val2 = MyCallback1(val1);  // val2 = 6.
  printf("C T1: MyCallback1 returned %" Pd ".\n", val2);
  SleepOnAnyOS(1);
  const intptr_t val3 = val2 - 1;  // val3 = 5.
  printf("C T1: MyCallback2(%" Pd ").\n", val3);
  MyCallback2(val3);  // Post 5 to Dart.
  printf("C T1: Work1 Done.\n");
}

Work2()

void dart::Work2

(

)

Definition at line 530 of file ffi_test_functions_vmspecific.cc.

             {
  printf("C T2: Work2 Start.\n");
  const intptr_t val1 = 5;
  printf("C T2: MyCallbackNonBlocking(%" Pd ").\n", val1);
  MyCallbackNonBlocking(val1);  // Post 5 to Dart.
  const intptr_t val2 = 1;
  printf("C T2: MyCallbackBlocking(%" Pd ").\n", val2);
  const intptr_t val3 = MyCallbackBlocking(val2);  // val3 = 4.
  printf("C T2: MyCallbackBlocking returned %" Pd ".\n", val3);
  printf("C T2: MyCallbackNonBlocking(%" Pd ").\n", val3);
  MyCallbackNonBlocking(val3);  // Post 4 to Dart.
  printf("C T2: Work2 Done.\n");
}

Work2_2()

void dart::Work2_2

(

)

Definition at line 820 of file ffi_test_functions_vmspecific.cc.

               {
  printf("C T2: Work2 Start.\n");
  const intptr_t val1 = 5;
  printf("C T2: MyCallback2(%" Pd ").\n", val1);
  MyCallback2(val1);  // Post 5 to Dart.
  const intptr_t val2 = 1;
  printf("C T2: MyCallback1(%" Pd ").\n", val2);
  const intptr_t val3 = MyCallback1(val2);  // val3 = 4.
  printf("C T2: MyCallback1 returned %" Pd ".\n", val3);
  printf("C T2: MyCallback2(%" Pd ").\n", val3);
  MyCallback2(val3);  // Post 4 to Dart.
  printf("C T2: Work2 Done.\n");
}

WriteApiMessage()

std::unique_ptr< Message > dart::WriteApiMessage	(	Zone *	zone,
		Dart_CObject *	obj,
		Dart_Port	dest_port,
		Message::Priority	priority
	)

Definition at line 3436 of file message_snapshot.cc.

                                                                   {
  ApiMessageSerializer serializer(zone);
  if (!serializer.Serialize(obj)) {
    return nullptr;
  }
  return serializer.Finish(dest_port, priority);
}

WriteCidRangeVectorTo()

static void dart::WriteCidRangeVectorTo ( const CidRangeVector &  ranges, BaseTextBuffer *  buffer  )

static

Definition at line 439 of file il_test.cc.

                                                          {
  if (ranges.is_empty()) {
    buffer->AddString("empty CidRangeVector");
    return;
  }
  buffer->AddString("non-empty CidRangeVector:\n");
  for (const auto& range : ranges) {
    for (intptr_t cid = range.cid_start; cid <= range.cid_end; cid++) {
      buffer->AddString("  * ");
      WriteCidTo(cid, buffer);
      buffer->AddString("\n");
    }
  }
}

WriteCidTo()

static void dart::WriteCidTo ( intptr_t  cid, BaseTextBuffer *  buffer  )

static

Definition at line 383 of file il_test.cc.

                                                             {
  ClassTable* const class_table = IsolateGroup::Current()->class_table();
  buffer->Printf("%" Pd "", cid);
  if (class_table->HasValidClassAt(cid)) {
    const auto& cls = Class::Handle(class_table->At(cid));
    buffer->Printf(" (%s", cls.ScrubbedNameCString());
    if (cls.is_abstract()) {
      buffer->AddString(", abstract");
    }
    buffer->AddString(")");
  }
}

WriteHeaderRelaxed()

static DART_FORCE_INLINE void dart::WriteHeaderRelaxed ( ObjectPtr  obj, uword  header  )

static

Definition at line 124 of file scavenger.cc.

                                                            {
  reinterpret_cast<std::atomic<uword>*>(UntaggedObject::ToAddr(obj))
      ->store(header, std::memory_order_relaxed);
}

WriteMessage()

std::unique_ptr< Message > dart::WriteMessage	(	bool	same_group,
		const Object &	obj,
		Dart_Port	dest_port,
		Message::Priority	priority
	)

Definition at line 3416 of file message_snapshot.cc.

                                                                {
  if (ApiObjectConverter::CanConvert(obj.ptr())) {
    return Message::New(dest_port, obj.ptr(), priority);
  } else if (same_group) {
    const Object& copy = Object::Handle(CopyMutableObjectGraph(obj));
    auto handle =
        IsolateGroup::Current()->api_state()->AllocatePersistentHandle();
    handle->set_ptr(copy.ptr());
    return std::make_unique<Message>(dest_port, handle, priority);
  }
 
  Thread* thread = Thread::Current();
  MessageSerializer serializer(thread);
  serializer.Serialize(obj);
  return serializer.Finish(dest_port, priority);
}

Variable Documentation

ab

const CatchEntryMove dart::ab[] = {kA, kB}

Definition at line 31 of file catch_entry_moves_test.cc.

{kA, kB};

abcde

const CatchEntryMove dart::abcde[] = {kA, kB, kC, kD, kE}

Definition at line 27 of file catch_entry_moves_test.cc.

{kA, kB, kC, kD, kE};

abcdx

const CatchEntryMove dart::abcdx[] = {kA, kB, kC, kD, kX}

Definition at line 28 of file catch_entry_moves_test.cc.

{kA, kB, kC, kD, kX};

abxde

const CatchEntryMove dart::abxde[] = {kA, kB, kX, kD, kE}

Definition at line 30 of file catch_entry_moves_test.cc.

{kA, kB, kX, kD, kE};

add_breakpoint_at_activation_params

const MethodParameter* const dart::add_breakpoint_at_activation_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("objectId", true),
    nullptr,
}

Definition at line 4007 of file service.cc.

                                                                            {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("objectId", true),
    nullptr,
};

add_breakpoint_at_entry_params

const MethodParameter* const dart::add_breakpoint_at_entry_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("functionId", true),
    nullptr,
}

Definition at line 3978 of file service.cc.

                                                                       {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("functionId", true),
    nullptr,
};

add_breakpoint_params

const MethodParameter* const dart::add_breakpoint_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("scriptId", true),
    new UIntParameter("line", true),
    new UIntParameter("column", false),
    nullptr,
}

Definition at line 3934 of file service.cc.

                                                              {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("scriptId", true),
    new UIntParameter("line", true),
    new UIntParameter("column", false),
    nullptr,
};

add_breakpoint_with_script_uri_params

const MethodParameter* const dart::add_breakpoint_with_script_uri_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("scriptUri", true),
    new UIntParameter("line", true),
    new UIntParameter("column", false),
    nullptr,
}

Definition at line 3960 of file service.cc.

                                                                              {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("scriptUri", true),
    new UIntParameter("line", true),
    new UIntParameter("column", false),
    nullptr,
};

add_result

int64_t dart::add_result = 0

static

Definition at line 8590 of file dart_api_impl_test.cc.

APSR

const Register dart::APSR = R15

Definition at line 325 of file constants_arm.h.

ARGS_DESC_REG

const Register dart::ARGS_DESC_REG = R4

constexpr

Definition at line 317 of file constants_arm.h.

bare_instructions_frame_layout

const FrameLayout dart::bare_instructions_frame_layout

Initial value:

= {
    kFirstObjectSlotFromFp,  
     kLastFixedObjectSlotFromFp +
        2,  
     kParamEndSlotFromFp,
     kLastParamSlotFromEntrySp,
    kFirstLocalSlotFromFp +
        2,  
    kDartFrameFixedSize -
        2,                              
     0,  
     kSavedCallerFpSlotFromFp,
     kSavedCallerPcSlotFromFp,
     0,  
     kExitLinkSlotFromEntryFp,
}

Definition at line 56 of file stack_frame.cc.

                                                   {
    /*.first_object_from_pc =*/kFirstObjectSlotFromFp,  // No saved PP slot.
    /*.last_fixed_object_from_fp = */ kLastFixedObjectSlotFromFp +
        2,  // No saved CODE, PP slots
    /*.param_end_from_fp = */ kParamEndSlotFromFp,
    /*.last_param_from_entry_sp = */ kLastParamSlotFromEntrySp,
    /*.first_local_from_fp =*/kFirstLocalSlotFromFp +
        2,  // No saved CODE, PP slots.
    /*.dart_fixed_frame_size =*/kDartFrameFixedSize -
        2,                              // No saved CODE, PP slots.
    /*.saved_caller_pp_from_fp = */ 0,  // No saved PP slot.
    /*.saved_caller_fp_from_fp = */ kSavedCallerFpSlotFromFp,
    /*.saved_caller_pc_from_fp = */ kSavedCallerPcSlotFromFp,
    /*.code_from_fp = */ 0,  // No saved CODE
    /*.exit_link_slot_from_entry_fp = */ kExitLinkSlotFromEntryFp,
};

base64_digits

const char dart::base64_digits[65]

static

Initial value:

=
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Definition at line 42 of file json_writer.cc.

base64_pad

const char dart::base64_pad = '='

static

Definition at line 44 of file json_writer.cc.

bootstrap_libraries

const BootstrapLibProps dart::bootstrap_libraries[]

static

Initial value:

= {
    FOR_EACH_BOOTSTRAP_LIBRARY(MAKE_PROPERTIES)}

Definition at line 37 of file bootstrap.cc.

                                                       {
    FOR_EACH_BOOTSTRAP_LIBRARY(MAKE_PROPERTIES)};

BootStrapEntries

const struct dart::NativeEntries dart::BootStrapEntries[]

static

Initial value:

= {BOOTSTRAP_NATIVE_LIST(REGISTER_NATIVE_ENTRY)
 
 
 
}

BootStrapFfiEntries

const struct dart::FfiNativeEntries dart::BootStrapFfiEntries[]

static

Initial value:

= {
    BOOTSTRAP_FFI_NATIVE_LIST(REGISTER_FFI_NATIVE_ENTRY)}

build_expression_evaluation_scope_params

const MethodParameter* const dart::build_expression_evaluation_scope_params[]

static

Initial value:

=
    {
        RUNNABLE_ISOLATE_PARAMETER,
        new IdParameter("frameIndex", false),
        new IdParameter("targetId", false),
        nullptr,
}

Definition at line 2881 of file service.cc.

    {
        RUNNABLE_ISOLATE_PARAMETER,
        new IdParameter("frameIndex", false),
        new IdParameter("targetId", false),
        nullptr,
};

BuiltinEntries [1/2]

struct dart::NativeEntries dart::BuiltinEntries[] = {UNHANDLED_NATIVE_LIST(REGISTER_FUNCTION)}

static

BuiltinEntries [2/2]

struct dart::NativeEntries dart::BuiltinEntries[] = {STACKFRAME_NATIVE_LIST(REGISTER_FUNCTION)}

static

byte_data_finalizer_run

bool dart::byte_data_finalizer_run = false

static

Definition at line 2329 of file dart_api_impl_test.cc.

BYTECODE_MASK

const int dart::BYTECODE_MASK = 0xff

Definition at line 10 of file regexp_bytecodes.h.

BYTECODE_SHIFT

const int dart::BYTECODE_SHIFT = 8

Definition at line 15 of file regexp_bytecodes.h.

callback_

void(* dart::callback_) (Dart_Handle)

(

Dart_Handle

)

Definition at line 1103 of file ffi_test_functions_vmspecific.cc.

CALLEE_SAVED_TEMP

const Register dart::CALLEE_SAVED_TEMP = R8

constexpr

Definition at line 322 of file constants_arm.h.

CALLEE_SAVED_TEMP2

constexpr Register dart::CALLEE_SAVED_TEMP2 = R20

constexpr

Definition at line 155 of file constants_arm64.h.

cid

const intptr_t dart::cid

Definition at line 322 of file method_recognizer.cc.

class_name

const char* const dart::class_name

Definition at line 133 of file method_recognizer.cc.

cleanup_group_callback_data

void* dart::cleanup_group_callback_data

static

Definition at line 8542 of file dart_api_impl_test.cc.

cleanup_isolate_data

void* dart::cleanup_isolate_data

static

Definition at line 8509 of file dart_api_impl_test.cc.

cleanup_isolate_group_data

void* dart::cleanup_isolate_group_data

static

Definition at line 8508 of file dart_api_impl_test.cc.

clear_cpu_samples_params

const MethodParameter* const dart::clear_cpu_samples_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4499 of file service.cc.

                                                                 {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

clear_vm_timeline_params

const MethodParameter* const dart::clear_vm_timeline_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4285 of file service.cc.

                                                                 {
    NO_ISOLATE_PARAMETER,
    nullptr,
};

closure_to_callback_

Dart_PersistentHandle dart::closure_to_callback_

Definition at line 1104 of file ffi_test_functions_vmspecific.cc.

cobj_dynamic_type

Dart_CObject dart::cobj_dynamic_type = {Dart_CObject_kUnsupported, {false}}

static

Definition at line 32 of file message_snapshot.cc.

{Dart_CObject_kUnsupported, {false}};

cobj_empty_type_arguments

Dart_CObject dart::cobj_empty_type_arguments

static

Initial value:

= {Dart_CObject_kUnsupported,
                                                 {false}}

Definition at line 34 of file message_snapshot.cc.

                                                {Dart_CObject_kUnsupported,
                                                 {false}};

cobj_false

Dart_CObject dart::cobj_false = {Dart_CObject_kBool, {false}}

static

Definition at line 37 of file message_snapshot.cc.

{Dart_CObject_kBool, {false}};

cobj_sentinel

Dart_CObject dart::cobj_sentinel = {Dart_CObject_kUnsupported, {false}}

static

Definition at line 29 of file message_snapshot.cc.

{Dart_CObject_kUnsupported, {false}};

cobj_transition_sentinel

Dart_CObject dart::cobj_transition_sentinel

static

Initial value:

= {Dart_CObject_kUnsupported,
                                                {false}}

Definition at line 30 of file message_snapshot.cc.

                                               {Dart_CObject_kUnsupported,
                                                {false}};

cobj_true

Dart_CObject dart::cobj_true = {Dart_CObject_kBool, {true}}

static

Definition at line 36 of file message_snapshot.cc.

{Dart_CObject_kBool, {true}};

cobj_void_type

Dart_CObject dart::cobj_void_type = {Dart_CObject_kUnsupported, {false}}

static

Definition at line 33 of file message_snapshot.cc.

{Dart_CObject_kUnsupported, {false}};

CODE_REG

const Register dart::CODE_REG = R6

constexpr

Definition at line 318 of file constants_arm.h.

collect_all_garbage_params

const MethodParameter* const dart::collect_all_garbage_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4554 of file service.cc.

                                                                   {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

compile_expression_params

const MethodParameter* const dart::compile_expression_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new StringParameter("expression", true),
    new StringParameter("definitions", false),
    new StringParameter("definitionTypes", false),
    new StringParameter("typeDefinitions", false),
    new StringParameter("typeBounds", false),
    new StringParameter("typeDefaults", false),
    new StringParameter("libraryUri", true),
    new StringParameter("klass", false),
    new BoolParameter("isStatic", false),
    new StringParameter("method", false),
    new Int64Parameter("tokenPos", false),
    
    
    
    nullptr,
}

Definition at line 3197 of file service.cc.

                                                                  {
    RUNNABLE_ISOLATE_PARAMETER,
    new StringParameter("expression", true),
    new StringParameter("definitions", false),
    new StringParameter("definitionTypes", false),
    new StringParameter("typeDefinitions", false),
    new StringParameter("typeBounds", false),
    new StringParameter("typeDefaults", false),
    new StringParameter("libraryUri", true),
    new StringParameter("klass", false),
    new BoolParameter("isStatic", false),
    new StringParameter("method", false),
    new Int64Parameter("tokenPos", false),
    // TODO(jensj): Uncomment this line when DDS has rolled into flutter
    // (https://dart-review.googlesource.com/c/sdk/+/329322).
    // new StringParameter("scriptUri", false),
    nullptr,
};

cpu_reg_abi_names

const char *const dart::cpu_reg_abi_names

extern

Definition at line 138 of file constants_arm64.h.

cpu_reg_byte_names

const char *const dart::cpu_reg_byte_names

extern

Definition at line 107 of file constants_x64.h.

cpu_reg_names

const char *const dart::cpu_reg_names

extern

Definition at line 137 of file constants_arm64.h.

dart_api_data

const DartApi dart::dart_api_data

static

Initial value:

= {
    DART_API_DL_MAJOR_VERSION, DART_API_DL_MINOR_VERSION, dart_api_entries}

Definition at line 93 of file ffi.cc.

                                     {
    DART_API_DL_MAJOR_VERSION, DART_API_DL_MINOR_VERSION, dart_api_entries};

dart_api_entries

const DartApiEntry dart::dart_api_entries[]

static

Initial value:

= {
#define ENTRY(name, R, A)                                                      
                                                          
 
 
        DartApiEntry{nullptr, nullptr}}

Definition at line 86 of file ffi.cc.

                                               {
#define ENTRY(name, R, A)                                                      \
  DartApiEntry{#name, reinterpret_cast<void (*)()>(name)},
    DART_API_ALL_DL_SYMBOLS(ENTRY)
#undef ENTRY
        DartApiEntry{nullptr, nullptr}};

DART_USED

const SRegister STMP dart::DART_USED = EvenSRegisterOf(DTMP)

Definition at line 292 of file constants_arm.h.

data

int8_t dart::data[kExtLength]

static

Initial value:

= {
    0x41, 0x42, 0x41, 0x42, 0x41, 0x42, 0x41, 0x42,
    0x41, 0x42, 0x41, 0x42, 0x41, 0x42, 0x41, 0x42,
}

Definition at line 2256 of file dart_api_impl_test.cc.

                                 {
    0x41, 0x42, 0x41, 0x42, 0x41, 0x42, 0x41, 0x42,
    0x41, 0x42, 0x41, 0x42, 0x41, 0x42, 0x41, 0x42,
};

de

const CatchEntryMove dart::de[] = {kD, kE}

Definition at line 32 of file catch_entry_moves_test.cc.

{kD, kE};

decode_table

const int8_t dart::decode_table[]

static

Initial value:

= {
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -1, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63,  
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, 00, -2, -2,  
    -2, 00, 01, 02, 03, 04, 05, 06, 07, 8,  9,  10, 11, 12, 13, 14,  
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63,  
    -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,  
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2}

Definition at line 19 of file base64.cc.

                                     {
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -1, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63,  //
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, 00, -2, -2,  //
    -2, 00, 01, 02, 03, 04, 05, 06, 07, 8,  9,  10, 11, 12, 13, 14,  //
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63,  //
    -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,  //
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,  //
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2};

default_frame_layout

const FrameLayout dart::default_frame_layout

Initial value:

= {
     kFirstObjectSlotFromFp,
     kLastFixedObjectSlotFromFp,
     kParamEndSlotFromFp,
     kLastParamSlotFromEntrySp,
     kFirstLocalSlotFromFp,
     kDartFrameFixedSize,
     kSavedCallerPpSlotFromFp,
     kSavedCallerFpSlotFromFp,
     kSavedCallerPcSlotFromFp,
     kPcMarkerSlotFromFp,
     kExitLinkSlotFromEntryFp,
}

Definition at line 43 of file stack_frame.cc.

                                         {
    /*.first_object_from_fp = */ kFirstObjectSlotFromFp,
    /*.last_fixed_object_from_fp = */ kLastFixedObjectSlotFromFp,
    /*.param_end_from_fp = */ kParamEndSlotFromFp,
    /*.last_param_from_entry_sp = */ kLastParamSlotFromEntrySp,
    /*.first_local_from_fp = */ kFirstLocalSlotFromFp,
    /*.dart_fixed_frame_size = */ kDartFrameFixedSize,
    /*.saved_caller_pp_from_fp = */ kSavedCallerPpSlotFromFp,
    /*.saved_caller_fp_from_fp = */ kSavedCallerFpSlotFromFp,
    /*.saved_caller_pc_from_fp = */ kSavedCallerPcSlotFromFp,
    /*.code_from_fp = */ kPcMarkerSlotFromFp,
    /*.exit_link_slot_from_entry_fp = */ kExitLinkSlotFromEntryFp,
};

delete_on_finalization

Dart_WeakPersistentHandle dart::delete_on_finalization

Definition at line 4025 of file dart_api_impl_test.cc.

DISPATCH_TABLE_REG

constexpr Register dart::DISPATCH_TABLE_REG = NOTFP

constexpr

Definition at line 313 of file constants_arm.h.

double_abs_constant

const struct dart::ALIGN16 dart::double_abs_constant = {0x7FFFFFFFFFFFFFFFULL, 0x7FFFFFFFFFFFFFFFULL}

static

double_nan_constant

const double dart::double_nan_constant = NAN

static

Definition at line 141 of file thread.cc.

double_negate_constant

const struct dart::ALIGN16 dart::double_negate_constant = {0x8000000000000000ULL, 0x8000000000000000ULL}

static

DTMP

const DRegister dart::DTMP = EvenDRegisterOf(QTMP)

Definition at line 291 of file constants_arm.h.

enable_profiler_params

const MethodParameter* const dart::enable_profiler_params[]

static

Initial value:

= {
    nullptr,
}

Definition at line 4425 of file service.cc.

                                                               {
    nullptr,
};

enum_name

const char* const dart::enum_name

Definition at line 135 of file method_recognizer.cc.

evaluate_compiled_expression_params

const MethodParameter* const dart::evaluate_compiled_expression_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new UIntParameter("frameIndex", false),
    new IdParameter("targetId", false),
    new StringParameter("kernelBytes", true),
    nullptr,
}

Definition at line 3299 of file service.cc.

                                                                            {
    RUNNABLE_ISOLATE_PARAMETER,
    new UIntParameter("frameIndex", false),
    new IdParameter("targetId", false),
    new StringParameter("kernelBytes", true),
    nullptr,
};

evaluate_in_frame_params

const MethodParameter* const dart::evaluate_in_frame_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new UIntParameter("frameIndex", true),
    new MethodParameter("expression", true),
    nullptr,
}

Definition at line 3433 of file service.cc.

                                                                 {
    RUNNABLE_ISOLATE_PARAMETER,
    new UIntParameter("frameIndex", true),
    new MethodParameter("expression", true),
    nullptr,
};

evaluate_params

const MethodParameter* const dart::evaluate_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 2757 of file service.cc.

                                                        {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

event_queue

EventQueue* dart::event_queue

Definition at line 154 of file custom_isolate_test.cc.

exception_pause_mode_names

const char* const dart::exception_pause_mode_names[]

static

Initial value:

= {
    "All",
    "None",
    "Unhandled",
    nullptr,
}

Definition at line 5485 of file service.cc.

                                                        {
    "All",
    "None",
    "Unhandled",
    nullptr,
};

exception_pause_mode_values

Dart_ExceptionPauseInfo dart::exception_pause_mode_values[]

static

Initial value:

= {
    kPauseOnAllExceptions,
    kNoPauseOnExceptions,
    kPauseOnUnhandledExceptions,
    kInvalidExceptionPauseInfo,
}

Definition at line 5492 of file service.cc.

                                                               {
    kPauseOnAllExceptions,
    kNoPauseOnExceptions,
    kPauseOnUnhandledExceptions,
    kInvalidExceptionPauseInfo,
};

expected_allocation_cls

const char* dart::expected_allocation_cls = nullptr

static

Definition at line 10239 of file dart_api_impl_test.cc.

[struct]

const struct { ... } dart::factory_recognizer_list[]

Initial value:

= {RECOGNIZED_LIST_FACTORY_LIST(RECOGNIZE_FACTORY){
    Symbols::kIllegal, -1, 0, nullptr}}

false

dart::false

Definition at line 58 of file isolate_reload.cc.

FAR_TMP

constexpr Register dart::FAR_TMP = S8

constexpr

Definition at line 152 of file constants_riscv.h.

file_schema

const char* dart::file_schema = "file://"

Definition at line 293 of file ffi_dynamic_library.cc.

file_schema_length

const int dart::file_schema_length = 7

Definition at line 294 of file ffi_dynamic_library.cc.

finalizable_handle3

Dart_FinalizableHandle dart::finalizable_handle3

static

Definition at line 3888 of file dart_api_impl_test.cc.

finalizable_new_ref

Dart_FinalizableHandle dart::finalizable_new_ref = nullptr

static

Definition at line 3589 of file dart_api_impl_test.cc.

finalizable_new_ref_peer

void* dart::finalizable_new_ref_peer = 0

static

Definition at line 3590 of file dart_api_impl_test.cc.

finalizable_old_ref

Dart_FinalizableHandle dart::finalizable_old_ref = nullptr

static

Definition at line 3591 of file dart_api_impl_test.cc.

finalizable_old_ref_peer

void* dart::finalizable_old_ref_peer = 0

static

Definition at line 3592 of file dart_api_impl_test.cc.

finger_print

const uint32_t dart::finger_print

Definition at line 323 of file method_recognizer.cc.

FLAG_regexp_possessive_quantifier

constexpr bool dart::FLAG_regexp_possessive_quantifier = false

staticconstexpr

Definition at line 21 of file regexp_parser.cc.

float_absolute_constant

const struct dart::ALIGN16 dart::float_absolute_constant = {0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF}

static

float_negate_constant

const struct dart::ALIGN16 dart::float_negate_constant = {0x80000000, 0x80000000, 0x80000000, 0x80000000}

static

float_not_constant

const struct dart::ALIGN16 dart::float_not_constant = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}

static

float_zerow_constant

const struct dart::ALIGN16 dart::float_zerow_constant = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000}

static

found_allocation

bool dart::found_allocation = false

static

Definition at line 10240 of file dart_api_impl_test.cc.

fp

const uint32_t dart::fp

Definition at line 136 of file method_recognizer.cc.

FPREG

const Register dart::FPREG = FP

constexpr

Definition at line 315 of file constants_arm.h.

fpu_d_reg_names

const char* const dart::fpu_d_reg_names[kNumberOfDRegisters]

extern

fpu_reg_names

const char *const dart::fpu_reg_names

extern

Definition at line 139 of file constants_arm64.h.

fpu_s_reg_names

const char* const dart::fpu_s_reg_names[kNumberOfSRegisters]

extern

FpuTMP

const FpuRegister dart::FpuTMP = QTMP

Definition at line 297 of file constants_arm.h.

FTMP

const FRegister dart::FTMP = FT11

Definition at line 137 of file constants_riscv.h.

function_name

const char* const dart::function_name

Definition at line 134 of file method_recognizer.cc.

FUNCTION_REG

const Register dart::FUNCTION_REG = R0

constexpr

Definition at line 320 of file constants_arm.h.

GB

constexpr intptr_t dart::GB = 1 << GBLog2

constexpr

Definition at line 532 of file globals.h.

GBInWords

constexpr intptr_t dart::GBInWords = 1 << GBInWordsLog2

constexpr

Definition at line 539 of file globals.h.

GBInWordsLog2

constexpr intptr_t dart::GBInWordsLog2 = MBLog2 + KBInWordsLog2

constexpr

Definition at line 538 of file globals.h.

GBLog2

constexpr intptr_t dart::GBLog2 = MBLog2 + KBLog2

constexpr

Definition at line 531 of file globals.h.

gc_during_reload

dart::gc_during_reload

Definition at line 58 of file isolate_reload.cc.

get_allocation_profile_params

const MethodParameter* const dart::get_allocation_profile_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4541 of file service.cc.

                                                                      {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_allocation_traces_params

const MethodParameter* const dart::get_allocation_traces_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("classId", false),
    new Int64Parameter("timeOriginMicros", false),
    new Int64Parameter("timeExtentMicros", false),
    nullptr,
}

Definition at line 4459 of file service.cc.

                                                                     {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("classId", false),
    new Int64Parameter("timeOriginMicros", false),
    new Int64Parameter("timeExtentMicros", false),
    nullptr,
};

get_class_list_params

const MethodParameter* const dart::get_class_list_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5154 of file service.cc.

                                                              {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_cpu_samples_params

const MethodParameter* const dart::get_cpu_samples_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new Int64Parameter("timeOriginMicros", false),
    new Int64Parameter("timeExtentMicros", false),
    nullptr,
}

Definition at line 4448 of file service.cc.

                                                               {
    RUNNABLE_ISOLATE_PARAMETER,
    new Int64Parameter("timeOriginMicros", /*required=*/false),
    new Int64Parameter("timeExtentMicros", /*required=*/false),
    nullptr,
};

get_default_classes_aliases_params

const MethodParameter* const dart::get_default_classes_aliases_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5762 of file service.cc.

                                                                           {
    NO_ISOLATE_PARAMETER,
    nullptr,
};

get_flag_list_params

const MethodParameter* const dart::get_flag_list_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5593 of file service.cc.

                                                             {
    NO_ISOLATE_PARAMETER,
    nullptr,
};

get_heap_map_params

const MethodParameter* const dart::get_heap_map_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4565 of file service.cc.

                                                            {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_implementation_fields_params

const MethodParameter* const dart::get_implementation_fields_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    OBJECT_PARAMETER,
    nullptr,
}

Definition at line 5096 of file service.cc.

                                                                         {
    RUNNABLE_ISOLATE_PARAMETER,
    OBJECT_PARAMETER,
    nullptr,
};

get_inbound_references_params

const MethodParameter* const dart::get_inbound_references_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 2363 of file service.cc.

                                                                      {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_instances_as_list_params

const MethodParameter* const dart::get_instances_as_list_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("objectId", true),
    new BoolParameter("includeSubclasses", false),
    new BoolParameter("includeImplementers", false),
    nullptr,
}

Definition at line 3581 of file service.cc.

                                                                     {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("objectId", /*required=*/true),
    new BoolParameter("includeSubclasses", /*required=*/false),
    new BoolParameter("includeImplementers", /*required=*/false),
    nullptr,
};

get_instances_params

const MethodParameter* const dart::get_instances_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("objectId", true),
    new UIntParameter("limit", true),
    new BoolParameter("includeSubclasses", false),
    new BoolParameter("includeImplementers", false),
    nullptr,
}

Definition at line 3532 of file service.cc.

                                                             {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("objectId", /*required=*/true),
    new UIntParameter("limit", /*required=*/true),
    new BoolParameter("includeSubclasses", /*required=*/false),
    new BoolParameter("includeImplementers", /*required=*/false),
    nullptr,
};

get_isolate_group_memory_usage_params

const MethodParameter* const dart::get_isolate_group_memory_usage_params[]

static

Initial value:

= {
    ISOLATE_GROUP_PARAMETER,
    nullptr,
}

Definition at line 1616 of file service.cc.

                                                                              {
    ISOLATE_GROUP_PARAMETER,
    nullptr,
};

get_isolate_group_params

const MethodParameter* const dart::get_isolate_group_params[]

static

Initial value:

= {
    ISOLATE_GROUP_PARAMETER,
    nullptr,
}

Definition at line 1524 of file service.cc.

                                                                 {
    ISOLATE_GROUP_PARAMETER,
    nullptr,
};

get_isolate_metric_list_params

const MethodParameter* const dart::get_isolate_metric_list_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4105 of file service.cc.

                                                                       {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_isolate_metric_params

const MethodParameter* const dart::get_isolate_metric_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4123 of file service.cc.

                                                                  {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_isolate_object_store_params

const MethodParameter* const dart::get_isolate_object_store_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5144 of file service.cc.

                                                                        {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_isolate_params

const MethodParameter* const dart::get_isolate_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 1515 of file service.cc.

                                                           {
    ISOLATE_PARAMETER,
    nullptr,
};

get_isolate_pause_event_params

const MethodParameter* const dart::get_isolate_pause_event_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 1627 of file service.cc.

                                                                       {
    ISOLATE_PARAMETER,
    nullptr,
};

get_memory_usage_params

const MethodParameter* const dart::get_memory_usage_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 1607 of file service.cc.

                                                                {
    ISOLATE_PARAMETER,
    nullptr,
};

get_object_params

const MethodParameter* const dart::get_object_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new UIntParameter("offset", false),
    new UIntParameter("count", false),
    nullptr,
}

Definition at line 5039 of file service.cc.

                                                          {
    RUNNABLE_ISOLATE_PARAMETER,
    new UIntParameter("offset", false),
    new UIntParameter("count", false),
    nullptr,
};

get_object_store_params

const MethodParameter* const dart::get_object_store_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5134 of file service.cc.

                                                                {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_persistent_handles_params

const MethodParameter* const dart::get_persistent_handles_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4890 of file service.cc.

                                                                      {
    ISOLATE_PARAMETER,
    nullptr,
};

get_ports_params

const MethodParameter* const dart::get_ports_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 3685 of file service.cc.

                                                         {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_ports_private_params

const MethodParameter* const dart::get_ports_private_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4978 of file service.cc.

                                                                 {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_process_memory_usage_params

const MethodParameter* const dart::get_process_memory_usage_params[]

static

Initial value:

= {
    nullptr,
}

Definition at line 4821 of file service.cc.

                                                                        {
    nullptr,
};

get_reachable_size_params

const MethodParameter* const dart::get_reachable_size_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("targetId", true),
    nullptr,
}

Definition at line 2585 of file service.cc.

                                                                  {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("targetId", true),
    nullptr,
};

get_retained_size_params

const MethodParameter* const dart::get_retained_size_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("targetId", true),
    nullptr,
}

Definition at line 2546 of file service.cc.

                                                                 {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("targetId", true),
    nullptr,
};

get_retaining_path_params

const MethodParameter* const dart::get_retaining_path_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 2505 of file service.cc.

                                                                  {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_scripts_params

const MethodParameter* const dart::get_scripts_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 1636 of file service.cc.

                                                           {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_source_report_params

const MethodParameter* const dart::get_source_report_params[]

static

Initial value:

= {
 
    RUNNABLE_ISOLATE_PARAMETER,
    new EnumListParameter("reports", true, report_enum_names),
    new IdParameter("scriptId", false),
    new UIntParameter("tokenPos", false),
    new UIntParameter("endTokenPos", false),
    new BoolParameter("forceCompile", false),
 
    nullptr,
}

Definition at line 3718 of file service.cc.

                                                                 {
#if !defined(DART_PRECOMPILED_RUNTIME)
    RUNNABLE_ISOLATE_PARAMETER,
    new EnumListParameter("reports", true, report_enum_names),
    new IdParameter("scriptId", false),
    new UIntParameter("tokenPos", false),
    new UIntParameter("endTokenPos", false),
    new BoolParameter("forceCompile", false),
#endif
    nullptr,
};

get_stack_params

const MethodParameter* const dart::get_stack_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new UIntParameter("limit", false),
    nullptr,
}

Definition at line 1670 of file service.cc.

                                                         {
    RUNNABLE_ISOLATE_PARAMETER,
    new UIntParameter("limit", false),
    nullptr,
};

get_tag_profile_params

const MethodParameter* const dart::get_tag_profile_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4437 of file service.cc.

                                                               {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_type_arguments_list_params

const MethodParameter* const dart::get_type_arguments_list_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5165 of file service.cc.

                                                                       {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

get_version_params

const MethodParameter* const dart::get_version_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5201 of file service.cc.

                                                           {
    NO_ISOLATE_PARAMETER,
    nullptr,
};

get_vm_params

const MethodParameter* const dart::get_vm_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5247 of file service.cc.

                                                      {
    NO_ISOLATE_PARAMETER,
    nullptr,
};

get_vm_timeline_flags_params

const MethodParameter* const dart::get_vm_timeline_flags_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4257 of file service.cc.

                                                                     {
    NO_ISOLATE_PARAMETER,
    nullptr,
};

get_vm_timeline_micros_params

const MethodParameter* const dart::get_vm_timeline_micros_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4274 of file service.cc.

                                                                      {
    NO_ISOLATE_PARAMETER,
    nullptr,
};

get_vm_timeline_params

const MethodParameter* const dart::get_vm_timeline_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    new Int64Parameter("timeOriginMicros", false),
    new Int64Parameter("timeExtentMicros", false),
    nullptr,
}

Definition at line 4300 of file service.cc.

                                                               {
    NO_ISOLATE_PARAMETER,
    new Int64Parameter("timeOriginMicros", /*required=*/false),
    new Int64Parameter("timeExtentMicros", /*required=*/false),
    nullptr,
};

global_random

Random* dart::global_random = nullptr

static

Definition at line 78 of file random.cc.

global_random_mutex

Mutex* dart::global_random_mutex = nullptr

static

Definition at line 79 of file random.cc.

HEAP_BITS

const Register dart::HEAP_BITS = R28

Definition at line 156 of file constants_arm64.h.

heap_samples

intptr_t dart::heap_samples = 0

static

Definition at line 10238 of file dart_api_impl_test.cc.

IC_DATA_REG

const Register dart::IC_DATA_REG = R9

constexpr

Definition at line 316 of file constants_arm.h.

invalid_frame_layout

const FrameLayout dart::invalid_frame_layout

Initial value:

= {
     -1,
     -1,
     -1,
     -1,
     -1,
     -1,
     -1,
     -1,
     -1,
     -1,
     -1,
}

Definition at line 29 of file stack_frame.cc.

                                         {
    /*.first_object_from_fp = */ -1,
    /*.last_fixed_object_from_fp = */ -1,
    /*.param_end_from_fp = */ -1,
    /*.last_param_from_entry_sp = */ -1,
    /*.first_local_from_fp = */ -1,
    /*.dart_fixed_frame_size = */ -1,
    /*.saved_caller_pp_from_fp = */ -1,
    /*.saved_caller_fp_from_fp = */ -1,
    /*.saved_caller_pc_from_fp = */ -1,
    /*.code_from_fp = */ -1,
    /*.exit_link_slot_from_entry_fp = */ -1,
};

invoke_params

const MethodParameter* const dart::invoke_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 2624 of file service.cc.

                                                      {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

kA

const auto dart::kA = NewMove(1, 10)

Definition at line 20 of file catch_entry_moves_test.cc.

kAbiArgumentCpuRegs

constexpr RegList dart::kAbiArgumentCpuRegs

constexpr

Initial value:

=
    (1 << R0) | (1 << R1) | (1 << R2) | (1 << R3)

Definition at line 647 of file constants_arm.h.

kAbiArgumentFpuRegs

constexpr RegList dart::kAbiArgumentFpuRegs

constexpr

Initial value:

=
    R(FA0) | R(FA1) | R(FA2) | R(FA3) | R(FA4) | R(FA5) | R(FA6) | R(FA7)

Definition at line 520 of file constants_riscv.h.

kAbiFirstPreservedCpuReg

const Register dart::kAbiFirstPreservedCpuReg = R19

Definition at line 514 of file constants_arm64.h.

kAbiFirstPreservedFpuReg

const VRegister dart::kAbiFirstPreservedFpuReg = Q4

Definition at line 660 of file constants_arm.h.

kAbiLastPreservedCpuReg

const Register dart::kAbiLastPreservedCpuReg = R28

Definition at line 515 of file constants_arm64.h.

kAbiLastPreservedFpuReg

const VRegister dart::kAbiLastPreservedFpuReg = Q7

Definition at line 661 of file constants_arm.h.

kAbiPreservedCpuRegCount

constexpr int dart::kAbiPreservedCpuRegCount = 7

constexpr

Definition at line 658 of file constants_arm.h.

kAbiPreservedCpuRegs

const RegList dart::kAbiPreservedCpuRegs

constexpr

Initial value:

= (1 << R4) | (1 << R5) | (1 << R6) |
                                     (1 << R7) | (1 << R8) | (1 << R9) |
                                     (1 << R10)

Definition at line 655 of file constants_arm.h.

kAbiPreservedFpuRegCount

constexpr int dart::kAbiPreservedFpuRegCount = 4

constexpr

Definition at line 662 of file constants_arm.h.

kAbiPreservedFpuRegs

constexpr RegList dart::kAbiPreservedFpuRegs

constexpr

Initial value:

= R(FS0) | R(FS1) | R(FS2) | R(FS3) |
                                         R(FS4) | R(FS5) | R(FS6) | R(FS7) |
                                         R(FS8) | R(FS9) | R(FS10) | R(FS11)

Definition at line 525 of file constants_riscv.h.

kAbiVolatileCpuRegs

constexpr RegList dart::kAbiVolatileCpuRegs = kAbiArgumentCpuRegs | (1 << IP) | (1 << LR)

constexpr

Definition at line 649 of file constants_arm.h.

kAbiVolatileFpuRegs

const RegList dart::kAbiVolatileFpuRegs = R(Q0) | R(Q1) | R(Q2) | R(Q3)

constexpr

Definition at line 686 of file constants_arm.h.

kAcquireShift

const intptr_t dart::kAcquireShift = 26

Definition at line 948 of file constants_riscv.h.

kAllBenchmarks

constexpr const char* dart::kAllBenchmarks = "All Benchmarks"

staticconstexpr

Definition at line 45 of file run_vm_tests.cc.

kAllCpuRegistersList

const RegList dart::kAllCpuRegistersList = 0xFFFF

Definition at line 643 of file constants_arm.h.

kAllFpuRegistersList

const RegList dart::kAllFpuRegistersList = (1 << kNumberOfFpuRegisters) - 1

Definition at line 644 of file constants_arm.h.

kAllocatablePageSize

constexpr intptr_t dart::kAllocatablePageSize = 64 * KB

staticconstexpr

Definition at line 55 of file spaces.h.

kAllocationCanary

constexpr intptr_t dart::kAllocationCanary = 123

staticconstexpr

Definition at line 181 of file globals.h.

kAllocationRedZoneSize

constexpr intptr_t dart::kAllocationRedZoneSize = kObjectAlignment

staticconstexpr

Definition at line 41 of file page.h.

kArg1Reg

const Register dart::kArg1Reg = CallingConventions::ArgumentRegisters[0]

Definition at line 146 of file assembler_test.cc.

kArg2Reg

const Register dart::kArg2Reg = CallingConventions::ArgumentRegisters[1]

Definition at line 147 of file assembler_test.cc.

kAsciiWordMask

constexpr uintptr_t dart::kAsciiWordMask = 0x80808080u

staticconstexpr

Definition at line 18 of file unicode.cc.

KB

constexpr intptr_t dart::KB = 1 << KBLog2

constexpr

Definition at line 528 of file globals.h.

kB

const auto dart::kB = NewMove(2, 20)

Definition at line 21 of file catch_entry_moves_test.cc.

KBInWords

constexpr intptr_t dart::KBInWords = 1 << KBInWordsLog2

constexpr

Definition at line 535 of file globals.h.

KBInWordsLog2

constexpr intptr_t dart::KBInWordsLog2 = KBLog2 - kWordSizeLog2

constexpr

Definition at line 534 of file globals.h.

kBitsPerByte

constexpr intptr_t dart::kBitsPerByte = 1 << kBitsPerByteLog2

constexpr

Definition at line 463 of file globals.h.

kBitsPerByteLog2

constexpr intptr_t dart::kBitsPerByteLog2 = 3

constexpr

Definition at line 462 of file globals.h.

kBitsPerInt16

constexpr intptr_t dart::kBitsPerInt16 = kInt16Size * kBitsPerByte

constexpr

Definition at line 465 of file globals.h.

kBitsPerInt32

constexpr intptr_t dart::kBitsPerInt32 = kInt32Size * kBitsPerByte

constexpr

Definition at line 466 of file globals.h.

kBitsPerInt64

constexpr intptr_t dart::kBitsPerInt64 = kInt64Size * kBitsPerByte

constexpr

Definition at line 467 of file globals.h.

kBitsPerInt8

constexpr intptr_t dart::kBitsPerInt8 = kInt8Size * kBitsPerByte

constexpr

Definition at line 464 of file globals.h.

kBitsPerWord

constexpr intptr_t dart::kBitsPerWord = 1 << kBitsPerWordLog2

constexpr

Definition at line 514 of file globals.h.

kBitsPerWordLog2

constexpr intptr_t dart::kBitsPerWordLog2 = kWordSizeLog2 + kBitsPerByteLog2

constexpr

Definition at line 513 of file globals.h.

kBitVectorWordsPerBlock

constexpr intptr_t dart::kBitVectorWordsPerBlock = 1

staticconstexpr

Definition at line 32 of file page.h.

kBlockMask

constexpr intptr_t dart::kBlockMask = ~(kBlockSize - 1)

staticconstexpr

Definition at line 35 of file page.h.

kBlockSize

constexpr intptr_t dart::kBlockSize

staticconstexpr

Initial value:

=
    kObjectAlignment * kBitsPerWord * kBitVectorWordsPerBlock

Definition at line 33 of file page.h.

kBlocksPerPage

constexpr intptr_t dart::kBlocksPerPage = kPageSize / kBlockSize

staticconstexpr

Definition at line 36 of file page.h.

KBLog2

constexpr intptr_t dart::KBLog2 = 10

constexpr

Definition at line 527 of file globals.h.

kBoolValueBitPosition

constexpr intptr_t dart::kBoolValueBitPosition

staticconstexpr

Initial value:

=
    HostObjectAlignment::kBoolValueBitPosition

Definition at line 62 of file pointer_tagging.h.

kBoolValueMask

constexpr intptr_t dart::kBoolValueMask = HostObjectAlignment::kBoolValueMask

staticconstexpr

Definition at line 64 of file pointer_tagging.h.

kBoolVsNullBitPosition

constexpr intptr_t dart::kBoolVsNullBitPosition

staticconstexpr

Initial value:

=
    HostObjectAlignment::kBoolVsNullBitPosition

Definition at line 65 of file pointer_tagging.h.

kBoolVsNullMask

constexpr intptr_t dart::kBoolVsNullMask

staticconstexpr

Initial value:

=
    HostObjectAlignment::kBoolVsNullMask

Definition at line 67 of file pointer_tagging.h.

kBootstrapLibraryCount

constexpr intptr_t dart::kBootstrapLibraryCount

staticconstexpr

Initial value:

=
    ARRAY_SIZE(bootstrap_libraries)

Definition at line 42 of file bootstrap.cc.

kBreakInstructionFiller

const uint64_t dart::kBreakInstructionFiller = 0xE1200070

constexpr

Definition at line 1317 of file constants_arm.h.

kByteMask

constexpr int8_t dart::kByteMask = (1 << kDataBitsPerByte) - 1

staticconstexpr

Definition at line 19 of file datastream.h.

kBytesPerBigIntDigit

const intptr_t dart::kBytesPerBigIntDigit = 4

Definition at line 54 of file globals.h.

kC

const auto dart::kC = NewMove(3, 30)

Definition at line 22 of file catch_entry_moves_test.cc.

kCalculateCanonicalizeHash

const uint32_t dart::kCalculateCanonicalizeHash = 0

Definition at line 6444 of file object_test.cc.

kCallbackSlotsBeforeSavedArguments

constexpr intptr_t dart::kCallbackSlotsBeforeSavedArguments = 2

constexpr

Definition at line 70 of file stack_frame_arm.h.

kCallerSpSlotFromFp [1/5]

constexpr int dart::kCallerSpSlotFromFp = 2

staticconstexpr

Definition at line 49 of file stack_frame_arm.h.

kCallerSpSlotFromFp [2/5]

constexpr int dart::kCallerSpSlotFromFp = 2

staticconstexpr

Definition at line 49 of file stack_frame_arm64.h.

kCallerSpSlotFromFp [3/5]

constexpr int dart::kCallerSpSlotFromFp = 2

staticconstexpr

Definition at line 45 of file stack_frame_ia32.h.

kCallerSpSlotFromFp [4/5]

constexpr int dart::kCallerSpSlotFromFp = 0

staticconstexpr

Definition at line 49 of file stack_frame_riscv.h.

kCallerSpSlotFromFp [5/5]

constexpr int dart::kCallerSpSlotFromFp = 2

staticconstexpr

Definition at line 52 of file stack_frame_x64.h.

kClassIdTagMax

constexpr intptr_t dart::kClassIdTagMax = (1 << 20) - 1

staticconstexpr

Definition at line 22 of file class_id.h.

kCommonDoubleConstants

const double dart::kCommonDoubleConstants[]

Initial value:

= {
    -1.0, -0.5, -0.1, 0.0, 0.1, 0.5, 1.0, 2.0, 4.0, 5.0, 10.0, 20.0, 30.0, 64.0,
    255.0, NAN,
    
    2.718281828459045, 2.302585092994046, 0.6931471805599453,
    1.4426950408889634, 0.4342944819032518, 3.1415926535897932,
    0.7071067811865476, 1.4142135623730951}

Definition at line 22 of file flow_graph_builder.cc.

                                        {
    -1.0, -0.5, -0.1, 0.0, 0.1, 0.5, 1.0, 2.0, 4.0, 5.0, 10.0, 20.0, 30.0, 64.0,
    255.0, NAN,
    // From dart:math
    2.718281828459045, 2.302585092994046, 0.6931471805599453,
    1.4426950408889634, 0.4342944819032518, 3.1415926535897932,
    0.7071067811865476, 1.4142135623730951};

kCompilerPassesUsage

const char* dart::kCompilerPassesUsage

static

Initial value:

=
    "=== How to use --compiler-passes flag\n"
    "\n"
    "Pass the list of comma separated compiler pass filter flags.\n"
    "\n"
    "For the given pass Name the following flags are supported:\n"
    "\n"
    "     -Name          disable the pass\n"
    "     ]Name or Name  print IL after the pass\n"
    "     [Name          print IL before the pass\n"
    "     *Name          print IL before and after the pass\n"
    "     *              print IL after each pass.\n"
    "\n"
    " The flag can be followed by '+' which makes it sticky, e.g. Inlining+\n"
    " would cause IL to be printed after all passes that follow inlining and\n"
    " are not disabled.\n"
    "\n"
    "List of compiler passes:\n"

Definition at line 97 of file compiler_pass.cc.

kCompressedWordSize

constexpr intptr_t dart::kCompressedWordSize = kWordSize

staticconstexpr

Definition at line 42 of file globals.h.

kCompressedWordSizeLog2

constexpr intptr_t dart::kCompressedWordSizeLog2 = kWordSizeLog2

staticconstexpr

Definition at line 43 of file globals.h.

kConservativeInitialMarkSpeed

constexpr intptr_t dart::kConservativeInitialMarkSpeed = 20

staticconstexpr

Definition at line 52 of file pages.cc.

kConservativeInitialScavengeSpeed

constexpr intptr_t dart::kConservativeInitialScavengeSpeed = 40

staticconstexpr

Definition at line 771 of file scavenger.cc.

kCustomIsolateScriptChars

const char* dart::kCustomIsolateScriptChars

static

Definition at line 27 of file custom_isolate_test.cc.

kD

const auto dart::kD = NewMove(4, 40)

Definition at line 23 of file catch_entry_moves_test.cc.

kDartAvailableCpuRegs

const RegList dart::kDartAvailableCpuRegs

constexpr

Initial value:

=
    kAllCpuRegistersList & ~kReservedCpuRegisters

Definition at line 670 of file constants_arm.h.

kDartFirstVolatileCpuReg

const Register dart::kDartFirstVolatileCpuReg = R0

Definition at line 542 of file constants_arm64.h.

kDartFrameFixedSize [1/5]

constexpr int dart::kDartFrameFixedSize = 4

staticconstexpr

Definition at line 36 of file stack_frame_arm.h.

kDartFrameFixedSize [2/5]

constexpr int dart::kDartFrameFixedSize = 4

staticconstexpr

Definition at line 35 of file stack_frame_arm64.h.

kDartFrameFixedSize [3/5]

constexpr int dart::kDartFrameFixedSize = 3

staticconstexpr

Definition at line 33 of file stack_frame_ia32.h.

kDartFrameFixedSize [4/5]

constexpr int dart::kDartFrameFixedSize = 4

staticconstexpr

Definition at line 35 of file stack_frame_riscv.h.

kDartFrameFixedSize [5/5]

constexpr int dart::kDartFrameFixedSize = 4

staticconstexpr

Definition at line 38 of file stack_frame_x64.h.

kDartLastVolatileCpuReg

const Register dart::kDartLastVolatileCpuReg = R14

Definition at line 543 of file constants_arm64.h.

kDartVolatileCpuRegCount

const int dart::kDartVolatileCpuRegCount = 5

Definition at line 683 of file constants_arm.h.

kDartVolatileCpuRegs

const RegList dart::kDartVolatileCpuRegs

constexpr

Initial value:

=
    kDartAvailableCpuRegs & ~kAbiPreservedCpuRegs

Definition at line 678 of file constants_arm.h.

kDartVolatileFpuRegCount

const int dart::kDartVolatileFpuRegCount = 24

Definition at line 545 of file constants_arm64.h.

kDataBitsPerByte

constexpr int8_t dart::kDataBitsPerByte = 7

staticconstexpr

Definition at line 18 of file datastream.h.

kDataMemoryBarrier

constexpr uword dart::kDataMemoryBarrier = 0xf57ff050 | 0xb

constexpr

Definition at line 1318 of file constants_arm.h.

kDefaultMaxOldGenHeapSize

const intptr_t dart::kDefaultMaxOldGenHeapSize = (kWordSize <= 4) ? 1536 : 30720

Definition at line 62 of file globals.h.

kDefaultMaxSubtypeCacheEntries

constexpr intptr_t dart::kDefaultMaxSubtypeCacheEntries

staticconstexpr

Initial value:

=
    SubtypeTestCache::MaxEntriesForCacheAllocatedFor(1000)

Definition at line 45 of file runtime_entry.cc.

kDefaultNewGenSemiMaxSize

const intptr_t dart::kDefaultNewGenSemiMaxSize = (kWordSize <= 4) ? 8 : 16

Definition at line 63 of file globals.h.

kDefaultStackAllocation

constexpr intptr_t dart::kDefaultStackAllocation = 8

staticconstexpr

Definition at line 19 of file stacktrace.cc.

kDigitRangeCount

constexpr intptr_t dart::kDigitRangeCount = ARRAY_SIZE(kDigitRanges)

staticconstexpr

Definition at line 2780 of file regexp.cc.

kDigitRanges

constexpr int32_t dart::kDigitRanges[] = {'0', '9' + 1, kRangeEndMarker}

staticconstexpr

Definition at line 2779 of file regexp.cc.

{'0', '9' + 1, kRangeEndMarker};

kDontAssertNoSafepointScope

const bool dart::kDontAssertNoSafepointScope = false

Definition at line 18 of file lockers.h.

kDoubleSize

constexpr intptr_t dart::kDoubleSize = sizeof(double)

constexpr

Definition at line 456 of file globals.h.

kE

const auto dart::kE = NewMove(5, 50)

Definition at line 24 of file catch_entry_moves_test.cc.

kElfPageSize

constexpr intptr_t dart::kElfPageSize = 16 * KB

staticconstexpr

Definition at line 31 of file elf.h.

kEndByteMarker

constexpr uint8_t dart::kEndByteMarker = (255 - kMaxDataPerByte)

staticconstexpr

Definition at line 24 of file datastream.h.

kEndUnsignedByteMarker

constexpr uint8_t dart::kEndUnsignedByteMarker

staticconstexpr

Initial value:

=
    (255 - kMaxUnsignedDataPerByte)

Definition at line 25 of file datastream.h.

kernel_snapshot

const char* dart::kernel_snapshot = nullptr

static

Definition at line 47 of file run_vm_tests.cc.

kExceptionObjectReg

const Register dart::kExceptionObjectReg = R0

constexpr

Definition at line 328 of file constants_arm.h.

kExitLinkSlotFromEntryFp [1/4]

constexpr int dart::kExitLinkSlotFromEntryFp = -28

staticconstexpr

Definition at line 58 of file stack_frame_arm.h.

kExitLinkSlotFromEntryFp [2/4]

constexpr int dart::kExitLinkSlotFromEntryFp = -23

staticconstexpr

Definition at line 57 of file stack_frame_arm64.h.

kExitLinkSlotFromEntryFp [3/4]

constexpr int dart::kExitLinkSlotFromEntryFp = -8

staticconstexpr

Definition at line 52 of file stack_frame_ia32.h.

kExitLinkSlotFromEntryFp [4/4]

constexpr int dart::kExitLinkSlotFromEntryFp = -11

staticconstexpr

Definition at line 59 of file stack_frame_x64.h.

kExponentChar

constexpr char dart::kExponentChar = 'e'

staticconstexpr

Definition at line 15 of file double_conversion.cc.

kExtLength

constexpr intptr_t dart::kExtLength = 16

staticconstexpr

Definition at line 2255 of file dart_api_impl_test.cc.

kFalseIdentityHash

constexpr intptr_t dart::kFalseIdentityHash = 1237

staticconstexpr

Definition at line 10765 of file object.h.

kFalseOffsetFromNull

constexpr intptr_t dart::kFalseOffsetFromNull

staticconstexpr

Initial value:

=
    HostObjectAlignment::kFalseOffsetFromNull

Definition at line 71 of file pointer_tagging.h.

kFastAllocationFailed

const char* dart::kFastAllocationFailed = "fast allocation failed"

Definition at line 105 of file object_graph_copy.cc.

kFfiCallerTypedDataSlotFromFp [1/5]

constexpr int dart::kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp + 1

staticconstexpr

Definition at line 79 of file stack_frame_arm.h.

kFfiCallerTypedDataSlotFromFp [2/5]

constexpr int dart::kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp

staticconstexpr

Definition at line 73 of file stack_frame_arm64.h.

kFfiCallerTypedDataSlotFromFp [3/5]

constexpr int dart::kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp

staticconstexpr

Definition at line 63 of file stack_frame_ia32.h.

kFfiCallerTypedDataSlotFromFp [4/5]

constexpr int dart::kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp

staticconstexpr

Definition at line 72 of file stack_frame_riscv.h.

kFfiCallerTypedDataSlotFromFp [5/5]

constexpr int dart::kFfiCallerTypedDataSlotFromFp = kCallerSpSlotFromFp

staticconstexpr

Definition at line 74 of file stack_frame_x64.h.

kFinalizablePersistentHandleSizeInWords

constexpr int dart::kFinalizablePersistentHandleSizeInWords

staticconstexpr

Initial value:

=
    sizeof(FinalizablePersistentHandle) / kWordSize

Definition at line 513 of file dart_api_state.h.

kFinalizablePersistentHandlesPerChunk

constexpr int dart::kFinalizablePersistentHandlesPerChunk = 64

staticconstexpr

Definition at line 515 of file dart_api_state.h.

kFinalizerTwoEntriesNumObjects

const intptr_t dart::kFinalizerTwoEntriesNumObjects = 9

Definition at line 4267 of file object_test.cc.

kFirstErrorCid

const ClassId dart::kFirstErrorCid = kErrorCid

static

Definition at line 310 of file class_id.h.

kFirstInternalOnlyCid

constexpr intptr_t dart::kFirstInternalOnlyCid = kClassCid

constexpr

Definition at line 288 of file class_id.h.

kFirstLocalSlotFromFp [1/5]

constexpr int dart::kFirstLocalSlotFromFp = -3

staticconstexpr

Definition at line 43 of file stack_frame_arm.h.

kFirstLocalSlotFromFp [2/5]

constexpr int dart::kFirstLocalSlotFromFp = -3

staticconstexpr

Definition at line 42 of file stack_frame_arm64.h.

kFirstLocalSlotFromFp [3/5]

constexpr int dart::kFirstLocalSlotFromFp = -2

staticconstexpr

Definition at line 40 of file stack_frame_ia32.h.

kFirstLocalSlotFromFp [4/5]

constexpr int dart::kFirstLocalSlotFromFp = -5

staticconstexpr

Definition at line 42 of file stack_frame_riscv.h.

kFirstLocalSlotFromFp [5/5]

constexpr int dart::kFirstLocalSlotFromFp = -3

staticconstexpr

Definition at line 45 of file stack_frame_x64.h.

kFirstObjectSlotFromFp [1/5]

constexpr int dart::kFirstObjectSlotFromFp

staticconstexpr

Initial value:

=
    -1

Definition at line 39 of file stack_frame_arm.h.

kFirstObjectSlotFromFp [2/5]

constexpr int dart::kFirstObjectSlotFromFp

staticconstexpr

Initial value:

=
    -1

Definition at line 38 of file stack_frame_arm64.h.

kFirstObjectSlotFromFp [3/5]

constexpr int dart::kFirstObjectSlotFromFp

staticconstexpr

Initial value:

=
    -1

Definition at line 36 of file stack_frame_ia32.h.

kFirstObjectSlotFromFp [4/5]

constexpr int dart::kFirstObjectSlotFromFp

staticconstexpr

Initial value:

=
    -3

Definition at line 38 of file stack_frame_riscv.h.

kFirstObjectSlotFromFp [5/5]

constexpr int dart::kFirstObjectSlotFromFp

staticconstexpr

Initial value:

=
    -1

Definition at line 41 of file stack_frame_x64.h.

kFirstReference [1/2]

constexpr intptr_t dart::kFirstReference = 1

staticconstexpr

Definition at line 286 of file app_snapshot.cc.

kFirstReference [2/2]

constexpr intptr_t dart::kFirstReference = 1

staticconstexpr

Definition at line 2688 of file message_snapshot.cc.

kFirstTypedDataCid

const ClassId dart::kFirstTypedDataCid = kTypedDataInt8ArrayCid

static

Definition at line 377 of file class_id.h.

kFloatSize

constexpr intptr_t dart::kFloatSize = sizeof(float)

constexpr

Definition at line 457 of file globals.h.

kFpuRegisterSize

const int dart::kFpuRegisterSize = 16

Definition at line 298 of file constants_arm.h.

kFpuRegistersWithoutSOverlap

const RegList dart::kFpuRegistersWithoutSOverlap

Initial value:

=
    kAllFpuRegistersList &
    ~((1 << QRegister::kNumberOfOverlappingQRegisters) - 1)

Definition at line 688 of file constants_arm.h.

kGetterPrefix

const char* const dart::kGetterPrefix = "get:"

static

Definition at line 115 of file object.cc.

kGetterPrefixLength

const intptr_t dart::kGetterPrefixLength = strlen(kGetterPrefix)

static

Definition at line 116 of file object.cc.

kHeapBaseMask

constexpr uintptr_t dart::kHeapBaseMask = 0

staticconstexpr

Definition at line 97 of file pointer_tagging.h.

kill_params

const MethodParameter* const dart::kill_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4395 of file service.cc.

                                                    {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

kIllegalPosition

constexpr intptr_t dart::kIllegalPosition = -1

staticconstexpr

Definition at line 35 of file linearscan.cc.

kInfinitySymbol

constexpr const char* dart::kInfinitySymbol = "Infinity"

staticconstexpr

Definition at line 16 of file double_conversion.cc.

kInitialSize

intptr_t dart::kInitialSize = 8

static

Definition at line 13 of file hashmap_test.cc.

kInitPrefix

const char* const dart::kInitPrefix = "init:"

static

Definition at line 119 of file object.cc.

kInitPrefixLength

const intptr_t dart::kInitPrefixLength = strlen(kInitPrefix)

static

Definition at line 120 of file object.cc.

kInt16Size

constexpr intptr_t dart::kInt16Size = 1 << kInt16SizeLog2

constexpr

Definition at line 447 of file globals.h.

kInt16SizeLog2

constexpr intptr_t dart::kInt16SizeLog2 = 1

constexpr

Definition at line 446 of file globals.h.

kInt32Size

constexpr intptr_t dart::kInt32Size = 1 << kInt32SizeLog2

constexpr

Definition at line 450 of file globals.h.

kInt32SizeLog2

constexpr intptr_t dart::kInt32SizeLog2 = 2

constexpr

Definition at line 449 of file globals.h.

kInt64Size

constexpr intptr_t dart::kInt64Size = 1 << kInt64SizeLog2

constexpr

Definition at line 453 of file globals.h.

kInt64SizeLog2

constexpr intptr_t dart::kInt64SizeLog2 = 3

constexpr

Definition at line 452 of file globals.h.

kInt8Size

constexpr intptr_t dart::kInt8Size = 1 << kInt8SizeLog2

constexpr

Definition at line 444 of file globals.h.

kInt8SizeLog2

constexpr intptr_t dart::kInt8SizeLog2 = 0

constexpr

Definition at line 443 of file globals.h.

kInterruptStackLimit

constexpr uword dart::kInterruptStackLimit = ~static_cast<uword>(0)

staticconstexpr

Definition at line 427 of file stack_frame.h.

kIntptrMax

constexpr intptr_t dart::kIntptrMax = ~kIntptrMin

constexpr

Definition at line 557 of file globals.h.

kIntptrMin

constexpr intptr_t dart::kIntptrMin = (kIntptrOne << (kBitsPerWord - 1))

constexpr

Definition at line 556 of file globals.h.

kIntptrOne

constexpr intptr_t dart::kIntptrOne = 1

constexpr

Definition at line 555 of file globals.h.

kInvalidTryIndex

constexpr intptr_t dart::kInvalidTryIndex = -1

staticconstexpr

Definition at line 17 of file code_descriptors.h.

kIsolateReloadTestLibSource

const char* dart::kIsolateReloadTestLibSource

static

Initial value:

= R"(
@pragma("vm:external-name", "Test_Reload")
external void reloadTest();
@pragma("vm:external-name", "Test_CollectNewSpace")
external void collectNewSpace();
@pragma("vm:external-name", "Test_CollectOldSpace")
external void collectOldSpace();
)"

Definition at line 222 of file unit_test.cc.

kLastErrorCid

const ClassId dart::kLastErrorCid = kUnwindErrorCid

static

Definition at line 311 of file class_id.h.

kLastFixedObjectSlotFromFp [1/5]

constexpr int dart::kLastFixedObjectSlotFromFp = -2

staticconstexpr

Definition at line 41 of file stack_frame_arm.h.

kLastFixedObjectSlotFromFp [2/5]

constexpr int dart::kLastFixedObjectSlotFromFp = -2

staticconstexpr

Definition at line 40 of file stack_frame_arm64.h.

kLastFixedObjectSlotFromFp [3/5]

constexpr int dart::kLastFixedObjectSlotFromFp = -1

staticconstexpr

Definition at line 38 of file stack_frame_ia32.h.

kLastFixedObjectSlotFromFp [4/5]

constexpr int dart::kLastFixedObjectSlotFromFp = -4

staticconstexpr

Definition at line 40 of file stack_frame_riscv.h.

kLastFixedObjectSlotFromFp [5/5]

constexpr int dart::kLastFixedObjectSlotFromFp = -2

staticconstexpr

Definition at line 43 of file stack_frame_x64.h.

kLastInternalOnlyCid

constexpr intptr_t dart::kLastInternalOnlyCid = kUnwindErrorCid

constexpr

Definition at line 289 of file class_id.h.

kLastParamSlotFromEntrySp [1/5]

constexpr int dart::kLastParamSlotFromEntrySp = 0

staticconstexpr

Definition at line 50 of file stack_frame_arm.h.

kLastParamSlotFromEntrySp [2/5]

constexpr int dart::kLastParamSlotFromEntrySp = 0

staticconstexpr

Definition at line 50 of file stack_frame_arm64.h.

kLastParamSlotFromEntrySp [3/5]

constexpr int dart::kLastParamSlotFromEntrySp = 1

staticconstexpr

Definition at line 46 of file stack_frame_ia32.h.

kLastParamSlotFromEntrySp [4/5]

constexpr int dart::kLastParamSlotFromEntrySp = 0

staticconstexpr

Definition at line 50 of file stack_frame_riscv.h.

kLastParamSlotFromEntrySp [5/5]

constexpr int dart::kLastParamSlotFromEntrySp = 1

staticconstexpr

Definition at line 53 of file stack_frame_x64.h.

kLastTypedDataCid

const ClassId dart::kLastTypedDataCid

static

Initial value:

=
    kUnmodifiableTypedDataFloat64x2ArrayViewCid

Definition at line 378 of file class_id.h.

kLength

int dart::kLength = 16

static

Definition at line 2199 of file dart_api_impl_test.cc.

kLengthMask

constexpr intptr_t dart::kLengthMask = (1 << kLengthSize) - 1

staticconstexpr

Definition at line 119 of file string.cc.

kLengthSize

constexpr intptr_t dart::kLengthSize = 11

staticconstexpr

Definition at line 118 of file string.cc.

kLineTerminatorRangeCount

constexpr intptr_t dart::kLineTerminatorRangeCount

staticconstexpr

Initial value:

=
    ARRAY_SIZE(kLineTerminatorRanges)

Definition at line 2785 of file regexp.cc.

kLineTerminatorRanges

constexpr int32_t dart::kLineTerminatorRanges[]

staticconstexpr

Initial value:

= {
    0x000A, 0x000B, 0x000D, 0x000E, 0x2028, 0x202A, kRangeEndMarker}

Definition at line 2783 of file regexp.cc.

                                                   {
    0x000A, 0x000B, 0x000D, 0x000E, 0x2028, 0x202A, kRangeEndMarker};

kList

constexpr const char* dart::kList = "List all Tests and Benchmarks"

staticconstexpr

Definition at line 44 of file run_vm_tests.cc.

kLocalHandleSizeInWords

constexpr int dart::kLocalHandleSizeInWords = sizeof(LocalHandle) / kWordSize

staticconstexpr

Definition at line 364 of file dart_api_state.h.

kLocalHandlesPerChunk

constexpr int dart::kLocalHandlesPerChunk = 64

staticconstexpr

Definition at line 365 of file dart_api_state.h.

kMarkingStackBlockSize

constexpr int dart::kMarkingStackBlockSize = 64

staticconstexpr

Definition at line 284 of file pointer_block.h.

kMaxAddrSpaceInWords

const intptr_t dart::kMaxAddrSpaceInWords

Initial value:

= kMaxAddrSpaceMB >> kWordSizeLog2
                                                             << MBLog2

Definition at line 50 of file globals.h.

kMaxAddrSpaceMB

const intptr_t dart::kMaxAddrSpaceMB = (kWordSize <= 4) ? 4096 : 268435456

Definition at line 49 of file globals.h.

kMaxAllowedSeconds

int64_t dart::kMaxAllowedSeconds = kMaxInt32

static

Definition at line 15 of file date.cc.

kMaxDataPerByte

constexpr int8_t dart::kMaxDataPerByte

staticconstexpr

Initial value:

=
    (~kMinDataPerByte & kByteMask)

Definition at line 22 of file datastream.h.

kMaxElementSizeForEfficientCopy

const intptr_t dart::kMaxElementSizeForEfficientCopy

static

Initial value:

=
    compiler::target::kWordSize

Definition at line 6957 of file il.cc.

kMaxInt

constexpr int dart::kMaxInt = INT_MAX

constexpr

Definition at line 490 of file globals.h.

kMaxInt16

constexpr int16_t dart::kMaxInt16 = 0x7FFF

constexpr

Definition at line 480 of file globals.h.

kMaxInt32

constexpr int32_t dart::kMaxInt32 = 0x7FFFFFFF

constexpr

Definition at line 483 of file globals.h.

kMaxInt64

constexpr int64_t dart::kMaxInt64 = DART_INT64_C(0x7FFFFFFFFFFFFFFF)

constexpr

Definition at line 486 of file globals.h.

kMaxInt64RepresentableAsDouble

constexpr int64_t dart::kMaxInt64RepresentableAsDouble

constexpr

Initial value:

=
    DART_INT64_C(0x7FFFFFFFFFFFFC00)

Definition at line 494 of file globals.h.

kMaxInt8

constexpr int8_t dart::kMaxInt8 = 0x7F

constexpr

Definition at line 477 of file globals.h.

kMaxLocationCount

constexpr intptr_t dart::kMaxLocationCount = 2

staticconstexpr

Definition at line 73 of file locations.h.

kMaxLookaheadForBoyerMoore

constexpr intptr_t dart::kMaxLookaheadForBoyerMoore = 8

staticconstexpr

Definition at line 34 of file regexp.cc.

kMaxPosition

constexpr intptr_t dart::kMaxPosition = 0x7FFFFFFF

staticconstexpr

Definition at line 36 of file linearscan.cc.

kMaxSamplesPerTick

constexpr intptr_t dart::kMaxSamplesPerTick = 4

staticconstexpr

Definition at line 35 of file profiler.cc.

kMaxUint

constexpr int dart::kMaxUint = UINT_MAX

constexpr

Definition at line 491 of file globals.h.

kMaxUint16

constexpr uint16_t dart::kMaxUint16 = 0xFFFF

constexpr

Definition at line 481 of file globals.h.

kMaxUint32

constexpr uint32_t dart::kMaxUint32 = 0xFFFFFFFF

constexpr

Definition at line 484 of file globals.h.

kMaxUint64

constexpr uint64_t dart::kMaxUint64 = DART_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF)

constexpr

Definition at line 487 of file globals.h.

kMaxUint8

constexpr uint8_t dart::kMaxUint8 = 0xFF

constexpr

Definition at line 478 of file globals.h.

kMaxUnsignedDataPerByte

constexpr int8_t dart::kMaxUnsignedDataPerByte = kByteMask

staticconstexpr

Definition at line 20 of file datastream.h.

kMemoryTestLength

constexpr intptr_t dart::kMemoryTestLength = 1024

staticconstexpr

Definition at line 23 of file memory_copy_test.cc.

kMicrosecondsPerMillisecond

constexpr intptr_t dart::kMicrosecondsPerMillisecond = 1000

constexpr

Definition at line 561 of file globals.h.

kMicrosecondsPerSecond

constexpr intptr_t dart::kMicrosecondsPerSecond

constexpr

Initial value:

=
    (kMicrosecondsPerMillisecond * kMillisecondsPerSecond)

Definition at line 562 of file globals.h.

kMillisecondsPerSecond

constexpr intptr_t dart::kMillisecondsPerSecond = 1000

constexpr

Definition at line 560 of file globals.h.

kMinDataPerByte

constexpr int8_t dart::kMinDataPerByte = -(1 << (kDataBitsPerByte - 1))

staticconstexpr

Definition at line 21 of file datastream.h.

kMinInt

constexpr int dart::kMinInt = INT_MIN

constexpr

Definition at line 489 of file globals.h.

kMinInt16

constexpr int16_t dart::kMinInt16 = 0x8000

constexpr

Definition at line 479 of file globals.h.

kMinInt32

constexpr int32_t dart::kMinInt32 = 0x80000000

constexpr

Definition at line 482 of file globals.h.

kMinInt64

constexpr int64_t dart::kMinInt64 = DART_INT64_C(0x8000000000000000)

constexpr

Definition at line 485 of file globals.h.

kMinInt64RepresentableAsDouble

constexpr int64_t dart::kMinInt64RepresentableAsDouble = kMinInt64

constexpr

Definition at line 493 of file globals.h.

kMinInt8

constexpr int8_t dart::kMinInt8 = 0x80

constexpr

Definition at line 476 of file globals.h.

kNanosecondsPerMicrosecond

constexpr intptr_t dart::kNanosecondsPerMicrosecond = 1000

constexpr

Definition at line 564 of file globals.h.

kNanosecondsPerMillisecond

constexpr intptr_t dart::kNanosecondsPerMillisecond

constexpr

Initial value:

=
    (kNanosecondsPerMicrosecond * kMicrosecondsPerMillisecond)

Definition at line 565 of file globals.h.

kNanosecondsPerSecond

constexpr intptr_t dart::kNanosecondsPerSecond

constexpr

Initial value:

=
    (kNanosecondsPerMicrosecond * kMicrosecondsPerSecond)

Definition at line 567 of file globals.h.

kNaNSymbol

constexpr const char* dart::kNaNSymbol = "NaN"

staticconstexpr

Definition at line 17 of file double_conversion.cc.

kNativeArgumentNativeField1Value

intptr_t dart::kNativeArgumentNativeField1Value = 30

static

Definition at line 7067 of file dart_api_impl_test.cc.

kNativeArgumentNativeField2Value

intptr_t dart::kNativeArgumentNativeField2Value = 40

static

Definition at line 7068 of file dart_api_impl_test.cc.

kNativeField1Value

constexpr intptr_t dart::kNativeField1Value = 30

staticconstexpr

Definition at line 5571 of file dart_api_impl_test.cc.

kNativeField2Value

constexpr intptr_t dart::kNativeField2Value = 40

staticconstexpr

Definition at line 5572 of file dart_api_impl_test.cc.

kNewAllocatableSize

constexpr intptr_t dart::kNewAllocatableSize = 256 * KB

staticconstexpr

Definition at line 54 of file spaces.h.

kNewObjectAlignmentOffset

constexpr intptr_t dart::kNewObjectAlignmentOffset

staticconstexpr

Initial value:

=
    HostObjectAlignment::kNewObjectAlignmentOffset

Definition at line 50 of file pointer_tagging.h.

kNewObjectBitPosition

constexpr intptr_t dart::kNewObjectBitPosition

staticconstexpr

Initial value:

=
    HostObjectAlignment::kNewObjectBitPosition

Definition at line 54 of file pointer_tagging.h.

kNoFpuRegister

const FpuRegister dart::kNoFpuRegister = kNoQRegister

Definition at line 301 of file constants_arm.h.

kNone

constexpr const char* dart::kNone = "No Test or Benchmarks"

staticconstexpr

Definition at line 43 of file run_vm_tests.cc.

kNoSafepointScope

const bool dart::kNoSafepointScope = true

Definition at line 17 of file lockers.h.

kNoVirtualRegister

constexpr intptr_t dart::kNoVirtualRegister = -1

staticconstexpr

Definition at line 33 of file linearscan.cc.

kNullIdentityHash

constexpr intptr_t dart::kNullIdentityHash = 2011

staticconstexpr

Definition at line 10763 of file object.h.

kNumberOfDartAvailableCpuRegs

constexpr int dart::kNumberOfDartAvailableCpuRegs

constexpr

Initial value:

=
    kNumberOfCpuRegisters - kNumberOfReservedCpuRegisters

Definition at line 672 of file constants_arm.h.

kNumberOfFpuRegisters

const int dart::kNumberOfFpuRegisters = kNumberOfQRegisters

Definition at line 300 of file constants_arm.h.

kNumberOfReservedCpuRegisters

constexpr intptr_t dart::kNumberOfReservedCpuRegisters

constexpr

Initial value:

=
    Utils::CountOneBits32(kReservedCpuRegisters)

Definition at line 667 of file constants_arm.h.

kNumberOfReservedFpuRegisters

constexpr intptr_t dart::kNumberOfReservedFpuRegisters = 0

constexpr

Definition at line 530 of file constants_riscv.h.

kNumberOfSavedCpuRegisters

constexpr intptr_t dart::kNumberOfSavedCpuRegisters = kNumberOfCpuRegisters

staticconstexpr

Definition at line 3512 of file runtime_entry.cc.

kNumberOfSavedFpuRegisters

constexpr intptr_t dart::kNumberOfSavedFpuRegisters = kNumberOfFpuRegisters

staticconstexpr

Definition at line 3513 of file runtime_entry.cc.

kNumTypedDataCidRemainders

const int dart::kNumTypedDataCidRemainders = kTypedDataCidRemainderUnmodifiable + 1

Definition at line 265 of file class_id.h.

kObjectAlignment

constexpr intptr_t dart::kObjectAlignment

staticconstexpr

Initial value:

=
    HostObjectAlignment::kObjectAlignment

Definition at line 56 of file pointer_tagging.h.

kObjectAlignmentLog2

constexpr intptr_t dart::kObjectAlignmentLog2

staticconstexpr

Initial value:

=
    HostObjectAlignment::kObjectAlignmentLog2

Definition at line 58 of file pointer_tagging.h.

kObjectAlignmentMask

constexpr intptr_t dart::kObjectAlignmentMask

staticconstexpr

Initial value:

=
    HostObjectAlignment::kObjectAlignmentMask

Definition at line 60 of file pointer_tagging.h.

kObjectStartAlignment

constexpr intptr_t dart::kObjectStartAlignment = 64

staticconstexpr

Definition at line 74 of file pointer_tagging.h.

kObjectStoreFieldNames

const char* const dart::kObjectStoreFieldNames[]

static

Initial value:

= {
#define DECLARE_OBJECT_STORE_FIELD(Type, Name)       
    OBJECT_STORE_FIELD_LIST(DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD)
 
}

Definition at line 7023 of file app_snapshot.cc.

                                                    {
#define DECLARE_OBJECT_STORE_FIELD(Type, Name) #Name,
    OBJECT_STORE_FIELD_LIST(DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD,
                            DECLARE_OBJECT_STORE_FIELD)
#undef DECLARE_OBJECT_STORE_FIELD
};

kOffsetOfPtr

const intptr_t dart::kOffsetOfPtr = 32

Definition at line 136 of file globals.h.

kOffsetOfRawPtr

constexpr int dart::kOffsetOfRawPtr = kWordSize

staticconstexpr

Definition at line 241 of file handles.h.

kOffsetOfRawPtrInFinalizablePersistentHandle

constexpr int dart::kOffsetOfRawPtrInFinalizablePersistentHandle = 0

staticconstexpr

Definition at line 516 of file dart_api_state.h.

kOffsetOfRawPtrInLocalHandle

constexpr int dart::kOffsetOfRawPtrInLocalHandle = 0

staticconstexpr

Definition at line 366 of file dart_api_state.h.

kOffsetOfRawPtrInPersistentHandle

constexpr int dart::kOffsetOfRawPtrInPersistentHandle = 0

staticconstexpr

Definition at line 426 of file dart_api_state.h.

kOldObjectAlignmentOffset

constexpr intptr_t dart::kOldObjectAlignmentOffset

staticconstexpr

Initial value:

=
    HostObjectAlignment::kOldObjectAlignmentOffset

Definition at line 52 of file pointer_tagging.h.

kOptExtLength

constexpr intptr_t dart::kOptExtLength = 16

staticconstexpr

Definition at line 2394 of file dart_api_impl_test.cc.

kPageCacheCapacity

constexpr intptr_t dart::kPageCacheCapacity = 8 * kWordSize

staticconstexpr

Definition at line 26 of file page.cc.

kPageMask

constexpr intptr_t dart::kPageMask = ~(kPageSize - 1)

staticconstexpr

Definition at line 29 of file page.h.

kPageSize

constexpr intptr_t dart::kPageSize = 512 * KB

staticconstexpr

Definition at line 27 of file page.h.

kPageSizeInWords

constexpr intptr_t dart::kPageSizeInWords = kPageSize / kWordSize

staticconstexpr

Definition at line 28 of file page.h.

kParamEndSlotFromFp [1/5]

constexpr int dart::kParamEndSlotFromFp = 1

staticconstexpr

Definition at line 48 of file stack_frame_arm.h.

kParamEndSlotFromFp [2/5]

constexpr int dart::kParamEndSlotFromFp = 1

staticconstexpr

Definition at line 48 of file stack_frame_arm64.h.

kParamEndSlotFromFp [3/5]

constexpr int dart::kParamEndSlotFromFp = 1

staticconstexpr

Definition at line 44 of file stack_frame_ia32.h.

kParamEndSlotFromFp [4/5]

constexpr int dart::kParamEndSlotFromFp = -1

staticconstexpr

Definition at line 48 of file stack_frame_riscv.h.

kParamEndSlotFromFp [5/5]

constexpr int dart::kParamEndSlotFromFp = 1

staticconstexpr

Definition at line 51 of file stack_frame_x64.h.

kPcMarkerSlotFromFp [1/5]

constexpr int dart::kPcMarkerSlotFromFp = -1

staticconstexpr

Definition at line 45 of file stack_frame_arm.h.

kPcMarkerSlotFromFp [2/5]

constexpr int dart::kPcMarkerSlotFromFp = -1

staticconstexpr

Definition at line 44 of file stack_frame_arm64.h.

kPcMarkerSlotFromFp [3/5]

constexpr int dart::kPcMarkerSlotFromFp = -1

staticconstexpr

Definition at line 41 of file stack_frame_ia32.h.

kPcMarkerSlotFromFp [4/5]

constexpr int dart::kPcMarkerSlotFromFp = -3

staticconstexpr

Definition at line 44 of file stack_frame_riscv.h.

kPcMarkerSlotFromFp [5/5]

constexpr int dart::kPcMarkerSlotFromFp = -1

staticconstexpr

Definition at line 47 of file stack_frame_x64.h.

kPersistentHandleSizeInWords

constexpr int dart::kPersistentHandleSizeInWords

staticconstexpr

Initial value:

=
    sizeof(PersistentHandle) / kWordSize

Definition at line 423 of file dart_api_state.h.

kPersistentHandlesPerChunk

constexpr int dart::kPersistentHandlesPerChunk = 64

staticconstexpr

Definition at line 425 of file dart_api_state.h.

kPreferredLoopAlignment

const intptr_t dart::kPreferredLoopAlignment = 1

Definition at line 1341 of file constants_arm.h.

kPromotionStackBlockSize

constexpr int dart::kPromotionStackBlockSize = 64

staticconstexpr

Definition at line 296 of file pointer_block.h.

kQuadSize

constexpr intptr_t dart::kQuadSize = 4 * kFloatSize

constexpr

Definition at line 458 of file globals.h.

kRangeEndMarker

constexpr int32_t dart::kRangeEndMarker = Utf::kMaxCodePoint + 1

staticconstexpr

Definition at line 2764 of file regexp.cc.

kReadOnlyGCBits

constexpr uword dart::kReadOnlyGCBits

staticconstexpr

Initial value:

=
    UntaggedObject::AlwaysSetBit::encode(true) |
    UntaggedObject::NotMarkedBit::encode(false) |
    UntaggedObject::OldAndNotRememberedBit::encode(true) |
    UntaggedObject::NewBit::encode(false)

Definition at line 600 of file image_snapshot.cc.

kRecordSubtypeRangeCheckScript

const char* dart::kRecordSubtypeRangeCheckScript

Initial value:

=
    R"(
      class A {}
      class B extends A {}
      class C implements A {}
      class D<T> {}
 
      getType<T>() => T;
      getRecordType1() => getType<(int, A)>();
      getRecordType2() => getType<(A, int, String)>();
      getRecordType3() => getType<(int, D)>();
 
      createObj1() => (1, B());
      createObj2() => (1, 'bye');
      createObj3() => (1, foo: B());
      createObj4() => (1, B(), 2);
      createObj5() => (C(), 2, 'hi');
      createObj6() => (D(), 2, 'hi');
      createObj7() => (3, D<int>());
      createObj8() => (D<int>(), 3);
)"

Definition at line 1229 of file type_testing_stubs_test.cc.

kRegexpOptimization

constexpr bool dart::kRegexpOptimization = true

staticconstexpr

Definition at line 31 of file regexp.cc.

kRegisterAllocationBias

constexpr int dart::kRegisterAllocationBias = 0

constexpr

Definition at line 675 of file constants_arm.h.

kReleaseShift

const intptr_t dart::kReleaseShift = 25

Definition at line 947 of file constants_riscv.h.

kReservedCpuRegisters

const RegList dart::kReservedCpuRegisters

constexpr

Initial value:

= (1 << SPREG) | (1 << FPREG) | (1 << TMP) |
                                      (1 << PP) | (1 << THR) | (1 << LR) |
                                      (1 << PC) | (1 << NOTFP)

Definition at line 664 of file constants_arm.h.

kReservedFpuRegisters

constexpr intptr_t dart::kReservedFpuRegisters = 0

constexpr

Definition at line 529 of file constants_riscv.h.

kRssSlack

constexpr int64_t dart::kRssSlack = 20 * MB

staticconstexpr

Definition at line 197 of file zone_test.cc.

kSafepointKind

const uint8_t dart::kSafepointKind

Initial value:

= UntaggedPcDescriptors::kIcCall |
                               UntaggedPcDescriptors::kUnoptStaticCall |
                               UntaggedPcDescriptors::kRuntimeCall

Definition at line 1313 of file debugger.cc.

kSavedCallerFpSlotFromFp [1/5]

constexpr int dart::kSavedCallerFpSlotFromFp = 0

staticconstexpr

Definition at line 46 of file stack_frame_arm.h.

kSavedCallerFpSlotFromFp [2/5]

constexpr int dart::kSavedCallerFpSlotFromFp = 0

staticconstexpr

Definition at line 45 of file stack_frame_arm64.h.

kSavedCallerFpSlotFromFp [3/5]

constexpr int dart::kSavedCallerFpSlotFromFp = 0

staticconstexpr

Definition at line 42 of file stack_frame_ia32.h.

kSavedCallerFpSlotFromFp [4/5]

constexpr int dart::kSavedCallerFpSlotFromFp = -2

staticconstexpr

Definition at line 45 of file stack_frame_riscv.h.

kSavedCallerFpSlotFromFp [5/5]

constexpr int dart::kSavedCallerFpSlotFromFp = 0

staticconstexpr

Definition at line 48 of file stack_frame_x64.h.

kSavedCallerPcSlotFromFp [1/5]

constexpr int dart::kSavedCallerPcSlotFromFp = 1

staticconstexpr

Definition at line 47 of file stack_frame_arm.h.

kSavedCallerPcSlotFromFp [2/5]

constexpr int dart::kSavedCallerPcSlotFromFp = 1

staticconstexpr

Definition at line 46 of file stack_frame_arm64.h.

kSavedCallerPcSlotFromFp [3/5]

constexpr int dart::kSavedCallerPcSlotFromFp = 1

staticconstexpr

Definition at line 43 of file stack_frame_ia32.h.

kSavedCallerPcSlotFromFp [4/5]

constexpr int dart::kSavedCallerPcSlotFromFp = -1

staticconstexpr

Definition at line 46 of file stack_frame_riscv.h.

kSavedCallerPcSlotFromFp [5/5]

constexpr int dart::kSavedCallerPcSlotFromFp = 1

staticconstexpr

Definition at line 49 of file stack_frame_x64.h.

kSavedCallerPpSlotFromFp [1/5]

constexpr int dart::kSavedCallerPpSlotFromFp = -2

staticconstexpr

Definition at line 44 of file stack_frame_arm.h.

kSavedCallerPpSlotFromFp [2/5]

constexpr int dart::kSavedCallerPpSlotFromFp = -2

staticconstexpr

Definition at line 43 of file stack_frame_arm64.h.

kSavedCallerPpSlotFromFp [3/5]

constexpr int dart::kSavedCallerPpSlotFromFp = kSavedCallerFpSlotFromFp

staticconstexpr

Definition at line 49 of file stack_frame_ia32.h.

kSavedCallerPpSlotFromFp [4/5]

constexpr int dart::kSavedCallerPpSlotFromFp = -4

staticconstexpr

Definition at line 43 of file stack_frame_riscv.h.

kSavedCallerPpSlotFromFp [5/5]

constexpr int dart::kSavedCallerPpSlotFromFp = -2

staticconstexpr

Definition at line 46 of file stack_frame_x64.h.

kSavedPcSlotFromSp [1/5]

constexpr int dart::kSavedPcSlotFromSp = -1

staticconstexpr

Definition at line 37 of file stack_frame_arm.h.

kSavedPcSlotFromSp [2/5]

constexpr int dart::kSavedPcSlotFromSp = -1

staticconstexpr

Definition at line 36 of file stack_frame_arm64.h.

kSavedPcSlotFromSp [3/5]

constexpr int dart::kSavedPcSlotFromSp = -1

staticconstexpr

Definition at line 34 of file stack_frame_ia32.h.

kSavedPcSlotFromSp [4/5]

constexpr int dart::kSavedPcSlotFromSp = -1

staticconstexpr

Definition at line 36 of file stack_frame_riscv.h.

kSavedPcSlotFromSp [5/5]

constexpr int dart::kSavedPcSlotFromSp = -1

staticconstexpr

Definition at line 39 of file stack_frame_x64.h.

kSegmentCacheCapacity

constexpr intptr_t dart::kSegmentCacheCapacity = 16

staticconstexpr

Definition at line 53 of file zone.cc.

kSendLength

constexpr intptr_t dart::kSendLength = 16

staticconstexpr

Definition at line 8225 of file dart_api_impl_test.cc.

kSetterPrefix

const char* const dart::kSetterPrefix = "set:"

static

Definition at line 117 of file object.cc.

kSetterPrefixLength

const intptr_t dart::kSetterPrefixLength = strlen(kSetterPrefix)

static

Definition at line 118 of file object.cc.

kShouldWriteProtectCodeByDefault

constexpr bool dart::kShouldWriteProtectCodeByDefault = false

staticconstexpr

Definition at line 20 of file code_patcher.cc.

kSignBitDouble

constexpr int64_t dart::kSignBitDouble = DART_INT64_C(0x8000000000000000)

constexpr

Definition at line 496 of file globals.h.

kSignedEnd

constexpr intptr_t dart::kSignedEnd = kMaxInt16

staticconstexpr

Definition at line 17 of file datastream_test.cc.

kSignedStart

constexpr intptr_t dart::kSignedStart = kMinInt16

staticconstexpr

Definition at line 16 of file datastream_test.cc.

kSimd128Size

constexpr intptr_t dart::kSimd128Size = sizeof(simd128_value_t)

constexpr

Definition at line 459 of file globals.h.

kSizes

const size_t dart::kSizes[]

static

Initial value:

= {
  64 * KB,
  64 * KB + 2 * kWordSize,
  64 * KB - 2 * kWordSize,
  128 * KB,
  128 * KB + 2 * kWordSize,
  128 * KB - 2 * kWordSize,
  256 * KB,
  256 * KB + 2 * kWordSize,
  256 * KB - 2 * kWordSize,
  512 * KB,
  512 * KB + 2 * kWordSize,
  512 * KB - 2 * kWordSize,
}

Definition at line 202 of file zone_test.cc.

                               {
  64 * KB,
  64 * KB + 2 * kWordSize,
  64 * KB - 2 * kWordSize,
  128 * KB,
  128 * KB + 2 * kWordSize,
  128 * KB - 2 * kWordSize,
  256 * KB,
  256 * KB + 2 * kWordSize,
  256 * KB - 2 * kWordSize,
  512 * KB,
  512 * KB + 2 * kWordSize,
  512 * KB - 2 * kWordSize,
};

kSmiBits

const intptr_t dart::kSmiBits = kBitsPerWord - 2

Definition at line 24 of file globals.h.

kSmiBits32

const intptr_t dart::kSmiBits32 = kBitsPerInt32 - 2

Definition at line 32 of file globals.h.

kSmiMax

const intptr_t dart::kSmiMax = (static_cast<intptr_t>(1) << kSmiBits) - 1

Definition at line 28 of file globals.h.

kSmiMax32

const intptr_t dart::kSmiMax32 = (static_cast<intptr_t>(1) << kSmiBits32) - 1

Definition at line 33 of file globals.h.

kSmiMin

const intptr_t dart::kSmiMin = -(static_cast<intptr_t>(1) << kSmiBits)

Definition at line 29 of file globals.h.

kSmiMin32

const intptr_t dart::kSmiMin32 = -(static_cast<intptr_t>(1) << kSmiBits32)

Definition at line 34 of file globals.h.

kSpaceRangeCount

constexpr intptr_t dart::kSpaceRangeCount = ARRAY_SIZE(kSpaceRanges)

staticconstexpr

Definition at line 2775 of file regexp.cc.

kSpaceRanges

constexpr int32_t dart::kSpaceRanges[]

staticconstexpr

Initial value:

= {
    '\t',   '\r' + 1, ' ',    ' ' + 1, 0x00A0, 0x00A1, 0x1680,
    0x1681, 0x2000,   0x200B, 0x2028,  0x202A, 0x202F, 0x2030,
    0x205F, 0x2060,   0x3000, 0x3001,  0xFEFF, 0xFF00, kRangeEndMarker}

Definition at line 2771 of file regexp.cc.

                                          {
    '\t',   '\r' + 1, ' ',    ' ' + 1, 0x00A0, 0x00A1, 0x1680,
    0x1681, 0x2000,   0x200B, 0x2028,  0x202A, 0x202F, 0x2030,
    0x205F, 0x2060,   0x3000, 0x3001,  0xFEFF, 0xFF00, kRangeEndMarker};

kStackTraceObjectReg

const Register dart::kStackTraceObjectReg = R1

constexpr

Definition at line 329 of file constants_arm.h.

kStoreBufferBlockSize

constexpr int dart::kStoreBufferBlockSize = 1024

staticconstexpr

Definition at line 263 of file pointer_block.h.

kStoreBufferWrapperSize

constexpr int dart::kStoreBufferWrapperSize = 24

constexpr

Definition at line 676 of file constants_arm.h.

kStringHashM

constexpr uint32_t dart::kStringHashM = 0x5bd1e995

staticconstexpr

Definition at line 101 of file utils.cc.

kStringHashR

constexpr int dart::kStringHashR = 24

staticconstexpr

Definition at line 102 of file utils.cc.

kSubtypeRangeCheckScript

const char* dart::kSubtypeRangeCheckScript

Definition at line 851 of file type_testing_stubs_test.cc.

kSurrogateRangeCount

constexpr intptr_t dart::kSurrogateRangeCount = ARRAY_SIZE(kSurrogateRanges)

staticconstexpr

Definition at line 2782 of file regexp.cc.

kSurrogateRanges

constexpr int32_t dart::kSurrogateRanges[] = {0xd800, 0xe000, kRangeEndMarker}

staticconstexpr

Definition at line 2781 of file regexp.cc.

{0xd800, 0xe000, kRangeEndMarker};

kTempVirtualRegister

constexpr intptr_t dart::kTempVirtualRegister = -2

staticconstexpr

Definition at line 34 of file linearscan.cc.

kTestNumNativeFields

constexpr int dart::kTestNumNativeFields = 2

staticconstexpr

Definition at line 5570 of file dart_api_impl_test.cc.

kTestPcOffset

constexpr uint32_t dart::kTestPcOffset = 0x4

staticconstexpr

Definition at line 16 of file bitmap_test.cc.

kTestResultStrings

const char* dart::kTestResultStrings[]

static

Initial value:

= {
    "fails in runtime",
    "passes in TTS",
    "passes in STC stub",
    "passes in runtime, adding new STC entry",
    "passes in runtime, no changes to max size STC",
    "passes in runtime, initial TTS stub specialization",
    "passes in runtime, TTS stub respecialized",
}

Definition at line 242 of file type_testing_stubs_test.cc.

                                          {
    "fails in runtime",
    "passes in TTS",
    "passes in STC stub",
    "passes in runtime, adding new STC entry",
    "passes in runtime, no changes to max size STC",
    "passes in runtime, initial TTS stub specialization",
    "passes in runtime, TTS stub respecialized",
};

kTestSpillSlotBitCount

constexpr intptr_t dart::kTestSpillSlotBitCount = 0

staticconstexpr

Definition at line 17 of file bitmap_test.cc.

kTrueIdentityHash

constexpr intptr_t dart::kTrueIdentityHash = 1231

staticconstexpr

Definition at line 10764 of file object.h.

kTrueOffsetFromNull

constexpr intptr_t dart::kTrueOffsetFromNull

staticconstexpr

Initial value:

=
    HostObjectAlignment::kTrueOffsetFromNull

Definition at line 69 of file pointer_tagging.h.

kTypedDataCidRemainderExternal

const int dart::kTypedDataCidRemainderExternal = 2

Definition at line 263 of file class_id.h.

kTypedDataCidRemainderInternal

const int dart::kTypedDataCidRemainderInternal = 0

Definition at line 261 of file class_id.h.

kTypedDataCidRemainderUnmodifiable

const int dart::kTypedDataCidRemainderUnmodifiable = 3

Definition at line 264 of file class_id.h.

kTypedDataCidRemainderView

const int dart::kTypedDataCidRemainderView = 1

Definition at line 262 of file class_id.h.

kUnallocatedReference [1/2]

constexpr intptr_t dart::kUnallocatedReference = -1

staticconstexpr

Definition at line 290 of file app_snapshot.cc.

kUnallocatedReference [2/2]

constexpr intptr_t dart::kUnallocatedReference = -1

staticconstexpr

Definition at line 2689 of file message_snapshot.cc.

kUnboxedAddress

constexpr Representation dart::kUnboxedAddress = kUnboxedUword

staticconstexpr

Definition at line 182 of file locations.h.

kUnboxedBool

const Representation dart::kUnboxedBool = kTagged

static

Definition at line 8267 of file il.cc.

kUnboxedIntPtr

constexpr Representation dart::kUnboxedIntPtr = kUnboxedWord

staticconstexpr

Definition at line 176 of file locations.h.

kUnboxedUword

constexpr Representation dart::kUnboxedUword

staticconstexpr

Initial value:

=
    compiler::target::kWordSize == 4 ? kUnboxedUint32 : kUnboxedInt64

Definition at line 171 of file locations.h.

kUnboxedWord

constexpr Representation dart::kUnboxedWord

staticconstexpr

Initial value:

=
    compiler::target::kWordSize == 4 ? kUnboxedInt32 : kUnboxedInt64

Definition at line 164 of file locations.h.

kUnicodeIdentity

const char* dart::kUnicodeIdentity

static

Initial value:

=
    "Invalid identity escape in Unicode pattern"

Definition at line 466 of file regexp_parser.cc.

kUnInitialized

constexpr uint8_t dart::kUnInitialized = 0xFE

staticconstexpr

Definition at line 24 of file memory_copy_test.cc.

kUnreachableReference

constexpr intptr_t dart::kUnreachableReference = 0

staticconstexpr

Definition at line 284 of file app_snapshot.cc.

kUnsetThreadLocalKey [1/6]

const ThreadLocalKey dart::kUnsetThreadLocalKey

static

Initial value:

=
    static_cast<pthread_key_t>(-1)

Definition at line 24 of file os_thread_absl.h.

kUnsetThreadLocalKey [2/6]

const ThreadLocalKey dart::kUnsetThreadLocalKey

static

Initial value:

=
    static_cast<pthread_key_t>(-1)

Definition at line 23 of file os_thread_android.h.

kUnsetThreadLocalKey [3/6]

const ThreadLocalKey dart::kUnsetThreadLocalKey

static

Initial value:

=
    static_cast<pthread_key_t>(-1)

Definition at line 24 of file os_thread_fuchsia.h.

kUnsetThreadLocalKey [4/6]

const ThreadLocalKey dart::kUnsetThreadLocalKey

static

Initial value:

=
    static_cast<pthread_key_t>(-1)

Definition at line 23 of file os_thread_linux.h.

kUnsetThreadLocalKey [5/6]

const ThreadLocalKey dart::kUnsetThreadLocalKey

static

Initial value:

=
    static_cast<pthread_key_t>(-1)

Definition at line 23 of file os_thread_macos.h.

kUnsetThreadLocalKey [6/6]

const ThreadLocalKey dart::kUnsetThreadLocalKey = TLS_OUT_OF_INDEXES

static

Definition at line 23 of file os_thread_win.h.

kUnsignedEnd

constexpr intptr_t dart::kUnsignedEnd = kMaxUint16

staticconstexpr

Definition at line 15 of file datastream_test.cc.

kUwordMax

constexpr uword dart::kUwordMax = static_cast<uword>(-1)

constexpr

Definition at line 519 of file globals.h.

kUwordOne

constexpr uword dart::kUwordOne = 1U

staticconstexpr

Definition at line 126 of file bitfield.h.

kValidPc

const uword dart::kValidPc = 0xFF

Definition at line 29 of file profiler_test.cc.

kValidTimeStamp

const int64_t dart::kValidTimeStamp = 1

Definition at line 26 of file profiler_test.cc.

kVMHandleSizeInWords

constexpr int dart::kVMHandleSizeInWords = 2

staticconstexpr

Definition at line 238 of file handles.h.

kVMHandlesPerChunk

constexpr int dart::kVMHandlesPerChunk = 63

staticconstexpr

Definition at line 240 of file handles.h.

kWordMax

constexpr word dart::kWordMax = (static_cast<uword>(1) << (kBitsPerWord - 1)) - 1

constexpr

Definition at line 518 of file globals.h.

kWordMin

constexpr word dart::kWordMin = static_cast<uword>(1) << (kBitsPerWord - 1)

constexpr

Definition at line 517 of file globals.h.

kWordRangeCount

constexpr intptr_t dart::kWordRangeCount = ARRAY_SIZE(kWordRanges)

staticconstexpr

Definition at line 2778 of file regexp.cc.

kWordRanges

constexpr int32_t dart::kWordRanges[]

staticconstexpr

Initial value:

= {
    '0', '9' + 1, 'A', 'Z' + 1, '_', '_' + 1, 'a', 'z' + 1, kRangeEndMarker}

Definition at line 2776 of file regexp.cc.

                                         {
    '0', '9' + 1, 'A', 'Z' + 1, '_', '_' + 1, 'a', 'z' + 1, kRangeEndMarker};

kWordSize

constexpr intptr_t dart::kWordSize = 1 << kWordSizeLog2

constexpr

Definition at line 509 of file globals.h.

kWordSizeLog2

constexpr intptr_t dart::kWordSizeLog2 = kInt64SizeLog2

constexpr

Definition at line 507 of file globals.h.

kWRegMask

const int64_t dart::kWRegMask = 0x00000000ffffffffL

Definition at line 483 of file constants_arm64.h.

kWRegSizeInBits

const int dart::kWRegSizeInBits = 32

Definition at line 481 of file constants_arm64.h.

kWriteBarrierObjectReg

const Register dart::kWriteBarrierObjectReg = R1

constexpr

Definition at line 332 of file constants_arm.h.

kWriteBarrierSlotReg

const Register dart::kWriteBarrierSlotReg = R9

constexpr

Definition at line 334 of file constants_arm.h.

kWriteBarrierValueReg

const Register dart::kWriteBarrierValueReg = R0

constexpr

Definition at line 333 of file constants_arm.h.

kX

const auto dart::kX = NewMove(-1, -10)

Definition at line 25 of file catch_entry_moves_test.cc.

kXRegMask

const int64_t dart::kXRegMask = 0xffffffffffffffffL

Definition at line 482 of file constants_arm64.h.

kXRegSizeInBits

const int dart::kXRegSizeInBits = 64

Definition at line 480 of file constants_arm64.h.

kZapCodeReg

constexpr uword dart::kZapCodeReg = 0xf1f1f1f1

staticconstexpr

Definition at line 258 of file stub_code_compiler.h.

kZapReturnAddress

constexpr uword dart::kZapReturnAddress = 0xe1e1e1e1

staticconstexpr

Definition at line 261 of file stub_code_compiler.h.

kZapUninitializedWord

constexpr uword dart::kZapUninitializedWord = 0xabababababababab

staticconstexpr

Definition at line 179 of file globals.h.

last_allocation_cls

const char* dart::last_allocation_cls = nullptr

static

Definition at line 10237 of file dart_api_impl_test.cc.

last_allocation_context

void* dart::last_allocation_context = nullptr

static

Definition at line 10236 of file dart_api_impl_test.cc.

lookup_package_uris_params

const MethodParameter* const dart::lookup_package_uris_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5476 of file service.cc.

                                                                   {
    ISOLATE_PARAMETER,
    nullptr,
};

lookup_resolved_package_uris_params

const MethodParameter* const dart::lookup_resolved_package_uris_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5467 of file service.cc.

                                                                            {
    ISOLATE_PARAMETER,
    nullptr,
};

loop_reset_count

bool dart::loop_reset_count = false

static

Definition at line 9900 of file dart_api_impl_test.cc.

loop_test_exit

bool dart::loop_test_exit = false

static

Definition at line 9899 of file dart_api_impl_test.cc.

loop_test_lock

Monitor* dart::loop_test_lock = new Monitor()

static

Definition at line 9898 of file dart_api_impl_test.cc.

MAX_FIRST_ARG

const unsigned int dart::MAX_FIRST_ARG = 0x7fffffu

Definition at line 14 of file regexp_bytecodes.h.

MAX_NOP_SIZE

const int dart::MAX_NOP_SIZE = 8

Definition at line 455 of file constants_ia32.h.

MB

constexpr intptr_t dart::MB = 1 << MBLog2

constexpr

Definition at line 530 of file globals.h.

MBInWords

constexpr intptr_t dart::MBInWords = 1 << MBInWordsLog2

constexpr

Definition at line 537 of file globals.h.

MBInWordsLog2

constexpr intptr_t dart::MBInWordsLog2 = KBLog2 + KBInWordsLog2

constexpr

Definition at line 536 of file globals.h.

MBLog2

constexpr intptr_t dart::MBLog2 = KBLog2 + KBLog2

constexpr

Definition at line 529 of file globals.h.

my_callback_blocking_fp_

intptr_t(* dart::my_callback_blocking_fp_) (intptr_t)

(

intptr_t

)

Definition at line 445 of file ffi_test_functions_vmspecific.cc.

my_callback_blocking_send_port_

Dart_Port dart::my_callback_blocking_send_port_

Definition at line 446 of file ffi_test_functions_vmspecific.cc.

my_callback_non_blocking_fp_

void(* dart::my_callback_non_blocking_fp_) (intptr_t)

(

intptr_t

)

Definition at line 448 of file ffi_test_functions_vmspecific.cc.

my_callback_non_blocking_send_port_

Dart_Port dart::my_callback_non_blocking_send_port_

Definition at line 449 of file ffi_test_functions_vmspecific.cc.

name

const char* const dart::name

Definition at line 324 of file method_recognizer.cc.

names

const char* const dart::names[]

static

Initial value:

= {
    
  nullptr,
#define DEFINE_SYMBOL_LITERAL(symbol, literal)         
 
 
  "",  
#define DEFINE_TOKEN_SYMBOL_INDEX(t, s, p, a)   
 
 
 
    
}

Definition at line 24 of file symbols.cc.

                                   {
    // clang-format off
  nullptr,
#define DEFINE_SYMBOL_LITERAL(symbol, literal) literal,
  PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_LITERAL)
#undef DEFINE_SYMBOL_LITERAL
  "",  // matches kTokenTableStart.
#define DEFINE_TOKEN_SYMBOL_INDEX(t, s, p, a) s,
  DART_TOKEN_LIST(DEFINE_TOKEN_SYMBOL_INDEX)
  DART_KEYWORD_LIST(DEFINE_TOKEN_SYMBOL_INDEX)
#undef DEFINE_TOKEN_SYMBOL_INDEX
    // clang-format on
};

NULL_REG

constexpr Register dart::NULL_REG = R22

constexpr

Definition at line 157 of file constants_arm64.h.

opt_data

int8_t dart::opt_data[kOptExtLength]

static

Initial value:

= {
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
}

Definition at line 2395 of file dart_api_impl_test.cc.

                                        {
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
};

PAD

const char dart::PAD = '='

static

Definition at line 37 of file base64.cc.

page_cache

VirtualMemory* dart::page_cache[kPageCacheCapacity] = {nullptr}

static

Definition at line 28 of file page.cc.

{nullptr};

page_cache_mutex

Mutex* dart::page_cache_mutex = nullptr

static

Definition at line 27 of file page.cc.

page_cache_size

intptr_t dart::page_cache_size = 0

static

Definition at line 29 of file page.cc.

pause_params

const MethodParameter* const dart::pause_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4409 of file service.cc.

                                                     {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

persistent_handle1

Dart_PersistentHandle dart::persistent_handle1

static

Definition at line 3828 of file dart_api_impl_test.cc.

platform_strong_dill

const uint8_t * dart::platform_strong_dill = kPlatformStrongDill

Definition at line 39 of file unit_test.cc.

platform_strong_dill_size

const intptr_t dart::platform_strong_dill_size = kPlatformStrongDillSize

Definition at line 40 of file unit_test.cc.

pointer_prefix

const char* dart::pointer_prefix = ""

Definition at line 20 of file memory_copy_test.cc.

PP

const Register dart::PP = R5

constexpr

Definition at line 312 of file constants_arm.h.

QTMP

const QRegister dart::QTMP = Q7

Definition at line 290 of file constants_arm.h.

[struct]

const struct { ... } dart::recognized_methods[MethodRecognizer::kNumRecognizedMethods]

Initial value:

= {
    {"", "", "Unknown", 0},
#define RECOGNIZE_METHOD(class_name, function_name, enum_name, fp)             
                                                      
 
 
}

ref_counted_resource_mutex

std::mutex dart::ref_counted_resource_mutex

Definition at line 1333 of file ffi_test_functions_vmspecific.cc.

reload

Cause GC during dart::reload

explicit

Definition at line 58 of file isolate_reload.cc.

reload_sources_params

const MethodParameter* const dart::reload_sources_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new BoolParameter("force", false),
    new BoolParameter("pause", false),
    new StringParameter("rootLibUri", false),
    new StringParameter("packagesUri", false),
    nullptr,
}

Definition at line 3831 of file service.cc.

                                                              {
    RUNNABLE_ISOLATE_PARAMETER,
    new BoolParameter("force", false),
    new BoolParameter("pause", false),
    new StringParameter("rootLibUri", false),
    new StringParameter("packagesUri", false),
    nullptr,
};

ReloadEntries

struct dart::NativeEntries dart::ReloadEntries[] = {RELOAD_NATIVE_LIST(REGISTER_FUNCTION)}

static

remove_breakpoint_params

const MethodParameter* const dart::remove_breakpoint_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4035 of file service.cc.

                                                                 {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

report_enum_names

const char* const dart::report_enum_names[]

static

Initial value:

= {
    SourceReport::kCallSitesStr,           SourceReport::kCoverageStr,
    SourceReport::kPossibleBreakpointsStr, SourceReport::kProfileStr,
    SourceReport::kBranchCoverageStr,      nullptr,
}

Definition at line 3711 of file service.cc.

                                               {
    SourceReport::kCallSitesStr,           SourceReport::kCoverageStr,
    SourceReport::kPossibleBreakpointsStr, SourceReport::kProfileStr,
    SourceReport::kBranchCoverageStr,      nullptr,
};

request_heap_snapshot_params

const MethodParameter* const dart::request_heap_snapshot_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 4590 of file service.cc.

                                                                     {
    RUNNABLE_ISOLATE_PARAMETER,
    nullptr,
};

resume_params

const MethodParameter* const dart::resume_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new EnumParameter("step", false, step_enum_names),
    new UIntParameter("frameIndex", false),
    nullptr,
}

Definition at line 4322 of file service.cc.

                                                      {
    RUNNABLE_ISOLATE_PARAMETER,
    new EnumParameter("step", false, step_enum_names),
    new UIntParameter("frameIndex", false),
    nullptr,
};

run_filter

const char* dart::run_filter = kNone

static

Definition at line 46 of file run_vm_tests.cc.

run_matches

int dart::run_matches = 0

static

Definition at line 49 of file run_vm_tests.cc.

runtime_frame_layout

FrameLayout dart::runtime_frame_layout = invalid_frame_layout

Definition at line 81 of file stack_frame.cc.

RV_B

constexpr ExtensionSet dart::RV_B = RV_Zba | RV_Zbb | RV_Zbc | RV_Zbs

staticconstexpr

Definition at line 1599 of file constants_riscv.h.

RV_G

constexpr ExtensionSet dart::RV_G = RV_I | RV_M | RV_A | RV_F | RV_D

staticconstexpr

Definition at line 1593 of file constants_riscv.h.

RV_GC

constexpr ExtensionSet dart::RV_GC = RV_G | RV_C

staticconstexpr

Definition at line 1594 of file constants_riscv.h.

RV_GCB

constexpr ExtensionSet dart::RV_GCB = RV_GC | RV_B

staticconstexpr

Definition at line 1600 of file constants_riscv.h.

saved_echo

char* dart::saved_echo = nullptr

Definition at line 240 of file custom_isolate_test.cc.

segment_cache

VirtualMemory* dart::segment_cache[kSegmentCacheCapacity] = {nullptr}

static

Definition at line 55 of file zone.cc.

{nullptr};

segment_cache_mutex

Mutex* dart::segment_cache_mutex = nullptr

static

Definition at line 54 of file zone.cc.

segment_cache_size

intptr_t dart::segment_cache_size = 0

static

Definition at line 56 of file zone.cc.

send_port_

Dart_Port dart::send_port_

Definition at line 618 of file ffi_test_functions_vmspecific.cc.

service_methods_

const ServiceMethodDescriptor dart::service_methods_[]

static

Definition at line 5847 of file service.cc.

                                                          {
  { "_echo", Echo,
    nullptr },
  { "_respondWithMalformedJson", RespondWithMalformedJson,
    nullptr },
  { "_respondWithMalformedObject", RespondWithMalformedObject,
    nullptr },
  { "_triggerEchoEvent", TriggerEchoEvent,
    nullptr },
  { "addBreakpoint", AddBreakpoint,
    add_breakpoint_params },
  { "addBreakpointWithScriptUri", AddBreakpointWithScriptUri,
    add_breakpoint_with_script_uri_params },
  { "addBreakpointAtEntry", AddBreakpointAtEntry,
    add_breakpoint_at_entry_params },
  { "_addBreakpointAtActivation", AddBreakpointAtActivation,
    add_breakpoint_at_activation_params },
  { "_buildExpressionEvaluationScope", BuildExpressionEvaluationScope,
    build_expression_evaluation_scope_params },
  { "clearCpuSamples", ClearCpuSamples,
    clear_cpu_samples_params },
  { "clearVMTimeline", ClearVMTimeline,
    clear_vm_timeline_params, },
  { "_compileExpression", CompileExpression, compile_expression_params },
  { "_enableProfiler", EnableProfiler,
    enable_profiler_params, },
  { "evaluate", Evaluate,
    evaluate_params },
  { "evaluateInFrame", EvaluateInFrame,
    evaluate_in_frame_params },
  { "_getAllocationProfile", GetAllocationProfile,
    get_allocation_profile_params },
  { "getAllocationProfile", GetAllocationProfilePublic,
    get_allocation_profile_params },
  { "getAllocationTraces", GetAllocationTraces,
      get_allocation_traces_params },
  { "getClassList", GetClassList,
    get_class_list_params },
  { "getCpuSamples", GetCpuSamples,
    get_cpu_samples_params },
  { "getFlagList", GetFlagList,
    get_flag_list_params },
  { "_getHeapMap", GetHeapMap,
    get_heap_map_params },
  { "_getImplementationFields", GetImplementationFields,
    get_implementation_fields_params },
  { "getInboundReferences", GetInboundReferences,
    get_inbound_references_params },
  { "getInstances", GetInstances,
    get_instances_params },
  { "getInstancesAsList", GetInstancesAsList,
    get_instances_as_list_params },
#if defined(SUPPORT_PERFETTO)
  { "getPerfettoCpuSamples", GetPerfettoCpuSamples,
    get_cpu_samples_params },
  { "getPerfettoVMTimeline", GetPerfettoVMTimeline,
    get_vm_timeline_params },
#endif  // defined(SUPPORT_PERFETTO)
  { "getPorts", GetPorts,
    get_ports_params },
  { "getIsolate", GetIsolate,
    get_isolate_params },
  { "_getIsolateObjectStore", GetIsolateObjectStore,
    get_isolate_object_store_params },
  { "getIsolateGroup", GetIsolateGroup,
    get_isolate_group_params },
  { "getMemoryUsage", GetMemoryUsage,
    get_memory_usage_params },
  { "getIsolateGroupMemoryUsage", GetIsolateGroupMemoryUsage,
    get_isolate_group_memory_usage_params },
  { "_getIsolateMetric", GetIsolateMetric,
    get_isolate_metric_params },
  { "_getIsolateMetricList", GetIsolateMetricList,
    get_isolate_metric_list_params },
  { "getIsolatePauseEvent", GetIsolatePauseEvent,
    get_isolate_pause_event_params },
  { "getObject", GetObject,
    get_object_params },
  { "_getObjectStore", GetObjectStore,
    get_object_store_params },
  { "_getPersistentHandles", GetPersistentHandles,
      get_persistent_handles_params, },
  { "_getPorts", GetPortsPrivate,
    get_ports_private_params },
  { "getProcessMemoryUsage", GetProcessMemoryUsage,
    get_process_memory_usage_params },
  { "_getReachableSize", GetReachableSize,
    get_reachable_size_params },
  { "_getRetainedSize", GetRetainedSize,
    get_retained_size_params },
  { "lookupResolvedPackageUris", LookupResolvedPackageUris,
    lookup_resolved_package_uris_params },
  { "lookupPackageUris", LookupPackageUris,
    lookup_package_uris_params },
  { "getRetainingPath", GetRetainingPath,
    get_retaining_path_params },
  { "getScripts", GetScripts,
    get_scripts_params },
  { "getSourceReport", GetSourceReport,
    get_source_report_params },
  { "getStack", GetStack,
    get_stack_params },
  { "_getTagProfile", GetTagProfile,
    get_tag_profile_params },
  { "_getTypeArgumentsList", GetTypeArgumentsList,
    get_type_arguments_list_params },
  { "getVersion", GetVersion,
    get_version_params },
  { "getVM", GetVM,
    get_vm_params },
  { "getVMTimeline", GetVMTimeline,
    get_vm_timeline_params },
  { "getVMTimelineFlags", GetVMTimelineFlags,
    get_vm_timeline_flags_params },
  { "getVMTimelineMicros", GetVMTimelineMicros,
    get_vm_timeline_micros_params },
  { "invoke", Invoke, invoke_params },
  { "kill", Kill, kill_params },
  { "pause", Pause,
    pause_params },
  { "removeBreakpoint", RemoveBreakpoint,
    remove_breakpoint_params },
  { "reloadSources", ReloadSources,
    reload_sources_params },
  { "_reloadSources", ReloadSources,
    reload_sources_params },
  { "resume", Resume,
    resume_params },
  { "requestHeapSnapshot", RequestHeapSnapshot,
    request_heap_snapshot_params },
  { "_evaluateCompiledExpression", EvaluateCompiledExpression,
    evaluate_compiled_expression_params },
  { "setBreakpointState", SetBreakpointState,
    set_breakpoint_state_params },
  { "setExceptionPauseMode", SetExceptionPauseMode,
    set_exception_pause_mode_params },
  { "setIsolatePauseMode", SetIsolatePauseMode,
    set_isolate_pause_mode_params },
  { "setFlag", SetFlag,
    set_flags_params },
  { "setLibraryDebuggable", SetLibraryDebuggable,
    set_library_debuggable_params },
  { "setName", SetName,
    set_name_params },
  { "_setStreamIncludePrivateMembers", SetStreamIncludePrivateMembers,
    set_stream_include_private_members_params },
  { "setTraceClassAllocation", SetTraceClassAllocation,
    set_trace_class_allocation_params },
  { "setVMName", SetVMName,
    set_vm_name_params },
  { "setVMTimelineFlags", SetVMTimelineFlags,
    set_vm_timeline_flags_params },
  { "_collectAllGarbage", CollectAllGarbage,
    collect_all_garbage_params },
  { "_getDefaultClassesAliases", GetDefaultClassesAliases,
    get_default_classes_aliases_params },
};

set_breakpoint_state_params

const MethodParameter* const dart::set_breakpoint_state_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    new IdParameter("breakpointId", true),
    new BoolParameter("enable", true),
    nullptr,
}

Definition at line 5564 of file service.cc.

                                                                    {
    ISOLATE_PARAMETER,
    new IdParameter("breakpointId", true),
    new BoolParameter("enable", true),
    nullptr,
};

set_exception_pause_mode_params

const MethodParameter* const dart::set_exception_pause_mode_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    new EnumParameter("mode", true, exception_pause_mode_names),
    nullptr,
}

Definition at line 5499 of file service.cc.

                                                                        {
    ISOLATE_PARAMETER,
    new EnumParameter("mode", true, exception_pause_mode_names),
    nullptr,
};

set_flags_params

const MethodParameter* const dart::set_flags_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    nullptr,
}

Definition at line 5602 of file service.cc.

                                                         {
    NO_ISOLATE_PARAMETER,
    nullptr,
};

set_isolate_pause_mode_params

const MethodParameter* const dart::set_isolate_pause_mode_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    new EnumParameter("exceptionPauseMode", false, exception_pause_mode_names),
    new BoolParameter("shouldPauseOnExit", false),
    nullptr,
}

Definition at line 5526 of file service.cc.

                                                                      {
    ISOLATE_PARAMETER,
    new EnumParameter("exceptionPauseMode", false, exception_pause_mode_names),
    new BoolParameter("shouldPauseOnExit", false),
    nullptr,
};

set_library_debuggable_params

const MethodParameter* const dart::set_library_debuggable_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("libraryId", true),
    new BoolParameter("isDebuggable", true),
    nullptr,
}

Definition at line 5681 of file service.cc.

                                                                      {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("libraryId", true),
    new BoolParameter("isDebuggable", true),
    nullptr,
};

set_name_params

const MethodParameter* const dart::set_name_params[]

static

Initial value:

= {
    ISOLATE_PARAMETER,
    new MethodParameter("name", true),
    nullptr,
}

Definition at line 5704 of file service.cc.

                                                        {
    ISOLATE_PARAMETER,
    new MethodParameter("name", true),
    nullptr,
};

set_stream_include_private_members_params

const MethodParameter* const dart::set_stream_include_private_members_params[]

static

Initial value:

= {
        NO_ISOLATE_PARAMETER,
        new BoolParameter("includePrivateMembers", true),
        nullptr,
}

Definition at line 1558 of file service.cc.

                                                  {
        NO_ISOLATE_PARAMETER,
        new BoolParameter("includePrivateMembers", true),
        nullptr,
};

set_trace_class_allocation_params

const MethodParameter* const dart::set_trace_class_allocation_params[]

static

Initial value:

= {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("classId", true),
    new BoolParameter("enable", true),
    nullptr,
}

Definition at line 5739 of file service.cc.

                                                                          {
    RUNNABLE_ISOLATE_PARAMETER,
    new IdParameter("classId", true),
    new BoolParameter("enable", true),
    nullptr,
};

set_vm_name_params

const MethodParameter* const dart::set_vm_name_params[]

static

Initial value:

= {
    NO_ISOLATE_PARAMETER,
    new MethodParameter("name", true),
    nullptr,
}

Definition at line 5721 of file service.cc.

                                                           {
    NO_ISOLATE_PARAMETER,
    new MethodParameter("name", true),
    nullptr,
};

shutdown_isolate_data

void* dart::shutdown_isolate_data

static

Definition at line 8507 of file dart_api_impl_test.cc.

shutdown_isolate_group_data

void* dart::shutdown_isolate_group_data

static

Definition at line 8506 of file dart_api_impl_test.cc.

simd_op_information

const SimdOpInfo dart::simd_op_information[]

static

Initial value:

= {
#define CASE(Arity, Mask, Name, Args, Result)                                  
                                                                            
 
 
}

Definition at line 8281 of file il.cc.

                                                {
#define CASE(Arity, Mask, Name, Args, Result)                                  \
  {Arity, HAS_##Mask, REP(Result), {PP_APPLY(ENCODE_INPUTS_##Arity, Args)}},
    SIMD_OP_LIST(CASE, CASE)
#undef CASE
};

simd_op_result_cids

const intptr_t dart::simd_op_result_cids[]

static

Initial value:

= {
#define kInt8Cid        
#define CASE(Arity, Mask, Name, Args, Result)                
 
 
 
}

Definition at line 1783 of file type_propagator.cc.

                                              {
#define kInt8Cid kSmiCid
#define CASE(Arity, Mask, Name, Args, Result) k##Result##Cid,
    SIMD_OP_LIST(CASE, CASE)
#undef CASE
#undef kWordCid
};

SPREG

const Register dart::SPREG = SP

constexpr

Definition at line 314 of file constants_arm.h.

step_enum_names

const char* const dart::step_enum_names[]

static

Initial value:

= {
    "None", "Into", "Over", "Out", "Rewind", "OverAsyncSuspension", nullptr,
}

Definition at line 4311 of file service.cc.

                                             {
    "None", "Into", "Over", "Out", "Rewind", "OverAsyncSuspension", nullptr,
};

step_enum_values

const Debugger::ResumeAction dart::step_enum_values[]

static

Initial value:

= {
    Debugger::kContinue,   Debugger::kStepInto,
    Debugger::kStepOver,   Debugger::kStepOut,
    Debugger::kStepRewind, Debugger::kStepOverAsyncSuspension,
    Debugger::kContinue,  
}

Definition at line 4315 of file service.cc.

                                                       {
    Debugger::kContinue,   Debugger::kStepInto,
    Debugger::kStepOver,   Debugger::kStepOut,
    Debugger::kStepRewind, Debugger::kStepOverAsyncSuspension,
    Debugger::kContinue,  // Default value
};

streams_

StreamInfo* const dart::streams_[]

static

Initial value:

= {
    &Service::vm_stream,       &Service::isolate_stream,
    &Service::debug_stream,    &Service::gc_stream,
    &Service::echo_stream,     &Service::heapsnapshot_stream,
    &Service::logging_stream,  &Service::extension_stream,
    &Service::timeline_stream, &Service::profiler_stream,
}

Definition at line 419 of file service.cc.

                                      {
    &Service::vm_stream,       &Service::isolate_stream,
    &Service::debug_stream,    &Service::gc_stream,
    &Service::echo_stream,     &Service::heapsnapshot_stream,
    &Service::logging_stream,  &Service::extension_stream,
    &Service::timeline_stream, &Service::profiler_stream,
};

symbol_id

const intptr_t dart::symbol_id

Definition at line 321 of file method_recognizer.cc.

test_libs_

MallocGrowableArray<TestLibEntry>* dart::test_libs_ = nullptr

static

Definition at line 182 of file unit_test.cc.

test_output_

const char* dart::test_output_ = nullptr

static

Definition at line 20 of file log_test.cc.

TESTING_runtime_fail_on_existing_cache_entry

bool dart::TESTING_runtime_fail_on_existing_cache_entry = false

Definition at line 7675 of file object.cc.

THR

const Register dart::THR = R10

constexpr

Definition at line 321 of file constants_arm.h.

TMP

const Register dart::TMP = IP

constexpr

Definition at line 310 of file constants_arm.h.

TMP2

const Register dart::TMP2 = kNoRegister

constexpr

Definition at line 311 of file constants_arm.h.

use_set_return

bool dart::use_set_return = false

static

Definition at line 787 of file dart_api_impl_test.cc.

use_throw_exception

bool dart::use_throw_exception = false

static

Definition at line 790 of file dart_api_impl_test.cc.

vm_name

char* dart::vm_name = nullptr

static

Definition at line 356 of file service.cc.

VTMP

const VRegister dart::VTMP = V31

Definition at line 127 of file constants_arm64.h.

weak1

Dart_WeakPersistentHandle dart::weak1 = nullptr

static

Definition at line 4513 of file dart_api_impl_test.cc.

weak2

Dart_WeakPersistentHandle dart::weak2 = nullptr

static

Definition at line 4514 of file dart_api_impl_test.cc.

weak3

Dart_WeakPersistentHandle dart::weak3 = nullptr

static

Definition at line 4515 of file dart_api_impl_test.cc.

weak_persistent_handle2

Dart_WeakPersistentHandle dart::weak_persistent_handle2

static

Definition at line 3829 of file dart_api_impl_test.cc.

weak_persistent_handle3

Dart_WeakPersistentHandle dart::weak_persistent_handle3

static

Definition at line 3830 of file dart_api_impl_test.cc.

WRITE_BARRIER_STATE

constexpr Register dart::WRITE_BARRIER_STATE = S11

constexpr

Definition at line 165 of file constants_riscv.h.

xbcde

const CatchEntryMove dart::xbcde[] = {kX, kB, kC, kD, kE}

Definition at line 29 of file catch_entry_moves_test.cc.

{kX, kB, kC, kD, kE};