blob: 8b87a7ab2e181b74cbb048efd03fc2df74fb905b [file] [log] [blame]
// Copyright (c) 2016, 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_SIMULATOR_DBC_H_
#define RUNTIME_VM_SIMULATOR_DBC_H_
#ifndef RUNTIME_VM_SIMULATOR_H_
#error Do not include simulator_dbc.h directly; use simulator.h.
#endif
#include "vm/compiler/method_recognizer.h"
#include "vm/constants_dbc.h"
namespace dart {
class Array;
class Code;
class Isolate;
class ObjectPointerVisitor;
class RawArray;
class RawCode;
class RawFunction;
class RawICData;
class RawImmutableArray;
class RawObject;
class RawObjectPool;
class SimulatorSetjmpBuffer;
class Thread;
// Simulator intrinsic handler. It is invoked on entry to the intrinsified
// function via Intrinsic bytecode before the frame is setup.
// If the handler returns true then Intrinsic bytecode works as a return
// instruction returning the value in result. Otherwise interpreter proceeds to
// execute the body of the function.
typedef bool (*IntrinsicHandler)(Thread* thread,
RawObject** FP,
RawObject** result);
class Simulator {
public:
static const uword kSimulatorStackUnderflowSize = 0x80;
Simulator();
~Simulator();
// The currently executing Simulator instance, which is associated to the
// current isolate
static Simulator* Current();
// Low address (DBC stack grows up).
uword stack_base() const { return stack_base_; }
// Limit for StackOverflowError.
uword overflow_stack_limit() const { return overflow_stack_limit_; }
// High address (DBC stack grows up).
uword stack_limit() const { return stack_limit_; }
// Call on program start.
static void Init();
RawObject* Call(const Code& code,
const Array& arguments_descriptor,
const Array& arguments,
Thread* thread);
void JumpToFrame(uword pc, uword sp, uword fp, Thread* thread);
uword get_sp() const { return reinterpret_cast<uword>(fp_); }
uword get_fp() const { return reinterpret_cast<uword>(fp_); }
uword get_pc() const { return reinterpret_cast<uword>(pc_); }
enum IntrinsicId {
#define V(test_class_name, test_function_name, enum_name, fp) \
k##enum_name##Intrinsic,
ALL_INTRINSICS_LIST(V) GRAPH_INTRINSICS_LIST(V)
#undef V
kIntrinsicCount,
};
static bool IsSupportedIntrinsic(IntrinsicId id) {
return intrinsics_[id] != NULL;
}
enum SpecialIndex {
kExceptionSpecialIndex,
kStackTraceSpecialIndex,
kSpecialIndexCount
};
void VisitObjectPointers(ObjectPointerVisitor* visitor);
private:
uintptr_t* stack_;
uword stack_base_;
uword overflow_stack_limit_;
uword stack_limit_;
RawObject** fp_;
uword pc_;
DEBUG_ONLY(uint64_t icount_;)
SimulatorSetjmpBuffer* last_setjmp_buffer_;
RawObjectPool* pp_; // Pool Pointer.
RawArray* argdesc_; // Arguments Descriptor: used to pass information between
// call instruction and the function entry.
RawObject* special_[kSpecialIndexCount];
static IntrinsicHandler intrinsics_[kIntrinsicCount];
void Exit(Thread* thread,
RawObject** base,
RawObject** exit_frame,
uint32_t* pc);
void CallRuntime(Thread* thread,
RawObject** base,
RawObject** exit_frame,
uint32_t* pc,
intptr_t argc_tag,
RawObject** args,
RawObject** result,
uword target);
void Invoke(Thread* thread,
RawObject** call_base,
RawObject** call_top,
uint32_t** pc,
RawObject*** FP,
RawObject*** SP);
bool Deoptimize(Thread* thread,
uint32_t** pc,
RawObject*** FP,
RawObject*** SP,
bool is_lazy);
void InlineCacheMiss(int checked_args,
Thread* thread,
RawICData* icdata,
RawObject** call_base,
RawObject** top,
uint32_t* pc,
RawObject** FP,
RawObject** SP);
void InstanceCall1(Thread* thread,
RawICData* icdata,
RawObject** call_base,
RawObject** call_top,
uint32_t** pc,
RawObject*** FP,
RawObject*** SP,
bool optimized);
void InstanceCall2(Thread* thread,
RawICData* icdata,
RawObject** call_base,
RawObject** call_top,
uint32_t** pc,
RawObject*** FP,
RawObject*** SP,
bool optimized);
void PrepareForTailCall(RawCode* code,
RawImmutableArray* args_desc,
RawObject** FP,
RawObject*** SP,
uint32_t** pc);
#if !defined(PRODUCT)
// Returns true if tracing of executed instructions is enabled.
bool IsTracingExecution() const;
// Prints bytecode instruction at given pc for instruction tracing.
void TraceInstruction(uint32_t* pc) const;
#endif // !defined(PRODUCT)
// Longjmp support for exceptions.
SimulatorSetjmpBuffer* last_setjmp_buffer() { return last_setjmp_buffer_; }
void set_last_setjmp_buffer(SimulatorSetjmpBuffer* buffer) {
last_setjmp_buffer_ = buffer;
}
friend class SimulatorSetjmpBuffer;
DISALLOW_COPY_AND_ASSIGN(Simulator);
};
} // namespace dart
#endif // RUNTIME_VM_SIMULATOR_DBC_H_