Cleanup access to Instruction's fields (especially deopt_id_).

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"
@@ skipping 601 matching lines @@
         env_(NULL),
         locs_(NULL),
         place_id_(kNoPlaceId) { }
 
   virtual ~Instruction() { }
 
   virtual Tag tag() const = 0;
 
   intptr_t deopt_id() const {
     ASSERT(CanDeoptimize() || CanBecomeDeoptimizationTarget());
-    return deopt_id_;
+    return GetDeoptId();
   }
 
   const ICData* GetICData(
       const ZoneGrowableArray<const ICData*>& ic_data_array) const;
 
   virtual intptr_t token_pos() const { return Scanner::kNoSourcePos; }
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   void SetInputAt(intptr_t i, Value* value) {
@@ skipping 77 matching lines @@
 
 DECLARE_INSTRUCTION_TYPE_CHECK(Definition, Definition)
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 FOR_EACH_ABSTRACT_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 
 #undef INSTRUCTION_TYPE_CHECK
 #undef DECLARE_INSTRUCTION_TYPE_CHECK
 
   // Returns structure describing location constraints required
   // to emit native code for this instruction.
-  virtual LocationSummary* locs() {
+  LocationSummary* locs() {
     ASSERT(locs_ != NULL);
     return locs_;
   }
 
+  bool HasLocs() const { return locs_ != NULL; }
+
   virtual LocationSummary* MakeLocationSummary(Isolate* isolate,
                                                bool is_optimizing) const = 0;
 
   void InitializeLocationSummary(Isolate* isolate, bool optimizing) {
     ASSERT(locs_ == NULL);
     locs_ = MakeLocationSummary(isolate, optimizing);
   }
 
   static LocationSummary* MakeCallSummary(Isolate* isolate);
 
@@ skipping 106 matching lines @@
   }
 
   void InheritDeoptTargetAfter(FlowGraph* flow_graph,
                                Definition* call,
                                Definition* result);
 
   virtual bool MayThrow() const = 0;
 
   bool IsDominatedBy(Instruction* dom);
 
+  void ClearEnv() { env_ = NULL; }
+
  protected:
+  // GetDeoptId and/or CopyDeoptIdFrom.
+  friend class CallSiteInliner;
+  friend class LICM;
+  friend class ComparisonInstr;
+  friend class Scheduler;
+  friend class BlockEntryInstr;
+
   // Fetch deopt id without checking if this computation can deoptimize.
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
+  void CopyDeoptIdFrom(const Instruction& instr) {
+    deopt_id_ = instr.deopt_id_;
+  }
+
  private:
-  friend class FlowGraphPrinter;
-  friend class Definition;  // Needed for InsertBefore, InsertAfter.
-  friend class CallSiteInliner;
-
-  // deopt_id_ write access.
-  friend class ComparisonInstr;
-  friend class LICM;
-  friend class Scheduler;
-  friend class BlockEntryInstr;
-  friend class BranchSimplifier;
-
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
   enum {
     kNoPlaceId = -1
   };
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
@@ skipping 1354 matching lines @@
   Token::Kind kind() const { return kind_; }
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right) = 0;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch) = 0;
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels) = 0;
 
-  void SetDeoptId(intptr_t deopt_id) {
-    deopt_id_ = deopt_id;
+  void SetDeoptId(const Instruction& instr) {

[Cutch, 2014/12/16 16:49:30]

Why not unify this with CopyDeoptIdFrom?

[srdjan, 2014/12/16 16:54:06]

CopyDeoptId is protected, few classes can do it. Here we make an exception and
make the setting public.

+    CopyDeoptIdFrom(instr);
   }
 
   // Operation class id is computed from collected ICData.
   void set_operation_cid(intptr_t value) { operation_cid_ = value; }
   intptr_t operation_cid() const { return operation_cid_; }
 
   void NegateComparison() {
     kind_ = Token::NegateComparison(kind_);
   }
 
@@ skipping 5747 matching lines @@
       Isolate* isolate, bool opt) const {                                     \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_