mirror of
https://github.com/dart-lang/sdk
synced 2024-09-05 00:13:50 +00:00
![Alexander Markov](/assets/img/avatar_default.png)
This is a reland of commit bc8afad855
On top of the original commit, this change fixes incorrect
propagation of async/async*/sync* modifiers from a function to
its dynamic invocation forwarder.
TEST=ci, runtime/tests/vm/dart/regress_b_238653741_test.dart
Fixes b/238653741
Issue: https://github.com/dart-lang/sdk/issues/48378
Original change's description:
> [vm] Cleanup old async/async*/sync* implementation from the VM
>
> TEST=ci
>
> Issue: https://github.com/dart-lang/sdk/issues/48378
> Change-Id: I089ba4ed5613f30eec29f0db4ac6d5d8fbffd185
> Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/249980
> Reviewed-by: Martin Kustermann <kustermann@google.com>
> Reviewed-by: Slava Egorov <vegorov@google.com>
> Commit-Queue: Alexander Markov <alexmarkov@google.com>
Change-Id: Iaad033d974a23fc6c5880a3d7f41818eb117f839
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/251300
Commit-Queue: Alexander Markov <alexmarkov@google.com>
Reviewed-by: Slava Egorov <vegorov@google.com>
373 lines
12 KiB
C++
373 lines
12 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.
|
|
|
|
#ifndef RUNTIME_VM_CODE_DESCRIPTORS_H_
|
|
#define RUNTIME_VM_CODE_DESCRIPTORS_H_
|
|
|
|
#include "vm/datastream.h"
|
|
#include "vm/globals.h"
|
|
#include "vm/growable_array.h"
|
|
#include "vm/log.h"
|
|
#include "vm/runtime_entry.h"
|
|
#include "vm/token_position.h"
|
|
|
|
namespace dart {
|
|
|
|
static const intptr_t kInvalidTryIndex = -1;
|
|
|
|
class DescriptorList : public ZoneAllocated {
|
|
public:
|
|
explicit DescriptorList(
|
|
Zone* zone,
|
|
const GrowableArray<const Function*>* inline_id_to_function = nullptr);
|
|
|
|
~DescriptorList() {}
|
|
|
|
void AddDescriptor(UntaggedPcDescriptors::Kind kind,
|
|
intptr_t pc_offset,
|
|
intptr_t deopt_id,
|
|
TokenPosition token_pos,
|
|
intptr_t try_index,
|
|
intptr_t yield_index);
|
|
|
|
PcDescriptorsPtr FinalizePcDescriptors(uword entry_point);
|
|
|
|
private:
|
|
static constexpr intptr_t kInitialStreamSize = 64;
|
|
|
|
const Function& function_;
|
|
const Script& script_;
|
|
ZoneWriteStream encoded_data_;
|
|
|
|
intptr_t prev_pc_offset;
|
|
intptr_t prev_deopt_id;
|
|
int32_t prev_token_pos;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(DescriptorList);
|
|
};
|
|
|
|
class CompressedStackMapsBuilder : public ZoneAllocated {
|
|
public:
|
|
explicit CompressedStackMapsBuilder(Zone* zone)
|
|
: encoded_bytes_(zone, kInitialStreamSize) {}
|
|
|
|
void AddEntry(intptr_t pc_offset,
|
|
BitmapBuilder* bitmap,
|
|
intptr_t spill_slot_bit_count);
|
|
|
|
CompressedStackMapsPtr Finalize() const;
|
|
|
|
private:
|
|
static constexpr intptr_t kInitialStreamSize = 16;
|
|
|
|
ZoneWriteStream encoded_bytes_;
|
|
intptr_t last_pc_offset_ = 0;
|
|
DISALLOW_COPY_AND_ASSIGN(CompressedStackMapsBuilder);
|
|
};
|
|
|
|
class ExceptionHandlerList : public ZoneAllocated {
|
|
public:
|
|
struct HandlerDesc {
|
|
intptr_t outer_try_index; // Try block in which this try block is nested.
|
|
intptr_t pc_offset; // Handler PC offset value.
|
|
bool is_generated; // False if this is directly from Dart code.
|
|
const Array* handler_types; // Catch clause guards.
|
|
bool needs_stacktrace;
|
|
};
|
|
|
|
explicit ExceptionHandlerList(const Function& function)
|
|
: list_(),
|
|
has_async_handler_(function.IsAsyncFunction() ||
|
|
function.IsAsyncGenerator()) {}
|
|
|
|
intptr_t Length() const { return list_.length(); }
|
|
|
|
void AddPlaceHolder() {
|
|
struct HandlerDesc data;
|
|
data.outer_try_index = -1;
|
|
data.pc_offset = ExceptionHandlers::kInvalidPcOffset;
|
|
data.is_generated = true;
|
|
data.handler_types = NULL;
|
|
data.needs_stacktrace = false;
|
|
list_.Add(data);
|
|
}
|
|
|
|
void AddHandler(intptr_t try_index,
|
|
intptr_t outer_try_index,
|
|
intptr_t pc_offset,
|
|
bool is_generated,
|
|
const Array& handler_types,
|
|
bool needs_stacktrace) {
|
|
ASSERT(try_index >= 0);
|
|
while (Length() <= try_index) {
|
|
AddPlaceHolder();
|
|
}
|
|
list_[try_index].outer_try_index = outer_try_index;
|
|
ASSERT(list_[try_index].pc_offset == ExceptionHandlers::kInvalidPcOffset);
|
|
list_[try_index].pc_offset = pc_offset;
|
|
list_[try_index].is_generated = is_generated;
|
|
ASSERT(handler_types.IsZoneHandle());
|
|
list_[try_index].handler_types = &handler_types;
|
|
list_[try_index].needs_stacktrace |= needs_stacktrace;
|
|
}
|
|
|
|
// Called by rethrows, to mark their enclosing handlers.
|
|
void SetNeedsStackTrace(intptr_t try_index) {
|
|
// Rethrows can be generated outside a try by the compiler.
|
|
if (try_index == kInvalidTryIndex) {
|
|
return;
|
|
}
|
|
ASSERT(try_index >= 0);
|
|
while (Length() <= try_index) {
|
|
AddPlaceHolder();
|
|
}
|
|
list_[try_index].needs_stacktrace = true;
|
|
}
|
|
|
|
static bool ContainsCatchAllType(const Array& array) {
|
|
auto& type = AbstractType::Handle();
|
|
for (intptr_t i = 0; i < array.Length(); i++) {
|
|
type ^= array.At(i);
|
|
if (type.IsCatchAllType()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ExceptionHandlersPtr FinalizeExceptionHandlers(uword entry_point) const;
|
|
|
|
private:
|
|
GrowableArray<struct HandlerDesc> list_;
|
|
const bool has_async_handler_;
|
|
DISALLOW_COPY_AND_ASSIGN(ExceptionHandlerList);
|
|
};
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
// Used to construct CatchEntryMoves for the AOT mode of compilation.
|
|
class CatchEntryMovesMapBuilder : public ZoneAllocated {
|
|
public:
|
|
CatchEntryMovesMapBuilder();
|
|
|
|
void NewMapping(intptr_t pc_offset);
|
|
void Append(const CatchEntryMove& move);
|
|
void EndMapping();
|
|
TypedDataPtr FinalizeCatchEntryMovesMap();
|
|
|
|
private:
|
|
class TrieNode;
|
|
|
|
Zone* zone_;
|
|
TrieNode* root_;
|
|
intptr_t current_pc_offset_;
|
|
GrowableArray<CatchEntryMove> moves_;
|
|
ZoneWriteStream stream_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(CatchEntryMovesMapBuilder);
|
|
};
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
// Instructions have two pieces of information needed to get accurate source
|
|
// locations: the token position and the inlining id. The inlining id tells us
|
|
// which function, and thus which script, to use for this instruction and the
|
|
// token position, when real, tells us the position in the source for the
|
|
// script for the instruction.
|
|
//
|
|
// Thus, we bundle the two pieces of information in InstructionSource structs
|
|
// when copying or retrieving to lower the likelihood that the token position
|
|
// is used without the appropriate inlining id.
|
|
struct InstructionSource {
|
|
// Treat an instruction source without inlining id information as unset.
|
|
InstructionSource() : InstructionSource(TokenPosition::kNoSource) {}
|
|
explicit InstructionSource(TokenPosition pos) : InstructionSource(pos, -1) {}
|
|
InstructionSource(TokenPosition pos, intptr_t id)
|
|
: token_pos(pos), inlining_id(id) {}
|
|
|
|
const TokenPosition token_pos;
|
|
const intptr_t inlining_id;
|
|
|
|
DISALLOW_ALLOCATION();
|
|
};
|
|
|
|
struct CodeSourceMapOps : AllStatic {
|
|
static const uint8_t kChangePosition = 0;
|
|
static const uint8_t kAdvancePC = 1;
|
|
static const uint8_t kPushFunction = 2;
|
|
static const uint8_t kPopFunction = 3;
|
|
static const uint8_t kNullCheck = 4;
|
|
|
|
static uint8_t Read(ReadStream* stream,
|
|
int32_t* arg1,
|
|
int32_t* arg2 = nullptr);
|
|
|
|
static void Write(BaseWriteStream* stream,
|
|
uint8_t op,
|
|
int32_t arg1 = 0,
|
|
int32_t arg2 = 0);
|
|
|
|
private:
|
|
static constexpr intptr_t kOpBits = 3;
|
|
|
|
using OpField = BitField<int32_t, uint8_t, 0, kOpBits>;
|
|
using ArgField = BitField<int32_t, int32_t, OpField::kNextBit>;
|
|
|
|
static constexpr int32_t kMaxArgValue =
|
|
Utils::NBitMask<int32_t>(ArgField::bitsize() - 1);
|
|
static constexpr int32_t kMinArgValue = ~kMaxArgValue;
|
|
static constexpr int32_t kSignBits = static_cast<uint32_t>(kMinArgValue) << 1;
|
|
};
|
|
|
|
// A CodeSourceMap maps from pc offsets to a stack of inlined functions and
|
|
// their positions. This is encoded as a little bytecode that pushes and pops
|
|
// functions and changes the top function's position as the PC advances.
|
|
// Decoding happens by running this bytecode until we reach the desired PC.
|
|
//
|
|
// The implementation keeps track of two sets of state: one written to the byte
|
|
// stream and one that is buffered. On the JIT, this buffering effectively gives
|
|
// us a peephole optimization that merges adjacent advance PC bytecodes. On AOT,
|
|
// this allows to skip encoding our position until we reach a PC where we might
|
|
// throw.
|
|
class CodeSourceMapBuilder : public ZoneAllocated {
|
|
public:
|
|
CodeSourceMapBuilder(
|
|
Zone* zone,
|
|
bool stack_traces_only,
|
|
const GrowableArray<intptr_t>& caller_inline_id,
|
|
const GrowableArray<TokenPosition>& inline_id_to_token_pos,
|
|
const GrowableArray<const Function*>& inline_id_to_function);
|
|
|
|
// The position at which a function implicitly starts, for both the root and
|
|
// after a push bytecode. We use the classifying position kDartCodePrologue
|
|
// since it is the most common.
|
|
static const TokenPosition& kInitialPosition;
|
|
|
|
void BeginCodeSourceRange(int32_t pc_offset, const InstructionSource& source);
|
|
void EndCodeSourceRange(int32_t pc_offset, const InstructionSource& source);
|
|
void NoteDescriptor(UntaggedPcDescriptors::Kind kind,
|
|
int32_t pc_offset,
|
|
const InstructionSource& source);
|
|
void NoteNullCheck(int32_t pc_offset,
|
|
const InstructionSource& source,
|
|
intptr_t name_index);
|
|
void WriteFunctionEntrySourcePosition(const InstructionSource& source);
|
|
|
|
// If source is from an inlined call, returns the token position of the
|
|
// original call in the root function, otherwise the source's token position.
|
|
TokenPosition RootPosition(const InstructionSource& source);
|
|
ArrayPtr InliningIdToFunction();
|
|
CodeSourceMapPtr Finalize();
|
|
|
|
const GrowableArray<const Function*>& inline_id_to_function() const {
|
|
return inline_id_to_function_;
|
|
}
|
|
|
|
private:
|
|
intptr_t GetFunctionId(intptr_t inline_id);
|
|
void StartInliningInterval(int32_t pc_offset,
|
|
const InstructionSource& source);
|
|
|
|
void BufferChangePosition(TokenPosition pos);
|
|
void WriteChangePosition(TokenPosition pos);
|
|
void BufferAdvancePC(int32_t distance) { buffered_pc_offset_ += distance; }
|
|
void WriteAdvancePC(int32_t distance) {
|
|
CodeSourceMapOps::Write(&stream_, CodeSourceMapOps::kAdvancePC, distance);
|
|
written_pc_offset_ += distance;
|
|
}
|
|
void BufferPush(intptr_t inline_id) {
|
|
buffered_inline_id_stack_.Add(inline_id);
|
|
buffered_token_pos_stack_.Add(kInitialPosition);
|
|
}
|
|
void WritePush(intptr_t inline_id) {
|
|
CodeSourceMapOps::Write(&stream_, CodeSourceMapOps::kPushFunction,
|
|
GetFunctionId(inline_id));
|
|
written_inline_id_stack_.Add(inline_id);
|
|
written_token_pos_stack_.Add(kInitialPosition);
|
|
}
|
|
void BufferPop() {
|
|
buffered_inline_id_stack_.RemoveLast();
|
|
buffered_token_pos_stack_.RemoveLast();
|
|
}
|
|
void WritePop() {
|
|
CodeSourceMapOps::Write(&stream_, CodeSourceMapOps::kPopFunction);
|
|
written_inline_id_stack_.RemoveLast();
|
|
written_token_pos_stack_.RemoveLast();
|
|
}
|
|
void WriteNullCheck(int32_t name_index) {
|
|
CodeSourceMapOps::Write(&stream_, CodeSourceMapOps::kNullCheck, name_index);
|
|
}
|
|
|
|
void FlushBuffer();
|
|
|
|
bool IsOnBufferedStack(intptr_t inline_id) {
|
|
for (intptr_t i = 0; i < buffered_inline_id_stack_.length(); i++) {
|
|
if (buffered_inline_id_stack_[i] == inline_id) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Zone* const zone_;
|
|
intptr_t buffered_pc_offset_;
|
|
GrowableArray<intptr_t> buffered_inline_id_stack_;
|
|
GrowableArray<TokenPosition> buffered_token_pos_stack_;
|
|
|
|
intptr_t written_pc_offset_;
|
|
GrowableArray<intptr_t> written_inline_id_stack_;
|
|
GrowableArray<TokenPosition> written_token_pos_stack_;
|
|
|
|
const GrowableArray<intptr_t>& caller_inline_id_;
|
|
const GrowableArray<TokenPosition>& inline_id_to_token_pos_;
|
|
const GrowableArray<const Function*>& inline_id_to_function_;
|
|
|
|
const GrowableObjectArray& inlined_functions_;
|
|
|
|
Script& script_;
|
|
ZoneWriteStream stream_;
|
|
|
|
const bool stack_traces_only_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(CodeSourceMapBuilder);
|
|
};
|
|
|
|
class CodeSourceMapReader : public ValueObject {
|
|
public:
|
|
CodeSourceMapReader(const CodeSourceMap& map,
|
|
const Array& functions,
|
|
const Function& root)
|
|
: map_(map), functions_(functions), root_(root) {}
|
|
|
|
void GetInlinedFunctionsAt(int32_t pc_offset,
|
|
GrowableArray<const Function*>* function_stack,
|
|
GrowableArray<TokenPosition>* token_positions);
|
|
NOT_IN_PRODUCT(void PrintJSONInlineIntervals(JSONObject* jsobj));
|
|
void DumpInlineIntervals(uword start);
|
|
void DumpSourcePositions(uword start);
|
|
|
|
intptr_t GetNullCheckNameIndexAt(int32_t pc_offset);
|
|
|
|
private:
|
|
static const TokenPosition& InitialPosition() {
|
|
if (FLAG_precompiled_mode) {
|
|
// In precompiled mode, the CodeSourceMap stores lines instead of
|
|
// real token positions and uses kNoSourcePos for no line information.
|
|
return TokenPosition::kNoSource;
|
|
} else {
|
|
return CodeSourceMapBuilder::kInitialPosition;
|
|
}
|
|
}
|
|
|
|
// Reads a TokenPosition value from a CSM, handling the different encoding for
|
|
// when non-symbolic stack traces are enabled.
|
|
static TokenPosition ReadPosition(ReadStream* stream);
|
|
|
|
const CodeSourceMap& map_;
|
|
const Array& functions_;
|
|
const Function& root_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(CodeSourceMapReader);
|
|
};
|
|
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_VM_CODE_DESCRIPTORS_H_
|