Add type testers to all IL Computation classes.

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 121 matching lines @@
   // 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;
 
   static LocationSummary* MakeCallSummary();
 
+  // Declare an enum value used to define type-test predicates.
+  enum ComputationType {
+#define DECLARE_COMPUTATION_TYPE(ShortName, ClassName) k##ShortName,
+
+  FOR_EACH_COMPUTATION(DECLARE_COMPUTATION_TYPE)
+
+#undef DECLARE_COMPUTATION_TYPE
+  };
+
+  virtual ComputationType computation_type() const = 0;
+
+  // Declare predicate for each computation.
+#define DECLARE_PREDICATE(ShortName, ClassName)                             \
+  bool Is##ShortName() const { return computation_type() == k##ShortName; } \
+  ClassName* As##ShortName() {                                              \
+    if (!Is##ShortName()) return NULL;                                      \
+    return reinterpret_cast<ClassName*>(this);                              \

[Vyacheslav Egorov (Google), 2012/06/07 12:07:16]

this should be static_cast.

[Florian Schneider, 2012/06/07 12:31:47]

Done.

+  }
+
+  FOR_EACH_COMPUTATION(DECLARE_PREDICATE)
+
+#undef DECLARE_PREDICATE
+
  private:
   friend class Instruction;
   static intptr_t GetNextCid(Isolate* isolate) {
     intptr_t tmp = isolate->computation_id();
     isolate->set_computation_id(tmp + 1);
     return tmp;
   }
   static ICData* GetICDataForCid(intptr_t cid, Isolate* isolate) {
     if (isolate->ic_data_array() == Array::null()) {
       return NULL;
@@ skipping 77 matching lines @@
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 };
 
 
 class Value : public TemplateComputation<0> {
  public:
   Value() { }
 
-#define DEFINE_TESTERS(ShortName, ClassName)                                   \
-  virtual ClassName* As##ShortName() { return NULL; }                          \
-  bool Is##ShortName() { return As##ShortName() != NULL; }
-
-  FOR_EACH_VALUE(DEFINE_TESTERS)
-#undef DEFINE_TESTERS
-
  private:
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 
 // Functions defined in all concrete computation classes.
 #define DECLARE_COMPUTATION(ShortName)                                         \
   virtual void Accept(FlowGraphVisitor* visitor);                              \
+  virtual ComputationType computation_type() const {                           \
+    return Computation::k##ShortName;                                          \
+  }                                                                            \
   virtual const char* DebugName() const { return #ShortName; }                 \
   virtual RawAbstractType* StaticType() const;                                 \
   virtual LocationSummary* MakeLocationSummary() const;                        \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
   DECLARE_COMPUTATION(ShortName)                                               \
-  virtual ShortName##Val* As##ShortName() { return this; }                     \
   virtual void PrintTo(BufferFormatter* f) const;
 
 
 class BindInstr;
 
 class UseVal : public Value {
  public:
   explicit UseVal(BindInstr* definition) : definition_(definition) {}
 
   DECLARE_VALUE(Use)
@@ skipping 236 matching lines @@
                       Value* left,
                       Value* right)
     : token_index_(token_index),
       try_index_(try_index) {
     ASSERT(left != NULL);
     ASSERT(right != NULL);
     inputs_[0] = left;
     inputs_[1] = right;
   }
 
-  DECLARE_COMPUTATION(EqualityCompareComp)
+  DECLARE_COMPUTATION(EqualityCompare)
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const intptr_t token_index_;
@@ skipping 1469 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_