Support Throw and ReThrow in SSA-based compiler.

vm/intermediate_language.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 1782 matching lines @@
   virtual bool Is##type() const { return true; }                               \
   virtual type##Instr* As##type() { return this; }                             \
   virtual intptr_t InputCount() const;                                         \
   virtual Value* InputAt(intptr_t i) const;                                    \
   virtual void SetInputAt(intptr_t i, Value* value);                           \
   virtual const char* DebugName() const { return #type; }                      \
   virtual void PrintTo(BufferFormatter* f) const;                              \
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
 
+#define DECLARE_CALL_INSTRUCTION(type)                                         \
+  virtual void Accept(FlowGraphVisitor* visitor);                              \
+  virtual bool Is##type() const { return true; }                               \
+  virtual type##Instr* As##type() { return this; }                             \
+  virtual intptr_t InputCount() const { return 0; }                            \
+  virtual Value* InputAt(intptr_t i) const {                                   \
+    UNREACHABLE();                                                             \
+    return NULL;                                                               \
+  }                                                                            \
+  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }         \
+  virtual const char* DebugName() const { return #type; }                      \
+  virtual void PrintTo(BufferFormatter* f) const;                              \
+  virtual void PrintToVisualizer(BufferFormatter* f) const;
+
+
 class Instruction : public ZoneAllocated {
  public:
   Instruction()
       : lifetime_position_(-1), previous_(NULL), next_(NULL), env_(NULL) { }
 
   virtual bool IsBlockEntry() const { return false; }
   BlockEntryInstr* AsBlockEntry() {
     return IsBlockEntry() ? reinterpret_cast<BlockEntryInstr*>(this) : NULL;
   }
   virtual bool IsDefinition() const { return false; }
@@ skipping 111 matching lines @@
   Instruction* next_;
   Environment* env_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 class InstructionWithInputs : public Instruction {
  public:
   InstructionWithInputs() : locs_(NULL) { }
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
   virtual LocationSummary* MakeLocationSummary() const = 0;
 
  private:
@@ skipping 500 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public InstructionWithInputs {
  public:
   explicit PushArgumentInstr(Value* value) : value_(value) { }
 
   DECLARE_INSTRUCTION(PushArgument)
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   Value* value() const { return value_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 class ReturnInstr : public InstructionWithInputs {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : InstructionWithInputs(),
         cid_(Isolate::Current()->GetNextCid()),
         token_pos_(token_pos),
         value_(value) {
     ASSERT(value_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Return)
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   intptr_t cid() const { return cid_; }
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return value_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public InstructionWithInputs {
  public:
-  ThrowInstr(intptr_t token_pos,
-             intptr_t try_index,
-             Value* exception)
+  ThrowInstr(intptr_t token_pos, intptr_t try_index)
       : InstructionWithInputs(),
         cid_(Isolate::Current()->GetNextCid()),
         token_pos_(token_pos),
-        try_index_(try_index),
-        exception_(exception) {
-    ASSERT(exception_ != NULL);
-  }
+        try_index_(try_index) { }
 
-  DECLARE_INSTRUCTION(Throw)
+  DECLARE_CALL_INSTRUCTION(Throw)
+
+  virtual intptr_t ArgumentCount() const { return 1; }
 
   intptr_t cid() const { return cid_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
-  Value* exception() const { return exception_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
   const intptr_t try_index_;
-  Value* exception_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public InstructionWithInputs {
  public:
   ReThrowInstr(intptr_t token_pos,
-               intptr_t try_index,
-               Value* exception,
-               Value* stack_trace)
+               intptr_t try_index)
       : InstructionWithInputs(),
         cid_(Isolate::Current()->GetNextCid()),
         token_pos_(token_pos),
-        try_index_(try_index),
-        exception_(exception),
-        stack_trace_(stack_trace) {
-    ASSERT(exception_ != NULL);
-    ASSERT(stack_trace_ != NULL);
-  }
+        try_index_(try_index) { }
 
-  DECLARE_INSTRUCTION(ReThrow)
+  DECLARE_CALL_INSTRUCTION(ReThrow)
+
+  virtual intptr_t ArgumentCount() const { return 2; }
 
   intptr_t cid() const { return cid_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
-  Value* exception() const { return exception_; }
-  Value* stack_trace() const { return stack_trace_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
   const intptr_t try_index_;
-  Value* exception_;
-  Value* stack_trace_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class GotoInstr : public InstructionWithInputs {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
     : successor_(entry),
       parallel_move_(NULL) {
   }
 
   DECLARE_INSTRUCTION(Goto)
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   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; }
@@ skipping 44 matching lines @@
     ASSERT(Token::IsEqualityOperator(kind) ||
            Token::IsRelationalOperator(kind) ||
            Token::IsTypeTestOperator(kind));
     Isolate* isolate = Isolate::Current();
     cid_ = isolate->GetNextCid();
     ic_data_ = isolate->GetICDataForCid(cid_);
   }
 
   DECLARE_INSTRUCTION(Branch)
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   Value* left() const { return left_; }
   Value* right() const { return right_; }
   Token::Kind kind() const { return kind_; }
   void set_kind(Token::Kind kind) {
     ASSERT(Token::IsEqualityOperator(kind) ||
            Token::IsRelationalOperator(kind) ||
            Token::IsTypeTestOperator(kind));
     kind_ = kind;
   }
 
@@ skipping 127 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_