Vyacheslav Egorov
cc8877fcc7
* Add rule forwarding stores to non-late final fields to
consequitive loads.
* Allow specialization of InstanceCall with an empty ICData in AOT
mode.
Additionally rewrite regression test for 836c04f using explicit
block building. The source based test was too fragile and sensitive
to various optimizations.
TEST=vm/cc/IL_Canonicalize_FinalFieldForwarding,vm/cc/IL_Canonicalize_InstanceCallWithNoICDataInAOT
Bug: https://github.com/dart-lang/sdk/issues/48433
Cq-Include-Trybots: luci.dart.try:vm-kernel-precomp-linux-debug-x64-try,vm-kernel-precomp-linux-release-simarm-try,vm-kernel-precomp-linux-product-x64-try
Change-Id: Icb766d48ebaed6626c8d010f528fa6d82c432930
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/279515
Reviewed-by: Alexander Markov <alexmarkov@google.com>
Commit-Queue: Slava Egorov <vegorov@google.com>
118 lines
4.0 KiB
C++
118 lines
4.0 KiB
C++
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
// Defines growable array classes, that differ where they are allocated:
|
|
// - GrowableArray: allocated on stack.
|
|
// - ZoneGrowableArray: allocated in the zone.
|
|
// - MallocGrowableArray: allocates using malloc/realloc; free is only called
|
|
// at destruction.
|
|
|
|
#ifndef RUNTIME_VM_GROWABLE_ARRAY_H_
|
|
#define RUNTIME_VM_GROWABLE_ARRAY_H_
|
|
|
|
#include "platform/growable_array.h"
|
|
#include "vm/thread_state.h"
|
|
#include "vm/zone.h"
|
|
|
|
namespace dart {
|
|
|
|
template <typename T>
|
|
class GrowableArray : public BaseGrowableArray<T, ValueObject, Zone> {
|
|
public:
|
|
GrowableArray(Zone* zone, intptr_t initial_capacity)
|
|
: BaseGrowableArray<T, ValueObject, Zone>(initial_capacity,
|
|
ASSERT_NOTNULL(zone)) {}
|
|
explicit GrowableArray(intptr_t initial_capacity)
|
|
: BaseGrowableArray<T, ValueObject, Zone>(
|
|
initial_capacity,
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {}
|
|
GrowableArray()
|
|
: BaseGrowableArray<T, ValueObject, Zone>(
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {}
|
|
|
|
GrowableArray(std::initializer_list<T> values)
|
|
: BaseGrowableArray<T, ValueObject, Zone>(
|
|
values.size(),
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {
|
|
for (auto& value : values) {
|
|
this->Add(value);
|
|
}
|
|
}
|
|
|
|
GrowableArray(GrowableArray&& other) = default;
|
|
GrowableArray& operator=(GrowableArray&& other) = default;
|
|
~GrowableArray() = default;
|
|
DISALLOW_COPY_AND_ASSIGN(GrowableArray);
|
|
};
|
|
|
|
template <typename T>
|
|
class ZoneGrowableArray : public BaseGrowableArray<T, ZoneAllocated, Zone> {
|
|
public:
|
|
ZoneGrowableArray(Zone* zone, intptr_t initial_capacity)
|
|
: BaseGrowableArray<T, ZoneAllocated, Zone>(initial_capacity,
|
|
ASSERT_NOTNULL(zone)) {}
|
|
explicit ZoneGrowableArray(intptr_t initial_capacity)
|
|
: BaseGrowableArray<T, ZoneAllocated, Zone>(
|
|
initial_capacity,
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {}
|
|
ZoneGrowableArray()
|
|
: BaseGrowableArray<T, ZoneAllocated, Zone>(
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {}
|
|
|
|
ZoneGrowableArray(ZoneGrowableArray&& other) = default;
|
|
ZoneGrowableArray& operator=(ZoneGrowableArray&& other) = default;
|
|
~ZoneGrowableArray() = default;
|
|
DISALLOW_COPY_AND_ASSIGN(ZoneGrowableArray);
|
|
};
|
|
|
|
// T must be a Handle type.
|
|
template <typename T, typename B>
|
|
class BaseGrowableHandlePtrArray : public B {
|
|
public:
|
|
BaseGrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
|
|
: zone_(zone), array_(zone, initial_capacity) {}
|
|
|
|
// Use unique zone handles to store objects.
|
|
void Add(const T& t) { array_.Add(&T::ZoneHandle(zone_, t.ptr())); }
|
|
|
|
T& operator[](intptr_t index) const { return *array_[index]; }
|
|
|
|
const T& At(intptr_t index) const { return operator[](index); }
|
|
|
|
void SetAt(intptr_t index, const T& t) {
|
|
array_[index] = &T::ZoneHandle(zone_, t.ptr());
|
|
}
|
|
|
|
intptr_t length() const { return array_.length(); }
|
|
|
|
void Clear() { array_.Clear(); }
|
|
|
|
const GrowableArray<T*>& growable_array() const { return array_; }
|
|
|
|
private:
|
|
Zone* zone_;
|
|
GrowableArray<T*> array_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(BaseGrowableHandlePtrArray);
|
|
};
|
|
|
|
template <typename T>
|
|
class GrowableHandlePtrArray
|
|
: public BaseGrowableHandlePtrArray<T, ValueObject> {
|
|
public:
|
|
GrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
|
|
: BaseGrowableHandlePtrArray<T, ValueObject>(zone, initial_capacity) {}
|
|
};
|
|
|
|
template <typename T>
|
|
class ZoneGrowableHandlePtrArray
|
|
: public BaseGrowableHandlePtrArray<T, ZoneAllocated> {
|
|
public:
|
|
ZoneGrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
|
|
: BaseGrowableHandlePtrArray<T, ZoneAllocated>(zone, initial_capacity) {}
|
|
};
|
|
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_VM_GROWABLE_ARRAY_H_
|