Eliminate some unnecessary handle allocations in the compiler.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, 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"
 #include "vm/handles_impl.h"
 #include "vm/locations.h"
 #include "vm/object.h"
+#include "vm/parser.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 
 class BitVector;
 class BlockEntryInstr;
 class BufferFormatter;
 class CatchBlockEntryInstr;
 class ComparisonInstr;
@@ skipping 1727 matching lines @@
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
   Definition();
 
   virtual Definition* AsDefinition() { return this; }
 
   bool IsComparison() { return (AsComparison() != NULL); }
   virtual ComparisonInstr* AsComparison() { return NULL; }
 
-  // Overridden by definitions that push arguments.
+  // Overridden by definitions that have pushed arguments.
   virtual intptr_t ArgumentCount() const { return 0; }
 
   // Overridden by definitions that have call counts.
   virtual intptr_t CallCount() const {
     UNREACHABLE();
     return -1;
   }
 
   intptr_t temp_index() const { return temp_index_; }
   void set_temp_index(intptr_t index) { temp_index_ = index; }
@@ skipping 152 matching lines @@
 }
 
 
 inline void Value::BindToEnvironment(Definition* def) {
   RemoveFromUseList();
   set_definition(def);
   def->AddEnvUse(this);
 }
 
 
+template<intptr_t N>
+class TemplateDefinition : public Definition {
+ public:
+  TemplateDefinition<N>() : inputs_() { }
+
+  virtual intptr_t InputCount() const { return N; }
+  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
+
+ protected:
+  EmbeddedArray<Value*, N> inputs_;
+
+ private:
+  friend class BranchInstr;
+  friend class IfThenElseInstr;
+
+  virtual void RawSetInputAt(intptr_t i, Value* value) {
+    inputs_[i] = value;
+  }
+};
+
+
+struct BranchLabels {
+  Label* true_label;
+  Label* false_label;
+  Label* fall_through;
+};
+
+
 class PhiInstr : public Definition {
  public:
   PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
     : block_(block),
       inputs_(num_inputs),
       is_alive_(false),
       representation_(kTagged),
       reaching_defs_(NULL) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
@@ skipping 115 matching lines @@
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   const intptr_t index_;
   BlockEntryInstr* block_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
-class PushArgumentInstr : public Definition {
+class PushArgumentInstr : public TemplateDefinition<1> {
  public:
   explicit PushArgumentInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(PushArgument)
 
-  intptr_t InputCount() const { return 1; }
-  Value* InputAt(intptr_t i) const {
-    ASSERT(i == 0);
-    return value_;
-  }
-
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual CompileType ComputeType() const;
 
-  Value* value() const { return value_; }
-
-  virtual intptr_t Hashcode() const {
-    UNREACHABLE();
-    return 0;
-  }
+  Value* value() const { return InputAt(0); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool MayThrow() const { return false; }
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    ASSERT(i == 0);
-    value_ = value;
-  }
-
-  Value* value_;
-
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
 class ReturnInstr : public TemplateInstruction<1> {
@@ skipping 133 matching lines @@
  private:
   JoinEntryInstr* successor_;
   double edge_weight_;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
-template<intptr_t N>
-class TemplateDefinition : public Definition {
- public:
-  TemplateDefinition<N>() : inputs_() { }
-
-  virtual intptr_t InputCount() const { return N; }
-  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
-
- protected:
-  EmbeddedArray<Value*, N> inputs_;
-
- private:
-  friend class BranchInstr;
-  friend class IfThenElseInstr;
-
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    inputs_[i] = value;
-  }
-};
-
-
-struct BranchLabels {
-  Label* true_label;
-  Label* false_label;
-  Label* fall_through;
-};
-
-
 class ComparisonInstr : public TemplateDefinition<2> {
  public:
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual ComparisonInstr* AsComparison() { return this; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Token::Kind kind() const { return kind_; }
 
@@ skipping 5543 matching lines @@
       }
     }
 
     ShallowIterator iterator_;
   };
 
   // Construct an environment by constructing uses from an array of definitions.
   static Environment* From(Isolate* isolate,
                            const GrowableArray<Definition*>& definitions,
                            intptr_t fixed_parameter_count,
-                           const Code& code);
+                           const ParsedFunction* parsed_function);
 
   void set_locations(Location* locations) {
     ASSERT(locations_ == NULL);
     locations_ = locations;
   }
 
   void set_deopt_id(intptr_t deopt_id) { deopt_id_ = deopt_id; }
   intptr_t deopt_id() const { return deopt_id_; }
 
   Environment* outer() const { return outer_; }
@@ skipping 19 matching lines @@
       index -= env->Length();
       env = env->outer_;
     }
     return env->ValueAt(index);
   }
 
   intptr_t fixed_parameter_count() const {
     return fixed_parameter_count_;
   }
 
-  const Code& code() const { return code_; }
+  const Code& code() const { return parsed_function_->code(); }
 
   Environment* DeepCopy(Isolate* isolate) const {
     return DeepCopy(isolate, Length());
   }
 
   void DeepCopyTo(Isolate* isolate, Instruction* instr) const;
   void DeepCopyToOuter(Isolate* isolate, Instruction* instr) const;
 
   void PrintTo(BufferFormatter* f) const;
   const char* ToCString() const;
 
   // Deep copy an environment.  The 'length' parameter may be less than the
   // environment's length in order to drop values (e.g., passed arguments)
   // from the copy.
   Environment* DeepCopy(Isolate* isolate, intptr_t length) const;
 
  private:
   friend class ShallowIterator;
 
   Environment(intptr_t length,
               intptr_t fixed_parameter_count,
               intptr_t deopt_id,
-              const Code& code,
+              const ParsedFunction* parsed_function,
               Environment* outer)
       : values_(length),
         locations_(NULL),
         fixed_parameter_count_(fixed_parameter_count),
         deopt_id_(deopt_id),
-        code_(code),
+        parsed_function_(parsed_function),
         outer_(outer) { }
 
 
   GrowableArray<Value*> values_;
   Location* locations_;
   const intptr_t fixed_parameter_count_;
   intptr_t deopt_id_;
-  const Code& code_;
+  const ParsedFunction* parsed_function_;
   Environment* outer_;
 
   DISALLOW_COPY_AND_ASSIGN(Environment);
 };
 
 
 // Visitor base class to visit each instruction and computation in a flow
 // graph as defined by a reversed list of basic blocks.
 class FlowGraphVisitor : public ValueObject {
  public:
@@ skipping 23 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_