diff options
Diffstat (limited to 'Source/JavaScriptCore/bytecode/ArrayProfile.h')
| -rw-r--r-- | Source/JavaScriptCore/bytecode/ArrayProfile.h | 116 |
1 files changed, 79 insertions, 37 deletions
diff --git a/Source/JavaScriptCore/bytecode/ArrayProfile.h b/Source/JavaScriptCore/bytecode/ArrayProfile.h index 384275689..66b295da7 100644 --- a/Source/JavaScriptCore/bytecode/ArrayProfile.h +++ b/Source/JavaScriptCore/bytecode/ArrayProfile.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012 Apple Inc. All rights reserved. + * Copyright (C) 2012, 2013 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,6 +26,7 @@ #ifndef ArrayProfile_h #define ArrayProfile_h +#include "ConcurrentJITLock.h" #include "JSArray.h" #include "Structure.h" #include <wtf/HashMap.h> @@ -36,20 +37,44 @@ namespace JSC { class CodeBlock; class LLIntOffsetsExtractor; -// This is a bitfield where each bit represents an IndexingType that we have seen. -// There are 32 indexing types, so an unsigned is enough. +// This is a bitfield where each bit represents an type of array access that we have seen. +// There are 16 indexing types that use the lower bits. +// There are 9 typed array types taking the bits 16 to 25. typedef unsigned ArrayModes; +const ArrayModes Int8ArrayMode = 1 << 16; +const ArrayModes Int16ArrayMode = 1 << 17; +const ArrayModes Int32ArrayMode = 1 << 18; +const ArrayModes Uint8ArrayMode = 1 << 19; +const ArrayModes Uint8ClampedArrayMode = 1 << 20; +const ArrayModes Uint16ArrayMode = 1 << 21; +const ArrayModes Uint32ArrayMode = 1 << 22; +const ArrayModes Float32ArrayMode = 1 << 23; +const ArrayModes Float64ArrayMode = 1 << 24; + #define asArrayModes(type) \ (static_cast<unsigned>(1) << static_cast<unsigned>(type)) +#define ALL_TYPED_ARRAY_MODES \ + (Int8ArrayMode \ + | Int16ArrayMode \ + | Int32ArrayMode \ + | Uint8ArrayMode \ + | Uint8ClampedArrayMode \ + | Uint16ArrayMode \ + | Uint32ArrayMode \ + | Float32ArrayMode \ + | Float64ArrayMode \ + ) + #define ALL_NON_ARRAY_ARRAY_MODES \ (asArrayModes(NonArray) \ | asArrayModes(NonArrayWithInt32) \ | asArrayModes(NonArrayWithDouble) \ | asArrayModes(NonArrayWithContiguous) \ | asArrayModes(NonArrayWithArrayStorage) \ - | asArrayModes(NonArrayWithSlowPutArrayStorage)) + | asArrayModes(NonArrayWithSlowPutArrayStorage) \ + | ALL_TYPED_ARRAY_MODES) #define ALL_ARRAY_ARRAY_MODES \ (asArrayModes(ArrayClass) \ @@ -64,6 +89,29 @@ typedef unsigned ArrayModes; inline ArrayModes arrayModeFromStructure(Structure* structure) { + switch (structure->classInfo()->typedArrayStorageType) { + case TypeInt8: + return Int8ArrayMode; + case TypeUint8: + return Uint8ArrayMode; + case TypeUint8Clamped: + return Uint8ClampedArrayMode; + case TypeInt16: + return Int16ArrayMode; + case TypeUint16: + return Uint16ArrayMode; + case TypeInt32: + return Int32ArrayMode; + case TypeUint32: + return Uint32ArrayMode; + case TypeFloat32: + return Float32ArrayMode; + case TypeFloat64: + return Float64ArrayMode; + case TypeDataView: + case NotTypedArray: + break; + } return asArrayModes(structure->indexingType()); } @@ -79,6 +127,11 @@ inline bool mergeArrayModes(ArrayModes& left, ArrayModes right) return true; } +inline bool arrayModesAreClearOrTop(ArrayModes modes) +{ + return !modes || modes == ALL_ARRAY_MODES; +} + // Checks if proven is a subset of expected. inline bool arrayModesAlreadyChecked(ArrayModes proven, ArrayModes expected) { @@ -129,66 +182,55 @@ class ArrayProfile { public: ArrayProfile() : m_bytecodeOffset(std::numeric_limits<unsigned>::max()) - , m_lastSeenStructure(0) - , m_expectedStructure(0) + , m_lastSeenStructureID(0) , m_mayStoreToHole(false) , m_outOfBounds(false) , m_mayInterceptIndexedAccesses(false) , m_usesOriginalArrayStructures(true) + , m_didPerformFirstRunPruning(false) , m_observedArrayModes(0) { } ArrayProfile(unsigned bytecodeOffset) : m_bytecodeOffset(bytecodeOffset) - , m_lastSeenStructure(0) - , m_expectedStructure(0) + , m_lastSeenStructureID(0) , m_mayStoreToHole(false) , m_outOfBounds(false) , m_mayInterceptIndexedAccesses(false) , m_usesOriginalArrayStructures(true) + , m_didPerformFirstRunPruning(false) , m_observedArrayModes(0) { } unsigned bytecodeOffset() const { return m_bytecodeOffset; } - Structure** addressOfLastSeenStructure() { return &m_lastSeenStructure; } + StructureID* addressOfLastSeenStructureID() { return &m_lastSeenStructureID; } ArrayModes* addressOfArrayModes() { return &m_observedArrayModes; } bool* addressOfMayStoreToHole() { return &m_mayStoreToHole; } + + void setOutOfBounds() { m_outOfBounds = true; } bool* addressOfOutOfBounds() { return &m_outOfBounds; } void observeStructure(Structure* structure) { - m_lastSeenStructure = structure; + m_lastSeenStructureID = structure->id(); } - void computeUpdatedPrediction(CodeBlock*, OperationInProgress = NoOperation); + void computeUpdatedPrediction(const ConcurrentJITLocker&, CodeBlock*); + void computeUpdatedPrediction(const ConcurrentJITLocker&, CodeBlock*, Structure* lastSeenStructure); - Structure* expectedStructure() const - { - if (structureIsPolymorphic()) - return 0; - return m_expectedStructure; - } - bool structureIsPolymorphic() const - { - return m_expectedStructure == polymorphicStructure(); - } - bool hasDefiniteStructure() const - { - return !structureIsPolymorphic() && m_expectedStructure; - } - ArrayModes observedArrayModes() const { return m_observedArrayModes; } - ArrayModes updatedObservedArrayModes() const; // Computes the observed array modes without updating the profile. - bool mayInterceptIndexedAccesses() const { return m_mayInterceptIndexedAccesses; } + ArrayModes observedArrayModes(const ConcurrentJITLocker&) const { return m_observedArrayModes; } + bool mayInterceptIndexedAccesses(const ConcurrentJITLocker&) const { return m_mayInterceptIndexedAccesses; } - bool mayStoreToHole() const { return m_mayStoreToHole; } - bool outOfBounds() const { return m_outOfBounds; } + bool mayStoreToHole(const ConcurrentJITLocker&) const { return m_mayStoreToHole; } + bool outOfBounds(const ConcurrentJITLocker&) const { return m_outOfBounds; } - bool usesOriginalArrayStructures() const { return m_usesOriginalArrayStructures; } + bool usesOriginalArrayStructures(const ConcurrentJITLocker&) const { return m_usesOriginalArrayStructures; } - CString briefDescription(CodeBlock*); + CString briefDescription(const ConcurrentJITLocker&, CodeBlock*); + CString briefDescriptionWithoutUpdating(const ConcurrentJITLocker&); private: friend class LLIntOffsetsExtractor; @@ -196,16 +238,16 @@ private: static Structure* polymorphicStructure() { return static_cast<Structure*>(reinterpret_cast<void*>(1)); } unsigned m_bytecodeOffset; - Structure* m_lastSeenStructure; - Structure* m_expectedStructure; + StructureID m_lastSeenStructureID; bool m_mayStoreToHole; // This flag may become overloaded to indicate other special cases that were encountered during array access, as it depends on indexing type. Since we currently have basically just one indexing type (two variants of ArrayStorage), this flag for now just means exactly what its name implies. bool m_outOfBounds; - bool m_mayInterceptIndexedAccesses; - bool m_usesOriginalArrayStructures; + bool m_mayInterceptIndexedAccesses : 1; + bool m_usesOriginalArrayStructures : 1; + bool m_didPerformFirstRunPruning : 1; ArrayModes m_observedArrayModes; }; -typedef SegmentedVector<ArrayProfile, 4, 0> ArrayProfileVector; +typedef SegmentedVector<ArrayProfile, 4> ArrayProfileVector; } // namespace JSC |