More fixes for background compilation

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 696 matching lines @@
   // Normal instructions can have 0 (inside a block) or 1 (last instruction in
   // a block) successors. Branch instruction with >1 successors override this
   // function.
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   void Goto(JoinEntryInstr* entry);
 
   virtual const char* DebugName() const = 0;
 
+#if defined(DEBUG)
+  // Checks that the field stored in an instruction has proper form:
+  // - must be a zone-handle
+  // - In background compilation, must be cloned.
+  // Aborts if field is not OK.
+  void CheckField(const Field& field) const;
+#else
+  void CheckField(const Field& field) const {}
+#endif  // DEBUG
+
   // Printing support.
   const char* ToCString() const;
 #ifndef PRODUCT
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 #endif
 
 #define DECLARE_INSTRUCTION_TYPE_CHECK(Name, Type)                             \
   bool Is##Name() { return (As##Name() != NULL); }                             \
   virtual Type* As##Name() { return NULL; }
@@ skipping 2816 matching lines @@
                           StoreBarrierType emit_store_barrier,
                           TokenPosition token_pos)
       : field_(field),
         offset_in_bytes_(field.Offset()),
         emit_store_barrier_(emit_store_barrier),
         token_pos_(token_pos),
         is_potential_unboxed_initialization_(false),
         is_object_reference_initialization_(false) {
     SetInputAt(kInstancePos, instance);
     SetInputAt(kValuePos, value);
+    CheckField(field);
   }
 
   StoreInstanceFieldInstr(intptr_t offset_in_bytes,
                           Value* instance,
                           Value* value,
                           StoreBarrierType emit_store_barrier,
                           TokenPosition token_pos)
       : field_(Field::ZoneHandle()),
         offset_in_bytes_(offset_in_bytes),
         emit_store_barrier_(emit_store_barrier),
@@ skipping 81 matching lines @@
 
 
 class GuardFieldInstr : public TemplateInstruction<1, NoThrow, Pure> {
  public:
   GuardFieldInstr(Value* value,
                   const Field& field,
                   intptr_t deopt_id)
     : TemplateInstruction(deopt_id),
       field_(field) {
     SetInputAt(0, value);
+    CheckField(field);
   }
 
   Value* value() const { return inputs_[0]; }
 
   const Field& field() const { return field_; }
 
   virtual bool CanDeoptimize() const { return true; }
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Ensure that we record kDeopt PC descriptor in unoptimized code.
     return true;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(GuardFieldInstr);
 };
 
 
 class GuardFieldClassInstr : public GuardFieldInstr {
  public:
   GuardFieldClassInstr(Value* value,
                        const Field& field,
                        intptr_t deopt_id)
-    : GuardFieldInstr(value, field, deopt_id) { }
+      : GuardFieldInstr(value, field, deopt_id) {
+    CheckField(field);
+  }
 
   DECLARE_INSTRUCTION(GuardFieldClass)
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldClassInstr);
 };
 
 
 class GuardFieldLengthInstr : public GuardFieldInstr {
  public:
   GuardFieldLengthInstr(Value* value,
                        const Field& field,
                        intptr_t deopt_id)
-    : GuardFieldInstr(value, field, deopt_id) { }
+      : GuardFieldInstr(value, field, deopt_id) {
+    CheckField(field);
+  }
 
   DECLARE_INSTRUCTION(GuardFieldLength)
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldLengthInstr);
 };
@@ skipping 34 matching lines @@
 
 class StoreStaticFieldInstr : public TemplateDefinition<1, NoThrow> {
  public:
   StoreStaticFieldInstr(const Field& field,
                         Value* value,
                         TokenPosition token_pos)
       : field_(field),
         token_pos_(token_pos) {
     ASSERT(field.IsZoneHandle());
     SetInputAt(kValuePos, value);
+    CheckField(field);
   }
 
   enum {
     kValuePos = 0
   };
 
   DECLARE_INSTRUCTION(StoreStaticField)
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[kValuePos]; }
@@ skipping 871 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class InitStaticFieldInstr : public TemplateInstruction<1, Throws> {
  public:
   InitStaticFieldInstr(Value* input, const Field& field)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         field_(field) {
     SetInputAt(0, input);
+    CheckField(field);
   }
 
   virtual TokenPosition token_pos() const {
     return field_.token_pos();
   }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
   virtual bool CanDeoptimize() const { return true; }
@@ skipping 3555 matching lines @@
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {    \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_