diff options
Diffstat (limited to 'chromium/v8/src/builtins/base.tq')
-rw-r--r-- | chromium/v8/src/builtins/base.tq | 653 |
1 files changed, 429 insertions, 224 deletions
diff --git a/chromium/v8/src/builtins/base.tq b/chromium/v8/src/builtins/base.tq index 1b9d577f101..20c4f4b9e03 100644 --- a/chromium/v8/src/builtins/base.tq +++ b/chromium/v8/src/builtins/base.tq @@ -26,6 +26,7 @@ type AbstractCode extends HeapObject generates 'TNode<AbstractCode>'; type Code extends AbstractCode generates 'TNode<Code>'; type JSReceiver extends HeapObject generates 'TNode<JSReceiver>'; type Context extends HeapObject generates 'TNode<Context>'; +type NativeContext extends Context generates 'TNode<Context>'; type String extends HeapObject generates 'TNode<String>'; type Oddball extends HeapObject generates 'TNode<Oddball>'; type HeapNumber extends HeapObject generates 'TNode<HeapNumber>'; @@ -35,34 +36,56 @@ type Numeric = Number|BigInt; type Boolean extends Oddball generates 'TNode<Oddball>'; type JSProxy extends JSReceiver generates 'TNode<JSProxy>'; type JSObject extends JSReceiver generates 'TNode<JSObject>'; -type JSArray extends JSObject generates 'TNode<JSArray>'; +type JSArgumentsObjectWithLength extends JSObject + generates 'TNode<JSArgumentsObjectWithLength>'; +type JSArray extends JSArgumentsObjectWithLength + generates 'TNode<JSArray>'; type JSFunction extends JSObject generates 'TNode<JSFunction>'; type JSBoundFunction extends JSObject generates 'TNode<JSBoundFunction>'; type Callable = JSFunction|JSBoundFunction|JSProxy; type Map extends HeapObject generates 'TNode<Map>'; type FixedArrayBase extends HeapObject generates 'TNode<FixedArrayBase>'; type FixedArray extends FixedArrayBase generates 'TNode<FixedArray>'; -type FixedDoubleArray extends FixedArrayBase generates -'TNode<FixedDoubleArray>'; -type FixedTypedArrayBase extends FixedArrayBase generates -'TNode<FixedTypedArrayBase>'; -type FixedTypedArray extends FixedTypedArrayBase generates -'TNode<FixedTypedArray>'; -type NumberDictionary extends HeapObject generates 'TNode<NumberDictionary>'; +type FixedDoubleArray extends FixedArrayBase + generates 'TNode<FixedDoubleArray>'; +type FixedTypedArrayBase extends FixedArrayBase + generates 'TNode<FixedTypedArrayBase>'; +type FixedTypedArray extends FixedTypedArrayBase + generates 'TNode<FixedTypedArray>'; +type NumberDictionary extends HeapObject + generates 'TNode<NumberDictionary>'; + +type NativeContextSlot generates 'TNode<IntPtrT>' constexpr 'int32_t'; +const FAST_ALIASED_ARGUMENTS_MAP_INDEX: constexpr NativeContextSlot + generates 'Context::FAST_ALIASED_ARGUMENTS_MAP_INDEX'; +const SLOW_ALIASED_ARGUMENTS_MAP_INDEX: constexpr NativeContextSlot + generates 'Context::SLOW_ALIASED_ARGUMENTS_MAP_INDEX'; +const STRICT_ARGUMENTS_MAP_INDEX: constexpr NativeContextSlot + generates 'Context::STRICT_ARGUMENTS_MAP_INDEX'; +const SLOPPY_ARGUMENTS_MAP_INDEX: constexpr NativeContextSlot + generates 'Context::SLOPPY_ARGUMENTS_MAP_INDEX'; +extern operator '[]' macro LoadContextElement( + NativeContext, NativeContextSlot): Object; + +extern operator '[]' macro LoadContextElement(Context, intptr): Object; +extern operator '[]' macro LoadContextElement(Context, Smi): Object; type JSArrayBuffer extends JSObject generates 'TNode<JSArrayBuffer>'; -type JSArrayBufferView extends JSObject generates 'TNode<JSArrayBufferView>'; -type JSTypedArray extends JSArrayBufferView generates 'TNode<JSTypedArray>'; +type JSArrayBufferView extends JSObject + generates 'TNode<JSArrayBufferView>'; +type JSTypedArray extends JSArrayBufferView + generates 'TNode<JSTypedArray>'; type JSDataView extends JSArrayBufferView generates 'TNode<JSDataView>'; type InstanceType generates 'TNode<Int32T>' constexpr 'InstanceType'; type ElementsKind generates 'TNode<Int32T>' constexpr 'ElementsKind'; type LanguageMode generates 'TNode<Smi>' constexpr 'LanguageMode'; -type ExtractFixedArrayFlags generates -'TNode<Smi>' constexpr 'ExtractFixedArrayFlags'; +type ExtractFixedArrayFlags + generates 'TNode<Smi>' constexpr 'ExtractFixedArrayFlags'; type ParameterMode generates 'TNode<Int32T>' constexpr 'ParameterMode'; -type RootListIndex generates 'TNode<Int32T>' constexpr 'Heap::RootListIndex'; -type WriteBarrierMode generates 'TNode<Int32T>' constexpr 'WriteBarrierMode'; +type RootIndex generates 'TNode<Int32T>' constexpr 'RootIndex'; +type WriteBarrierMode + generates 'TNode<Int32T>' constexpr 'WriteBarrierMode'; type MessageTemplate constexpr 'MessageTemplate::Template'; @@ -70,30 +93,38 @@ type ToIntegerTruncationMode constexpr 'ToIntegerTruncationMode'; const NO_ELEMENTS: constexpr ElementsKind generates 'NO_ELEMENTS'; -const PACKED_SMI_ELEMENTS: constexpr ElementsKind generates -'PACKED_SMI_ELEMENTS'; -const HOLEY_SMI_ELEMENTS: constexpr ElementsKind generates 'HOLEY_SMI_ELEMENTS'; -const PACKED_ELEMENTS: constexpr ElementsKind generates 'PACKED_ELEMENTS'; +const PACKED_SMI_ELEMENTS: + constexpr ElementsKind generates 'PACKED_SMI_ELEMENTS'; +const HOLEY_SMI_ELEMENTS: + constexpr ElementsKind generates 'HOLEY_SMI_ELEMENTS'; +const PACKED_ELEMENTS: + constexpr ElementsKind generates 'PACKED_ELEMENTS'; const HOLEY_ELEMENTS: constexpr ElementsKind generates 'HOLEY_ELEMENTS'; -const PACKED_DOUBLE_ELEMENTS: constexpr ElementsKind generates -'PACKED_DOUBLE_ELEMENTS'; -const HOLEY_DOUBLE_ELEMENTS: constexpr ElementsKind generates -'HOLEY_DOUBLE_ELEMENTS'; -const DICTIONARY_ELEMENTS: constexpr ElementsKind generates -'DICTIONARY_ELEMENTS'; +const PACKED_DOUBLE_ELEMENTS: + constexpr ElementsKind generates 'PACKED_DOUBLE_ELEMENTS'; +const HOLEY_DOUBLE_ELEMENTS: + constexpr ElementsKind generates 'HOLEY_DOUBLE_ELEMENTS'; +const DICTIONARY_ELEMENTS: + constexpr ElementsKind generates 'DICTIONARY_ELEMENTS'; const UINT8_ELEMENTS: constexpr ElementsKind generates 'UINT8_ELEMENTS'; const INT8_ELEMENTS: constexpr ElementsKind generates 'INT8_ELEMENTS'; -const UINT16_ELEMENTS: constexpr ElementsKind generates 'UINT16_ELEMENTS'; +const UINT16_ELEMENTS: + constexpr ElementsKind generates 'UINT16_ELEMENTS'; const INT16_ELEMENTS: constexpr ElementsKind generates 'INT16_ELEMENTS'; -const UINT32_ELEMENTS: constexpr ElementsKind generates 'UINT32_ELEMENTS'; +const UINT32_ELEMENTS: + constexpr ElementsKind generates 'UINT32_ELEMENTS'; const INT32_ELEMENTS: constexpr ElementsKind generates 'INT32_ELEMENTS'; -const FLOAT32_ELEMENTS: constexpr ElementsKind generates 'FLOAT32_ELEMENTS'; -const FLOAT64_ELEMENTS: constexpr ElementsKind generates 'FLOAT64_ELEMENTS'; -const UINT8_CLAMPED_ELEMENTS: constexpr ElementsKind generates -'UINT8_CLAMPED_ELEMENTS'; -const BIGUINT64_ELEMENTS: constexpr ElementsKind generates 'BIGUINT64_ELEMENTS'; -const BIGINT64_ELEMENTS: constexpr ElementsKind generates 'BIGINT64_ELEMENTS'; +const FLOAT32_ELEMENTS: + constexpr ElementsKind generates 'FLOAT32_ELEMENTS'; +const FLOAT64_ELEMENTS: + constexpr ElementsKind generates 'FLOAT64_ELEMENTS'; +const UINT8_CLAMPED_ELEMENTS: + constexpr ElementsKind generates 'UINT8_CLAMPED_ELEMENTS'; +const BIGUINT64_ELEMENTS: + constexpr ElementsKind generates 'BIGUINT64_ELEMENTS'; +const BIGINT64_ELEMENTS: + constexpr ElementsKind generates 'BIGINT64_ELEMENTS'; type FixedUint8Array extends FixedTypedArray; type FixedInt8Array extends FixedTypedArray; @@ -107,40 +138,42 @@ type FixedUint8ClampedArray extends FixedTypedArray; type FixedBigUint64Array extends FixedTypedArray; type FixedBigInt64Array extends FixedTypedArray; -const kAllFixedArrays: constexpr ExtractFixedArrayFlags generates -'ExtractFixedArrayFlag::kAllFixedArrays'; -const kFixedArrays: constexpr ExtractFixedArrayFlags generates -'ExtractFixedArrayFlag::kFixedArrays'; - -const kFixedCOWArrayMapRootIndex: constexpr RootListIndex generates -'Heap::kFixedCOWArrayMapRootIndex'; -const kEmptyFixedArrayRootIndex: constexpr RootListIndex generates -'Heap::kEmptyFixedArrayRootIndex'; - -const kInvalidArrayLength: constexpr MessageTemplate generates -'MessageTemplate::kInvalidArrayLength'; -const kCalledNonCallable: constexpr MessageTemplate generates -'MessageTemplate::kCalledNonCallable'; -const kCalledOnNullOrUndefined: constexpr MessageTemplate generates -'MessageTemplate::kCalledOnNullOrUndefined'; +const kFixedDoubleArrays: constexpr ExtractFixedArrayFlags + generates 'ExtractFixedArrayFlag::kFixedDoubleArrays'; +const kAllFixedArrays: constexpr ExtractFixedArrayFlags + generates 'ExtractFixedArrayFlag::kAllFixedArrays'; +const kFixedArrays: constexpr ExtractFixedArrayFlags + generates 'ExtractFixedArrayFlag::kFixedArrays'; + +const kFixedCOWArrayMapRootIndex: + constexpr RootIndex generates 'RootIndex::kFixedCOWArrayMap'; +const kEmptyFixedArrayRootIndex: + constexpr RootIndex generates 'RootIndex::kEmptyFixedArray'; + +const kInvalidArrayLength: constexpr MessageTemplate + generates 'MessageTemplate::kInvalidArrayLength'; +const kCalledNonCallable: constexpr MessageTemplate + generates 'MessageTemplate::kCalledNonCallable'; +const kCalledOnNullOrUndefined: constexpr MessageTemplate + generates 'MessageTemplate::kCalledOnNullOrUndefined'; const kMaxSafeInteger: constexpr float64 generates 'kMaxSafeInteger'; -const kTruncateMinusZero: constexpr ToIntegerTruncationMode generates -'ToIntegerTruncationMode::kTruncateMinusZero'; - -const kNotTypedArray: constexpr MessageTemplate generates -'MessageTemplate::kNotTypedArray'; -const kDetachedOperation: constexpr MessageTemplate generates -'MessageTemplate::kDetachedOperation'; -const kBadSortComparisonFunction: constexpr MessageTemplate generates -'MessageTemplate::kBadSortComparisonFunction'; -const kIncompatibleMethodReceiver: constexpr MessageTemplate generates -'MessageTemplate::kIncompatibleMethodReceiver'; -const kInvalidDataViewAccessorOffset: constexpr MessageTemplate generates -'MessageTemplate::kInvalidDataViewAccessorOffset'; -const kStrictReadOnlyProperty: constexpr MessageTemplate generates -'MessageTemplate::kStrictReadOnlyProperty'; +const kTruncateMinusZero: constexpr ToIntegerTruncationMode + generates 'ToIntegerTruncationMode::kTruncateMinusZero'; + +const kNotTypedArray: constexpr MessageTemplate + generates 'MessageTemplate::kNotTypedArray'; +const kDetachedOperation: constexpr MessageTemplate + generates 'MessageTemplate::kDetachedOperation'; +const kBadSortComparisonFunction: constexpr MessageTemplate + generates 'MessageTemplate::kBadSortComparisonFunction'; +const kIncompatibleMethodReceiver: constexpr MessageTemplate + generates 'MessageTemplate::kIncompatibleMethodReceiver'; +const kInvalidDataViewAccessorOffset: constexpr MessageTemplate + generates 'MessageTemplate::kInvalidDataViewAccessorOffset'; +const kStrictReadOnlyProperty: constexpr MessageTemplate + generates 'MessageTemplate::kStrictReadOnlyProperty'; extern macro TheHoleConstant(): Oddball; extern macro NullConstant(): Oddball; @@ -149,12 +182,14 @@ extern macro TrueConstant(): Boolean; extern macro FalseConstant(): Boolean; extern macro Int32TrueConstant(): bool; extern macro Int32FalseConstant(): bool; +extern macro LengthStringConstant(): String; const Hole: Oddball = TheHoleConstant(); const Null: Oddball = NullConstant(); const Undefined: Oddball = UndefinedConstant(); const True: Boolean = TrueConstant(); const False: Boolean = FalseConstant(); +const kLengthString: String = LengthStringConstant(); const true: constexpr bool generates 'true'; const false: constexpr bool generates 'false'; @@ -163,11 +198,11 @@ const kStrict: constexpr LanguageMode generates 'LanguageMode::kStrict'; const kSloppy: constexpr LanguageMode generates 'LanguageMode::kSloppy'; const SMI_PARAMETERS: constexpr ParameterMode generates 'SMI_PARAMETERS'; -const INTPTR_PARAMETERS: constexpr ParameterMode generates 'INTPTR_PARAMETERS'; - +const INTPTR_PARAMETERS: + constexpr ParameterMode generates 'INTPTR_PARAMETERS'; -const SKIP_WRITE_BARRIER: constexpr WriteBarrierMode - generates 'SKIP_WRITE_BARRIER'; +const SKIP_WRITE_BARRIER: + constexpr WriteBarrierMode generates 'SKIP_WRITE_BARRIER'; extern macro Is64(): constexpr bool; @@ -175,6 +210,7 @@ extern macro SelectBooleanConstant(bool): Boolean; extern macro Print(constexpr string); extern macro Print(constexpr string, Object); +extern macro Comment(constexpr string); extern macro Print(Object); extern macro DebugBreak(); extern macro ToInteger_Inline(Context, Object): Number; @@ -187,14 +223,18 @@ extern macro GetProperty(Context, Object, Object): Object; extern builtin SetProperty(Context, Object, Object, Object); extern builtin DeleteProperty(Context, Object, Object, LanguageMode); extern builtin HasProperty(Context, JSReceiver, Object): Boolean; +extern macro HasProperty_Inline(Context, JSReceiver, Object): Boolean; extern macro ThrowRangeError(Context, constexpr MessageTemplate): never; extern macro ThrowTypeError(Context, constexpr MessageTemplate): never; extern macro ThrowTypeError(Context, constexpr MessageTemplate, Object): never; extern macro ThrowTypeError( Context, constexpr MessageTemplate, Object, Object, Object): never; -extern macro ArraySpeciesCreate(Context, Object, Number): Object; -extern macro EnsureArrayPushable(Map): ElementsKind labels Bailout; +extern macro ArraySpeciesCreate(Context, Object, Number): JSReceiver; +extern macro InternalArrayCreate(Context, Number): JSArray; +extern macro EnsureArrayPushable(Map): ElementsKind + labels Bailout; +extern macro EnsureArrayLengthWritable(Map) labels Bailout; extern builtin ToObject(Context, Object): JSReceiver; extern macro ToObject_Inline(Context, Object): JSReceiver; @@ -203,17 +243,19 @@ extern macro IsTheHole(Object): bool; extern macro IsString(HeapObject): bool; extern builtin ToString(Context, Object): String; -extern runtime CreateDataProperty(Context, Object, Object, Object); +extern runtime NormalizeElements(Context, JSObject); +extern runtime TransitionElementsKindWithKind(Context, JSObject, Smi); +extern runtime CreateDataProperty(Context, JSReceiver, Object, Object); -extern macro LoadRoot(constexpr RootListIndex): Object; -extern macro StoreRoot(constexpr RootListIndex, Object): Object; -extern macro LoadAndUntagToWord32Root(constexpr RootListIndex): int32; +extern macro LoadRoot(constexpr RootIndex): Object; +extern macro StoreRoot(constexpr RootIndex, Object): Object; +extern macro LoadAndUntagToWord32Root(constexpr RootIndex): int32; extern runtime StringEqual(Context, String, String): Oddball; extern builtin StringLessThan(Context, String, String): Boolean; extern macro StrictEqual(Object, Object): Boolean; -extern runtime SmiLexicographicCompare(Context, Object, Object): Number; +extern macro SmiLexicographicCompare(Smi, Smi): Smi; extern operator '<' macro Int32LessThan(int32, int32): bool; extern operator '>' macro Int32GreaterThan(int32, int32): bool; @@ -230,6 +272,10 @@ extern operator '>=' macro SmiGreaterThanOrEqual(Smi, Smi): bool; extern operator '==' macro ElementsKindEqual( constexpr ElementsKind, constexpr ElementsKind): constexpr bool; extern operator '==' macro ElementsKindEqual(ElementsKind, ElementsKind): bool; +operator '!=' macro ElementsKindNotEqual( + k1: ElementsKind, k2: ElementsKind): bool { + return !ElementsKindEqual(k1, k2); +} extern macro IsFastElementsKind(constexpr ElementsKind): constexpr bool; extern macro IsDoubleElementsKind(constexpr ElementsKind): constexpr bool; @@ -243,22 +289,25 @@ extern operator '<' macro IntPtrLessThan(intptr, intptr): bool; extern operator '>' macro IntPtrGreaterThan(intptr, intptr): bool; extern operator '<=' macro IntPtrLessThanOrEqual(intptr, intptr): bool; extern operator '>=' macro IntPtrGreaterThanOrEqual(intptr, intptr): bool; +extern operator '>' macro UintPtrGreaterThan(uintptr, uintptr): bool; extern operator '>=' macro UintPtrGreaterThanOrEqual(uintptr, uintptr): bool; extern operator '==' macro Float64Equal(float64, float64): bool; extern operator '!=' macro Float64NotEqual(float64, float64): bool; +extern operator '>' macro Float64GreaterThan(float64, float64): bool; + +extern operator '==' macro BranchIfNumberEqual(Number, Number): never + labels Taken, NotTaken; +extern operator '<' macro BranchIfNumberLessThan(Number, Number): never + labels Taken, NotTaken; +extern operator '<=' macro BranchIfNumberLessThanOrEqual(Number, Number): never + labels Taken, NotTaken; -extern operator -'<' macro BranchIfNumberLessThan(Number, Number): never labels Taken, NotTaken; -extern operator -'<=' macro BranchIfNumberLessThanOrEqual(Number, Number): never labels Taken, - NotTaken; -extern operator -'>' macro BranchIfNumberGreaterThan(Number, Number): never labels Taken, - NotTaken; +extern operator '>' macro BranchIfNumberGreaterThan(Number, Number): never + labels Taken, NotTaken; extern operator '>=' macro BranchIfNumberGreaterThanOrEqual(Number, Number): - never labels Taken, - NotTaken; + never + labels Taken, NotTaken; extern operator '==' macro WordEqual(Object, Object): bool; extern operator '!=' macro WordNotEqual(Object, Object): bool; @@ -271,6 +320,7 @@ extern operator '>>>' macro SmiShr(Smi, constexpr int31): Smi; extern operator '<<' macro SmiShl(Smi, constexpr int31): Smi; extern operator '+' macro IntPtrAdd(intptr, intptr): intptr; +extern operator '+' macro UintPtrAdd(uintptr, uintptr): uintptr; extern operator '-' macro IntPtrSub(intptr, intptr): intptr; extern operator '>>>' macro WordShr(uintptr, uintptr): uintptr; extern operator '<<' macro WordShl(intptr, intptr): intptr; @@ -296,14 +346,16 @@ extern operator '<<' macro Word32Shl(uint32, uint32): uint32; extern operator '|' macro Word32Or(int32, int32): int32; extern operator '|' macro Word32Or(uint32, uint32): uint32; +extern operator '+' macro Float64Add(float64, float64): float64; + extern operator '+' macro NumberAdd(Number, Number): Number; extern operator '-' macro NumberSub(Number, Number): Number; extern macro NumberMin(Number, Number): Number; extern macro NumberMax(Number, Number): Number; -macro min(x: Number, y: Number): Number { +macro Min(x: Number, y: Number): Number { return NumberMin(x, y); } -macro max(x: Number, y: Number): Number { +macro Max(x: Number, y: Number): Number { return NumberMax(x, y); } @@ -316,68 +368,89 @@ extern operator '!' macro IsFalse(Boolean): bool; extern operator '.map' macro LoadMap(HeapObject): Map; extern operator '.map=' macro StoreMap(HeapObject, Map); -extern operator -'.instanceType' macro LoadInstanceType(HeapObject): InstanceType; +extern operator '.instanceType' macro LoadInstanceType(HeapObject): + InstanceType; extern operator '.length' macro LoadStringLengthAsWord(String): intptr; extern operator '.length' macro GetArgumentsLength(constexpr Arguments): intptr; -extern operator -'[]' macro GetArgumentValue(constexpr Arguments, intptr): Object; +extern operator '[]' macro GetArgumentValue( + constexpr Arguments, intptr): Object; -extern operator 'is<Smi>' macro TaggedIsSmi(Object): bool; -extern operator 'isnt<Smi>' macro TaggedIsNotSmi(Object): bool; +extern macro TaggedIsSmi(Object): bool; +extern macro TaggedIsNotSmi(Object): bool; extern macro TaggedIsPositiveSmi(Object): bool; -extern macro HeapObjectToJSDataView(HeapObject): JSDataView labels CastError; -extern macro TaggedToHeapObject(Object): HeapObject labels CastError; -extern macro TaggedToSmi(Object): Smi labels CastError; -extern macro HeapObjectToJSArray(HeapObject): JSArray labels CastError; -extern macro HeapObjectToCallable(HeapObject): Callable labels CastError; -extern macro HeapObjectToFixedArray(HeapObject): - FixedArray labels CastError; -extern macro HeapObjectToFixedDoubleArray(HeapObject): - FixedDoubleArray labels CastError; -extern macro TaggedToNumber(Object): Number labels CastError; - -macro cast_HeapObject<A : type>(o : HeapObject) : A labels CastError; -cast_HeapObject<HeapObject>(o : HeapObject) : HeapObject labels CastError { return o; } -cast_HeapObject<FixedArray>(o: HeapObject): FixedArray labels CastError { +extern macro HeapObjectToJSDataView(HeapObject): JSDataView + labels CastError; +extern macro TaggedToHeapObject(Object): HeapObject + labels CastError; +extern macro TaggedToSmi(Object): Smi + labels CastError; +extern macro HeapObjectToJSArray(HeapObject): JSArray + labels CastError; +extern macro HeapObjectToCallable(HeapObject): Callable + labels CastError; +extern macro HeapObjectToFixedArray(HeapObject): FixedArray + labels CastError; +extern macro HeapObjectToFixedDoubleArray(HeapObject): FixedDoubleArray + labels CastError; +extern macro TaggedToNumber(Object): Number + labels CastError; + +macro CastHeapObject<A: type>(o: HeapObject): A + labels CastError; +CastHeapObject<HeapObject>(o: HeapObject): HeapObject + labels CastError { + return o; +} +CastHeapObject<FixedArray>(o: HeapObject): FixedArray + labels CastError { return HeapObjectToFixedArray(o) otherwise CastError; } -cast_HeapObject<FixedDoubleArray>(o: HeapObject): FixedDoubleArray labels CastError { +CastHeapObject<FixedDoubleArray>(o: HeapObject): FixedDoubleArray + labels CastError { return HeapObjectToFixedDoubleArray(o) otherwise CastError; } -cast_HeapObject<JSDataView>(o: HeapObject): JSDataView labels CastError { +CastHeapObject<JSDataView>(o: HeapObject): JSDataView + labels CastError { return HeapObjectToJSDataView(o) otherwise CastError; } -cast_HeapObject<Callable>(o: HeapObject): Callable labels CastError { +CastHeapObject<Callable>(o: HeapObject): Callable + labels CastError { return HeapObjectToCallable(o) otherwise CastError; } -cast_HeapObject<JSArray>(o: HeapObject): JSArray labels CastError { +CastHeapObject<JSArray>(o: HeapObject): JSArray + labels CastError { return HeapObjectToJSArray(o) otherwise CastError; } -macro cast<A : type>(o: HeapObject): A labels CastError { - return cast_HeapObject<A>(o) otherwise CastError; +macro Cast<A: type>(o: HeapObject): A + labels CastError { + return CastHeapObject<A>(o) otherwise CastError; } -// cast_HeapObject allows this default-implementation to be non-recursive. +// CastHeapObject allows this default-implementation to be non-recursive. // Otherwise the generated CSA code might run into infinite recursion. -macro cast<A : type>(o: Object): A labels CastError { - return cast_HeapObject<A>( - TaggedToHeapObject(o) otherwise CastError) otherwise CastError; +macro Cast<A: type>(o: Object): A + labels CastError { + return CastHeapObject<A>(TaggedToHeapObject(o) otherwise CastError) + otherwise CastError; } -cast<Smi>(o: Object): Smi labels CastError { +Cast<Smi>(o: Object): Smi + labels CastError { return TaggedToSmi(o) otherwise CastError; } -cast<Number>(o: Object): Number labels CastError { +Cast<Number>(o: Object): Number + labels CastError { return TaggedToNumber(o) otherwise CastError; } extern macro AllocateHeapNumberWithValue(float64): HeapNumber; extern macro ChangeInt32ToTagged(int32): Number; extern macro ChangeUint32ToTagged(uint32): Number; +extern macro ChangeUintPtrToFloat64(uintptr): float64; +extern macro ChangeUintPtrToTagged(uintptr): Number; extern macro Unsigned(int32): uint32; extern macro Unsigned(intptr): uintptr; extern macro Unsigned(RawPtr): uintptr; @@ -396,6 +469,8 @@ extern macro ChangeNumberToFloat64(Number): float64; extern macro ChangeFloat64ToUintPtr(float64): uintptr; extern macro ChangeInt32ToIntPtr(int32): intptr; // Sign-extends. extern macro ChangeUint32ToWord(uint32): uintptr; // Doesn't sign-extend. +extern macro LoadNativeContext(Context): NativeContext; +extern macro LoadJSArrayElementsMap(constexpr ElementsKind, Context): Map; extern macro NumberConstant(constexpr float64): Number; extern macro NumberConstant(constexpr int32): Number; @@ -409,137 +484,157 @@ extern macro BoolConstant(constexpr bool): bool; extern macro StringConstant(constexpr string): String; extern macro LanguageModeConstant(constexpr LanguageMode): LanguageMode; extern macro Int32Constant(constexpr ElementsKind): ElementsKind; +extern macro IntPtrConstant(constexpr NativeContextSlot): NativeContextSlot; -macro from_constexpr<A : type>(o: constexpr int31): A; -from_constexpr<intptr>(i: constexpr int31): intptr { +macro FromConstexpr<A: type>(o: constexpr int31): A; +FromConstexpr<intptr>(i: constexpr int31): intptr { return IntPtrConstant(i); } -from_constexpr<int31>(i: constexpr int31): int31 { +FromConstexpr<int31>(i: constexpr int31): int31 { return Int32Constant(i); } -from_constexpr<int32>(i: constexpr int31): int32 { +FromConstexpr<int32>(i: constexpr int31): int32 { return Int32Constant(i); } -from_constexpr<uint32>(i: constexpr int31): uint32 { +FromConstexpr<uint32>(i: constexpr int31): uint32 { return Unsigned(Int32Constant(i)); } -from_constexpr<uintptr>(i: constexpr int31): uintptr { +FromConstexpr<uintptr>(i: constexpr int31): uintptr { return ChangeUint32ToWord(i); } -from_constexpr<Smi>(i: constexpr int31): Smi { +FromConstexpr<Smi>(i: constexpr int31): Smi { return SmiConstant(i); } -from_constexpr<Number>(i: constexpr int31): Number { +FromConstexpr<Number>(i: constexpr int31): Number { return SmiConstant(i); } -from_constexpr<float64>(i: constexpr int31): float64 { +FromConstexpr<float64>(i: constexpr int31): float64 { return Float64Constant(i); } -macro from_constexpr<A : type>(o: constexpr int32): A; -from_constexpr<intptr>(i: constexpr int32): intptr { +macro FromConstexpr<A: type>(o: constexpr int32): A; +FromConstexpr<intptr>(i: constexpr int32): intptr { return IntPtrConstant(i); } -from_constexpr<int32>(i: constexpr int32): int32 { +FromConstexpr<int32>(i: constexpr int32): int32 { return Int32Constant(i); } -from_constexpr<Number>(i: constexpr int32): Number { +FromConstexpr<Number>(i: constexpr int32): Number { return NumberConstant(i); } -macro from_constexpr<A : type>(o: constexpr float64): A; -from_constexpr<Number>(f: constexpr float64): Number { +macro FromConstexpr<A: type>(o: constexpr float64): A; +FromConstexpr<Number>(f: constexpr float64): Number { return NumberConstant(f); } -macro from_constexpr<A : type>(b: constexpr bool): A; -from_constexpr<bool>(b: constexpr bool): bool { +macro FromConstexpr<A: type>(b: constexpr bool): A; +FromConstexpr<bool>(b: constexpr bool): bool { return BoolConstant(b); } -macro from_constexpr<A : type>(l: constexpr LanguageMode): A; -from_constexpr<LanguageMode>(b: constexpr LanguageMode): LanguageMode { +macro FromConstexpr<A: type>(l: constexpr LanguageMode): A; +FromConstexpr<LanguageMode>(b: constexpr LanguageMode): LanguageMode { return LanguageModeConstant(b); } -macro from_constexpr<A : type>(e: constexpr ElementsKind): A; -from_constexpr<ElementsKind>(e: constexpr ElementsKind): ElementsKind { +macro FromConstexpr<A: type>(e: constexpr ElementsKind): A; +FromConstexpr<ElementsKind>(e: constexpr ElementsKind): ElementsKind { return Int32Constant(e); } -macro from_constexpr<A : type>(s: constexpr string): A; -from_constexpr<String>(s: constexpr string): String { +macro FromConstexpr<A: type>(s: constexpr string): A; +FromConstexpr<String>(s: constexpr string): String { return StringConstant(s); } -from_constexpr<Object>(s: constexpr string): Object { +FromConstexpr<Object>(s: constexpr string): Object { return StringConstant(s); } +macro FromConstexpr<A: type>(e: constexpr NativeContextSlot): A; +FromConstexpr<NativeContextSlot>(c: constexpr NativeContextSlot): + NativeContextSlot { + return IntPtrConstant(c); +} -macro convert<A : type>(i: constexpr int31): A { +macro Convert<A: type>(i: constexpr int31): A { return i; } -macro convert<A : type>(i: int32): A; -convert<Number>(i: int32): Number { +extern macro ConvertElementsKindToInt(ElementsKind): int32; + +macro Convert<A: type>(elementsKind: ElementsKind): A; +Convert<int32>(elementsKind: ElementsKind): int32 { + return ConvertElementsKindToInt(elementsKind); +} + +macro Convert<A: type>(i: int32): A; +Convert<Number>(i: int32): Number { return ChangeInt32ToTagged(i); } -convert<intptr>(i: int32): intptr { +Convert<intptr>(i: int32): intptr { return ChangeInt32ToIntPtr(i); } -convert<Smi>(i: int32): Smi { +Convert<Smi>(i: int32): Smi { return SmiFromInt32(i); } -macro convert<A : type>(ui: uint32): A; -convert<Number>(ui: uint32): Number { +macro Convert<A: type>(ui: uint32): A; +Convert<Number>(ui: uint32): Number { return ChangeUint32ToTagged(ui); } -convert<Smi>(ui: uint32): Smi { +Convert<Smi>(ui: uint32): Smi { return SmiFromInt32(Signed(ui)); } -convert<uintptr>(ui: uint32): uintptr { +Convert<uintptr>(ui: uint32): uintptr { return ChangeUint32ToWord(ui); } -macro convert<A : type>(i: intptr): A; -convert<int32>(i: intptr): int32 { +macro Convert<A: type>(i: intptr): A; +Convert<int32>(i: intptr): int32 { return TruncateIntPtrToInt32(i); } -convert<Smi>(i: intptr): Smi { +Convert<Smi>(i: intptr): Smi { return SmiTag(i); } -macro convert<A : type>(ui: uintptr): A; -convert<uint32>(ui: uintptr): uint32 { +macro Convert<A: type>(ui: uintptr): A; +Convert<uint32>(ui: uintptr): uint32 { return Unsigned(TruncateIntPtrToInt32(Signed(ui))); } -macro convert<A : type>(s: Smi): A; -convert<intptr>(s: Smi): intptr { +macro Convert<A: type>(s: Smi): A; +Convert<intptr>(s: Smi): intptr { return SmiUntag(s); } -convert<int32>(s: Smi): int32 { +Convert<int32>(s: Smi): int32 { return SmiToInt32(s); } -macro convert<A : type>(h: HeapNumber): A; -convert<float64>(h: HeapNumber): float64 { +macro Convert<A: type>(h: HeapNumber): A; +Convert<float64>(h: HeapNumber): float64 { return LoadHeapNumberValue(h); } -macro convert<A : type>(n: Number): A; -convert<float64>(n: Number): float64 { +macro Convert<A: type>(n: Number): A; +Convert<float64>(n: Number): float64 { return ChangeNumberToFloat64(n); } -macro convert<A : type>(f: float32): A; -convert<float64>(f: float32): float64 { +macro Convert<A: type>(f: float32): A; +Convert<float64>(f: float32): float64 { return ChangeFloat32ToFloat64(f); } -macro convert<A : type>(d: float64): A; -convert<Number>(d: float64): Number { +macro Convert<A: type>(d: float64): A; +Convert<Number>(d: float64): Number { return AllocateHeapNumberWithValue(d); } -convert<uintptr>(d: float64): uintptr { +Convert<float64>(ui: uintptr): float64 { + return ChangeUintPtrToFloat64(ui); +} +Convert<Number>(ui: uintptr): Number { + return ChangeUintPtrToTagged(ui); +} +Convert<uintptr>(d: float64): uintptr { return ChangeFloat64ToUintPtr(d); } -macro convert<A : type>(r: RawPtr): A; -convert<uintptr>(r: RawPtr): uintptr { +macro Convert<A: type>(r: RawPtr): A; +Convert<uintptr>(r: RawPtr): uintptr { return Unsigned(r); } -convert<intptr>(r: RawPtr): intptr { +Convert<intptr>(r: RawPtr): intptr { return Signed(r); } extern macro UnsafeCastNumberToHeapNumber(Number): HeapNumber; extern macro UnsafeCastObjectToFixedArrayBase(Object): FixedArrayBase; extern macro UnsafeCastObjectToFixedArray(Object): FixedArray; +extern macro UnsafeCastObjectToContext(Object): Context; extern macro UnsafeCastObjectToFixedDoubleArray(Object): FixedDoubleArray; extern macro UnsafeCastObjectToHeapNumber(Object): HeapNumber; extern macro UnsafeCastObjectToCallable(Object): Callable; @@ -553,61 +648,109 @@ extern macro UnsafeCastObjectToJSReceiver(Object): JSReceiver; extern macro UnsafeCastObjectToJSObject(Object): JSObject; extern macro UnsafeCastObjectToMap(Object): Map; -macro unsafe_cast<A : type>(n: Number): A; -unsafe_cast<HeapNumber>(n: Number): HeapNumber { +macro UnsafeCast<A: type>(n: Number): A; +UnsafeCast<HeapNumber>(n: Number): HeapNumber { return UnsafeCastNumberToHeapNumber(n); } -macro unsafe_cast<A : type>(o: Object): A; -unsafe_cast<FixedArray>(o: Object): FixedArray { +macro UnsafeCast<A: type>(o: Object): A; +UnsafeCast<Object>(o: Object): Object { + return o; +} +UnsafeCast<FixedArray>(o: Object): FixedArray { return UnsafeCastObjectToFixedArray(o); } -unsafe_cast<FixedDoubleArray>(o: Object): FixedDoubleArray { +UnsafeCast<FixedDoubleArray>(o: Object): FixedDoubleArray { return UnsafeCastObjectToFixedDoubleArray(o); } -unsafe_cast<HeapNumber>(o: Object): HeapNumber { +UnsafeCast<HeapNumber>(o: Object): HeapNumber { return UnsafeCastObjectToHeapNumber(o); } -unsafe_cast<Callable>(o: Object): Callable { +UnsafeCast<Callable>(o: Object): Callable { return UnsafeCastObjectToCallable(o); } -unsafe_cast<Smi>(o: Object): Smi { +UnsafeCast<Smi>(o: Object): Smi { return UnsafeCastObjectToSmi(o); } -unsafe_cast<Number>(o: Object): Number { +UnsafeCast<Number>(o: Object): Number { return UnsafeCastObjectToNumber(o); } -unsafe_cast<HeapObject>(o: Object): HeapObject { +UnsafeCast<HeapObject>(o: Object): HeapObject { return UnsafeCastObjectToHeapObject(o); } -unsafe_cast<JSArray>(o: Object): JSArray { +UnsafeCast<JSArray>(o: Object): JSArray { return UnsafeCastObjectToJSArray(o); } -unsafe_cast<FixedTypedArrayBase>(o: Object): FixedTypedArrayBase { +UnsafeCast<FixedTypedArrayBase>(o: Object): FixedTypedArrayBase { return UnsafeCastObjectToFixedTypedArrayBase(o); } -unsafe_cast<NumberDictionary>(o: Object): NumberDictionary { +UnsafeCast<NumberDictionary>(o: Object): NumberDictionary { return UnsafeCastObjectToNumberDictionary(o); } -unsafe_cast<JSReceiver>(o: Object): JSReceiver { +UnsafeCast<JSReceiver>(o: Object): JSReceiver { return UnsafeCastObjectToJSReceiver(o); } -unsafe_cast<JSObject>(o: Object): JSObject { +UnsafeCast<JSObject>(o: Object): JSObject { return UnsafeCastObjectToJSObject(o); } -unsafe_cast<Map>(o: Object): Map { +UnsafeCast<Map>(o: Object): Map { return UnsafeCastObjectToMap(o); } -unsafe_cast<FixedArrayBase>(o: Object): FixedArrayBase { +UnsafeCast<FixedArrayBase>(o: Object): FixedArrayBase { return UnsafeCastObjectToFixedArrayBase(o); } +UnsafeCast<Context>(o: Object): Context { + return UnsafeCastObjectToContext(o); +} + +// RawCasts should *never* be used anywhere in Torque code except for +// in Torque-based UnsafeCast operators preceeded by an appropriate +// type check(). +extern macro RawCastObjectToJSArgumentsObjectWithLength(Object): + JSArgumentsObjectWithLength; + +macro BranchIfJSArgumentsObjectWithLength(context: Context, o: Object): never + labels True, False { + const heapObject: HeapObject = Cast<HeapObject>(o) otherwise False; + const map: Map = heapObject.map; + const nativeContext: NativeContext = LoadNativeContext(context); + if (map == nativeContext[FAST_ALIASED_ARGUMENTS_MAP_INDEX]) goto True; + if (map == nativeContext[SLOW_ALIASED_ARGUMENTS_MAP_INDEX]) goto True; + if (map == nativeContext[STRICT_ARGUMENTS_MAP_INDEX]) goto True; + if (map != nativeContext[SLOPPY_ARGUMENTS_MAP_INDEX]) goto False; + goto True; +} + +macro UnsafeCast<A: type>(context: Context, o: Object): A; +UnsafeCast<JSArgumentsObjectWithLength>( + context: Context, o: Object): JSArgumentsObjectWithLength { + assert(BranchIfJSArgumentsObjectWithLength(context, o)); + return RawCastObjectToJSArgumentsObjectWithLength(o); +} + +macro Cast<A: type>(context: Context, o: Object): A + labels CastError; +Cast<JSArgumentsObjectWithLength>(context: Context, o: Object): + JSArgumentsObjectWithLength + labels CastError { + if (BranchIfJSArgumentsObjectWithLength(context, o)) { + return UnsafeCast<JSArgumentsObjectWithLength>(context, o); + } else { + goto CastError; + } +} -const kCOWMap: Map = unsafe_cast<Map>(LoadRoot(kFixedCOWArrayMapRootIndex)); +const kCOWMap: Map = UnsafeCast<Map>(LoadRoot(kFixedCOWArrayMapRootIndex)); const kEmptyFixedArray: FixedArrayBase = - unsafe_cast<FixedArrayBase>(LoadRoot(kEmptyFixedArrayRootIndex)); + UnsafeCast<FixedArrayBase>(LoadRoot(kEmptyFixedArrayRootIndex)); -extern macro BranchIfFastJSArray(Object, Context): never labels Taken, NotTaken; -extern macro BranchIfNotFastJSArray(Object, Context): never labels Taken, - NotTaken; +extern macro BranchIfFastJSArray(Object, Context): never + labels Taken, NotTaken; +extern macro BranchIfNotFastJSArray(Object, Context): never + labels Taken, NotTaken; + +macro EnsureFastJSArray(context: Context, object: Object) labels Bailout { + if (BranchIfNotFastJSArray(object, context)) goto Bailout; +} extern macro IsPrototypeInitialArrayPrototype(Context, Map): bool; extern macro IsNoElementsProtectorCellInvalid(): bool; @@ -615,38 +758,43 @@ extern macro IsArraySpeciesProtectorCellInvalid(): bool; extern macro IsTypedArraySpeciesProtectorCellInvalid(): bool; extern macro IsPromiseSpeciesProtectorCellInvalid(): bool; -extern operator -'.buffer' macro LoadTypedArrayBuffer(JSTypedArray): JSArrayBuffer; +extern operator '.buffer' macro LoadTypedArrayBuffer(JSTypedArray): + JSArrayBuffer; extern operator '.data_ptr' macro LoadDataPtr(JSTypedArray): RawPtr; extern operator '.elements_kind' macro LoadMapElementsKind(Map): ElementsKind; -extern operator -'.elements_kind' macro LoadElementsKind(JSTypedArray): ElementsKind; +extern operator '.elements_kind' macro LoadElementsKind(JSTypedArray): + ElementsKind; extern operator '.elements' macro LoadElements(JSObject): FixedArrayBase; extern operator '.elements=' macro StoreElements(JSObject, FixedArrayBase); -extern operator '.length' macro LoadTypedArrayLength(JSTypedArray): Smi; +extern operator '.length' macro LoadJSTypedArrayLength(JSTypedArray): Smi; extern operator '.length' macro LoadJSArrayLength(JSArray): Number; +extern operator '.length' macro LoadJSArgumentsObjectWithLength( + JSArgumentsObjectWithLength): Object; extern operator '.length_fast' macro LoadFastJSArrayLength(JSArray): Smi; extern operator '.length=' macro StoreJSArrayLength(JSArray, Smi); extern operator '.length' macro LoadFixedArrayBaseLength(FixedArrayBase): Smi; extern operator '[]' macro LoadFixedArrayElement(FixedArray, intptr): Object; extern operator '[]' macro LoadFixedArrayElement(FixedArray, Smi): Object; -extern operator -'[]' macro LoadFixedArrayElement(FixedArray, constexpr int31): Object; -extern operator -'[]=' macro StoreFixedArrayElement(FixedArray, intptr, Object): void; -extern operator -'[]=' macro StoreFixedArrayElement( +extern operator '[]' macro LoadFixedArrayElement( + FixedArray, constexpr int31): Object; +extern operator '[]=' macro StoreFixedArrayElement( + FixedArray, intptr, Object): void; +extern operator '[]=' macro StoreFixedArrayElement( FixedArray, constexpr int31, Object): void; -extern operator -'[]=' macro StoreFixedArrayElementSmi(FixedArray, Smi, Object): void; +extern operator '[]=' macro StoreFixedArrayElementSmi( + FixedArray, Smi, Object): void; +operator '[]=' macro StoreFixedDoubleArrayNumber( + a: FixedDoubleArray, index: Smi, value: Number): void { + a[index] = Convert<float64>(value); +} -extern macro StoreFixedArrayElementSmi(FixedArray, Smi, Object, - constexpr WriteBarrierMode): void; +extern macro StoreFixedArrayElementSmi( + FixedArray, Smi, Object, constexpr WriteBarrierMode): void; extern operator '.instance_type' macro LoadMapInstanceType(Map): int32; @@ -660,9 +808,8 @@ macro StoreFixedDoubleArrayElementWithSmiIndex( StoreFixedDoubleArrayElement(array, index, value, SMI_PARAMETERS); } -extern macro BasicLoadNumberDictionaryElement(NumberDictionary, intptr): - Object labels NotData, - IfHole; +extern macro BasicLoadNumberDictionaryElement(NumberDictionary, intptr): Object + labels NotData, IfHole; extern macro BasicStoreNumberDictionaryElement(NumberDictionary, intptr, Object) labels NotData, IfHole, ReadOnly; @@ -672,6 +819,28 @@ extern macro IsFastSmiOrTaggedElementsKind(ElementsKind): bool; extern macro IsFastSmiElementsKind(ElementsKind): bool; extern macro IsHoleyFastElementsKind(ElementsKind): bool; +macro AllowDoubleElements(kind: ElementsKind): ElementsKind { + if (kind == PACKED_SMI_ELEMENTS) { + return PACKED_DOUBLE_ELEMENTS; + } else if (kind == HOLEY_SMI_ELEMENTS) { + return HOLEY_DOUBLE_ELEMENTS; + } + return kind; +} + +macro AllowNonNumberElements(kind: ElementsKind): ElementsKind { + if (kind == PACKED_SMI_ELEMENTS) { + return PACKED_ELEMENTS; + } else if (kind == HOLEY_SMI_ELEMENTS) { + return HOLEY_ELEMENTS; + } else if (kind == PACKED_DOUBLE_ELEMENTS) { + return PACKED_ELEMENTS; + } else if (kind == HOLEY_DOUBLE_ELEMENTS) { + return HOLEY_ELEMENTS; + } + return kind; +} + extern macro AllocateZeroedFixedArray(intptr): FixedArray; extern macro AllocateZeroedFixedDoubleArray(intptr): FixedDoubleArray; @@ -687,8 +856,12 @@ extern macro AllocateJSArray(constexpr ElementsKind, Map, Smi, Smi): JSArray; extern macro IsElementsKindGreaterThan( ElementsKind, constexpr ElementsKind): bool; +extern operator '[]=' macro StoreFixedDoubleArrayElementSmi( + FixedDoubleArray, Smi, float64): void; + extern macro LoadDoubleWithHoleCheck(FixedDoubleArray, Smi): float64 -labels IfHole; + labels IfHole; +extern macro StoreFixedDoubleArrayHoleSmi(FixedDoubleArray, Smi): void; extern macro Call(Context, Callable, Object): Object; extern macro Call(Context, Callable, Object, Object): Object; @@ -699,18 +872,21 @@ extern macro Call( extern macro Call( Context, Callable, Object, Object, Object, Object, Object, Object): Object; +extern macro ExtractFixedArray(FixedArrayBase, Smi, Smi, Smi): FixedArrayBase; extern macro ExtractFixedArray( - FixedArray, Smi, Smi, Smi, constexpr ExtractFixedArrayFlags): FixedArray; + FixedArrayBase, Smi, Smi, Smi, + constexpr ExtractFixedArrayFlags): FixedArrayBase; extern builtin ExtractFastJSArray(Context, JSArray, Smi, Smi): JSArray; -macro LoadElementNoHole<T : type>(a: JSArray, index: Smi): Object labels IfHole; +macro LoadElementNoHole<T: type>(a: JSArray, index: Smi): Object + labels IfHole; LoadElementNoHole<FixedArray>(a: JSArray, index: Smi): Object -labels IfHole { + labels IfHole { try { let elements: FixedArray = - cast<FixedArray>(a.elements) otherwise Unexpected; + Cast<FixedArray>(a.elements) otherwise Unexpected; let e: Object = elements[index]; if (e == Hole) { goto IfHole; @@ -723,10 +899,10 @@ labels IfHole { } LoadElementNoHole<FixedDoubleArray>(a: JSArray, index: Smi): Object -labels IfHole { + labels IfHole { try { let elements: FixedDoubleArray = - cast<FixedDoubleArray>(a.elements) otherwise Unexpected; + Cast<FixedDoubleArray>(a.elements) otherwise Unexpected; let e: float64 = LoadDoubleWithHoleCheck(elements, index) otherwise IfHole; return AllocateHeapNumberWithValue(e); } @@ -735,29 +911,39 @@ labels IfHole { } } +extern macro TransitionElementsKind(JSObject, Map, ElementsKind, ElementsKind): + void + labels Bailout; + extern macro IsCallable(HeapObject): bool; extern macro IsJSArray(HeapObject): bool; +extern macro IsJSReceiver(HeapObject): bool; extern macro TaggedIsCallable(Object): bool; extern macro IsDetachedBuffer(JSArrayBuffer): bool; extern macro IsHeapNumber(HeapObject): bool; extern macro IsFixedArray(HeapObject): bool; +extern macro IsNumber(Object): bool; extern macro IsExtensibleMap(Map): bool; extern macro IsCustomElementsReceiverInstanceType(int32): bool; +extern macro IsFastJSArray(Object, Context): bool; extern macro Typeof(Object): Object; +extern macro LoadTargetFromFrame(): JSFunction; // Return true iff number is NaN. macro NumberIsNaN(number: Number): bool { - typeswitch(number) { - case (Smi) { + typeswitch (number) { + case (Smi): { return false; - } case (hn : HeapNumber) { - let value: float64 = convert<float64>(hn); + } + case (hn: HeapNumber): { + let value: float64 = Convert<float64>(hn); return value != value; } } } -extern macro BranchIfToBooleanIsTrue(Object): never labels Taken, NotTaken; +extern macro BranchIfToBooleanIsTrue(Object): never + labels Taken, NotTaken; macro ToBoolean(obj: Object): bool { if (BranchIfToBooleanIsTrue(obj)) { @@ -767,7 +953,8 @@ macro ToBoolean(obj: Object): bool { } } -macro ToIndex(input: Object, context: Context): Number labels RangeError { +macro ToIndex(input: Object, context: Context): Number + labels RangeError { if (input == Undefined) { return 0; } @@ -779,3 +966,21 @@ macro ToIndex(input: Object, context: Context): Number labels RangeError { return value; } + +macro GetLengthProperty(context: Context, o: Object): Number { + try { + return (Cast<JSArray>(o) otherwise CheckArgs).length; + } + label CheckArgs { + const a: JSArgumentsObjectWithLength = + Cast<JSArgumentsObjectWithLength>(context, o) otherwise Slow; + const length: Object = a.length; + return Cast<Smi>(length) otherwise goto ToLength(length); + } + label Slow deferred { + goto ToLength(GetProperty(context, o, kLengthString)); + } + label ToLength(length: Object) deferred { + return ToLength_Inline(context, length); + } +} |