Add Load/Store Static/Instance fields.

runtime/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 10 matching lines @@
 // <Computation> ::=
 //   <Value>
 // | AssertAssignable <Value> <AbstractType>
 // | InstanceCall <AstNode> <String> <Value> ...
 // | StaticCall <StaticCallNode> <Value> ...
 // | LoadLocal <LocalVariable>
 // | StoreLocal <LocalVariable> <Value>
 // | StoreIndexed <Value> <Value> <Value> <Value>
 // | StrictCompare <Token::kind> <Value> <Value>
 // | NativeCall <NativeBodyNode>
+// | LoadInstanceField <LoadInstanceFieldNode> <Value>
+// | StoreInstanceField <StoreInstanceFieldNode> <Value> <Value>
+// | LoadStaticField <Field>
+// | StoreStaticField <StoreStaticFieldNode> <Value>
 //
 // <Value> ::=
 //   Temp <int>
 // | Constant <Instance>
 
 // M is a two argument macro.  It is applied to each concrete value's
 // typename and classname.
 #define FOR_EACH_VALUE(M)                                                      \
   M(Temp, TempVal)                                                             \
   M(Constant, ConstantVal)                                                     \
 
 
 // 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)                                                \
   FOR_EACH_VALUE(M)                                                            \
   M(AssertAssignable, AssertAssignableComp)                                    \
   M(InstanceCall, InstanceCallComp)                                            \
   M(StaticCall, StaticCallComp)                                                \
   M(LoadLocal, LoadLocalComp)                                                  \
   M(StoreLocal, StoreLocalComp)                                                \
   M(StrictCompare, StrictCompareComp)                                          \
   M(NativeCall, NativeCallComp)                                                \
   M(StoreIndexed, StoreIndexedComp)                                            \
   M(InstanceSetter, InstanceSetterComp)                                        \
+  M(StoreInstanceField, StoreInstanceFieldComp)                                \
+  M(LoadInstanceField, LoadInstanceFieldComp)                                  \
+  M(LoadStaticField, LoadStaticFieldComp)                                      \
+  M(StoreStaticField, StoreStaticFieldComp)
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 class Computation : public ZoneAllocated {
  public:
   Computation() { }
 
@@ skipping 211 matching lines @@
     return ast_node_.native_c_function_name();
   }
 
  private:
   const NativeBodyNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallComp);
 };
 
 
+class LoadInstanceFieldComp : public Computation {
+ public:
+  LoadInstanceFieldComp(LoadInstanceFieldNode* ast_node, Value* instance)
+      : ast_node_(*ast_node), instance_(instance) {
+    ASSERT(instance_ != NULL);
+  }
+
+  DECLARE_COMPUTATION(LoadInstanceFieldComp)
+
+  RawString* name() const { return ast_node_.field().name(); }

[Kevin Millikin (Google), 2012/03/05 11:02:41]

Might also just expose a const Field& accessor instead (also in
StoreInstanceFieldComp below).  I've been doing something like that because it's
more flexible and less API surface.

I don't have strong opinions one way or the other except that it should feel
uniform when we're all done adding classes to the IL.

[srdjan, 2012/03/05 18:35:21]

Using Field type as suggested

+  intptr_t field_offset() const { return ast_node_.field().Offset(); }
+
+  Value* instance() const { return instance_; }
+
+ private:
+  const LoadInstanceFieldNode& ast_node_;
+  Value* instance_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldComp);
+};
+
+
+class StoreInstanceFieldComp : public Computation {
+ public:
+  StoreInstanceFieldComp(StoreInstanceFieldNode* ast_node,
+                         Value* instance,
+                         Value* value)
+      : ast_node_(*ast_node), instance_(instance), value_(value) {
+    ASSERT(instance_ != NULL);
+    ASSERT(value_ != NULL);
+  }
+
+  DECLARE_COMPUTATION(StoreInstanceFieldComp)
+
+  intptr_t node_id() const { return ast_node_.id(); }
+  intptr_t token_index() const { return ast_node_.token_index(); }
+  RawString* field_name() const { return ast_node_.field().name(); }
+  RawAbstractType* field_type() const { return ast_node_.field().type(); }
+  intptr_t field_offset() const { return ast_node_.field().Offset(); }
+
+  Value* instance() const { return instance_; }
+  Value* value() const { return value_; }
+
+ private:
+  const StoreInstanceFieldNode& ast_node_;
+  Value* instance_;
+  Value* value_;
+
+  DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldComp);
+};
+
+
+class LoadStaticFieldComp : public Computation {
+ public:
+  explicit LoadStaticFieldComp(const Field& field) : field_(field) {}
+
+  DECLARE_COMPUTATION(LoadStaticFieldComp);
+
+  const Field& field() const { return field_; }
+
+ private:
+  const Field& field_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldComp);
+};
+
+
+class StoreStaticFieldComp : public Computation {
+ public:
+  StoreStaticFieldComp(StoreStaticFieldNode* ast_node, Value* value)
+      : ast_node_(*ast_node), value_(value) {
+    ASSERT(value != NULL);
+  }
+
+  DECLARE_COMPUTATION(StoreStaticFieldComp);
+
+  intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t node_id() const { return ast_node_.id(); }
+  const Field& field() const { return ast_node_.field(); }
+  Value* value() const { return value_; }
+
+ private:
+  const StoreStaticFieldNode& ast_node_;
+  Value* value_;
+
+  DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldComp);
+};
+
+
 // Not simply an InstanceCall because it has somewhat more complicated
 // semantics: the value operand is preserved in a placeholder (the first
 // operand is a preallocated slot that can be used).
 class StoreIndexedComp : public Computation {
  public:
   StoreIndexedComp(StoreIndexedNode* node,
                    Value* placeholder,
                    Value* array,
                    Value* index,
                    Value* value)
@@ skipping 331 matching lines @@
 #undef DECLARE_VISIT_INSTRUCTION
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_