Support verified heap pointer writes on ia32.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 26 matching lines @@
 #include "vm/parser.h"
 #include "vm/report.h"
 #include "vm/reusable_handles.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
+#include "vm/verified_memory.h"
 #include "vm/weak_code.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, huge_method_cutoff_in_code_size, 200000,
     "Huge method cutoff in unoptimized code size (in bytes).");
 DEFINE_FLAG(int, huge_method_cutoff_in_tokens, 20000,
     "Huge method cutoff in tokens: Disables optimizations for huge methods.");
 DEFINE_FLAG(bool, overlap_type_arguments, true,
     "When possible, partially or fully overlap the type arguments of a type "
@@ skipping 1634 matching lines @@
   uword end = address + size;
   while (cur < end) {
     *reinterpret_cast<uword*>(cur) = initial_value;
     cur += kWordSize;
   }
   uword tags = 0;
   ASSERT(class_id != kIllegalCid);
   tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
   reinterpret_cast<RawObject*>(address)->tags_ = tags;
+  VerifiedMemory::Accept(address, size);
 }
 
 
 void Object::CheckHandle() const {
 #if defined(DEBUG)
   if (raw_ != Object::null()) {
     if ((reinterpret_cast<uword>(raw_) & kSmiTagMask) == kSmiTag) {
       ASSERT(vtable() == Smi::handle_vtable_);
       return;
     }
@@ skipping 89 matching lines @@
   // TODO(koda): This will trip when we start allocating black.
   // Revisit code below at that point, to account for the new write barrier.
   ASSERT(!raw_clone->IsMarked());
   // Copy the body of the original into the clone.
   uword orig_addr = RawObject::ToAddr(orig.raw());
   uword clone_addr = RawObject::ToAddr(raw_clone);
   static const intptr_t kHeaderSizeInBytes = sizeof(RawObject);
   memmove(reinterpret_cast<uint8_t*>(clone_addr + kHeaderSizeInBytes),
           reinterpret_cast<uint8_t*>(orig_addr + kHeaderSizeInBytes),
           size - kHeaderSizeInBytes);
+  VerifiedMemory::Accept(clone_addr, size);
   // Add clone to store buffer, if needed.
   if (!raw_clone->IsOldObject()) {
     // No need to remember an object in new space.
     return raw_clone;
   } else if (orig.raw()->IsOldObject() && !orig.raw()->IsRemembered()) {
     // Old original doesn't need to be remembered, so neither does the clone.
     return raw_clone;
   }
   StoreBufferUpdateVisitor visitor(Isolate::Current(), raw_clone);
   raw_clone->VisitPointers(&visitor);
@@ skipping 10337 matching lines @@
   intptr_t pointer_offset_count = assembler->CountPointerOffsets();
   Code& code = Code::ZoneHandle(Code::New(pointer_offset_count));
   Instructions& instrs =
       Instructions::ZoneHandle(Instructions::New(assembler->CodeSize()));
 
   // Copy the instructions into the instruction area and apply all fixups.
   // Embedded pointers are still in handles at this point.
   MemoryRegion region(reinterpret_cast<void*>(instrs.EntryPoint()),
                       instrs.size());
   assembler->FinalizeInstructions(region);
+  VerifiedMemory::Accept(region.start(), region.size());
   CPU::FlushICache(instrs.EntryPoint(), instrs.size());
 
   code.set_compile_timestamp(OS::GetCurrentTimeMicros());
   CodeObservers::NotifyAll(name,
                            instrs.EntryPoint(),
                            assembler->prologue_offset(),
                            instrs.size(),
                            optimized);
 
   {
@@ skipping 6620 matching lines @@
     // This should be caught before we reach here.
     FATAL1("Fatal error in Array::New: invalid len %" Pd "\n", len);
   }
   {
     RawArray* raw = reinterpret_cast<RawArray*>(
         Object::Allocate(class_id,
                          Array::InstanceSize(len),
                          space));
     NoGCScope no_gc;
     raw->StoreSmi(&(raw->ptr()->length_), Smi::New(len));
+    VerifiedMemory::Accept(reinterpret_cast<uword>(raw->ptr()),
+                           Array::InstanceSize(len));
     return raw;
   }
 }
 
 
 RawArray* Array::Slice(intptr_t start,
                        intptr_t count,
                        bool with_type_argument) const {
   // TODO(vegorov) introduce an array allocation method that fills newly
   // allocated array with values from the given source array instead of
@@ skipping 1593 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart