Revert 21502 - "Move OS::MemCopy and OS::MemMove out of platform to utils"

src/liveedit.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 #include "v8.h"
 
 #include "liveedit.h"
 
 #include "code-stubs.h"
@@ skipping 1295 matching lines @@
     if (new_buffer_size > kMaximalBufferSize) {
       V8::FatalProcessOutOfMemory("RelocInfoBuffer::GrowBuffer");
     }
 
     // Set up new buffer.
     byte* new_buffer = NewArray<byte>(new_buffer_size);
 
     // Copy the data.
     int curently_used_size =
         static_cast<int>(buffer_ + buffer_size_ - reloc_info_writer_.pos());
-    MemMove(new_buffer + new_buffer_size - curently_used_size,
-            reloc_info_writer_.pos(), curently_used_size);
+    OS::MemMove(new_buffer + new_buffer_size - curently_used_size,
+                reloc_info_writer_.pos(), curently_used_size);
 
     reloc_info_writer_.Reposition(
         new_buffer + new_buffer_size - curently_used_size,
         reloc_info_writer_.last_pc());
 
     DeleteArray(buffer_);
     buffer_ = new_buffer;
     buffer_size_ = new_buffer_size;
   }
 
@@ skipping 32 matching lines @@
       if (RelocInfo::IsRealRelocMode(rinfo->rmode())) {
         buffer_writer.Write(it.rinfo());
       }
     }
   }
 
   Vector<byte> buffer = buffer_writer.GetResult();
 
   if (buffer.length() == code->relocation_size()) {
     // Simply patch relocation area of code.
-    MemCopy(code->relocation_start(), buffer.start(), buffer.length());
+    OS::MemCopy(code->relocation_start(), buffer.start(), buffer.length());
     return code;
   } else {
     // Relocation info section now has different size. We cannot simply
     // rewrite it inside code object. Instead we have to create a new
     // code object.
     Handle<Code> result(isolate->factory()->CopyCode(code, buffer));
     return result;
   }
 }
 
@@ skipping 248 matching lines @@
           Smi::cast(Memory::Object_at(padding_pointer))->value();
       if (padding_counter * kPointerSize < shortage_bytes) {
         return "Not enough space for frame dropper frame "
             "(even with padding frame)";
       }
       Memory::Object_at(padding_pointer) =
           Smi::FromInt(padding_counter - shortage_bytes / kPointerSize);
 
       StackFrame* pre_pre_frame = frames[top_frame_index - 2];
 
-      MemMove(padding_start + kPointerSize - shortage_bytes,
-              padding_start + kPointerSize,
-              Debug::FramePaddingLayout::kFrameBaseSize * kPointerSize);
+      OS::MemMove(padding_start + kPointerSize - shortage_bytes,
+                  padding_start + kPointerSize,
+                  Debug::FramePaddingLayout::kFrameBaseSize * kPointerSize);
 
       pre_top_frame->UpdateFp(pre_top_frame->fp() - shortage_bytes);
       pre_pre_frame->SetCallerFp(pre_top_frame->fp());
       unused_stack_top -= shortage_bytes;
 
       STATIC_ASSERT(sizeof(Address) == kPointerSize);
       top_frame_pc_address -= shortage_bytes / kPointerSize;
     } else {
       return "Not enough space for frame dropper frame";
     }
@@ skipping 367 matching lines @@
 void LiveEditFunctionTracker::RecordRootFunctionInfo(Handle<Code> code) {
   isolate_->active_function_info_listener()->FunctionCode(code);
 }
 
 
 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
   return isolate->active_function_info_listener() != NULL;
 }
 
 } }  // namespace v8::internal