Narrow the scope of writable code to the forwarding phase of become instead of the whole isolate re…

runtime/vm/become.cc

 // Copyright (c) 2016, 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/become.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 
 #include "vm/dart_api_state.h"
@@ skipping 130 matching lines @@
 
   intptr_t count() const { return count_; }
 
  private:
   int count_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardHeapPointersHandleVisitor);
 };
 
 
+// On IA32, object pointers are embedded directly in the instruction stream,
+// which is normally write-protected, so we need to make it temporarily writable
+// to forward the pointers. On all other architectures, object pointers are
+// accessed through ObjectPools.
+class WritableCodeLiteralsScope : public ValueObject {
+ public:
+  explicit WritableCodeLiteralsScope(Heap* heap) : heap_(heap) {
+#if defined(TARGET_ARCH_IA32)
+    if (FLAG_write_protect_code) {
+      heap_->WriteProtectCode(false);
+    }
+#endif
+  }
+
+  ~WritableCodeLiteralsScope() {
+#if defined(TARGET_ARCH_IA32)
+    if (FLAG_write_protect_code) {
+      heap_->WriteProtectCode(true);
+    }
+#endif
+  }
+
+ private:
+  Heap* heap_;
+};
+
+
 void Become::MakeDummyObject(const Instance& instance) {
   // Make the forward pointer point to itself.
   // This is needed to distinguish it from a real forward object.
   ForwardObjectTo(instance.raw(), instance.raw());
 }
 
+
 static bool IsDummyObject(RawObject* object) {
   if (!object->IsForwardingCorpse()) return false;
   return GetForwardedObject(object) == object;
 }
 
+
 void Become::ElementsForwardIdentity(const Array& before, const Array& after) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Heap* heap = isolate->heap();
 
   TIMELINE_FUNCTION_GC_DURATION(thread, "Become::ElementsForwardIdentity");
   HeapIterationScope his;
 
   // Setup forwarding pointers.
   ASSERT(before.Length() == after.Length());
@@ skipping 31 matching lines @@
 
     // C++ pointers
     ForwardPointersVisitor pointer_visitor(isolate);
     isolate->VisitObjectPointers(&pointer_visitor, true);
 
     // Weak persistent handles.
     ForwardHeapPointersHandleVisitor handle_visitor;
     isolate->VisitWeakPersistentHandles(&handle_visitor);
 
     //   Heap pointers (may require updating the remembered set)
-    ForwardHeapPointersVisitor object_visitor(&pointer_visitor);
-    heap->VisitObjects(&object_visitor);
-    pointer_visitor.VisitingObject(NULL);
+    {
+      WritableCodeLiteralsScope writable_code(heap);
+      ForwardHeapPointersVisitor object_visitor(&pointer_visitor);
+      heap->VisitObjects(&object_visitor);
+      pointer_visitor.VisitingObject(NULL);
+    }
 
 #if !defined(PRODUCT)
     tds.SetNumArguments(2);
     tds.FormatArgument(0, "Remapped objects", "%" Pd,  before.Length());
     tds.FormatArgument(1, "Remapped references", "%" Pd,
                        pointer_visitor.count() + handle_visitor.count());
 #endif
   }
 
 #if defined(DEBUG)
   for (intptr_t i = 0; i < before.Length(); i++) {
     ASSERT(before.At(i) == after.At(i));
   }
 #endif
 }
 
 }  // namespace dart