| // Copyright 2016 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef V8_CODE_STUB_ASSEMBLER_H_ |
| #define V8_CODE_STUB_ASSEMBLER_H_ |
| |
| #include <functional> |
| |
| #include "src/compiler/code-assembler.h" |
| #include "src/globals.h" |
| #include "src/objects.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| class CallInterfaceDescriptor; |
| class StatsCounter; |
| class StubCache; |
| |
| enum class PrimitiveType { kBoolean, kNumber, kString, kSymbol }; |
| |
| #define HEAP_CONSTANT_LIST(V) \ |
| V(BooleanMap, BooleanMap) \ |
| V(CodeMap, CodeMap) \ |
| V(empty_string, EmptyString) \ |
| V(EmptyFixedArray, EmptyFixedArray) \ |
| V(FalseValue, False) \ |
| V(FixedArrayMap, FixedArrayMap) \ |
| V(FixedCOWArrayMap, FixedCOWArrayMap) \ |
| V(FixedDoubleArrayMap, FixedDoubleArrayMap) \ |
| V(HeapNumberMap, HeapNumberMap) \ |
| V(MinusZeroValue, MinusZero) \ |
| V(NanValue, Nan) \ |
| V(NullValue, Null) \ |
| V(TheHoleValue, TheHole) \ |
| V(TrueValue, True) \ |
| V(UndefinedValue, Undefined) |
| |
| // Provides JavaScript-specific "macro-assembler" functionality on top of the |
| // CodeAssembler. By factoring the JavaScript-isms out of the CodeAssembler, |
| // it's possible to add JavaScript-specific useful CodeAssembler "macros" |
| // without modifying files in the compiler directory (and requiring a review |
| // from a compiler directory OWNER). |
| class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler { |
| public: |
| CodeStubAssembler(compiler::CodeAssemblerState* state) |
| : compiler::CodeAssembler(state) {} |
| |
| enum AllocationFlag : uint8_t { |
| kNone = 0, |
| kDoubleAlignment = 1, |
| kPretenured = 1 << 1 |
| }; |
| |
| typedef base::Flags<AllocationFlag> AllocationFlags; |
| |
| // TODO(ishell): Fix all loads/stores from arrays by int32 offsets/indices |
| // and eventually remove INTEGER_PARAMETERS in favour of INTPTR_PARAMETERS. |
| enum ParameterMode { INTEGER_PARAMETERS, SMI_PARAMETERS, INTPTR_PARAMETERS }; |
| |
| // On 32-bit platforms, there is a slight performance advantage to doing all |
| // of the array offset/index arithmetic with SMIs, since it's possible |
| // to save a few tag/untag operations without paying an extra expense when |
| // calculating array offset (the smi math can be folded away) and there are |
| // fewer live ranges. Thus only convert indices to untagged value on 64-bit |
| // platforms. |
| ParameterMode OptimalParameterMode() const { |
| return Is64() ? INTPTR_PARAMETERS : SMI_PARAMETERS; |
| } |
| |
| compiler::Node* UntagParameter(compiler::Node* value, ParameterMode mode) { |
| if (mode != SMI_PARAMETERS) value = SmiUntag(value); |
| return value; |
| } |
| |
| compiler::Node* TagParameter(compiler::Node* value, ParameterMode mode) { |
| if (mode != SMI_PARAMETERS) value = SmiTag(value); |
| return value; |
| } |
| |
| compiler::Node* NoContextConstant(); |
| #define HEAP_CONSTANT_ACCESSOR(rootName, name) compiler::Node* name##Constant(); |
| HEAP_CONSTANT_LIST(HEAP_CONSTANT_ACCESSOR) |
| #undef HEAP_CONSTANT_ACCESSOR |
| |
| #define HEAP_CONSTANT_TEST(rootName, name) \ |
| compiler::Node* Is##name(compiler::Node* value); |
| HEAP_CONSTANT_LIST(HEAP_CONSTANT_TEST) |
| #undef HEAP_CONSTANT_TEST |
| |
| compiler::Node* HashSeed(); |
| compiler::Node* StaleRegisterConstant(); |
| |
| compiler::Node* IntPtrOrSmiConstant(int value, ParameterMode mode); |
| |
| compiler::Node* IntPtrAddFoldConstants(compiler::Node* left, |
| compiler::Node* right); |
| compiler::Node* IntPtrSubFoldConstants(compiler::Node* left, |
| compiler::Node* right); |
| // Round the 32bits payload of the provided word up to the next power of two. |
| compiler::Node* IntPtrRoundUpToPowerOfTwo32(compiler::Node* value); |
| compiler::Node* IntPtrMax(compiler::Node* left, compiler::Node* right); |
| |
| // Float64 operations. |
| compiler::Node* Float64Ceil(compiler::Node* x); |
| compiler::Node* Float64Floor(compiler::Node* x); |
| compiler::Node* Float64Round(compiler::Node* x); |
| compiler::Node* Float64Trunc(compiler::Node* x); |
| |
| // Tag a Word as a Smi value. |
| compiler::Node* SmiTag(compiler::Node* value); |
| // Untag a Smi value as a Word. |
| compiler::Node* SmiUntag(compiler::Node* value); |
| |
| // Smi conversions. |
| compiler::Node* SmiToFloat64(compiler::Node* value); |
| compiler::Node* SmiFromWord(compiler::Node* value) { return SmiTag(value); } |
| compiler::Node* SmiFromWord32(compiler::Node* value); |
| compiler::Node* SmiToWord(compiler::Node* value) { return SmiUntag(value); } |
| compiler::Node* SmiToWord32(compiler::Node* value); |
| |
| // Smi operations. |
| compiler::Node* SmiAdd(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiSub(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiEqual(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiAbove(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiAboveOrEqual(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiBelow(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiLessThan(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiLessThanOrEqual(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiMax(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiMin(compiler::Node* a, compiler::Node* b); |
| // Computes a % b for Smi inputs a and b; result is not necessarily a Smi. |
| compiler::Node* SmiMod(compiler::Node* a, compiler::Node* b); |
| // Computes a * b for Smi inputs a and b; result is not necessarily a Smi. |
| compiler::Node* SmiMul(compiler::Node* a, compiler::Node* b); |
| compiler::Node* SmiOr(compiler::Node* a, compiler::Node* b) { |
| return BitcastWordToTaggedSigned( |
| WordOr(BitcastTaggedToWord(a), BitcastTaggedToWord(b))); |
| } |
| |
| // Smi | HeapNumber operations. |
| compiler::Node* NumberInc(compiler::Node* value); |
| |
| // Allocate an object of the given size. |
| compiler::Node* Allocate(compiler::Node* size, AllocationFlags flags = kNone); |
| compiler::Node* Allocate(int size, AllocationFlags flags = kNone); |
| compiler::Node* InnerAllocate(compiler::Node* previous, int offset); |
| compiler::Node* InnerAllocate(compiler::Node* previous, |
| compiler::Node* offset); |
| compiler::Node* IsRegularHeapObjectSize(compiler::Node* size); |
| |
| typedef std::function<compiler::Node*()> ConditionBody; |
| void Assert(ConditionBody condition_body, const char* string = nullptr, |
| const char* file = nullptr, int line = 0); |
| |
| // Check a value for smi-ness |
| compiler::Node* TaggedIsSmi(compiler::Node* a); |
| // Check that the value is a non-negative smi. |
| compiler::Node* WordIsPositiveSmi(compiler::Node* a); |
| // Check that a word has a word-aligned address. |
| compiler::Node* WordIsWordAligned(compiler::Node* word); |
| compiler::Node* WordIsPowerOfTwo(compiler::Node* value); |
| |
| void BranchIfSmiEqual(compiler::Node* a, compiler::Node* b, Label* if_true, |
| Label* if_false) { |
| Branch(SmiEqual(a, b), if_true, if_false); |
| } |
| |
| void BranchIfSmiLessThan(compiler::Node* a, compiler::Node* b, Label* if_true, |
| Label* if_false) { |
| Branch(SmiLessThan(a, b), if_true, if_false); |
| } |
| |
| void BranchIfSmiLessThanOrEqual(compiler::Node* a, compiler::Node* b, |
| Label* if_true, Label* if_false) { |
| Branch(SmiLessThanOrEqual(a, b), if_true, if_false); |
| } |
| |
| void BranchIfFloat64IsNaN(compiler::Node* value, Label* if_true, |
| Label* if_false) { |
| Branch(Float64Equal(value, value), if_false, if_true); |
| } |
| |
| // Branches to {if_true} if ToBoolean applied to {value} yields true, |
| // otherwise goes to {if_false}. |
| void BranchIfToBooleanIsTrue(compiler::Node* value, Label* if_true, |
| Label* if_false); |
| |
| void BranchIfSimd128Equal(compiler::Node* lhs, compiler::Node* lhs_map, |
| compiler::Node* rhs, compiler::Node* rhs_map, |
| Label* if_equal, Label* if_notequal); |
| void BranchIfSimd128Equal(compiler::Node* lhs, compiler::Node* rhs, |
| Label* if_equal, Label* if_notequal) { |
| BranchIfSimd128Equal(lhs, LoadMap(lhs), rhs, LoadMap(rhs), if_equal, |
| if_notequal); |
| } |
| |
| void BranchIfJSReceiver(compiler::Node* object, Label* if_true, |
| Label* if_false); |
| void BranchIfJSObject(compiler::Node* object, Label* if_true, |
| Label* if_false); |
| void BranchIfFastJSArray(compiler::Node* object, compiler::Node* context, |
| Label* if_true, Label* if_false); |
| |
| // Load value from current frame by given offset in bytes. |
| compiler::Node* LoadFromFrame(int offset, |
| MachineType rep = MachineType::AnyTagged()); |
| // Load value from current parent frame by given offset in bytes. |
| compiler::Node* LoadFromParentFrame( |
| int offset, MachineType rep = MachineType::AnyTagged()); |
| |
| // Load an object pointer from a buffer that isn't in the heap. |
| compiler::Node* LoadBufferObject(compiler::Node* buffer, int offset, |
| MachineType rep = MachineType::AnyTagged()); |
| // Load a field from an object on the heap. |
| compiler::Node* LoadObjectField(compiler::Node* object, int offset, |
| MachineType rep = MachineType::AnyTagged()); |
| compiler::Node* LoadObjectField(compiler::Node* object, |
| compiler::Node* offset, |
| MachineType rep = MachineType::AnyTagged()); |
| // Load a SMI field and untag it. |
| compiler::Node* LoadAndUntagObjectField(compiler::Node* object, int offset); |
| // Load a SMI field, untag it, and convert to Word32. |
| compiler::Node* LoadAndUntagToWord32ObjectField(compiler::Node* object, |
| int offset); |
| // Load a SMI and untag it. |
| compiler::Node* LoadAndUntagSmi(compiler::Node* base, int index); |
| // Load a SMI root, untag it, and convert to Word32. |
| compiler::Node* LoadAndUntagToWord32Root(Heap::RootListIndex root_index); |
| |
| // Load the floating point value of a HeapNumber. |
| compiler::Node* LoadHeapNumberValue(compiler::Node* object); |
| // Load the Map of an HeapObject. |
| compiler::Node* LoadMap(compiler::Node* object); |
| // Load the instance type of an HeapObject. |
| compiler::Node* LoadInstanceType(compiler::Node* object); |
| // Compare the instance the type of the object against the provided one. |
| compiler::Node* HasInstanceType(compiler::Node* object, InstanceType type); |
| // Load the properties backing store of a JSObject. |
| compiler::Node* LoadProperties(compiler::Node* object); |
| // Load the elements backing store of a JSObject. |
| compiler::Node* LoadElements(compiler::Node* object); |
| // Load the length of a JSArray instance. |
| compiler::Node* LoadJSArrayLength(compiler::Node* array); |
| // Load the length of a fixed array base instance. |
| compiler::Node* LoadFixedArrayBaseLength(compiler::Node* array); |
| // Load the length of a fixed array base instance. |
| compiler::Node* LoadAndUntagFixedArrayBaseLength(compiler::Node* array); |
| // Load the bit field of a Map. |
| compiler::Node* LoadMapBitField(compiler::Node* map); |
| // Load bit field 2 of a map. |
| compiler::Node* LoadMapBitField2(compiler::Node* map); |
| // Load bit field 3 of a map. |
| compiler::Node* LoadMapBitField3(compiler::Node* map); |
| // Load the instance type of a map. |
| compiler::Node* LoadMapInstanceType(compiler::Node* map); |
| // Load the ElementsKind of a map. |
| compiler::Node* LoadMapElementsKind(compiler::Node* map); |
| // Load the instance descriptors of a map. |
| compiler::Node* LoadMapDescriptors(compiler::Node* map); |
| // Load the prototype of a map. |
| compiler::Node* LoadMapPrototype(compiler::Node* map); |
| // Load the prototype info of a map. The result has to be checked if it is a |
| // prototype info object or not. |
| compiler::Node* LoadMapPrototypeInfo(compiler::Node* map, |
| Label* if_has_no_proto_info); |
| // Load the instance size of a Map. |
| compiler::Node* LoadMapInstanceSize(compiler::Node* map); |
| // Load the inobject properties count of a Map (valid only for JSObjects). |
| compiler::Node* LoadMapInobjectProperties(compiler::Node* map); |
| // Load the constructor function index of a Map (only for primitive maps). |
| compiler::Node* LoadMapConstructorFunctionIndex(compiler::Node* map); |
| // Load the constructor of a Map (equivalent to Map::GetConstructor()). |
| compiler::Node* LoadMapConstructor(compiler::Node* map); |
| // Check if the map is set for slow properties. |
| compiler::Node* IsDictionaryMap(compiler::Node* map); |
| |
| // Load the hash field of a name as an uint32 value. |
| compiler::Node* LoadNameHashField(compiler::Node* name); |
| // Load the hash value of a name as an uint32 value. |
| // If {if_hash_not_computed} label is specified then it also checks if |
| // hash is actually computed. |
| compiler::Node* LoadNameHash(compiler::Node* name, |
| Label* if_hash_not_computed = nullptr); |
| |
| // Load length field of a String object. |
| compiler::Node* LoadStringLength(compiler::Node* object); |
| // Load value field of a JSValue object. |
| compiler::Node* LoadJSValueValue(compiler::Node* object); |
| // Load value field of a WeakCell object. |
| compiler::Node* LoadWeakCellValueUnchecked(compiler::Node* weak_cell); |
| compiler::Node* LoadWeakCellValue(compiler::Node* weak_cell, |
| Label* if_cleared = nullptr); |
| |
| // Load an array element from a FixedArray. |
| compiler::Node* LoadFixedArrayElement( |
| compiler::Node* object, compiler::Node* index, int additional_offset = 0, |
| ParameterMode parameter_mode = INTEGER_PARAMETERS); |
| // Load an array element from a FixedArray, untag it and return it as Word32. |
| compiler::Node* LoadAndUntagToWord32FixedArrayElement( |
| compiler::Node* object, compiler::Node* index, int additional_offset = 0, |
| ParameterMode parameter_mode = INTEGER_PARAMETERS); |
| // Load an array element from a FixedDoubleArray. |
| compiler::Node* LoadFixedDoubleArrayElement( |
| compiler::Node* object, compiler::Node* index, MachineType machine_type, |
| int additional_offset = 0, |
| ParameterMode parameter_mode = INTEGER_PARAMETERS, |
| Label* if_hole = nullptr); |
| |
| // Load Float64 value by |base| + |offset| address. If the value is a double |
| // hole then jump to |if_hole|. If |machine_type| is None then only the hole |
| // check is generated. |
| compiler::Node* LoadDoubleWithHoleCheck( |
| compiler::Node* base, compiler::Node* offset, Label* if_hole, |
| MachineType machine_type = MachineType::Float64()); |
| compiler::Node* LoadFixedTypedArrayElement( |
| compiler::Node* data_pointer, compiler::Node* index_node, |
| ElementsKind elements_kind, |
| ParameterMode parameter_mode = INTEGER_PARAMETERS); |
| |
| // Context manipulation |
| compiler::Node* LoadContextElement(compiler::Node* context, int slot_index); |
| compiler::Node* LoadContextElement(compiler::Node* context, |
| compiler::Node* slot_index); |
| compiler::Node* StoreContextElement(compiler::Node* context, int slot_index, |
| compiler::Node* value); |
| compiler::Node* StoreContextElement(compiler::Node* context, |
| compiler::Node* slot_index, |
| compiler::Node* value); |
| compiler::Node* LoadNativeContext(compiler::Node* context); |
| |
| compiler::Node* LoadJSArrayElementsMap(ElementsKind kind, |
| compiler::Node* native_context); |
| |
| // Store the floating point value of a HeapNumber. |
| compiler::Node* StoreHeapNumberValue(compiler::Node* object, |
| compiler::Node* value); |
| // Store a field to an object on the heap. |
| compiler::Node* StoreObjectField( |
| compiler::Node* object, int offset, compiler::Node* value); |
| compiler::Node* StoreObjectField(compiler::Node* object, |
| compiler::Node* offset, |
| compiler::Node* value); |
| compiler::Node* StoreObjectFieldNoWriteBarrier( |
| compiler::Node* object, int offset, compiler::Node* value, |
| MachineRepresentation rep = MachineRepresentation::kTagged); |
| compiler::Node* StoreObjectFieldNoWriteBarrier( |
| compiler::Node* object, compiler::Node* offset, compiler::Node* value, |
| MachineRepresentation rep = MachineRepresentation::kTagged); |
| // Store the Map of an HeapObject. |
| compiler::Node* StoreMapNoWriteBarrier(compiler::Node* object, |
| compiler::Node* map); |
| compiler::Node* StoreObjectFieldRoot(compiler::Node* object, int offset, |
| Heap::RootListIndex root); |
| // Store an array element to a FixedArray. |
| compiler::Node* StoreFixedArrayElement( |
| compiler::Node* object, int index, compiler::Node* value, |
| WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER, |
| ParameterMode parameter_mode = INTEGER_PARAMETERS) { |
| return StoreFixedArrayElement(object, Int32Constant(index), value, |
| barrier_mode, parameter_mode); |
| } |
| |
| compiler::Node* StoreFixedArrayElement( |
| compiler::Node* object, compiler::Node* index, compiler::Node* value, |
| WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER, |
| ParameterMode parameter_mode = INTEGER_PARAMETERS); |
| |
| compiler::Node* StoreFixedDoubleArrayElement( |
| compiler::Node* object, compiler::Node* index, compiler::Node* value, |
| ParameterMode parameter_mode = INTEGER_PARAMETERS); |
| |
| void StoreFieldsNoWriteBarrier(compiler::Node* start_address, |
| compiler::Node* end_address, |
| compiler::Node* value); |
| |
| // Allocate a HeapNumber without initializing its value. |
| compiler::Node* AllocateHeapNumber(MutableMode mode = IMMUTABLE); |
| // Allocate a HeapNumber with a specific value. |
| compiler::Node* AllocateHeapNumberWithValue(compiler::Node* value, |
| MutableMode mode = IMMUTABLE); |
| // Allocate a SeqOneByteString with the given length. |
| compiler::Node* AllocateSeqOneByteString(int length, |
| AllocationFlags flags = kNone); |
| compiler::Node* AllocateSeqOneByteString( |
| compiler::Node* context, compiler::Node* length, |
| ParameterMode mode = INTPTR_PARAMETERS, AllocationFlags flags = kNone); |
| // Allocate a SeqTwoByteString with the given length. |
| compiler::Node* AllocateSeqTwoByteString(int length, |
| AllocationFlags flags = kNone); |
| compiler::Node* AllocateSeqTwoByteString( |
| compiler::Node* context, compiler::Node* length, |
| ParameterMode mode = INTPTR_PARAMETERS, AllocationFlags flags = kNone); |
| |
| // Allocate a SlicedOneByteString with the given length, parent and offset. |
| // |length| and |offset| are expected to be tagged. |
| compiler::Node* AllocateSlicedOneByteString(compiler::Node* length, |
| compiler::Node* parent, |
| compiler::Node* offset); |
| // Allocate a SlicedTwoByteString with the given length, parent and offset. |
| // |length| and |offset| are expected to be tagged. |
| compiler::Node* AllocateSlicedTwoByteString(compiler::Node* length, |
| compiler::Node* parent, |
| compiler::Node* offset); |
| |
| // Allocate a one-byte ConsString with the given length, first and second |
| // parts. |length| is expected to be tagged, and |first| and |second| are |
| // expected to be one-byte strings. |
| compiler::Node* AllocateOneByteConsString(compiler::Node* length, |
| compiler::Node* first, |
| compiler::Node* second, |
| AllocationFlags flags = kNone); |
| // Allocate a two-byte ConsString with the given length, first and second |
| // parts. |length| is expected to be tagged, and |first| and |second| are |
| // expected to be two-byte strings. |
| compiler::Node* AllocateTwoByteConsString(compiler::Node* length, |
| compiler::Node* first, |
| compiler::Node* second, |
| AllocationFlags flags = kNone); |
| |
| // Allocate an appropriate one- or two-byte ConsString with the first and |
| // second parts specified by |first| and |second|. |
| compiler::Node* NewConsString(compiler::Node* context, compiler::Node* length, |
| compiler::Node* left, compiler::Node* right, |
| AllocationFlags flags = kNone); |
| |
| // Allocate a RegExpResult with the given length (the number of captures, |
| // including the match itself), index (the index where the match starts), |
| // and input string. |length| and |index| are expected to be tagged, and |
| // |input| must be a string. |
| compiler::Node* AllocateRegExpResult(compiler::Node* context, |
| compiler::Node* length, |
| compiler::Node* index, |
| compiler::Node* input); |
| |
| compiler::Node* AllocateNameDictionary(int capacity); |
| compiler::Node* AllocateNameDictionary(compiler::Node* capacity); |
| |
| compiler::Node* AllocateJSObjectFromMap(compiler::Node* map, |
| compiler::Node* properties = nullptr, |
| compiler::Node* elements = nullptr); |
| |
| void InitializeJSObjectFromMap(compiler::Node* object, compiler::Node* map, |
| compiler::Node* size, |
| compiler::Node* properties = nullptr, |
| compiler::Node* elements = nullptr); |
| |
| void InitializeJSObjectBody(compiler::Node* object, compiler::Node* map, |
| compiler::Node* size, |
| int start_offset = JSObject::kHeaderSize); |
| |
| // Allocate a JSArray without elements and initialize the header fields. |
| compiler::Node* AllocateUninitializedJSArrayWithoutElements( |
| ElementsKind kind, compiler::Node* array_map, compiler::Node* length, |
| compiler::Node* allocation_site); |
| // Allocate and return a JSArray with initialized header fields and its |
| // uninitialized elements. |
| // The ParameterMode argument is only used for the capacity parameter. |
| std::pair<compiler::Node*, compiler::Node*> |
| AllocateUninitializedJSArrayWithElements( |
| ElementsKind kind, compiler::Node* array_map, compiler::Node* length, |
| compiler::Node* allocation_site, compiler::Node* capacity, |
| ParameterMode capacity_mode = INTEGER_PARAMETERS); |
| // Allocate a JSArray and fill elements with the hole. |
| // The ParameterMode argument is only used for the capacity parameter. |
| compiler::Node* AllocateJSArray( |
| ElementsKind kind, compiler::Node* array_map, compiler::Node* capacity, |
| compiler::Node* length, compiler::Node* allocation_site = nullptr, |
| ParameterMode capacity_mode = INTEGER_PARAMETERS); |
| |
| compiler::Node* AllocateFixedArray(ElementsKind kind, |
| compiler::Node* capacity, |
| ParameterMode mode = INTEGER_PARAMETERS, |
| AllocationFlags flags = kNone); |
| |
| // Perform CreateArrayIterator (ES6 #sec-createarrayiterator). |
| compiler::Node* CreateArrayIterator(compiler::Node* array, |
| compiler::Node* array_map, |
| compiler::Node* array_type, |
| compiler::Node* context, |
| IterationKind mode); |
| |
| compiler::Node* AllocateJSArrayIterator(compiler::Node* array, |
| compiler::Node* array_map, |
| compiler::Node* map); |
| |
| void FillFixedArrayWithValue(ElementsKind kind, compiler::Node* array, |
| compiler::Node* from_index, |
| compiler::Node* to_index, |
| Heap::RootListIndex value_root_index, |
| ParameterMode mode = INTEGER_PARAMETERS); |
| |
| // Copies all elements from |from_array| of |length| size to |
| // |to_array| of the same size respecting the elements kind. |
| void CopyFixedArrayElements( |
| ElementsKind kind, compiler::Node* from_array, compiler::Node* to_array, |
| compiler::Node* length, |
| WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER, |
| ParameterMode mode = INTEGER_PARAMETERS) { |
| CopyFixedArrayElements(kind, from_array, kind, to_array, length, length, |
| barrier_mode, mode); |
| } |
| |
| // Copies |element_count| elements from |from_array| to |to_array| of |
| // |capacity| size respecting both array's elements kinds. |
| void CopyFixedArrayElements( |
| ElementsKind from_kind, compiler::Node* from_array, ElementsKind to_kind, |
| compiler::Node* to_array, compiler::Node* element_count, |
| compiler::Node* capacity, |
| WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER, |
| ParameterMode mode = INTEGER_PARAMETERS); |
| |
| // Copies |character_count| elements from |from_string| to |to_string| |
| // starting at the |from_index|'th character. |from_string| and |to_string| |
| // can either be one-byte strings or two-byte strings, although if |
| // |from_string| is two-byte, then |to_string| must be two-byte. |
| // |from_index|, |to_index| and |character_count| must be either Smis or |
| // intptr_ts depending on |mode| s.t. 0 <= |from_index| <= |from_index| + |
| // |character_count| <= from_string.length and 0 <= |to_index| <= |to_index| + |
| // |character_count| <= to_string.length. |
| void CopyStringCharacters(compiler::Node* from_string, |
| compiler::Node* to_string, |
| compiler::Node* from_index, |
| compiler::Node* to_index, |
| compiler::Node* character_count, |
| String::Encoding from_encoding, |
| String::Encoding to_encoding, ParameterMode mode); |
| |
| // Loads an element from |array| of |from_kind| elements by given |offset| |
| // (NOTE: not index!), does a hole check if |if_hole| is provided and |
| // converts the value so that it becomes ready for storing to array of |
| // |to_kind| elements. |
| compiler::Node* LoadElementAndPrepareForStore(compiler::Node* array, |
| compiler::Node* offset, |
| ElementsKind from_kind, |
| ElementsKind to_kind, |
| Label* if_hole); |
| |
| compiler::Node* CalculateNewElementsCapacity( |
| compiler::Node* old_capacity, ParameterMode mode = INTEGER_PARAMETERS); |
| |
| // Tries to grow the |elements| array of given |object| to store the |key| |
| // or bails out if the growing gap is too big. Returns new elements. |
| compiler::Node* TryGrowElementsCapacity(compiler::Node* object, |
| compiler::Node* elements, |
| ElementsKind kind, |
| compiler::Node* key, Label* bailout); |
| |
| // Tries to grow the |capacity|-length |elements| array of given |object| |
| // to store the |key| or bails out if the growing gap is too big. Returns |
| // new elements. |
| compiler::Node* TryGrowElementsCapacity(compiler::Node* object, |
| compiler::Node* elements, |
| ElementsKind kind, |
| compiler::Node* key, |
| compiler::Node* capacity, |
| ParameterMode mode, Label* bailout); |
| |
| // Grows elements capacity of given object. Returns new elements. |
| compiler::Node* GrowElementsCapacity( |
| compiler::Node* object, compiler::Node* elements, ElementsKind from_kind, |
| ElementsKind to_kind, compiler::Node* capacity, |
| compiler::Node* new_capacity, ParameterMode mode, Label* bailout); |
| |
| // Allocation site manipulation |
| void InitializeAllocationMemento(compiler::Node* base_allocation, |
| int base_allocation_size, |
| compiler::Node* allocation_site); |
| |
| compiler::Node* TryTaggedToFloat64(compiler::Node* value, |
| Label* if_valueisnotnumber); |
| compiler::Node* TruncateTaggedToFloat64(compiler::Node* context, |
| compiler::Node* value); |
| compiler::Node* TruncateTaggedToWord32(compiler::Node* context, |
| compiler::Node* value); |
| // Truncate the floating point value of a HeapNumber to an Int32. |
| compiler::Node* TruncateHeapNumberValueToWord32(compiler::Node* object); |
| |
| // Conversions. |
| compiler::Node* ChangeFloat64ToTagged(compiler::Node* value); |
| compiler::Node* ChangeInt32ToTagged(compiler::Node* value); |
| compiler::Node* ChangeUint32ToTagged(compiler::Node* value); |
| |
| // Type conversions. |
| // Throws a TypeError for {method_name} if {value} is not coercible to Object, |
| // or returns the {value} converted to a String otherwise. |
| compiler::Node* ToThisString(compiler::Node* context, compiler::Node* value, |
| char const* method_name); |
| // Throws a TypeError for {method_name} if {value} is neither of the given |
| // {primitive_type} nor a JSValue wrapping a value of {primitive_type}, or |
| // returns the {value} (or wrapped value) otherwise. |
| compiler::Node* ToThisValue(compiler::Node* context, compiler::Node* value, |
| PrimitiveType primitive_type, |
| char const* method_name); |
| |
| // Throws a TypeError for {method_name} if {value} is not of the given |
| // instance type. Returns {value}'s map. |
| compiler::Node* ThrowIfNotInstanceType(compiler::Node* context, |
| compiler::Node* value, |
| InstanceType instance_type, |
| char const* method_name); |
| |
| // Type checks. |
| // Check whether the map is for an object with special properties, such as a |
| // JSProxy or an object with interceptors. |
| compiler::Node* IsSpecialReceiverMap(compiler::Node* map); |
| compiler::Node* IsSpecialReceiverInstanceType(compiler::Node* instance_type); |
| compiler::Node* IsStringInstanceType(compiler::Node* instance_type); |
| compiler::Node* IsString(compiler::Node* object); |
| compiler::Node* IsJSObject(compiler::Node* object); |
| compiler::Node* IsJSGlobalProxy(compiler::Node* object); |
| compiler::Node* IsJSReceiverInstanceType(compiler::Node* instance_type); |
| compiler::Node* IsJSReceiver(compiler::Node* object); |
| compiler::Node* IsMap(compiler::Node* object); |
| compiler::Node* IsCallableMap(compiler::Node* map); |
| compiler::Node* IsName(compiler::Node* object); |
| compiler::Node* IsJSValue(compiler::Node* object); |
| compiler::Node* IsJSArray(compiler::Node* object); |
| compiler::Node* IsNativeContext(compiler::Node* object); |
| compiler::Node* IsWeakCell(compiler::Node* object); |
| compiler::Node* IsFixedDoubleArray(compiler::Node* object); |
| compiler::Node* IsHashTable(compiler::Node* object); |
| compiler::Node* IsDictionary(compiler::Node* object); |
| compiler::Node* IsUnseededNumberDictionary(compiler::Node* object); |
| |
| // ElementsKind helpers: |
| compiler::Node* IsFastElementsKind(compiler::Node* elements_kind); |
| compiler::Node* IsHoleyFastElementsKind(compiler::Node* elements_kind); |
| |
| // String helpers. |
| // Load a character from a String (might flatten a ConsString). |
| compiler::Node* StringCharCodeAt(compiler::Node* string, |
| compiler::Node* smi_index); |
| // Return the single character string with only {code}. |
| compiler::Node* StringFromCharCode(compiler::Node* code); |
| // Return a new string object which holds a substring containing the range |
| // [from,to[ of string. |from| and |to| are expected to be tagged. |
| compiler::Node* SubString(compiler::Node* context, compiler::Node* string, |
| compiler::Node* from, compiler::Node* to); |
| |
| // Return a new string object produced by concatenating |first| with |second|. |
| compiler::Node* StringAdd(compiler::Node* context, compiler::Node* first, |
| compiler::Node* second, |
| AllocationFlags flags = kNone); |
| |
| // Return the first index >= {from} at which {needle_char} was found in |
| // {string}, or -1 if such an index does not exist. The returned value is |
| // a Smi, {string} is expected to be a String, {needle_char} is an intptr, |
| // and {from} is expected to be tagged. |
| compiler::Node* StringIndexOfChar(compiler::Node* context, |
| compiler::Node* string, |
| compiler::Node* needle_char, |
| compiler::Node* from); |
| |
| compiler::Node* StringFromCodePoint(compiler::Node* codepoint, |
| UnicodeEncoding encoding); |
| |
| // Type conversion helpers. |
| // Convert a String to a Number. |
| compiler::Node* StringToNumber(compiler::Node* context, |
| compiler::Node* input); |
| compiler::Node* NumberToString(compiler::Node* context, |
| compiler::Node* input); |
| // Convert an object to a name. |
| compiler::Node* ToName(compiler::Node* context, compiler::Node* input); |
| // Convert a Non-Number object to a Number. |
| compiler::Node* NonNumberToNumber(compiler::Node* context, |
| compiler::Node* input); |
| // Convert any object to a Number. |
| compiler::Node* ToNumber(compiler::Node* context, compiler::Node* input); |
| |
| // Convert any object to a String. |
| compiler::Node* ToString(compiler::Node* context, compiler::Node* input); |
| |
| // Convert any object to a Primitive. |
| compiler::Node* JSReceiverToPrimitive(compiler::Node* context, |
| compiler::Node* input); |
| |
| // Convert a String to a flat String. |
| compiler::Node* FlattenString(compiler::Node* string); |
| |
| enum ToIntegerTruncationMode { |
| kNoTruncation, |
| kTruncateMinusZero, |
| }; |
| |
| // Convert any object to an Integer. |
| compiler::Node* ToInteger(compiler::Node* context, compiler::Node* input, |
| ToIntegerTruncationMode mode = kNoTruncation); |
| |
| // Returns a node that contains a decoded (unsigned!) value of a bit |
| // field |T| in |word32|. Returns result as an uint32 node. |
| template <typename T> |
| compiler::Node* DecodeWord32(compiler::Node* word32) { |
| return DecodeWord32(word32, T::kShift, T::kMask); |
| } |
| |
| // Returns a node that contains a decoded (unsigned!) value of a bit |
| // field |T| in |word|. Returns result as a word-size node. |
| template <typename T> |
| compiler::Node* DecodeWord(compiler::Node* word) { |
| return DecodeWord(word, T::kShift, T::kMask); |
| } |
| |
| // Returns a node that contains a decoded (unsigned!) value of a bit |
| // field |T| in |word32|. Returns result as a word-size node. |
| template <typename T> |
| compiler::Node* DecodeWordFromWord32(compiler::Node* word32) { |
| return DecodeWord<T>(ChangeUint32ToWord(word32)); |
| } |
| |
| // Decodes an unsigned (!) value from |word32| to an uint32 node. |
| compiler::Node* DecodeWord32(compiler::Node* word32, uint32_t shift, |
| uint32_t mask); |
| |
| // Decodes an unsigned (!) value from |word| to a word-size node. |
| compiler::Node* DecodeWord(compiler::Node* word, uint32_t shift, |
| uint32_t mask); |
| |
| // Returns true if any of the |T|'s bits in given |word32| are set. |
| template <typename T> |
| compiler::Node* IsSetWord32(compiler::Node* word32) { |
| return IsSetWord32(word32, T::kMask); |
| } |
| |
| // Returns true if any of the mask's bits in given |word32| are set. |
| compiler::Node* IsSetWord32(compiler::Node* word32, uint32_t mask) { |
| return Word32NotEqual(Word32And(word32, Int32Constant(mask)), |
| Int32Constant(0)); |
| } |
| |
| // Returns true if any of the |T|'s bits in given |word| are set. |
| template <typename T> |
| compiler::Node* IsSetWord(compiler::Node* word) { |
| return WordNotEqual(WordAnd(word, IntPtrConstant(T::kMask)), |
| IntPtrConstant(0)); |
| } |
| |
| void SetCounter(StatsCounter* counter, int value); |
| void IncrementCounter(StatsCounter* counter, int delta); |
| void DecrementCounter(StatsCounter* counter, int delta); |
| |
| // Generates "if (false) goto label" code. Useful for marking a label as |
| // "live" to avoid assertion failures during graph building. In the resulting |
| // code this check will be eliminated. |
| void Use(Label* label); |
| |
| // Various building blocks for stubs doing property lookups. |
| void TryToName(compiler::Node* key, Label* if_keyisindex, Variable* var_index, |
| Label* if_keyisunique, Label* if_bailout); |
| |
| // Calculates array index for given dictionary entry and entry field. |
| // See Dictionary::EntryToIndex(). |
| template <typename Dictionary> |
| compiler::Node* EntryToIndex(compiler::Node* entry, int field_index); |
| template <typename Dictionary> |
| compiler::Node* EntryToIndex(compiler::Node* entry) { |
| return EntryToIndex<Dictionary>(entry, Dictionary::kEntryKeyIndex); |
| } |
| // Calculate a valid size for the a hash table. |
| compiler::Node* HashTableComputeCapacity(compiler::Node* at_least_space_for); |
| |
| // Looks up an entry in a NameDictionaryBase successor. If the entry is found |
| // control goes to {if_found} and {var_name_index} contains an index of the |
| // key field of the entry found. If the key is not found control goes to |
| // {if_not_found}. |
| static const int kInlinedDictionaryProbes = 4; |
| template <typename Dictionary> |
| void NameDictionaryLookup(compiler::Node* dictionary, |
| compiler::Node* unique_name, Label* if_found, |
| Variable* var_name_index, Label* if_not_found, |
| int inlined_probes = kInlinedDictionaryProbes); |
| |
| compiler::Node* ComputeIntegerHash(compiler::Node* key, compiler::Node* seed); |
| |
| template <typename Dictionary> |
| void NumberDictionaryLookup(compiler::Node* dictionary, |
| compiler::Node* intptr_index, Label* if_found, |
| Variable* var_entry, Label* if_not_found); |
| |
| // Tries to check if {object} has own {unique_name} property. |
| void TryHasOwnProperty(compiler::Node* object, compiler::Node* map, |
| compiler::Node* instance_type, |
| compiler::Node* unique_name, Label* if_found, |
| Label* if_not_found, Label* if_bailout); |
| |
| // Tries to get {object}'s own {unique_name} property value. If the property |
| // is an accessor then it also calls a getter. If the property is a double |
| // field it re-wraps value in an immutable heap number. |
| void TryGetOwnProperty(compiler::Node* context, compiler::Node* receiver, |
| compiler::Node* object, compiler::Node* map, |
| compiler::Node* instance_type, |
| compiler::Node* unique_name, Label* if_found, |
| Variable* var_value, Label* if_not_found, |
| Label* if_bailout); |
| |
| void LoadPropertyFromFastObject(compiler::Node* object, compiler::Node* map, |
| compiler::Node* descriptors, |
| compiler::Node* name_index, |
| Variable* var_details, Variable* var_value); |
| |
| void LoadPropertyFromNameDictionary(compiler::Node* dictionary, |
| compiler::Node* entry, |
| Variable* var_details, |
| Variable* var_value); |
| |
| void LoadPropertyFromGlobalDictionary(compiler::Node* dictionary, |
| compiler::Node* entry, |
| Variable* var_details, |
| Variable* var_value, Label* if_deleted); |
| |
| // Generic property lookup generator. If the {object} is fast and |
| // {unique_name} property is found then the control goes to {if_found_fast} |
| // label and {var_meta_storage} and {var_name_index} will contain |
| // DescriptorArray and an index of the descriptor's name respectively. |
| // If the {object} is slow or global then the control goes to {if_found_dict} |
| // or {if_found_global} and the {var_meta_storage} and {var_name_index} will |
| // contain a dictionary and an index of the key field of the found entry. |
| // If property is not found or given lookup is not supported then |
| // the control goes to {if_not_found} or {if_bailout} respectively. |
| // |
| // Note: this code does not check if the global dictionary points to deleted |
| // entry! This has to be done by the caller. |
| void TryLookupProperty(compiler::Node* object, compiler::Node* map, |
| compiler::Node* instance_type, |
| compiler::Node* unique_name, Label* if_found_fast, |
| Label* if_found_dict, Label* if_found_global, |
| Variable* var_meta_storage, Variable* var_name_index, |
| Label* if_not_found, Label* if_bailout); |
| |
| void TryLookupElement(compiler::Node* object, compiler::Node* map, |
| compiler::Node* instance_type, |
| compiler::Node* intptr_index, Label* if_found, |
| Label* if_not_found, Label* if_bailout); |
| |
| // This is a type of a lookup in holder generator function. In case of a |
| // property lookup the {key} is guaranteed to be a unique name and in case of |
| // element lookup the key is an Int32 index. |
| typedef std::function<void(compiler::Node* receiver, compiler::Node* holder, |
| compiler::Node* map, compiler::Node* instance_type, |
| compiler::Node* key, Label* next_holder, |
| Label* if_bailout)> |
| LookupInHolder; |
| |
| // Generic property prototype chain lookup generator. |
| // For properties it generates lookup using given {lookup_property_in_holder} |
| // and for elements it uses {lookup_element_in_holder}. |
| // Upon reaching the end of prototype chain the control goes to {if_end}. |
| // If it can't handle the case {receiver}/{key} case then the control goes |
| // to {if_bailout}. |
| void TryPrototypeChainLookup(compiler::Node* receiver, compiler::Node* key, |
| LookupInHolder& lookup_property_in_holder, |
| LookupInHolder& lookup_element_in_holder, |
| Label* if_end, Label* if_bailout); |
| |
| // Instanceof helpers. |
| // ES6 section 7.3.19 OrdinaryHasInstance (C, O) |
| compiler::Node* OrdinaryHasInstance(compiler::Node* context, |
| compiler::Node* callable, |
| compiler::Node* object); |
| |
| // Load type feedback vector from the stub caller's frame. |
| compiler::Node* LoadTypeFeedbackVectorForStub(); |
| |
| // Update the type feedback vector. |
| void UpdateFeedback(compiler::Node* feedback, |
| compiler::Node* type_feedback_vector, |
| compiler::Node* slot_id); |
| |
| compiler::Node* LoadReceiverMap(compiler::Node* receiver); |
| |
| // Extends properties backing store by JSObject::kFieldsAdded elements. |
| void ExtendPropertiesBackingStore(compiler::Node* object); |
| |
| compiler::Node* PrepareValueForWrite(compiler::Node* value, |
| Representation representation, |
| Label* bailout); |
| |
| void StoreNamedField(compiler::Node* object, FieldIndex index, |
| Representation representation, compiler::Node* value, |
| bool transition_to_field); |
| |
| void StoreNamedField(compiler::Node* object, compiler::Node* offset, |
| bool is_inobject, Representation representation, |
| compiler::Node* value, bool transition_to_field); |
| |
| // Emits keyed sloppy arguments load. Returns either the loaded value. |
| compiler::Node* LoadKeyedSloppyArguments(compiler::Node* receiver, |
| compiler::Node* key, |
| Label* bailout) { |
| return EmitKeyedSloppyArguments(receiver, key, nullptr, bailout); |
| } |
| |
| // Emits keyed sloppy arguments store. |
| void StoreKeyedSloppyArguments(compiler::Node* receiver, compiler::Node* key, |
| compiler::Node* value, Label* bailout) { |
| DCHECK_NOT_NULL(value); |
| EmitKeyedSloppyArguments(receiver, key, value, bailout); |
| } |
| |
| // Loads script context from the script context table. |
| compiler::Node* LoadScriptContext(compiler::Node* context, int context_index); |
| |
| compiler::Node* ClampedToUint8(compiler::Node* int32_value); |
| |
| // Store value to an elements array with given elements kind. |
| void StoreElement(compiler::Node* elements, ElementsKind kind, |
| compiler::Node* index, compiler::Node* value, |
| ParameterMode mode); |
| |
| void EmitElementStore(compiler::Node* object, compiler::Node* key, |
| compiler::Node* value, bool is_jsarray, |
| ElementsKind elements_kind, |
| KeyedAccessStoreMode store_mode, Label* bailout); |
| |
| compiler::Node* CheckForCapacityGrow(compiler::Node* object, |
| compiler::Node* elements, |
| ElementsKind kind, |
| compiler::Node* length, |
| compiler::Node* key, ParameterMode mode, |
| bool is_js_array, Label* bailout); |
| |
| compiler::Node* CopyElementsOnWrite(compiler::Node* object, |
| compiler::Node* elements, |
| ElementsKind kind, compiler::Node* length, |
| ParameterMode mode, Label* bailout); |
| |
| void TransitionElementsKind(compiler::Node* object, compiler::Node* map, |
| ElementsKind from_kind, ElementsKind to_kind, |
| bool is_jsarray, Label* bailout); |
| |
| void TrapAllocationMemento(compiler::Node* object, Label* memento_found); |
| |
| compiler::Node* PageFromAddress(compiler::Node* address); |
| |
| // Get the enumerable length from |map| and return the result as a Smi. |
| compiler::Node* EnumLength(compiler::Node* map); |
| |
| // Check the cache validity for |receiver|. Branch to |use_cache| if |
| // the cache is valid, otherwise branch to |use_runtime|. |
| void CheckEnumCache(compiler::Node* receiver, |
| CodeStubAssembler::Label* use_cache, |
| CodeStubAssembler::Label* use_runtime); |
| |
| // Create a new weak cell with a specified value and install it into a |
| // feedback vector. |
| compiler::Node* CreateWeakCellInFeedbackVector( |
| compiler::Node* feedback_vector, compiler::Node* slot, |
| compiler::Node* value); |
| |
| // Create a new AllocationSite and install it into a feedback vector. |
| compiler::Node* CreateAllocationSiteInFeedbackVector( |
| compiler::Node* feedback_vector, compiler::Node* slot); |
| |
| enum class IndexAdvanceMode { kPre, kPost }; |
| |
| void BuildFastLoop( |
| const VariableList& var_list, MachineRepresentation index_rep, |
| compiler::Node* start_index, compiler::Node* end_index, |
| std::function<void(CodeStubAssembler* assembler, compiler::Node* index)> |
| body, |
| int increment, IndexAdvanceMode mode = IndexAdvanceMode::kPre); |
| |
| void BuildFastLoop( |
| MachineRepresentation index_rep, compiler::Node* start_index, |
| compiler::Node* end_index, |
| std::function<void(CodeStubAssembler* assembler, compiler::Node* index)> |
| body, |
| int increment, IndexAdvanceMode mode = IndexAdvanceMode::kPre) { |
| BuildFastLoop(VariableList(0, zone()), index_rep, start_index, end_index, |
| body, increment, mode); |
| } |
| |
| enum class ForEachDirection { kForward, kReverse }; |
| |
| void BuildFastFixedArrayForEach( |
| compiler::Node* fixed_array, ElementsKind kind, |
| compiler::Node* first_element_inclusive, |
| compiler::Node* last_element_exclusive, |
| std::function<void(CodeStubAssembler* assembler, |
| compiler::Node* fixed_array, compiler::Node* offset)> |
| body, |
| ParameterMode mode = INTPTR_PARAMETERS, |
| ForEachDirection direction = ForEachDirection::kReverse); |
| |
| compiler::Node* GetArrayAllocationSize(compiler::Node* element_count, |
| ElementsKind kind, ParameterMode mode, |
| int header_size) { |
| return ElementOffsetFromIndex(element_count, kind, mode, header_size); |
| } |
| |
| compiler::Node* GetFixedArrayAllocationSize(compiler::Node* element_count, |
| ElementsKind kind, |
| ParameterMode mode) { |
| return GetArrayAllocationSize(element_count, kind, mode, |
| FixedArray::kHeaderSize); |
| } |
| |
| enum RelationalComparisonMode { |
| kLessThan, |
| kLessThanOrEqual, |
| kGreaterThan, |
| kGreaterThanOrEqual |
| }; |
| |
| compiler::Node* RelationalComparison(RelationalComparisonMode mode, |
| compiler::Node* lhs, compiler::Node* rhs, |
| compiler::Node* context); |
| |
| void BranchIfNumericRelationalComparison(RelationalComparisonMode mode, |
| compiler::Node* lhs, |
| compiler::Node* rhs, Label* if_true, |
| Label* if_false); |
| |
| void GotoUnlessNumberLessThan(compiler::Node* lhs, compiler::Node* rhs, |
| Label* if_false); |
| |
| enum ResultMode { kDontNegateResult, kNegateResult }; |
| |
| compiler::Node* Equal(ResultMode mode, compiler::Node* lhs, |
| compiler::Node* rhs, compiler::Node* context); |
| |
| compiler::Node* StrictEqual(ResultMode mode, compiler::Node* lhs, |
| compiler::Node* rhs, compiler::Node* context); |
| |
| // ECMA#sec-samevalue |
| // Similar to StrictEqual except that NaNs are treated as equal and minus zero |
| // differs from positive zero. |
| // Unlike Equal and StrictEqual, returns a value suitable for use in Branch |
| // instructions, e.g. Branch(SameValue(...), &label). |
| compiler::Node* SameValue(compiler::Node* lhs, compiler::Node* rhs, |
| compiler::Node* context); |
| |
| compiler::Node* HasProperty( |
| compiler::Node* object, compiler::Node* key, compiler::Node* context, |
| Runtime::FunctionId fallback_runtime_function_id = Runtime::kHasProperty); |
| compiler::Node* ForInFilter(compiler::Node* key, compiler::Node* object, |
| compiler::Node* context); |
| |
| compiler::Node* Typeof(compiler::Node* value, compiler::Node* context); |
| |
| compiler::Node* InstanceOf(compiler::Node* object, compiler::Node* callable, |
| compiler::Node* context); |
| |
| // Debug helpers |
| compiler::Node* IsDebugActive(); |
| |
| // TypedArray/ArrayBuffer helpers |
| compiler::Node* IsDetachedBuffer(compiler::Node* buffer); |
| |
| compiler::Node* ElementOffsetFromIndex(compiler::Node* index, |
| ElementsKind kind, ParameterMode mode, |
| int base_size = 0); |
| |
| protected: |
| void DescriptorLookupLinear(compiler::Node* unique_name, |
| compiler::Node* descriptors, compiler::Node* nof, |
| Label* if_found, Variable* var_name_index, |
| Label* if_not_found); |
| |
| compiler::Node* CallGetterIfAccessor(compiler::Node* value, |
| compiler::Node* details, |
| compiler::Node* context, |
| compiler::Node* receiver, |
| Label* if_bailout); |
| |
| compiler::Node* TryToIntptr(compiler::Node* key, Label* miss); |
| |
| void BranchIfPrototypesHaveNoElements(compiler::Node* receiver_map, |
| Label* definitely_no_elements, |
| Label* possibly_elements); |
| |
| private: |
| friend class CodeStubArguments; |
| |
| compiler::Node* AllocateRawAligned(compiler::Node* size_in_bytes, |
| AllocationFlags flags, |
| compiler::Node* top_address, |
| compiler::Node* limit_address); |
| compiler::Node* AllocateRawUnaligned(compiler::Node* size_in_bytes, |
| AllocationFlags flags, |
| compiler::Node* top_adddress, |
| compiler::Node* limit_address); |
| // Allocate and return a JSArray of given total size in bytes with header |
| // fields initialized. |
| compiler::Node* AllocateUninitializedJSArray(ElementsKind kind, |
| compiler::Node* array_map, |
| compiler::Node* length, |
| compiler::Node* allocation_site, |
| compiler::Node* size_in_bytes); |
| |
| compiler::Node* SmiShiftBitsConstant(); |
| |
| // Emits keyed sloppy arguments load if the |value| is nullptr or store |
| // otherwise. Returns either the loaded value or |value|. |
| compiler::Node* EmitKeyedSloppyArguments(compiler::Node* receiver, |
| compiler::Node* key, |
| compiler::Node* value, |
| Label* bailout); |
| |
| compiler::Node* AllocateSlicedString(Heap::RootListIndex map_root_index, |
| compiler::Node* length, |
| compiler::Node* parent, |
| compiler::Node* offset); |
| |
| compiler::Node* AllocateConsString(Heap::RootListIndex map_root_index, |
| compiler::Node* length, |
| compiler::Node* first, |
| compiler::Node* second, |
| AllocationFlags flags); |
| |
| static const int kElementLoopUnrollThreshold = 8; |
| }; |
| |
| class CodeStubArguments { |
| public: |
| // |argc| specifies the number of arguments passed to the builtin excluding |
| // the receiver. |
| CodeStubArguments(CodeStubAssembler* assembler, compiler::Node* argc, |
| CodeStubAssembler::ParameterMode mode = |
| CodeStubAssembler::INTPTR_PARAMETERS); |
| |
| compiler::Node* GetReceiver(); |
| |
| // |index| is zero-based and does not include the receiver |
| compiler::Node* AtIndex(compiler::Node* index, |
| CodeStubAssembler::ParameterMode mode = |
| CodeStubAssembler::INTPTR_PARAMETERS); |
| |
| compiler::Node* AtIndex(int index); |
| |
| typedef std::function<void(CodeStubAssembler* assembler, compiler::Node* arg)> |
| ForEachBodyFunction; |
| |
| // Iteration doesn't include the receiver. |first| and |last| are zero-based. |
| void ForEach(ForEachBodyFunction body, compiler::Node* first = nullptr, |
| compiler::Node* last = nullptr, |
| CodeStubAssembler::ParameterMode mode = |
| CodeStubAssembler::INTPTR_PARAMETERS) { |
| CodeStubAssembler::VariableList list(0, assembler_->zone()); |
| ForEach(list, body, first, last); |
| } |
| |
| // Iteration doesn't include the receiver. |first| and |last| are zero-based. |
| void ForEach(const CodeStubAssembler::VariableList& vars, |
| ForEachBodyFunction body, compiler::Node* first = nullptr, |
| compiler::Node* last = nullptr, |
| CodeStubAssembler::ParameterMode mode = |
| CodeStubAssembler::INTPTR_PARAMETERS); |
| |
| void PopAndReturn(compiler::Node* value); |
| |
| private: |
| compiler::Node* GetArguments(); |
| |
| CodeStubAssembler* assembler_; |
| compiler::Node* argc_; |
| compiler::Node* arguments_; |
| compiler::Node* fp_; |
| }; |
| |
| #ifdef DEBUG |
| #define CSA_ASSERT(csa, x) \ |
| (csa)->Assert([&] { return (x); }, #x, __FILE__, __LINE__) |
| #else |
| #define CSA_ASSERT(csa, x) ((void)0) |
| #endif |
| |
| #ifdef ENABLE_SLOW_DCHECKS |
| #define CSA_SLOW_ASSERT(csa, x) \ |
| if (FLAG_enable_slow_asserts) { \ |
| (csa)->Assert([&] { return (x); }, #x, __FILE__, __LINE__); \ |
| } |
| #else |
| #define CSA_SLOW_ASSERT(csa, x) ((void)0) |
| #endif |
| |
| DEFINE_OPERATORS_FOR_FLAGS(CodeStubAssembler::AllocationFlags); |
| |
| } // namespace internal |
| } // namespace v8 |
| #endif // V8_CODE_STUB_ASSEMBLER_H_ |
