Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(795)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/vm/intermediate_language.h

Issue 10917085: Revert "Remove classes Computation and BindInstr." (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 8 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « runtime/vm/il_printer.cc ('k') | runtime/vm/intermediate_language.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/vm/intermediate_language.h
diff --git a/runtime/vm/intermediate_language.h b/runtime/vm/intermediate_language.h
index 217d091901f897982706b502656afe0b99806bd2..51720a50cb73b7dc0430c0c64d8cdb13da8adbf5 100644
--- a/runtime/vm/intermediate_language.h
+++ b/runtime/vm/intermediate_language.h
@@ -14,10 +14,13 @@
namespace dart {
+class BindInstr;
class BitVector;
class BlockEntryInstr;
class BufferFormatter;
-class ComparisonInstr;
+class ComparisonComp;
+class ConstantComp;
+class Computation;
class ControlInstruction;
class Definition;
class Environment;
@@ -182,6 +185,7 @@ class EmbeddedArray<T, 0> {
M(JoinEntry) \
M(TargetEntry) \
M(Phi) \
+ M(Bind) \
M(Parameter) \
M(ParallelMove) \
M(PushArgument) \
@@ -190,57 +194,6 @@ class EmbeddedArray<T, 0> {
M(ReThrow) \
M(Goto) \
M(Branch) \
- M(AssertAssignable) \
- M(AssertBoolean) \
- M(ArgumentDefinitionTest) \
- M(CurrentContext) \
- M(StoreContext) \
- M(ClosureCall) \
- M(InstanceCall) \
- M(PolymorphicInstanceCall) \
- M(StaticCall) \
- M(LoadLocal) \
- M(StoreLocal) \
- M(StrictCompare) \
- M(EqualityCompare) \
- M(RelationalOp) \
- M(NativeCall) \
- M(LoadIndexed) \
- M(StoreIndexed) \
- M(LoadInstanceField) \
- M(StoreInstanceField) \
- M(LoadStaticField) \
- M(StoreStaticField) \
- M(BooleanNegate) \
- M(InstanceOf) \
- M(CreateArray) \
- M(CreateClosure) \
- M(AllocateObject) \
- M(AllocateObjectWithBoundsCheck) \
- M(LoadVMField) \
- M(StoreVMField) \
- M(InstantiateTypeArguments) \
- M(ExtractConstructorTypeArguments) \
- M(ExtractConstructorInstantiator) \
- M(AllocateContext) \
- M(ChainContext) \
- M(CloneContext) \
- M(CatchEntry) \
- M(BinarySmiOp) \
- M(BinaryMintOp) \
- M(UnarySmiOp) \
- M(NumberNegate) \
- M(CheckStackOverflow) \
- M(DoubleToDouble) \
- M(SmiToDouble) \
- M(CheckClass) \
- M(CheckSmi) \
- M(Constant) \
- M(CheckEitherNonSmi) \
- M(UnboxedDoubleBinaryOp) \
- M(UnboxDouble) \
- M(BoxDouble) \
- M(CheckArrayBound) \
#define FORWARD_DECLARATION(type) class type##Instr;
@@ -250,32 +203,17 @@ FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
// Functions required in all concrete instruction classes.
#define DECLARE_INSTRUCTION(type) \
- virtual Tag tag() const { return k##type; } \
virtual void Accept(FlowGraphVisitor* visitor); \
virtual type##Instr* As##type() { return this; } \
virtual const char* DebugName() const { return #type; } \
- virtual LocationSummary* MakeLocationSummary() const; \
- virtual void EmitNativeCode(FlowGraphCompiler* compiler); \
+ virtual void PrintTo(BufferFormatter* f) const; \
+ virtual void PrintToVisualizer(BufferFormatter* f) const;
class Instruction : public ZoneAllocated {
public:
-#define DECLARE_TAG(type) k##type,
- enum Tag {
- FOR_EACH_INSTRUCTION(DECLARE_TAG)
- };
-#undef DECLARE_TAG
-
Instruction()
- : deopt_id_(Isolate::Current()->GetNextDeoptId()),
- lifetime_position_(-1),
- previous_(NULL),
- next_(NULL),
- env_(NULL) { }
-
- virtual Tag tag() const = 0;
-
- intptr_t deopt_id() const { return deopt_id_; }
+ : lifetime_position_(-1), previous_(NULL), next_(NULL), env_(NULL) { }
bool IsBlockEntry() { return (AsBlockEntry() != NULL); }
virtual BlockEntryInstr* AsBlockEntry() { return NULL; }
@@ -290,8 +228,8 @@ class Instruction : public ZoneAllocated {
virtual Value* InputAt(intptr_t i) const = 0;
virtual void SetInputAt(intptr_t i, Value* value) = 0;
- // Call instructions override this function and return the number of
- // pushed arguments.
+ // Call instructions override this function and return the
+ // number of pushed arguments.
virtual intptr_t ArgumentCount() const = 0;
// Returns true, if this instruction can deoptimize.
@@ -361,8 +299,6 @@ class Instruction : public ZoneAllocated {
virtual void RecordAssignedVars(BitVector* assigned_vars,
intptr_t fixed_parameter_count);
- virtual const char* DebugName() const = 0;
-
// Printing support.
virtual void PrintTo(BufferFormatter* f) const = 0;
virtual void PrintToVisualizer(BufferFormatter* f) const = 0;
@@ -382,10 +318,6 @@ FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
return NULL;
}
- virtual LocationSummary* MakeLocationSummary() const = 0;
-
- static LocationSummary* MakeCallSummary();
-
virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
UNIMPLEMENTED();
}
@@ -420,25 +352,9 @@ FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
return Isolate::kNoDeoptId;
}
- protected:
- // Fetch deopt id without checking if this computation can deoptimize.
- intptr_t GetDeoptId() const {
- return deopt_id_;
- }
-
private:
friend class Definition; // Needed for InsertBefore, InsertAfter.
- // Classes that set deopt_id_.
- friend class UnboxDoubleInstr;
- friend class UnboxedDoubleBinaryOpInstr;
- friend class CheckClassInstr;
- friend class CheckSmiInstr;
- friend class CheckNonSmiInstr;
- friend class CheckArrayBoundInstr;
- friend class CheckEitherNonSmiInstr;
-
- intptr_t deopt_id_;
intptr_t lifetime_position_; // Position used by register allocator.
Instruction* previous_;
Instruction* next_;
@@ -466,6 +382,8 @@ class TemplateInstruction: public Instruction {
return locs_;
}
+ virtual LocationSummary* MakeLocationSummary() const = 0;
+
protected:
EmbeddedArray<Value*, N> inputs_;
@@ -555,8 +473,9 @@ class ParallelMoveInstr : public TemplateInstruction<0> {
intptr_t NumMoves() const { return moves_.length(); }
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
+ LocationSummary* MakeLocationSummary() const { return NULL; }
+
+ void EmitNativeCode(FlowGraphCompiler* compiler) { UNREACHABLE(); }
private:
GrowableArray<MoveOperands*> moves_; // Elements cannot be null.
@@ -695,10 +614,6 @@ class ForwardInstructionIterator : public ValueObject {
// Removes 'current_' from graph and sets 'current_' to previous instruction.
void RemoveCurrentFromGraph();
- // Inserts replaces 'current_', which must be a definition, with another
- // definition. The new definition becomes 'current_'.
- void ReplaceCurrentWith(Definition* other);
-
Instruction* Current() const { return current_; }
private:
@@ -761,7 +676,7 @@ class GraphEntryInstr : public BlockEntryInstr {
Environment* start_env() const { return start_env_; }
void set_start_env(Environment* env) { start_env_ = env; }
- ConstantInstr* constant_null() const { return constant_null_; }
+ Definition* constant_null() const { return constant_null_; }
intptr_t spill_slot_count() const { return spill_slot_count_; }
void set_spill_slot_count(intptr_t count) {
@@ -771,14 +686,11 @@ class GraphEntryInstr : public BlockEntryInstr {
TargetEntryInstr* normal_entry() const { return normal_entry_; }
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
-
private:
TargetEntryInstr* normal_entry_;
GrowableArray<TargetEntryInstr*> catch_entries_;
Environment* start_env_;
- ConstantInstr* constant_null_;
+ Definition* constant_null_;
intptr_t spill_slot_count_;
DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
@@ -815,9 +727,6 @@ class JoinEntryInstr : public BlockEntryInstr {
intptr_t phi_count() const { return phi_count_; }
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
-
private:
GrowableArray<BlockEntryInstr*> predecessors_;
ZoneGrowableArray<PhiInstr*>* phis_;
@@ -868,9 +777,6 @@ class TargetEntryInstr : public BlockEntryInstr {
virtual void PrepareEntry(FlowGraphCompiler* compiler);
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
-
private:
BlockEntryInstr* predecessor_;
const intptr_t catch_try_index_;
@@ -896,12 +802,6 @@ class Definition : public Instruction {
virtual Definition* AsDefinition() { return this; }
- bool IsComparison() { return (AsComparison() != NULL); }
- virtual ComparisonInstr* AsComparison() { return NULL; }
-
- // Overridden by definitions that push arguments.
- virtual intptr_t ArgumentCount() const { return 0; }
-
intptr_t temp_index() const { return temp_index_; }
void set_temp_index(intptr_t index) { temp_index_ = index; }
@@ -920,8 +820,6 @@ class Definition : public Instruction {
// propagation during graph building.
virtual RawAbstractType* CompileType() const = 0;
- virtual intptr_t ResultCid() const = 0;
-
bool HasPropagatedType() const {
return !propagated_type_.IsNull();
}
@@ -943,71 +841,32 @@ class Definition : public Instruction {
bool has_propagated_cid() const { return propagated_cid_ != kIllegalCid; }
intptr_t propagated_cid() const { return propagated_cid_; }
-
// May compute and set propagated cid.
- virtual intptr_t GetPropagatedCid();
+ virtual intptr_t GetPropagatedCid() = 0;
// Returns true if the propagated cid has changed.
bool SetPropagatedCid(intptr_t cid);
- // Returns true if the definition may have side effects.
- // TODO(fschneider): Make this abstract and implement for all definitions
- // instead of returning the safe default (true).
- virtual bool HasSideEffect() const { return true; }
-
Value* input_use_list() { return input_use_list_; }
void set_input_use_list(Value* head) { input_use_list_ = head; }
Value* env_use_list() { return env_use_list_; }
void set_env_use_list(Value* head) { env_use_list_ = head; }
- // Returns a replacement for the definition or NULL if the definition can
- // be eliminated. By default returns the definition (input parameter)
- // which means no change.
- virtual Definition* Canonicalize();
-
// Replace uses of this definition with uses of other definition or value.
// Precondition: use lists must be properly calculated.
// Postcondition: use lists and use values are still valid.
void ReplaceUsesWith(Definition* other);
- // Replace this definition and all uses with another definition. If
- // replacing during iteration, pass the iterator so that the instruction
- // can be replaced without affecting iteration order, otherwise pass a
- // NULL iterator.
- void ReplaceWith(Definition* other, ForwardInstructionIterator* iterator);
-
// Insert this definition before 'next'.
void InsertBefore(Instruction* next);
// Insert this definition after 'prev'.
void InsertAfter(Instruction* prev);
- // Compares two definitions. Returns true, iff:
- // 1. They have the same tag.
- // 2. All input operands are Equals.
- // 3. They satisfy AttributesEqual.
- bool Equals(Definition* other) const;
-
- // Compare attributes of a definition (except input operands and tag).
- // All definition that participate in CSE have to override this function.
- // This function can assume that the argument has the same type as this.
- virtual bool AttributesEqual(Definition* other) const {
- UNREACHABLE();
- return false;
- }
-
- // Returns a hash code for use with hash maps.
- virtual intptr_t Hashcode() const;
-
- virtual void RecordAssignedVars(BitVector* assigned_vars,
- intptr_t fixed_parameter_count);
-
- // Printing support. These functions are sometimes overridden for custom
- // formatting. Otherwise, it prints in the format "opcode(op1, op2, op3)".
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintOperandsTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
+ // If this definition is a bind of a constant return it.
+ // Otherwise return NULL.
+ ConstantComp* AsConstant();
private:
intptr_t temp_index_;
@@ -1024,6 +883,48 @@ class Definition : public Instruction {
};
+class BindInstr : public Definition {
+ public:
+ BindInstr(UseKind used, Computation* computation)
+ : computation_(computation) {
+ ASSERT(computation != NULL);
+ set_use_kind(used);
+ }
+
+ DECLARE_INSTRUCTION(Bind)
+
+ // Overridden functions from class Instruction.
+ virtual intptr_t ArgumentCount() const;
+ intptr_t InputCount() const;
+ Value* InputAt(intptr_t i) const;
+ void SetInputAt(intptr_t i, Value* value);
+ virtual bool CanDeoptimize() const;
+ virtual void RecordAssignedVars(BitVector* assigned_vars,
+ intptr_t fixed_parameter_count);
+ virtual LocationSummary* locs();
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+ virtual Representation RequiredInputRepresentation(intptr_t i) const;
+ virtual Representation representation() const;
+ virtual intptr_t DeoptimizationTarget() const;
+
+ Computation* computation() const { return computation_; }
+ void set_computation(Computation* value) { computation_ = value; }
+
+ // Overridden functions from class Definition.
+ virtual RawAbstractType* CompileType() const;
+ virtual intptr_t GetPropagatedCid();
+
+ // Other functions that forward to the computation.
+ intptr_t Hashcode() const;
+ bool Equals(BindInstr* other) const;
+
+ private:
+ Computation* computation_;
+
+ DISALLOW_COPY_AND_ASSIGN(BindInstr);
+};
+
+
class PhiInstr : public Definition {
public:
explicit PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
@@ -1039,7 +940,7 @@ class PhiInstr : public Definition {
JoinEntryInstr* block() const { return block_; }
virtual RawAbstractType* CompileType() const;
- virtual intptr_t GetPropagatedCid();
+ virtual intptr_t GetPropagatedCid() { return propagated_cid(); }
virtual intptr_t ArgumentCount() const { return 0; }
@@ -1070,21 +971,8 @@ class PhiInstr : public Definition {
representation_ = r;
}
- virtual intptr_t Hashcode() const {
- UNREACHABLE();
- return 0;
- }
-
- virtual intptr_t ResultCid() const {
- UNREACHABLE();
- return kIllegalCid;
- }
-
DECLARE_INSTRUCTION(Phi)
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
-
private:
JoinEntryInstr* block_;
GrowableArray<Value*> inputs_;
@@ -1105,9 +993,8 @@ class ParameterInstr : public Definition {
// Compile type of the passed-in parameter.
virtual RawAbstractType* CompileType() const;
-
// No known propagated cid for parameters.
- virtual intptr_t GetPropagatedCid();
+ virtual intptr_t GetPropagatedCid() { return propagated_cid(); }
virtual intptr_t ArgumentCount() const { return 0; }
@@ -1120,19 +1007,6 @@ class ParameterInstr : public Definition {
virtual bool CanDeoptimize() const { return false; }
- virtual intptr_t Hashcode() const {
- UNREACHABLE();
- return 0;
- }
-
- virtual intptr_t ResultCid() const {
- UNREACHABLE();
- return kIllegalCid;
- }
-
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
-
private:
const intptr_t index_;
@@ -1144,7 +1018,6 @@ class PushArgumentInstr : public Definition {
public:
explicit PushArgumentInstr(Value* value) : value_(value), locs_(NULL) {
ASSERT(value != NULL);
- set_use_kind(kEffect); // Override the default.
}
DECLARE_INSTRUCTION(PushArgument)
@@ -1163,10 +1036,6 @@ class PushArgumentInstr : public Definition {
virtual RawAbstractType* CompileType() const;
virtual intptr_t GetPropagatedCid() { return propagated_cid(); }
- virtual intptr_t ResultCid() const {
- UNREACHABLE();
- return kIllegalCid;
- }
Value* value() const { return value_; }
@@ -1177,15 +1046,11 @@ class PushArgumentInstr : public Definition {
return locs_;
}
- virtual intptr_t Hashcode() const {
- UNREACHABLE();
- return 0;
- }
+ LocationSummary* MakeLocationSummary() const;
- virtual bool CanDeoptimize() const { return false; }
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
+ virtual bool CanDeoptimize() const { return false; }
private:
Value* value_;
@@ -1198,7 +1063,8 @@ class PushArgumentInstr : public Definition {
class ReturnInstr : public TemplateInstruction<1> {
public:
ReturnInstr(intptr_t token_pos, Value* value)
- : token_pos_(token_pos) {
+ : deopt_id_(Isolate::Current()->GetNextDeoptId()),
+ token_pos_(token_pos) {
ASSERT(value != NULL);
inputs_[0] = value;
}
@@ -1207,15 +1073,18 @@ class ReturnInstr : public TemplateInstruction<1> {
virtual intptr_t ArgumentCount() const { return 0; }
+ intptr_t deopt_id() const { return deopt_id_; }
intptr_t token_pos() const { return token_pos_; }
Value* value() const { return inputs_[0]; }
- virtual bool CanDeoptimize() const { return false; }
+ virtual LocationSummary* MakeLocationSummary() const;
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
+ virtual bool CanDeoptimize() const { return false; }
private:
+ const intptr_t deopt_id_;
const intptr_t token_pos_;
DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
@@ -1232,10 +1101,11 @@ class ThrowInstr : public TemplateInstruction<0> {
intptr_t token_pos() const { return token_pos_; }
- virtual bool CanDeoptimize() const { return false; }
+ virtual LocationSummary* MakeLocationSummary() const;
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
+ virtual bool CanDeoptimize() const { return false; }
private:
const intptr_t token_pos_;
@@ -1254,10 +1124,11 @@ class ReThrowInstr : public TemplateInstruction<0> {
intptr_t token_pos() const { return token_pos_; }
- virtual bool CanDeoptimize() const { return false; }
+ virtual LocationSummary* MakeLocationSummary() const;
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
+ virtual bool CanDeoptimize() const { return false; }
private:
const intptr_t token_pos_;
@@ -1281,6 +1152,10 @@ class GotoInstr : public TemplateInstruction<0> {
virtual intptr_t SuccessorCount() const;
virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
+ virtual LocationSummary* MakeLocationSummary() const;
+
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
virtual bool CanDeoptimize() const { return false; }
ParallelMoveInstr* parallel_move() const {
@@ -1298,9 +1173,6 @@ class GotoInstr : public TemplateInstruction<0> {
return parallel_move_;
}
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
-
private:
JoinEntryInstr* successor_;
@@ -1348,8 +1220,8 @@ class ControlInstruction : public Instruction {
class BranchInstr : public ControlInstruction {
public:
- explicit BranchInstr(ComparisonInstr* comparison)
- : comparison_(comparison) { }
+ explicit BranchInstr(ComparisonComp* computation)
+ : computation_(computation), locs_(NULL) { }
DECLARE_INSTRUCTION(Branch)
@@ -1359,43 +1231,157 @@ class BranchInstr : public ControlInstruction {
void SetInputAt(intptr_t i, Value* value);
virtual bool CanDeoptimize() const;
- ComparisonInstr* comparison() const { return comparison_; }
- void set_comparison(ComparisonInstr* value) { comparison_ = value; }
+ ComparisonComp* computation() const { return computation_; }
+ void set_computation(ComparisonComp* value) { computation_ = value; }
+
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
virtual LocationSummary* locs();
virtual intptr_t DeoptimizationTarget() const;
virtual Representation RequiredInputRepresentation(intptr_t i) const;
- // Replace the comparison with another, leaving the branch intact.
- void ReplaceWith(ComparisonInstr* other,
- ForwardInstructionIterator* ignored) {
- comparison_ = other;
- }
-
- virtual void PrintTo(BufferFormatter* f) const;
- virtual void PrintToVisualizer(BufferFormatter* f) const;
-
private:
- ComparisonInstr* comparison_;
+ ComparisonComp* computation_;
+ LocationSummary* locs_;
DISALLOW_COPY_AND_ASSIGN(BranchInstr);
};
-template<intptr_t N>
-class TemplateDefinition : public Definition {
+#undef DECLARE_INSTRUCTION
+
+
+// M is a two argument macro. It is applied to each concrete instruction's
+// (including the values) typename and classname.
+#define FOR_EACH_COMPUTATION(M) \
+ M(AssertAssignable, AssertAssignableComp) \
+ M(AssertBoolean, AssertBooleanComp) \
+ M(ArgumentDefinitionTest, ArgumentDefinitionTestComp) \
+ M(CurrentContext, CurrentContextComp) \
+ M(StoreContext, StoreContextComp) \
+ M(ClosureCall, ClosureCallComp) \
+ M(InstanceCall, InstanceCallComp) \
+ M(PolymorphicInstanceCall, PolymorphicInstanceCallComp) \
+ M(StaticCall, StaticCallComp) \
+ M(LoadLocal, LoadLocalComp) \
+ M(StoreLocal, StoreLocalComp) \
+ M(StrictCompare, StrictCompareComp) \
+ M(EqualityCompare, EqualityCompareComp) \
+ M(RelationalOp, RelationalOpComp) \
+ M(NativeCall, NativeCallComp) \
+ M(LoadIndexed, LoadIndexedComp) \
+ M(StoreIndexed, StoreIndexedComp) \
+ M(LoadInstanceField, LoadInstanceFieldComp) \
+ M(StoreInstanceField, StoreInstanceFieldComp) \
+ M(LoadStaticField, LoadStaticFieldComp) \
+ M(StoreStaticField, StoreStaticFieldComp) \
+ M(BooleanNegate, BooleanNegateComp) \
+ M(InstanceOf, InstanceOfComp) \
+ M(CreateArray, CreateArrayComp) \
+ M(CreateClosure, CreateClosureComp) \
+ M(AllocateObject, AllocateObjectComp) \
+ M(AllocateObjectWithBoundsCheck, AllocateObjectWithBoundsCheckComp) \
+ M(LoadVMField, LoadVMFieldComp) \
+ M(StoreVMField, StoreVMFieldComp) \
+ M(InstantiateTypeArguments, InstantiateTypeArgumentsComp) \
+ M(ExtractConstructorTypeArguments, ExtractConstructorTypeArgumentsComp) \
+ M(ExtractConstructorInstantiator, ExtractConstructorInstantiatorComp) \
+ M(AllocateContext, AllocateContextComp) \
+ M(ChainContext, ChainContextComp) \
+ M(CloneContext, CloneContextComp) \
+ M(CatchEntry, CatchEntryComp) \
+ M(BinarySmiOp, BinarySmiOpComp) \
+ M(BinaryMintOp, BinaryMintOpComp) \
+ M(UnarySmiOp, UnarySmiOpComp) \
+ M(NumberNegate, NumberNegateComp) \
+ M(CheckStackOverflow, CheckStackOverflowComp) \
+ M(DoubleToDouble, DoubleToDoubleComp) \
+ M(SmiToDouble, SmiToDoubleComp) \
+ M(CheckClass, CheckClassComp) \
+ M(CheckSmi, CheckSmiComp) \
+ M(Constant, ConstantComp) \
+ M(CheckEitherNonSmi, CheckEitherNonSmiComp) \
+ M(UnboxedDoubleBinaryOp, UnboxedDoubleBinaryOpComp) \
+ M(UnboxDouble, UnboxDoubleComp) \
+ M(BoxDouble, BoxDoubleComp) \
+ M(CheckArrayBound, CheckArrayBoundComp)
+
+
+#define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
+FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
+#undef FORWARD_DECLARATION
+
+
+class Computation : public ZoneAllocated {
public:
- TemplateDefinition<N>() : locs_(NULL) { }
+ Computation()
+ : deopt_id_(Isolate::Current()->GetNextDeoptId()), locs_(NULL) { }
- virtual intptr_t InputCount() const { return N; }
- virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
- virtual void SetInputAt(intptr_t i, Value* value) {
- ASSERT(value != NULL);
- inputs_[i] = value;
+ // Unique id used for deoptimization.
+ virtual intptr_t deopt_id() const {
+ ASSERT(CanDeoptimize());
+ return deopt_id_;
+ }
+
+ // Visiting support.
+ virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr) = 0;
+
+ virtual intptr_t InputCount() const = 0;
+ virtual Value* InputAt(intptr_t i) const = 0;
+ virtual void SetInputAt(intptr_t i, Value* value) = 0;
+
+ // Call computations override this function and return the
+ // number of pushed arguments.
+ virtual intptr_t ArgumentCount() const = 0;
+
+ // Returns true, if this computation can deoptimize.
+ virtual bool CanDeoptimize() const = 0;
+
+ // Returns a replacement for the instruction that wraps this computation.
+ // Returns NULL if instr can be eliminated.
+ // By default returns instr (input parameter) which means no change.
+ virtual Definition* TryReplace(BindInstr* instr) const;
+
+ // Compares two computations. Returns true, if:
+ // 1. They are of the same kind.
+ // 2. All input operands match.
+ // 3. All other attributes match.
+ bool Equals(Computation* other) const;
+
+ // Returns a hash code for use with hash maps.
+ virtual intptr_t Hashcode() const;
+
+ // Compare attributes of an computation (except input operands and kind).
+ // All computations that participate in CSE have to override this function.
+ virtual bool AttributesEqual(Computation* other) const {
+ UNREACHABLE();
+ return false;
}
- // Returns a structure describing the location constraints required
- // to emit native code for this definition.
+ // Returns true if the instruction may have side effects.
+ // TODO(fschneider): Make this abstract and implement for all computations
+ // instead of returning the safe default (true).
+ virtual bool HasSideEffect() const { return true; }
+
+ // Compile time type of the computation, which typically depends on the
+ // compile time types (and possibly propagated types) of its inputs.
+ virtual RawAbstractType* CompileType() const = 0;
+ virtual intptr_t ResultCid() const = 0;
+
+ // Mutate assigned_vars to add the local variable index for all
+ // frame-allocated locals assigned to by the computation.
+ virtual void RecordAssignedVars(BitVector* assigned_vars,
+ intptr_t fixed_parameter_count);
+
+ virtual const char* DebugName() const = 0;
+
+ // Printing support. These functions are sometimes overridden for custom
+ // formatting. Otherwise, it prints in the format "opcode(op1, op2, op3)".
+ virtual void PrintTo(BufferFormatter* f) const;
+ virtual void PrintOperandsTo(BufferFormatter* f) const;
+
+ // Returns structure describing location constraints required
+ // to emit native code for this computation.
LocationSummary* locs() {
if (locs_ == NULL) {
locs_ = MakeLocationSummary();
@@ -1403,22 +1389,176 @@ class TemplateDefinition : public Definition {
return locs_;
}
+ virtual ComparisonComp* AsComparison() { return NULL; }
+
+ // Create a location summary for this computation.
+ // TODO(fschneider): Temporarily returns NULL for instructions
+ // that are not yet converted to the location based code generation.
+ virtual LocationSummary* MakeLocationSummary() const = 0;
+
+ // TODO(fschneider): Make EmitNativeCode and locs const.
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler) = 0;
+
+ virtual void EmitBranchCode(FlowGraphCompiler* compiler,
+ BranchInstr* branch) {
+ UNREACHABLE();
+ }
+
+ static LocationSummary* MakeCallSummary();
+
+ // Declare an enum value used to define kind-test predicates.
+ enum ComputationKind {
+#define DECLARE_COMPUTATION_KIND(ShortName, ClassName) k##ShortName,
+
+ FOR_EACH_COMPUTATION(DECLARE_COMPUTATION_KIND)
+
+#undef DECLARE_COMPUTATION_KIND
+ };
+
+ virtual ComputationKind computation_kind() const = 0;
+
+ // Returns representation expected for the input operand at the given index.
+ virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+ return kTagged;
+ }
+
+ // Representation of the value produced by this computation.
+ virtual Representation representation() const {
+ return kTagged;
+ }
+
+ // Returns deoptimization id that corresponds to the deoptimization target
+ // that input operands conversions inserted for this instruction can jump
+ // to. Can return kNoDeoptId.
+ virtual intptr_t DeoptimizationTarget() const {
+ UNREACHABLE();
+ return Isolate::kNoDeoptId;
+ }
+
+ // Declare predicate for each computation.
+#define DECLARE_PREDICATE(ShortName, ClassName) \
+ inline bool Is##ShortName() const; \
+ inline const ClassName* As##ShortName() const; \
+ inline ClassName* As##ShortName();
+FOR_EACH_COMPUTATION(DECLARE_PREDICATE)
+#undef DECLARE_PREDICATE
+
protected:
- EmbeddedArray<Value*, N> inputs_;
+ // Fetch deopt id without checking if this computation can deoptimize.
+ intptr_t GetDeoptId() const {
+ return deopt_id_;
+ }
private:
friend class BranchInstr;
+ intptr_t deopt_id_;
LocationSummary* locs_;
+
+ DISALLOW_COPY_AND_ASSIGN(Computation);
};
-class ConstantInstr : public TemplateDefinition<0> {
+// Inlined functions from class BindInstr that forward to their computation.
+inline intptr_t BindInstr::ArgumentCount() const {
+ return computation()->ArgumentCount();
+}
+
+
+inline intptr_t BindInstr::InputCount() const {
+ return computation()->InputCount();
+}
+
+
+inline Value* BindInstr::InputAt(intptr_t i) const {
+ return computation()->InputAt(i);
+}
+
+
+inline void BindInstr::SetInputAt(intptr_t i, Value* value) {
+ computation()->SetInputAt(i, value);
+}
+
+inline bool BindInstr::CanDeoptimize() const {
+ return computation()->CanDeoptimize();
+}
+
+
+inline intptr_t BindInstr::Hashcode() const {
+ return computation()->Hashcode();
+}
+
+
+inline bool BindInstr::Equals(BindInstr* other) const {
+ return computation()->Equals(other->computation());
+}
+
+
+inline LocationSummary* BindInstr::locs() {
+ return computation()->locs();
+}
+
+
+inline Representation BindInstr::RequiredInputRepresentation(intptr_t i) const {
+ return computation()->RequiredInputRepresentation(i);
+}
+
+
+inline Representation BindInstr::representation() const {
+ return computation()->representation();
+}
+
+
+inline intptr_t BindInstr::DeoptimizationTarget() const {
+ return computation()->DeoptimizationTarget();
+}
+
+
+template<intptr_t N>
+class TemplateComputation : public Computation {
public:
- explicit ConstantInstr(const Object& value) : value_(value) { }
+ virtual intptr_t InputCount() const { return N; }
+ virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
+ virtual void SetInputAt(intptr_t i, Value* value) {
+ ASSERT(value != NULL);
+ inputs_[i] = value;
+ }
- DECLARE_INSTRUCTION(Constant)
- virtual RawAbstractType* CompileType() const;
+ protected:
+ EmbeddedArray<Value*, N> inputs_;
+};
+
+
+// Functions defined in all concrete computation classes.
+#define DECLARE_COMPUTATION(ShortName) \
+ virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr); \
+ virtual ComputationKind computation_kind() const { \
+ return Computation::k##ShortName; \
+ } \
+ virtual intptr_t ArgumentCount() const { return 0; } \
+ virtual const char* DebugName() const { return #ShortName; } \
+ virtual RawAbstractType* CompileType() const; \
+ virtual LocationSummary* MakeLocationSummary() const; \
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
+
+// Function defined in all call computation classes.
+#define DECLARE_CALL_COMPUTATION(ShortName) \
+ virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr); \
+ virtual ComputationKind computation_kind() const { \
+ return Computation::k##ShortName; \
+ } \
+ virtual const char* DebugName() const { return #ShortName; } \
+ virtual RawAbstractType* CompileType() const; \
+ virtual LocationSummary* MakeLocationSummary() const; \
+ virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
+
+class ConstantComp : public TemplateComputation<0> {
+ public:
+ explicit ConstantComp(const Object& value) : value_(value) { }
+
+ DECLARE_COMPUTATION(Constant)
const Object& value() const { return value_; }
@@ -1428,23 +1568,23 @@ class ConstantInstr : public TemplateDefinition<0> {
virtual intptr_t ResultCid() const;
- virtual bool AttributesEqual(Definition* other) const;
+ virtual bool AttributesEqual(Computation* other) const;
private:
const Object& value_;
- DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
+ DISALLOW_COPY_AND_ASSIGN(ConstantComp);
};
-class AssertAssignableInstr : public TemplateDefinition<3> {
+class AssertAssignableComp : public TemplateComputation<3> {
public:
- AssertAssignableInstr(intptr_t token_pos,
- Value* value,
- Value* instantiator,
- Value* instantiator_type_arguments,
- const AbstractType& dst_type,
- const String& dst_name)
+ AssertAssignableComp(intptr_t token_pos,
+ Value* value,
+ Value* instantiator,
+ Value* instantiator_type_arguments,
+ const AbstractType& dst_type,
+ const String& dst_name)
: token_pos_(token_pos),
dst_type_(dst_type),
dst_name_(dst_name),
@@ -1459,8 +1599,7 @@ class AssertAssignableInstr : public TemplateDefinition<3> {
inputs_[2] = instantiator_type_arguments;
}
- DECLARE_INSTRUCTION(AssertAssignable)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(AssertAssignable)
Value* value() const { return inputs_[0]; }
Value* instantiator() const { return inputs_[1]; }
@@ -1489,21 +1628,21 @@ class AssertAssignableInstr : public TemplateDefinition<3> {
const String& dst_name_;
bool is_eliminated_;
- DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
+ DISALLOW_COPY_AND_ASSIGN(AssertAssignableComp);
};
-class AssertBooleanInstr : public TemplateDefinition<1> {
+class AssertBooleanComp : public TemplateComputation<1> {
public:
- AssertBooleanInstr(intptr_t token_pos, Value* value)
+ AssertBooleanComp(intptr_t token_pos,
+ Value* value)
: token_pos_(token_pos),
is_eliminated_(false) {
ASSERT(value != NULL);
inputs_[0] = value;
}
- DECLARE_INSTRUCTION(AssertBoolean)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(AssertBoolean)
intptr_t token_pos() const { return token_pos_; }
Value* value() const { return inputs_[0]; }
@@ -1525,21 +1664,20 @@ class AssertBooleanInstr : public TemplateDefinition<1> {
const intptr_t token_pos_;
bool is_eliminated_;
- DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
+ DISALLOW_COPY_AND_ASSIGN(AssertBooleanComp);
};
-class ArgumentDefinitionTestInstr : public TemplateDefinition<1> {
+class ArgumentDefinitionTestComp : public TemplateComputation<1> {
public:
- ArgumentDefinitionTestInstr(ArgumentDefinitionTestNode* node,
- Value* saved_arguments_descriptor)
+ ArgumentDefinitionTestComp(ArgumentDefinitionTestNode* node,
+ Value* saved_arguments_descriptor)
: ast_node_(*node) {
ASSERT(saved_arguments_descriptor != NULL);
inputs_[0] = saved_arguments_descriptor;
}
- DECLARE_INSTRUCTION(ArgumentDefinitionTest)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(ArgumentDefinitionTest)
intptr_t token_pos() const { return ast_node_.token_pos(); }
intptr_t formal_parameter_index() const {
@@ -1558,36 +1696,34 @@ class ArgumentDefinitionTestInstr : public TemplateDefinition<1> {
private:
const ArgumentDefinitionTestNode& ast_node_;
- DISALLOW_COPY_AND_ASSIGN(ArgumentDefinitionTestInstr);
+ DISALLOW_COPY_AND_ASSIGN(ArgumentDefinitionTestComp);
};
// Denotes the current context, normally held in a register. This is
// a computation, not a value, because it's mutable.
-class CurrentContextInstr : public TemplateDefinition<0> {
+class CurrentContextComp : public TemplateComputation<0> {
public:
- CurrentContextInstr() { }
+ CurrentContextComp() { }
- DECLARE_INSTRUCTION(CurrentContext)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(CurrentContext)
virtual bool CanDeoptimize() const { return false; }
virtual intptr_t ResultCid() const { return kDynamicCid; }
private:
- DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
+ DISALLOW_COPY_AND_ASSIGN(CurrentContextComp);
};
-class StoreContextInstr : public TemplateDefinition<1> {
+class StoreContextComp : public TemplateComputation<1> {
public:
- explicit StoreContextInstr(Value* value) {
+ explicit StoreContextComp(Value* value) {
ASSERT(value != NULL);
inputs_[0] = value;
}
- DECLARE_INSTRUCTION(StoreContext);
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(StoreContext);
Value* value() const { return inputs_[0]; }
@@ -1595,19 +1731,18 @@ class StoreContextInstr : public TemplateDefinition<1> {
virtual intptr_t ResultCid() const { return kIllegalCid; }
private:
- DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
+ DISALLOW_COPY_AND_ASSIGN(StoreContextComp);
};
-class ClosureCallInstr : public TemplateDefinition<0> {
+class ClosureCallComp : public TemplateComputation<0> {
public:
- ClosureCallInstr(ClosureCallNode* node,
- ZoneGrowableArray<PushArgumentInstr*>* arguments)
+ ClosureCallComp(ClosureCallNode* node,
+ ZoneGrowableArray<PushArgumentInstr*>* arguments)
: ast_node_(*node),
arguments_(arguments) { }
- DECLARE_INSTRUCTION(ClosureCall)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_CALL_COMPUTATION(ClosureCall)
const Array& argument_names() const { return ast_node_.arguments()->names(); }
intptr_t token_pos() const { return ast_node_.token_pos(); }
@@ -1626,18 +1761,18 @@ class ClosureCallInstr : public TemplateDefinition<0> {
const ClosureCallNode& ast_node_;
ZoneGrowableArray<PushArgumentInstr*>* arguments_;
- DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
+ DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
};
-class InstanceCallInstr : public TemplateDefinition<0> {
+class InstanceCallComp : public TemplateComputation<0> {
public:
- InstanceCallInstr(intptr_t token_pos,
- const String& function_name,
- Token::Kind token_kind,
- ZoneGrowableArray<PushArgumentInstr*>* arguments,
- const Array& argument_names,
- intptr_t checked_argument_count)
+ InstanceCallComp(intptr_t token_pos,
+ const String& function_name,
+ Token::Kind token_kind,
+ ZoneGrowableArray<PushArgumentInstr*>* arguments,
+ const Array& argument_names,
+ intptr_t checked_argument_count)
: ic_data_(Isolate::Current()->GetICDataForDeoptId(deopt_id())),
token_pos_(token_pos),
function_name_(function_name),
@@ -1656,8 +1791,7 @@ class InstanceCallInstr : public TemplateDefinition<0> {
token_kind == Token::kILLEGAL);
}
- DECLARE_INSTRUCTION(InstanceCall)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_CALL_COMPUTATION(InstanceCall)
const ICData* ic_data() const { return ic_data_; }
bool HasICData() const {
@@ -1688,50 +1822,47 @@ class InstanceCallInstr : public TemplateDefinition<0> {
const Array& argument_names_;
const intptr_t checked_argument_count_;
- DISALLOW_COPY_AND_ASSIGN(InstanceCallInstr);
+ DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
};
-class PolymorphicInstanceCallInstr : public TemplateDefinition<0> {
+class PolymorphicInstanceCallComp : public TemplateComputation<0> {
public:
- PolymorphicInstanceCallInstr(InstanceCallInstr* instance_call,
- const ICData& ic_data,
- bool with_checks)
- : instance_call_(instance_call),
- ic_data_(ic_data),
- with_checks_(with_checks) {
+ PolymorphicInstanceCallComp(InstanceCallComp* comp,
+ const ICData& ic_data,
+ bool with_checks)
+ : instance_call_(comp), ic_data_(ic_data), with_checks_(with_checks) {
ASSERT(instance_call_ != NULL);
}
- InstanceCallInstr* instance_call() const { return instance_call_; }
+ InstanceCallComp* instance_call() const { return instance_call_; }
bool with_checks() const { return with_checks_; }
+ void PrintTo(BufferFormatter* f) const;
+
virtual intptr_t ArgumentCount() const {
return instance_call()->ArgumentCount();
}
- DECLARE_INSTRUCTION(PolymorphicInstanceCall)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_CALL_COMPUTATION(PolymorphicInstanceCall)
const ICData& ic_data() const { return ic_data_; }
virtual bool CanDeoptimize() const { return true; }
virtual intptr_t ResultCid() const { return kDynamicCid; }
- virtual void PrintTo(BufferFormatter* f) const;
-
private:
- InstanceCallInstr* instance_call_;
+ InstanceCallComp* instance_call_;
const ICData& ic_data_;
const bool with_checks_;
- DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
+ DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallComp);
};
-class ComparisonInstr : public TemplateDefinition<2> {
+class ComparisonComp : public TemplateComputation<2> {
public:
- ComparisonInstr(Token::Kind kind, Value* left, Value* right) : kind_(kind) {
+ ComparisonComp(Token::Kind kind, Value* left, Value* right) : kind_(kind) {
ASSERT(left != NULL);
ASSERT(right != NULL);
inputs_[0] = left;
@@ -1741,13 +1872,10 @@ class ComparisonInstr : public TemplateDefinition<2> {
Value* left() const { return inputs_[0]; }
Value* right() const { return inputs_[1]; }
- virtual ComparisonInstr* AsComparison() { return this; }
+ virtual ComparisonComp* AsComparison() { return this; }
Token::Kind kind() const { return kind_; }
- virtual void EmitBranchCode(FlowGraphCompiler* compiler,
- BranchInstr* branch) = 0;
-
private:
Token::Kind kind_;
};
@@ -1755,67 +1883,66 @@ class ComparisonInstr : public TemplateDefinition<2> {
// Inlined functions from class BranchInstr that forward to their comparison.
inline intptr_t BranchInstr::ArgumentCount() const {
- return comparison()->ArgumentCount();
+ return computation()->ArgumentCount();
}
inline intptr_t BranchInstr::InputCount() const {
- return comparison()->InputCount();
+ return computation()->InputCount();
}
inline Value* BranchInstr::InputAt(intptr_t i) const {
- return comparison()->InputAt(i);
+ return computation()->InputAt(i);
}
inline void BranchInstr::SetInputAt(intptr_t i, Value* value) {
- comparison()->SetInputAt(i, value);
+ computation()->SetInputAt(i, value);
}
inline bool BranchInstr::CanDeoptimize() const {
- return comparison()->CanDeoptimize();
+ return computation()->CanDeoptimize();
}
inline LocationSummary* BranchInstr::locs() {
- if (comparison()->locs_ == NULL) {
- LocationSummary* summary = comparison()->MakeLocationSummary();
+ if (computation_->locs_ == NULL) {
+ LocationSummary* summary = computation_->MakeLocationSummary();
// Branches don't produce a result.
summary->set_out(Location::NoLocation());
- comparison()->locs_ = summary;
+ computation_->locs_ = summary;
}
- return comparison()->locs_;
+ return computation_->locs_;
}
inline intptr_t BranchInstr::DeoptimizationTarget() const {
- return comparison()->DeoptimizationTarget();
+ return computation_->DeoptimizationTarget();
}
inline Representation BranchInstr::RequiredInputRepresentation(
intptr_t i) const {
- return comparison()->RequiredInputRepresentation(i);
+ return computation()->RequiredInputRepresentation(i);
}
-class StrictCompareInstr : public ComparisonInstr {
+class StrictCompareComp : public ComparisonComp {
public:
- StrictCompareInstr(Token::Kind kind, Value* left, Value* right)
- : ComparisonInstr(kind, left, right) {
+ StrictCompareComp(Token::Kind kind, Value* left, Value* right)
+ : ComparisonComp(kind, left, right) {
ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
}
- DECLARE_INSTRUCTION(StrictCompare)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(StrictCompare)
virtual void PrintOperandsTo(BufferFormatter* f) const;
virtual bool CanDeoptimize() const { return false; }
- virtual Definition* Canonicalize();
+ virtual Definition* TryReplace(BindInstr* instr) const;
virtual intptr_t ResultCid() const { return kBoolCid; }
@@ -1823,25 +1950,24 @@ class StrictCompareInstr : public ComparisonInstr {
BranchInstr* branch);
private:
- DISALLOW_COPY_AND_ASSIGN(StrictCompareInstr);
+ DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
};
-class EqualityCompareInstr : public ComparisonInstr {
+class EqualityCompareComp : public ComparisonComp {
public:
- EqualityCompareInstr(intptr_t token_pos,
- Token::Kind kind,
- Value* left,
- Value* right)
- : ComparisonInstr(kind, left, right),
+ EqualityCompareComp(intptr_t token_pos,
+ Token::Kind kind,
+ Value* left,
+ Value* right)
+ : ComparisonComp(kind, left, right),
ic_data_(Isolate::Current()->GetICDataForDeoptId(deopt_id())),
token_pos_(token_pos),
receiver_class_id_(kIllegalCid) {
ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
}
- DECLARE_INSTRUCTION(EqualityCompare)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(EqualityCompare)
const ICData* ic_data() const { return ic_data_; }
bool HasICData() const {
@@ -1880,25 +2006,24 @@ class EqualityCompareInstr : public ComparisonInstr {
const intptr_t token_pos_;
intptr_t receiver_class_id_; // Set by optimizer.
- DISALLOW_COPY_AND_ASSIGN(EqualityCompareInstr);
+ DISALLOW_COPY_AND_ASSIGN(EqualityCompareComp);
};
-class RelationalOpInstr : public ComparisonInstr {
+class RelationalOpComp : public ComparisonComp {
public:
- RelationalOpInstr(intptr_t token_pos,
- Token::Kind kind,
- Value* left,
- Value* right)
- : ComparisonInstr(kind, left, right),
+ RelationalOpComp(intptr_t token_pos,
+ Token::Kind kind,
+ Value* left,
+ Value* right)
+ : ComparisonComp(kind, left, right),
ic_data_(Isolate::Current()->GetICDataForDeoptId(deopt_id())),
token_pos_(token_pos),
operands_class_id_(kIllegalCid) {
ASSERT(Token::IsRelationalOperator(kind));
}
- DECLARE_INSTRUCTION(RelationalOp)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(RelationalOp)
const ICData* ic_data() const { return ic_data_; }
bool HasICData() const {
@@ -1942,16 +2067,16 @@ class RelationalOpInstr : public ComparisonInstr {
const intptr_t token_pos_;
intptr_t operands_class_id_; // class id of both operands.
- DISALLOW_COPY_AND_ASSIGN(RelationalOpInstr);
+ DISALLOW_COPY_AND_ASSIGN(RelationalOpComp);
};
-class StaticCallInstr : public TemplateDefinition<0> {
+class StaticCallComp : public TemplateComputation<0> {
public:
- StaticCallInstr(intptr_t token_pos,
- const Function& function,
- const Array& argument_names,
- ZoneGrowableArray<PushArgumentInstr*>* arguments)
+ StaticCallComp(intptr_t token_pos,
+ const Function& function,
+ const Array& argument_names,
+ ZoneGrowableArray<PushArgumentInstr*>* arguments)
: token_pos_(token_pos),
function_(function),
argument_names_(argument_names),
@@ -1961,8 +2086,7 @@ class StaticCallInstr : public TemplateDefinition<0> {
ASSERT(argument_names.IsZoneHandle());
}
- DECLARE_INSTRUCTION(StaticCall)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_CALL_COMPUTATION(StaticCall)
// Accessors forwarded to the AST node.
const Function& function() const { return function_; }
@@ -1989,18 +2113,17 @@ class StaticCallInstr : public TemplateDefinition<0> {
ZoneGrowableArray<PushArgumentInstr*>* arguments_;
MethodRecognizer::Kind recognized_;
- DISALLOW_COPY_AND_ASSIGN(StaticCallInstr);
+ DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
};
-class LoadLocalInstr : public TemplateDefinition<0> {
+class LoadLocalComp : public TemplateComputation<0> {
public:
- LoadLocalInstr(const LocalVariable& local, intptr_t context_level)
+ LoadLocalComp(const LocalVariable& local, intptr_t context_level)
: local_(local),
context_level_(context_level) { }
- DECLARE_INSTRUCTION(LoadLocal)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(LoadLocal)
const LocalVariable& local() const { return local_; }
intptr_t context_level() const { return context_level_; }
@@ -2014,23 +2137,22 @@ class LoadLocalInstr : public TemplateDefinition<0> {
const LocalVariable& local_;
const intptr_t context_level_;
- DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
+ DISALLOW_COPY_AND_ASSIGN(LoadLocalComp);
};
-class StoreLocalInstr : public TemplateDefinition<1> {
+class StoreLocalComp : public TemplateComputation<1> {
public:
- StoreLocalInstr(const LocalVariable& local,
- Value* value,
- intptr_t context_level)
+ StoreLocalComp(const LocalVariable& local,
+ Value* value,
+ intptr_t context_level)
: local_(local),
context_level_(context_level) {
ASSERT(value != NULL);
inputs_[0] = value;
}
- DECLARE_INSTRUCTION(StoreLocal)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(StoreLocal)
const LocalVariable& local() const { return local_; }
Value* value() const { return inputs_[0]; }
@@ -2048,17 +2170,16 @@ class StoreLocalInstr : public TemplateDefinition<1> {
const LocalVariable& local_;
const intptr_t context_level_;
- DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
+ DISALLOW_COPY_AND_ASSIGN(StoreLocalComp);
};
-class NativeCallInstr : public TemplateDefinition<0> {
+class NativeCallComp : public TemplateComputation<0> {
public:
- explicit NativeCallInstr(NativeBodyNode* node)
+ explicit NativeCallComp(NativeBodyNode* node)
: ast_node_(*node) {}
- DECLARE_INSTRUCTION(NativeCall)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(NativeCall)
intptr_t token_pos() const { return ast_node_.token_pos(); }
@@ -2088,19 +2209,18 @@ class NativeCallInstr : public TemplateDefinition<0> {
private:
const NativeBodyNode& ast_node_;
- DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
+ DISALLOW_COPY_AND_ASSIGN(NativeCallComp);
};
-class LoadInstanceFieldInstr : public TemplateDefinition<1> {
+class LoadInstanceFieldComp : public TemplateComputation<1> {
public:
- LoadInstanceFieldInstr(const Field& field, Value* instance) : field_(field) {
+ LoadInstanceFieldComp(const Field& field, Value* instance) : field_(field) {
ASSERT(instance != NULL);
inputs_[0] = instance;
}
- DECLARE_INSTRUCTION(LoadInstanceField)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(LoadInstanceField)
const Field& field() const { return field_; }
Value* instance() const { return inputs_[0]; }
@@ -2113,13 +2233,15 @@ class LoadInstanceFieldInstr : public TemplateDefinition<1> {
private:
const Field& field_;
- DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldInstr);
+ DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldComp);
};
-class StoreInstanceFieldInstr : public TemplateDefinition<2> {
+class StoreInstanceFieldComp : public TemplateComputation<2> {
public:
- StoreInstanceFieldInstr(const Field& field, Value* instance, Value* value)
+ StoreInstanceFieldComp(const Field& field,
+ Value* instance,
+ Value* value)
: field_(field) {
ASSERT(instance != NULL);
ASSERT(value != NULL);
@@ -2127,8 +2249,7 @@ class StoreInstanceFieldInstr : public TemplateDefinition<2> {
inputs_[1] = value;
}
- DECLARE_INSTRUCTION(StoreInstanceField)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(StoreInstanceField)
const Field& field() const { return field_; }
@@ -2143,16 +2264,15 @@ class StoreInstanceFieldInstr : public TemplateDefinition<2> {
private:
const Field& field_;
- DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
+ DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldComp);
};
-class LoadStaticFieldInstr : public TemplateDefinition<0> {
+class LoadStaticFieldComp : public TemplateComputation<0> {
public:
- explicit LoadStaticFieldInstr(const Field& field) : field_(field) {}
+ explicit LoadStaticFieldComp(const Field& field) : field_(field) {}
- DECLARE_INSTRUCTION(LoadStaticField);
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(LoadStaticField);
const Field& field() const { return field_; }
@@ -2164,21 +2284,20 @@ class LoadStaticFieldInstr : public TemplateDefinition<0> {
private:
const Field& field_;
- DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
+ DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldComp);
};
-class StoreStaticFieldInstr : public TemplateDefinition<1> {
+class StoreStaticFieldComp : public TemplateComputation<1> {
public:
- StoreStaticFieldInstr(const Field& field, Value* value)
+ StoreStaticFieldComp(const Field& field, Value* value)
: field_(field) {
ASSERT(field.IsZoneHandle());
ASSERT(value != NULL);
inputs_[0] = value;
}
- DECLARE_INSTRUCTION(StoreStaticField);
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(StoreStaticField);
const Field& field() const { return field_; }
Value* value() const { return inputs_[0]; }
@@ -2191,13 +2310,15 @@ class StoreStaticFieldInstr : public TemplateDefinition<1> {
private:
const Field& field_;
- DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldInstr);
+ DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldComp);
};
-class LoadIndexedInstr : public TemplateDefinition<2> {
+class LoadIndexedComp : public TemplateComputation<2> {
public:
- LoadIndexedInstr(Value* array, Value* index, intptr_t receiver_type)
+ LoadIndexedComp(Value* array,
+ Value* index,
+ intptr_t receiver_type)
: receiver_type_(receiver_type) {
ASSERT(array != NULL);
ASSERT(index != NULL);
@@ -2205,8 +2326,7 @@ class LoadIndexedInstr : public TemplateDefinition<2> {
inputs_[1] = index;
}
- DECLARE_INSTRUCTION(LoadIndexed)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(LoadIndexed)
Value* array() const { return inputs_[0]; }
Value* index() const { return inputs_[1]; }
@@ -2219,16 +2339,16 @@ class LoadIndexedInstr : public TemplateDefinition<2> {
private:
intptr_t receiver_type_;
- DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
+ DISALLOW_COPY_AND_ASSIGN(LoadIndexedComp);
};
-class StoreIndexedInstr : public TemplateDefinition<3> {
+class StoreIndexedComp : public TemplateComputation<3> {
public:
- StoreIndexedInstr(Value* array,
- Value* index,
- Value* value,
- intptr_t receiver_type)
+ StoreIndexedComp(Value* array,
+ Value* index,
+ Value* value,
+ intptr_t receiver_type)
: receiver_type_(receiver_type) {
ASSERT(array != NULL);
ASSERT(index != NULL);
@@ -2238,8 +2358,7 @@ class StoreIndexedInstr : public TemplateDefinition<3> {
inputs_[2] = value;
}
- DECLARE_INSTRUCTION(StoreIndexed)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(StoreIndexed)
Value* array() const { return inputs_[0]; }
Value* index() const { return inputs_[1]; }
@@ -2253,20 +2372,19 @@ class StoreIndexedInstr : public TemplateDefinition<3> {
private:
intptr_t receiver_type_;
- DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
+ DISALLOW_COPY_AND_ASSIGN(StoreIndexedComp);
};
// Note overrideable, built-in: value? false : true.
-class BooleanNegateInstr : public TemplateDefinition<1> {
+class BooleanNegateComp : public TemplateComputation<1> {
public:
- explicit BooleanNegateInstr(Value* value) {
+ explicit BooleanNegateComp(Value* value) {
ASSERT(value != NULL);
inputs_[0] = value;
}
- DECLARE_INSTRUCTION(BooleanNegate)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(BooleanNegate)
Value* value() const { return inputs_[0]; }
@@ -2274,18 +2392,18 @@ class BooleanNegateInstr : public TemplateDefinition<1> {
virtual intptr_t ResultCid() const { return kBoolCid; }
private:
- DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
+ DISALLOW_COPY_AND_ASSIGN(BooleanNegateComp);
};
-class InstanceOfInstr : public TemplateDefinition<3> {
+class InstanceOfComp : public TemplateComputation<3> {
public:
- InstanceOfInstr(intptr_t token_pos,
- Value* value,
- Value* instantiator,
- Value* instantiator_type_arguments,
- const AbstractType& type,
- bool negate_result)
+ InstanceOfComp(intptr_t token_pos,
+ Value* value,
+ Value* instantiator,
+ Value* instantiator_type_arguments,
+ const AbstractType& type,
+ bool negate_result)
: token_pos_(token_pos),
type_(type),
negate_result_(negate_result) {
@@ -2298,8 +2416,7 @@ class InstanceOfInstr : public TemplateDefinition<3> {
inputs_[2] = instantiator_type_arguments;
}
- DECLARE_INSTRUCTION(InstanceOf)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(InstanceOf)
Value* value() const { return inputs_[0]; }
Value* instantiator() const { return inputs_[1]; }
@@ -2322,21 +2439,20 @@ class InstanceOfInstr : public TemplateDefinition<3> {
const AbstractType& type_;
const bool negate_result_;
- DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
+ DISALLOW_COPY_AND_ASSIGN(InstanceOfComp);
};
-class AllocateObjectInstr : public TemplateDefinition<0> {
+class AllocateObjectComp : public TemplateComputation<0> {
public:
- AllocateObjectInstr(ConstructorCallNode* node,
- ZoneGrowableArray<PushArgumentInstr*>* arguments)
+ AllocateObjectComp(ConstructorCallNode* node,
+ ZoneGrowableArray<PushArgumentInstr*>* arguments)
: ast_node_(*node), arguments_(arguments) {
// Either no arguments or one type-argument and one instantiator.
ASSERT(arguments->is_empty() || (arguments->length() == 2));
}
- DECLARE_INSTRUCTION(AllocateObject)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_CALL_COMPUTATION(AllocateObject)
virtual intptr_t ArgumentCount() const { return arguments_->length(); }
PushArgumentInstr* ArgumentAt(intptr_t index) const {
@@ -2355,15 +2471,15 @@ class AllocateObjectInstr : public TemplateDefinition<0> {
const ConstructorCallNode& ast_node_;
ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
- DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
+ DISALLOW_COPY_AND_ASSIGN(AllocateObjectComp);
};
-class AllocateObjectWithBoundsCheckInstr : public TemplateDefinition<2> {
+class AllocateObjectWithBoundsCheckComp : public TemplateComputation<2> {
public:
- AllocateObjectWithBoundsCheckInstr(ConstructorCallNode* node,
- Value* type_arguments,
- Value* instantiator)
+ AllocateObjectWithBoundsCheckComp(ConstructorCallNode* node,
+ Value* type_arguments,
+ Value* instantiator)
: ast_node_(*node) {
ASSERT(type_arguments != NULL);
ASSERT(instantiator != NULL);
@@ -2371,8 +2487,7 @@ class AllocateObjectWithBoundsCheckInstr : public TemplateDefinition<2> {
inputs_[1] = instantiator;
}
- DECLARE_INSTRUCTION(AllocateObjectWithBoundsCheck)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(AllocateObjectWithBoundsCheck)
const Function& constructor() const { return ast_node_.constructor(); }
intptr_t token_pos() const { return ast_node_.token_pos(); }
@@ -2385,16 +2500,16 @@ class AllocateObjectWithBoundsCheckInstr : public TemplateDefinition<2> {
private:
const ConstructorCallNode& ast_node_;
- DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckInstr);
+ DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckComp);
};
-class CreateArrayInstr : public TemplateDefinition<1> {
+class CreateArrayComp : public TemplateComputation<1> {
public:
- CreateArrayInstr(intptr_t token_pos,
- ZoneGrowableArray<PushArgumentInstr*>* arguments,
- const AbstractType& type,
- Value* element_type)
+ CreateArrayComp(intptr_t token_pos,
+ ZoneGrowableArray<PushArgumentInstr*>* arguments,
+ const AbstractType& type,
+ Value* element_type)
: token_pos_(token_pos),
arguments_(arguments),
type_(type) {
@@ -2410,8 +2525,7 @@ class CreateArrayInstr : public TemplateDefinition<1> {
inputs_[0] = element_type;
}
- DECLARE_INSTRUCTION(CreateArray)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_CALL_COMPUTATION(CreateArray)
virtual intptr_t ArgumentCount() const { return arguments_->length(); }
@@ -2430,19 +2544,18 @@ class CreateArrayInstr : public TemplateDefinition<1> {
ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
const AbstractType& type_;
- DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
+ DISALLOW_COPY_AND_ASSIGN(CreateArrayComp);
};
-class CreateClosureInstr : public TemplateDefinition<0> {
+class CreateClosureComp : public TemplateComputation<0> {
public:
- CreateClosureInstr(ClosureNode* node,
- ZoneGrowableArray<PushArgumentInstr*>* arguments)
+ CreateClosureComp(ClosureNode* node,
+ ZoneGrowableArray<PushArgumentInstr*>* arguments)
: ast_node_(*node),
arguments_(arguments) { }
- DECLARE_INSTRUCTION(CreateClosure)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_CALL_COMPUTATION(CreateClosure)
intptr_t token_pos() const { return ast_node_.token_pos(); }
const Function& function() const { return ast_node_.function(); }
@@ -2461,15 +2574,15 @@ class CreateClosureInstr : public TemplateDefinition<0> {
const ClosureNode& ast_node_;
ZoneGrowableArray<PushArgumentInstr*>* arguments_;
- DISALLOW_COPY_AND_ASSIGN(CreateClosureInstr);
+ DISALLOW_COPY_AND_ASSIGN(CreateClosureComp);
};
-class LoadVMFieldInstr : public TemplateDefinition<1> {
+class LoadVMFieldComp : public TemplateComputation<1> {
public:
- LoadVMFieldInstr(Value* value,
- intptr_t offset_in_bytes,
- const AbstractType& type)
+ LoadVMFieldComp(Value* value,
+ intptr_t offset_in_bytes,
+ const AbstractType& type)
: offset_in_bytes_(offset_in_bytes),
type_(type),
result_cid_(kDynamicCid) {
@@ -2478,8 +2591,7 @@ class LoadVMFieldInstr : public TemplateDefinition<1> {
inputs_[0] = value;
}
- DECLARE_INSTRUCTION(LoadVMField)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(LoadVMField)
Value* value() const { return inputs_[0]; }
intptr_t offset_in_bytes() const { return offset_in_bytes_; }
@@ -2496,16 +2608,16 @@ class LoadVMFieldInstr : public TemplateDefinition<1> {
const AbstractType& type_;
intptr_t result_cid_;
- DISALLOW_COPY_AND_ASSIGN(LoadVMFieldInstr);
+ DISALLOW_COPY_AND_ASSIGN(LoadVMFieldComp);
};
-class StoreVMFieldInstr : public TemplateDefinition<2> {
+class StoreVMFieldComp : public TemplateComputation<2> {
public:
- StoreVMFieldInstr(Value* dest,
- intptr_t offset_in_bytes,
- Value* value,
- const AbstractType& type)
+ StoreVMFieldComp(Value* dest,
+ intptr_t offset_in_bytes,
+ Value* value,
+ const AbstractType& type)
: offset_in_bytes_(offset_in_bytes), type_(type) {
ASSERT(value != NULL);
ASSERT(dest != NULL);
@@ -2514,8 +2626,7 @@ class StoreVMFieldInstr : public TemplateDefinition<2> {
inputs_[1] = dest;
}
- DECLARE_INSTRUCTION(StoreVMField)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(StoreVMField)
Value* value() const { return inputs_[0]; }
Value* dest() const { return inputs_[1]; }
@@ -2531,15 +2642,15 @@ class StoreVMFieldInstr : public TemplateDefinition<2> {
const intptr_t offset_in_bytes_;
const AbstractType& type_;
- DISALLOW_COPY_AND_ASSIGN(StoreVMFieldInstr);
+ DISALLOW_COPY_AND_ASSIGN(StoreVMFieldComp);
};
-class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
+class InstantiateTypeArgumentsComp : public TemplateComputation<1> {
public:
- InstantiateTypeArgumentsInstr(intptr_t token_pos,
- const AbstractTypeArguments& type_arguments,
- Value* instantiator)
+ InstantiateTypeArgumentsComp(intptr_t token_pos,
+ const AbstractTypeArguments& type_arguments,
+ Value* instantiator)
: token_pos_(token_pos),
type_arguments_(type_arguments) {
ASSERT(type_arguments.IsZoneHandle());
@@ -2547,8 +2658,7 @@ class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
inputs_[0] = instantiator;
}
- DECLARE_INSTRUCTION(InstantiateTypeArguments)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(InstantiateTypeArguments)
Value* instantiator() const { return inputs_[0]; }
const AbstractTypeArguments& type_arguments() const {
@@ -2565,13 +2675,13 @@ class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
const intptr_t token_pos_;
const AbstractTypeArguments& type_arguments_;
- DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
+ DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsComp);
};
-class ExtractConstructorTypeArgumentsInstr : public TemplateDefinition<1> {
+class ExtractConstructorTypeArgumentsComp : public TemplateComputation<1> {
public:
- ExtractConstructorTypeArgumentsInstr(
+ ExtractConstructorTypeArgumentsComp(
intptr_t token_pos,
const AbstractTypeArguments& type_arguments,
Value* instantiator)
@@ -2581,8 +2691,7 @@ class ExtractConstructorTypeArgumentsInstr : public TemplateDefinition<1> {
inputs_[0] = instantiator;
}
- DECLARE_INSTRUCTION(ExtractConstructorTypeArguments)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(ExtractConstructorTypeArguments)
Value* instantiator() const { return inputs_[0]; }
const AbstractTypeArguments& type_arguments() const {
@@ -2599,21 +2708,20 @@ class ExtractConstructorTypeArgumentsInstr : public TemplateDefinition<1> {
const intptr_t token_pos_;
const AbstractTypeArguments& type_arguments_;
- DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsInstr);
+ DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsComp);
};
-class ExtractConstructorInstantiatorInstr : public TemplateDefinition<1> {
+class ExtractConstructorInstantiatorComp : public TemplateComputation<1> {
public:
- ExtractConstructorInstantiatorInstr(ConstructorCallNode* ast_node,
- Value* instantiator)
+ ExtractConstructorInstantiatorComp(ConstructorCallNode* ast_node,
+ Value* instantiator)
: ast_node_(*ast_node) {
ASSERT(instantiator != NULL);
inputs_[0] = instantiator;
}
- DECLARE_INSTRUCTION(ExtractConstructorInstantiator)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(ExtractConstructorInstantiator)
Value* instantiator() const { return inputs_[0]; }
const AbstractTypeArguments& type_arguments() const {
@@ -2628,19 +2736,18 @@ class ExtractConstructorInstantiatorInstr : public TemplateDefinition<1> {
private:
const ConstructorCallNode& ast_node_;
- DISALLOW_COPY_AND_ASSIGN(ExtractConstructorInstantiatorInstr);
+ DISALLOW_COPY_AND_ASSIGN(ExtractConstructorInstantiatorComp);
};
-class AllocateContextInstr : public TemplateDefinition<0> {
+class AllocateContextComp : public TemplateComputation<0> {
public:
- AllocateContextInstr(intptr_t token_pos,
- intptr_t num_context_variables)
+ AllocateContextComp(intptr_t token_pos,
+ intptr_t num_context_variables)
: token_pos_(token_pos),
num_context_variables_(num_context_variables) {}
- DECLARE_INSTRUCTION(AllocateContext);
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(AllocateContext);
intptr_t token_pos() const { return token_pos_; }
intptr_t num_context_variables() const { return num_context_variables_; }
@@ -2654,19 +2761,18 @@ class AllocateContextInstr : public TemplateDefinition<0> {
const intptr_t token_pos_;
const intptr_t num_context_variables_;
- DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
+ DISALLOW_COPY_AND_ASSIGN(AllocateContextComp);
};
-class ChainContextInstr : public TemplateDefinition<1> {
+class ChainContextComp : public TemplateComputation<1> {
public:
- explicit ChainContextInstr(Value* context_value) {
+ explicit ChainContextComp(Value* context_value) {
ASSERT(context_value != NULL);
inputs_[0] = context_value;
}
- DECLARE_INSTRUCTION(ChainContext)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(ChainContext)
Value* context_value() const { return inputs_[0]; }
@@ -2674,13 +2780,14 @@ class ChainContextInstr : public TemplateDefinition<1> {
virtual intptr_t ResultCid() const { return kIllegalCid; }
private:
- DISALLOW_COPY_AND_ASSIGN(ChainContextInstr);
+ DISALLOW_COPY_AND_ASSIGN(ChainContextComp);
};
-class CloneContextInstr : public TemplateDefinition<1> {
+class CloneContextComp : public TemplateComputation<1> {
public:
- CloneContextInstr(intptr_t token_pos, Value* context_value)
+ CloneContextComp(intptr_t token_pos,
+ Value* context_value)
: token_pos_(token_pos) {
ASSERT(context_value != NULL);
inputs_[0] = context_value;
@@ -2689,8 +2796,7 @@ class CloneContextInstr : public TemplateDefinition<1> {
intptr_t token_pos() const { return token_pos_; }
Value* context_value() const { return inputs_[0]; }
- DECLARE_INSTRUCTION(CloneContext)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(CloneContext)
virtual bool CanDeoptimize() const { return false; }
virtual intptr_t ResultCid() const { return kIllegalCid; }
@@ -2698,21 +2804,20 @@ class CloneContextInstr : public TemplateDefinition<1> {
private:
const intptr_t token_pos_;
- DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
+ DISALLOW_COPY_AND_ASSIGN(CloneContextComp);
};
-class CatchEntryInstr : public TemplateDefinition<0> {
+class CatchEntryComp : public TemplateComputation<0> {
public:
- CatchEntryInstr(const LocalVariable& exception_var,
- const LocalVariable& stacktrace_var)
+ CatchEntryComp(const LocalVariable& exception_var,
+ const LocalVariable& stacktrace_var)
: exception_var_(exception_var), stacktrace_var_(stacktrace_var) {}
const LocalVariable& exception_var() const { return exception_var_; }
const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
- DECLARE_INSTRUCTION(CatchEntry)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(CatchEntry)
virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ -2723,29 +2828,28 @@ class CatchEntryInstr : public TemplateDefinition<0> {
const LocalVariable& exception_var_;
const LocalVariable& stacktrace_var_;
- DISALLOW_COPY_AND_ASSIGN(CatchEntryInstr);
+ DISALLOW_COPY_AND_ASSIGN(CatchEntryComp);
};
-class CheckEitherNonSmiInstr : public TemplateDefinition<2> {
+class CheckEitherNonSmiComp : public TemplateComputation<2> {
public:
- CheckEitherNonSmiInstr(Value* left,
- Value* right,
- InstanceCallInstr* instance_call) {
+ CheckEitherNonSmiComp(Value* left,
+ Value* right,
+ InstanceCallComp* instance_call)
+ : instance_call_(instance_call) {
ASSERT(left != NULL);
ASSERT(right != NULL);
inputs_[0] = left;
inputs_[1] = right;
- deopt_id_ = instance_call->deopt_id();
}
- DECLARE_INSTRUCTION(CheckEitherNonSmi)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(CheckEitherNonSmi)
virtual bool CanDeoptimize() const { return true; }
virtual intptr_t ResultCid() const { return kIllegalCid; }
- virtual bool AttributesEqual(Definition* other) const { return true; }
+ virtual bool AttributesEqual(Computation* other) const { return true; }
virtual bool HasSideEffect() const { return false; }
@@ -2753,16 +2857,18 @@ class CheckEitherNonSmiInstr : public TemplateDefinition<2> {
Value* right() const { return inputs_[1]; }
- virtual Definition* Canonicalize();
+ virtual Definition* TryReplace(BindInstr* instr) const;
private:
- DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
+ InstanceCallComp* instance_call_;
+
+ DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiComp);
};
-class BoxDoubleInstr : public TemplateDefinition<1> {
+class BoxDoubleComp : public TemplateComputation<1> {
public:
- BoxDoubleInstr(Value* value, InstanceCallInstr* instance_call)
+ BoxDoubleComp(Value* value, InstanceCallComp* instance_call)
: token_pos_((instance_call != NULL) ? instance_call->token_pos() : 0) {
ASSERT(value != NULL);
inputs_[0] = value;
@@ -2774,7 +2880,7 @@ class BoxDoubleInstr : public TemplateDefinition<1> {
virtual bool CanDeoptimize() const { return false; }
virtual bool HasSideEffect() const { return false; }
- virtual bool AttributesEqual(Definition* other) const { return true; }
+ virtual bool AttributesEqual(Computation* other) const { return true; }
virtual intptr_t ResultCid() const;
@@ -2783,22 +2889,21 @@ class BoxDoubleInstr : public TemplateDefinition<1> {
return kUnboxedDouble;
}
- DECLARE_INSTRUCTION(BoxDouble)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(BoxDouble)
private:
const intptr_t token_pos_;
- DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
+ DISALLOW_COPY_AND_ASSIGN(BoxDoubleComp);
};
-class UnboxDoubleInstr : public TemplateDefinition<1> {
+class UnboxDoubleComp : public TemplateComputation<1> {
public:
- UnboxDoubleInstr(Value* value, intptr_t deopt_id) {
+ UnboxDoubleComp(Value* value, intptr_t deopt_id)
+ : deopt_id_(deopt_id) {
ASSERT(value != NULL);
inputs_[0] = value;
- deopt_id_ = deopt_id;
}
Value* value() const { return inputs_[0]; }
@@ -2815,28 +2920,28 @@ class UnboxDoubleInstr : public TemplateDefinition<1> {
}
virtual bool HasSideEffect() const { return false; }
- virtual bool AttributesEqual(Definition* other) const { return true; }
+ virtual bool AttributesEqual(Computation* other) const { return true; }
- DECLARE_INSTRUCTION(UnboxDouble)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(UnboxDouble)
private:
- DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
+ const intptr_t deopt_id_;
+
+ DISALLOW_COPY_AND_ASSIGN(UnboxDoubleComp);
};
-class UnboxedDoubleBinaryOpInstr : public TemplateDefinition<2> {
+class UnboxedDoubleBinaryOpComp : public TemplateComputation<2> {
public:
- UnboxedDoubleBinaryOpInstr(Token::Kind op_kind,
- Value* left,
- Value* right,
- InstanceCallInstr* instance_call)
- : op_kind_(op_kind) {
+ UnboxedDoubleBinaryOpComp(Token::Kind op_kind,
+ Value* left,
+ Value* right,
+ InstanceCallComp* call)
+ : op_kind_(op_kind), deopt_id_(call->deopt_id()) {
ASSERT(left != NULL);
ASSERT(right != NULL);
inputs_[0] = left;
inputs_[1] = right;
- deopt_id_ = instance_call->deopt_id();
}
Value* left() const { return inputs_[0]; }
@@ -2849,7 +2954,7 @@ class UnboxedDoubleBinaryOpInstr : public TemplateDefinition<2> {
virtual bool CanDeoptimize() const { return false; }
virtual bool HasSideEffect() const { return false; }
- virtual bool AttributesEqual(Definition* other) const {
+ virtual bool AttributesEqual(Computation* other) const {
return op_kind() == other->AsUnboxedDoubleBinaryOp()->op_kind();
}
@@ -2866,25 +2971,25 @@ class UnboxedDoubleBinaryOpInstr : public TemplateDefinition<2> {
}
virtual intptr_t DeoptimizationTarget() const {
- return deopt_id();
+ return deopt_id_;
}
- DECLARE_INSTRUCTION(UnboxedDoubleBinaryOp)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(UnboxedDoubleBinaryOp)
private:
const Token::Kind op_kind_;
+ const intptr_t deopt_id_;
- DISALLOW_COPY_AND_ASSIGN(UnboxedDoubleBinaryOpInstr);
+ DISALLOW_COPY_AND_ASSIGN(UnboxedDoubleBinaryOpComp);
};
-class BinarySmiOpInstr : public TemplateDefinition<2> {
+class BinarySmiOpComp : public TemplateComputation<2> {
public:
- BinarySmiOpInstr(Token::Kind op_kind,
- InstanceCallInstr* instance_call,
- Value* left,
- Value* right)
+ BinarySmiOpComp(Token::Kind op_kind,
+ InstanceCallComp* instance_call,
+ Value* left,
+ Value* right)
: op_kind_(op_kind),
instance_call_(instance_call) {
ASSERT(left != NULL);
@@ -2898,14 +3003,13 @@ class BinarySmiOpInstr : public TemplateDefinition<2> {
Token::Kind op_kind() const { return op_kind_; }
- InstanceCallInstr* instance_call() const { return instance_call_; }
+ InstanceCallComp* instance_call() const { return instance_call_; }
const ICData* ic_data() const { return instance_call()->ic_data(); }
virtual void PrintOperandsTo(BufferFormatter* f) const;
- DECLARE_INSTRUCTION(BinarySmiOp)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(BinarySmiOp)
virtual bool CanDeoptimize() const;
@@ -2913,18 +3017,18 @@ class BinarySmiOpInstr : public TemplateDefinition<2> {
private:
const Token::Kind op_kind_;
- InstanceCallInstr* instance_call_;
+ InstanceCallComp* instance_call_;
- DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
+ DISALLOW_COPY_AND_ASSIGN(BinarySmiOpComp);
};
-class BinaryMintOpInstr : public TemplateDefinition<2> {
+class BinaryMintOpComp : public TemplateComputation<2> {
public:
- BinaryMintOpInstr(Token::Kind op_kind,
- InstanceCallInstr* instance_call,
- Value* left,
- Value* right)
+ BinaryMintOpComp(Token::Kind op_kind,
+ InstanceCallComp* instance_call,
+ Value* left,
+ Value* right)
: op_kind_(op_kind),
instance_call_(instance_call) {
ASSERT(left != NULL);
@@ -2938,32 +3042,31 @@ class BinaryMintOpInstr : public TemplateDefinition<2> {
Token::Kind op_kind() const { return op_kind_; }
- InstanceCallInstr* instance_call() const { return instance_call_; }
+ InstanceCallComp* instance_call() const { return instance_call_; }
const ICData* ic_data() const { return instance_call()->ic_data(); }
virtual void PrintOperandsTo(BufferFormatter* f) const;
- DECLARE_INSTRUCTION(BinaryMintOp)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(BinaryMintOp)
virtual bool CanDeoptimize() const { return true; }
virtual intptr_t ResultCid() const;
private:
const Token::Kind op_kind_;
- InstanceCallInstr* instance_call_;
+ InstanceCallComp* instance_call_;
- DISALLOW_COPY_AND_ASSIGN(BinaryMintOpInstr);
+ DISALLOW_COPY_AND_ASSIGN(BinaryMintOpComp);
};
// Handles both Smi operations: BIT_OR and NEGATE.
-class UnarySmiOpInstr : public TemplateDefinition<1> {
+class UnarySmiOpComp : public TemplateComputation<1> {
public:
- UnarySmiOpInstr(Token::Kind op_kind,
- InstanceCallInstr* instance_call,
- Value* value)
+ UnarySmiOpComp(Token::Kind op_kind,
+ InstanceCallComp* instance_call,
+ Value* value)
: op_kind_(op_kind), instance_call_(instance_call) {
ASSERT((op_kind == Token::kNEGATE) || (op_kind == Token::kBIT_NOT));
ASSERT(value != NULL);
@@ -2973,61 +3076,58 @@ class UnarySmiOpInstr : public TemplateDefinition<1> {
Value* value() const { return inputs_[0]; }
Token::Kind op_kind() const { return op_kind_; }
- InstanceCallInstr* instance_call() const { return instance_call_; }
+ InstanceCallComp* instance_call() const { return instance_call_; }
virtual void PrintOperandsTo(BufferFormatter* f) const;
- DECLARE_INSTRUCTION(UnarySmiOp)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(UnarySmiOp)
virtual bool CanDeoptimize() const { return op_kind() == Token::kNEGATE; }
virtual intptr_t ResultCid() const { return kSmiCid; }
private:
const Token::Kind op_kind_;
- InstanceCallInstr* instance_call_;
+ InstanceCallComp* instance_call_;
- DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
+ DISALLOW_COPY_AND_ASSIGN(UnarySmiOpComp);
};
// Handles non-Smi NEGATE operations
-class NumberNegateInstr : public TemplateDefinition<1> {
+class NumberNegateComp : public TemplateComputation<1> {
public:
- NumberNegateInstr(InstanceCallInstr* instance_call, Value* value)
- : instance_call_(instance_call) {
+ NumberNegateComp(InstanceCallComp* instance_call,
+ Value* value) : instance_call_(instance_call) {
ASSERT(value != NULL);
inputs_[0] = value;
}
Value* value() const { return inputs_[0]; }
- InstanceCallInstr* instance_call() const { return instance_call_; }
+ InstanceCallComp* instance_call() const { return instance_call_; }
const ICData* ic_data() const { return instance_call()->ic_data(); }
- DECLARE_INSTRUCTION(NumberNegate)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(NumberNegate)
virtual bool CanDeoptimize() const { return true; }
virtual intptr_t ResultCid() const { return kDoubleCid; }
private:
- InstanceCallInstr* instance_call_;
+ InstanceCallComp* instance_call_;
- DISALLOW_COPY_AND_ASSIGN(NumberNegateInstr);
+ DISALLOW_COPY_AND_ASSIGN(NumberNegateComp);
};
-class CheckStackOverflowInstr : public TemplateDefinition<0> {
+class CheckStackOverflowComp : public TemplateComputation<0> {
public:
- explicit CheckStackOverflowInstr(intptr_t token_pos)
+ explicit CheckStackOverflowComp(intptr_t token_pos)
: token_pos_(token_pos) {}
intptr_t token_pos() const { return token_pos_; }
- DECLARE_INSTRUCTION(CheckStackOverflow)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(CheckStackOverflow)
virtual bool CanDeoptimize() const { return false; }
virtual intptr_t ResultCid() const { return kIllegalCid; }
@@ -3035,13 +3135,13 @@ class CheckStackOverflowInstr : public TemplateDefinition<0> {
private:
const intptr_t token_pos_;
- DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
+ DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowComp);
};
-class DoubleToDoubleInstr : public TemplateDefinition<1> {
+class DoubleToDoubleComp : public TemplateComputation<1> {
public:
- DoubleToDoubleInstr(Value* value, InstanceCallInstr* instance_call)
+ DoubleToDoubleComp(Value* value, InstanceCallComp* instance_call)
: instance_call_(instance_call) {
ASSERT(value != NULL);
inputs_[0] = value;
@@ -3049,30 +3149,28 @@ class DoubleToDoubleInstr : public TemplateDefinition<1> {
Value* value() const { return inputs_[0]; }
- InstanceCallInstr* instance_call() const { return instance_call_; }
+ InstanceCallComp* instance_call() const { return instance_call_; }
- DECLARE_INSTRUCTION(DoubleToDouble)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(DoubleToDouble)
virtual bool CanDeoptimize() const { return true; }
virtual intptr_t ResultCid() const { return kDoubleCid; }
private:
- InstanceCallInstr* instance_call_;
+ InstanceCallComp* instance_call_;
- DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
+ DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleComp);
};
-class SmiToDoubleInstr : public TemplateDefinition<0> {
+class SmiToDoubleComp : public TemplateComputation<0> {
public:
- explicit SmiToDoubleInstr(InstanceCallInstr* instance_call)
+ explicit SmiToDoubleComp(InstanceCallComp* instance_call)
: instance_call_(instance_call) { }
- InstanceCallInstr* instance_call() const { return instance_call_; }
+ InstanceCallComp* instance_call() const { return instance_call_; }
- DECLARE_INSTRUCTION(SmiToDouble)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_CALL_COMPUTATION(SmiToDouble)
virtual intptr_t ArgumentCount() const { return 1; }
@@ -3080,30 +3178,29 @@ class SmiToDoubleInstr : public TemplateDefinition<0> {
virtual intptr_t ResultCid() const { return kDoubleCid; }
private:
- InstanceCallInstr* instance_call_;
+ InstanceCallComp* instance_call_;
- DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
+ DISALLOW_COPY_AND_ASSIGN(SmiToDoubleComp);
};
-class CheckClassInstr : public TemplateDefinition<1> {
+class CheckClassComp : public TemplateComputation<1> {
public:
- CheckClassInstr(Value* value,
- InstanceCallInstr* instance_call,
- const ICData& unary_checks)
- : unary_checks_(unary_checks) {
+ CheckClassComp(Value* value,
+ InstanceCallComp* instance_call,
+ const ICData& unary_checks)
+ : instance_call_(instance_call),
+ unary_checks_(unary_checks) {
ASSERT(value != NULL);
inputs_[0] = value;
- deopt_id_ = instance_call->deopt_id();
}
- DECLARE_INSTRUCTION(CheckClass)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(CheckClass)
virtual bool CanDeoptimize() const { return true; }
virtual intptr_t ResultCid() const { return kIllegalCid; }
- virtual bool AttributesEqual(Definition* other) const;
+ virtual bool AttributesEqual(Computation* other) const;
virtual bool HasSideEffect() const { return false; }
@@ -3111,66 +3208,70 @@ class CheckClassInstr : public TemplateDefinition<1> {
const ICData& unary_checks() const { return unary_checks_; }
- virtual Definition* Canonicalize();
+ virtual intptr_t deopt_id() const { return instance_call_->deopt_id(); }
+
+ virtual Definition* TryReplace(BindInstr* instr) const;
virtual void PrintOperandsTo(BufferFormatter* f) const;
private:
+ InstanceCallComp* instance_call_;
const ICData& unary_checks_;
- DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
+ DISALLOW_COPY_AND_ASSIGN(CheckClassComp);
};
-class CheckSmiInstr : public TemplateDefinition<1> {
+class CheckSmiComp : public TemplateComputation<1> {
public:
- CheckSmiInstr(Value* value, intptr_t original_deopt_id) {
+ CheckSmiComp(Value* value, intptr_t original_deopt_id)
+ : original_deopt_id_(original_deopt_id) {
ASSERT(value != NULL);
ASSERT(original_deopt_id != Isolate::kNoDeoptId);
inputs_[0] = value;
- deopt_id_ = original_deopt_id;
}
- DECLARE_INSTRUCTION(CheckSmi)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(CheckSmi)
virtual bool CanDeoptimize() const { return true; }
virtual intptr_t ResultCid() const { return kIllegalCid; }
- virtual bool AttributesEqual(Definition* other) const { return true; }
+ virtual bool AttributesEqual(Computation* other) const { return true; }
virtual bool HasSideEffect() const { return false; }
- virtual Definition* Canonicalize();
+ virtual Definition* TryReplace(BindInstr* instr) const;
Value* value() const { return inputs_[0]; }
+ virtual intptr_t deopt_id() const { return original_deopt_id_; }
+
private:
- DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
+ const intptr_t original_deopt_id_;
+
+ DISALLOW_COPY_AND_ASSIGN(CheckSmiComp);
};
-class CheckArrayBoundInstr : public TemplateDefinition<2> {
+class CheckArrayBoundComp : public TemplateComputation<2> {
public:
- CheckArrayBoundInstr(Value* array,
- Value* index,
- intptr_t array_type,
- InstanceCallInstr* instance_call)
- : array_type_(array_type) {
+ CheckArrayBoundComp(Value* array,
+ Value* index,
+ intptr_t array_type,
+ InstanceCallComp* instance_call)
+ : array_type_(array_type), instance_call_(instance_call) {
ASSERT(array != NULL);
ASSERT(index != NULL);
inputs_[0] = array;
inputs_[1] = index;
- deopt_id_ = instance_call->deopt_id();
}
- DECLARE_INSTRUCTION(CheckArrayBound)
- virtual RawAbstractType* CompileType() const;
+ DECLARE_COMPUTATION(CheckArrayBound)
virtual bool CanDeoptimize() const { return true; }
virtual intptr_t ResultCid() const { return kIllegalCid; }
- virtual bool AttributesEqual(Definition* other) const;
+ virtual bool AttributesEqual(Computation* other) const;
virtual bool HasSideEffect() const { return false; }
@@ -3179,14 +3280,34 @@ class CheckArrayBoundInstr : public TemplateDefinition<2> {
intptr_t array_type() const { return array_type_; }
+ virtual intptr_t deopt_id() const { return instance_call_->deopt_id(); }
+
private:
intptr_t array_type_;
+ InstanceCallComp* instance_call_;
- DISALLOW_COPY_AND_ASSIGN(CheckArrayBoundInstr);
+ DISALLOW_COPY_AND_ASSIGN(CheckArrayBoundComp);
};
-#undef DECLARE_INSTRUCTION
+#undef DECLARE_COMPUTATION
+
+
+// Implementation of type testers and cast functins.
+#define DEFINE_COMPUTATION_PREDICATE(ShortName, ClassName) \
+bool Computation::Is##ShortName() const { \
+ return computation_kind() == k##ShortName; \
+} \
+const ClassName* Computation::As##ShortName() const { \
+ if (!Is##ShortName()) return NULL; \
+ return static_cast<const ClassName*>(this); \
+} \
+ClassName* Computation::As##ShortName() { \
+ if (!Is##ShortName()) return NULL; \
+ return static_cast<ClassName*>(this); \
+}
+FOR_EACH_COMPUTATION(DEFINE_COMPUTATION_PREDICATE)
+#undef DEFINE_COMPUTATION_PREDICATE
class Environment : public ZoneAllocated {
@@ -3256,13 +3377,18 @@ class FlowGraphVisitor : public ValueObject {
// instructions in order from the block entry to exit.
virtual void VisitBlocks();
- // Visit functions for instruction classes, with an empty default
- // implementation.
+ // Visit functions for instruction and computation classes, with empty
+ // default implementations.
+#define DECLARE_VISIT_COMPUTATION(ShortName, ClassName) \
+ virtual void Visit##ShortName(ClassName* comp, BindInstr* instr) { }
+
#define DECLARE_VISIT_INSTRUCTION(ShortName) \
virtual void Visit##ShortName(ShortName##Instr* instr) { }
+ FOR_EACH_COMPUTATION(DECLARE_VISIT_COMPUTATION)
FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
+#undef DECLARE_VISIT_COMPUTATION
#undef DECLARE_VISIT_INSTRUCTION
protected:
« no previous file with comments | « runtime/vm/il_printer.cc ('k') | runtime/vm/intermediate_language.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698