Alexander Markov
76091c13db
These bytecode instructions are added in order to shrink constant pools and reduce time spent for reading constant pool entries. Change-Id: I8522f73dc7a6236969ac0422c6cb89b945559b2d Reviewed-on: https://dart-review.googlesource.com/75125 Reviewed-by: Zach Anderson <zra@google.com> Commit-Queue: Alexander Markov <alexmarkov@google.com>
239 lines
10 KiB
C++
239 lines
10 KiB
C++
// Copyright (c) 2018, 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_COMPILER_FRONTEND_BYTECODE_FLOW_GRAPH_BUILDER_H_
|
|
#define RUNTIME_VM_COMPILER_FRONTEND_BYTECODE_FLOW_GRAPH_BUILDER_H_
|
|
|
|
#include "vm/compiler/backend/il.h"
|
|
#include "vm/compiler/frontend/base_flow_graph_builder.h"
|
|
#include "vm/constants_kbc.h"
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
namespace dart {
|
|
namespace kernel {
|
|
|
|
#define FOR_EACH_BYTECODE_IN_FLOW_GRAPH_BUILDER(M) \
|
|
M(Allocate) \
|
|
M(AllocateContext) \
|
|
M(AllocateT) \
|
|
M(AssertAssignable) \
|
|
M(AssertBoolean) \
|
|
M(AssertSubtype) \
|
|
M(BooleanNegateTOS) \
|
|
M(CheckFunctionTypeArgs) \
|
|
M(CheckStack) \
|
|
M(CloneContext) \
|
|
M(CreateArrayTOS) \
|
|
M(Drop1) \
|
|
M(Entry) \
|
|
M(EntryFixed) \
|
|
M(EntryOptional) \
|
|
M(Frame) \
|
|
M(IfEqNull) \
|
|
M(IfEqStrictTOS) \
|
|
M(IfNeStrictTOS) \
|
|
M(IndirectStaticCall) \
|
|
M(InstanceCall) \
|
|
M(InstantiateType) \
|
|
M(InstantiateTypeArgumentsTOS) \
|
|
M(Jump) \
|
|
M(JumpIfNoAsserts) \
|
|
M(JumpIfNotZeroTypeArgs) \
|
|
M(LoadConstant) \
|
|
M(LoadContextParent) \
|
|
M(LoadContextVar) \
|
|
M(LoadFieldTOS) \
|
|
M(LoadTypeArgumentsField) \
|
|
M(MoveSpecial) \
|
|
M(NativeCall) \
|
|
M(PopLocal) \
|
|
M(Push) \
|
|
M(PushConstant) \
|
|
M(PushFalse) \
|
|
M(PushInt) \
|
|
M(PushNull) \
|
|
M(PushStatic) \
|
|
M(PushTrue) \
|
|
M(ReturnTOS) \
|
|
M(SetFrame) \
|
|
M(StoreContextParent) \
|
|
M(StoreContextVar) \
|
|
M(StoreFieldTOS) \
|
|
M(StoreIndexedTOS) \
|
|
M(StoreLocal) \
|
|
M(StoreStaticTOS) \
|
|
M(Throw) \
|
|
M(Trap)
|
|
|
|
// This class builds flow graph from bytecode. It is used either to compile
|
|
// from bytecode, or generate bytecode interpreter (the latter is not
|
|
// fully implemented yet).
|
|
// TODO(alexmarkov): extend this class and IL to generate an interpreter in
|
|
// addition to compiling bytecode.
|
|
class BytecodeFlowGraphBuilder {
|
|
public:
|
|
BytecodeFlowGraphBuilder(BaseFlowGraphBuilder* flow_graph_builder,
|
|
ParsedFunction* parsed_function,
|
|
ZoneGrowableArray<const ICData*>* ic_data_array)
|
|
: flow_graph_builder_(flow_graph_builder),
|
|
zone_(flow_graph_builder->zone_),
|
|
is_generating_interpreter_(
|
|
false), // TODO(alexmarkov): pass as argument
|
|
parsed_function_(parsed_function),
|
|
ic_data_array_(ic_data_array),
|
|
object_pool_(ObjectPool::Handle(zone_)),
|
|
raw_bytecode_(nullptr),
|
|
bytecode_length_(0),
|
|
pc_(0),
|
|
bytecode_instr_(KernelBytecode::kTrap),
|
|
position_(TokenPosition::kNoSource),
|
|
local_vars_(zone_, 0),
|
|
parameters_(zone_, 0),
|
|
exception_var_(nullptr),
|
|
stacktrace_var_(nullptr),
|
|
prologue_info_(-1, -1),
|
|
throw_no_such_method_(nullptr) {}
|
|
|
|
FlowGraph* BuildGraph();
|
|
|
|
protected:
|
|
// Returns `true` if building a flow graph for a bytecode interpreter, or
|
|
// `false` if compiling a function from bytecode.
|
|
bool is_generating_interpreter() const { return is_generating_interpreter_; }
|
|
|
|
private:
|
|
// Operand of bytecode instruction, either intptr_t value (if compiling
|
|
// bytecode) or Definition (if generating interpreter).
|
|
class Operand {
|
|
public:
|
|
explicit Operand(Definition* definition)
|
|
: definition_(definition), value_(0) {
|
|
ASSERT(definition != nullptr);
|
|
}
|
|
|
|
explicit Operand(intptr_t value) : definition_(nullptr), value_(value) {}
|
|
|
|
Definition* definition() const {
|
|
ASSERT(definition_ != nullptr);
|
|
return definition_;
|
|
}
|
|
|
|
intptr_t value() const {
|
|
ASSERT(definition_ == nullptr);
|
|
return value_;
|
|
}
|
|
|
|
private:
|
|
Definition* definition_;
|
|
intptr_t value_;
|
|
};
|
|
|
|
// Constant from a constant pool.
|
|
// It is either Object (if compiling bytecode) or Definition
|
|
// (if generating interpreter).
|
|
class Constant {
|
|
public:
|
|
explicit Constant(Definition* definition)
|
|
: definition_(definition), value_(Object::null_object()) {
|
|
ASSERT(definition != nullptr);
|
|
}
|
|
|
|
explicit Constant(Zone* zone, const Object& value)
|
|
: definition_(nullptr), value_(value) {}
|
|
|
|
Definition* definition() const {
|
|
ASSERT(definition_ != nullptr);
|
|
return definition_;
|
|
}
|
|
|
|
const Object& value() const {
|
|
ASSERT(definition_ == nullptr);
|
|
return value_;
|
|
}
|
|
|
|
private:
|
|
Definition* definition_;
|
|
const Object& value_;
|
|
};
|
|
|
|
Operand DecodeOperandA();
|
|
Operand DecodeOperandB();
|
|
Operand DecodeOperandC();
|
|
Operand DecodeOperandD();
|
|
Operand DecodeOperandX();
|
|
Operand DecodeOperandT();
|
|
KBCInstr InstructionAt(intptr_t pc, KernelBytecode::Opcode expect_opcode);
|
|
Constant ConstantAt(Operand entry_index, intptr_t add_index = 0);
|
|
void PushConstant(Constant constant);
|
|
Constant PopConstant();
|
|
void LoadStackSlots(intptr_t num_slots);
|
|
void AllocateLocalVariables(Operand frame_size,
|
|
intptr_t num_param_locals = 0);
|
|
LocalVariable* AllocateParameter(intptr_t param_index,
|
|
VariableIndex var_index);
|
|
void AllocateFixedParameters();
|
|
LocalVariable* LocalVariableAt(intptr_t local_index);
|
|
void StoreLocal(Operand local_index);
|
|
void LoadLocal(Operand local_index);
|
|
Value* Pop();
|
|
ArgumentArray GetArguments(int count);
|
|
void PropagateStackState(intptr_t target_pc);
|
|
void BuildIfStrictCompare(Token::Kind cmp_kind);
|
|
|
|
void BuildInstruction(KernelBytecode::Opcode opcode);
|
|
|
|
#define DECLARE_BUILD_METHOD(bytecode) void Build##bytecode();
|
|
|
|
FOR_EACH_BYTECODE_IN_FLOW_GRAPH_BUILDER(DECLARE_BUILD_METHOD)
|
|
#undef DECLARE_BUILD_METHOD
|
|
|
|
void ProcessICDataInObjectPool(const ObjectPool& object_pool);
|
|
intptr_t GetTryIndex(const PcDescriptors& descriptors, intptr_t pc);
|
|
JoinEntryInstr* EnsureControlFlowJoin(const PcDescriptors& descriptors,
|
|
intptr_t pc);
|
|
void CollectControlFlow(const PcDescriptors& descriptors,
|
|
const ExceptionHandlers& handlers,
|
|
GraphEntryInstr* graph_entry);
|
|
|
|
Thread* thread() const { return flow_graph_builder_->thread_; }
|
|
Isolate* isolate() const { return thread()->isolate(); }
|
|
|
|
ParsedFunction* parsed_function() {
|
|
ASSERT(!is_generating_interpreter());
|
|
return parsed_function_;
|
|
}
|
|
const Function& function() { return parsed_function()->function(); }
|
|
|
|
BaseFlowGraphBuilder* flow_graph_builder_;
|
|
Zone* zone_;
|
|
bool is_generating_interpreter_;
|
|
|
|
// The following members are available only when compiling bytecode.
|
|
|
|
ParsedFunction* parsed_function_;
|
|
ZoneGrowableArray<const ICData*>* ic_data_array_;
|
|
ObjectPool& object_pool_;
|
|
KBCInstr* raw_bytecode_;
|
|
intptr_t bytecode_length_;
|
|
intptr_t pc_;
|
|
KBCInstr bytecode_instr_;
|
|
TokenPosition position_; // TODO(alexmarkov): Set/update.
|
|
Fragment code_;
|
|
ZoneGrowableArray<LocalVariable*> local_vars_;
|
|
ZoneGrowableArray<LocalVariable*> parameters_;
|
|
LocalVariable* exception_var_;
|
|
LocalVariable* stacktrace_var_;
|
|
IntMap<JoinEntryInstr*> jump_targets_;
|
|
IntMap<Value*> stack_states_;
|
|
PrologueInfo prologue_info_;
|
|
JoinEntryInstr* throw_no_such_method_;
|
|
};
|
|
|
|
} // namespace kernel
|
|
} // namespace dart
|
|
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
#endif // RUNTIME_VM_COMPILER_FRONTEND_BYTECODE_FLOW_GRAPH_BUILDER_H_
|