Move OS::MemCopy and OS::MemMove out of platform to utils

src/hydrogen-gvn.cc

 // Copyright 2013 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 "hydrogen.h"
 #include "hydrogen-gvn.h"
 #include "v8.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 122 matching lines @@
 
 HInstructionMap::HInstructionMap(Zone* zone, const HInstructionMap* other)
     : array_size_(other->array_size_),
       lists_size_(other->lists_size_),
       count_(other->count_),
       present_depends_on_(other->present_depends_on_),
       array_(zone->NewArray<HInstructionMapListElement>(other->array_size_)),
       lists_(zone->NewArray<HInstructionMapListElement>(other->lists_size_)),
       free_list_head_(other->free_list_head_),
       side_effects_tracker_(other->side_effects_tracker_) {
-  OS::MemCopy(
-      array_, other->array_, array_size_ * sizeof(HInstructionMapListElement));
-  OS::MemCopy(
-      lists_, other->lists_, lists_size_ * sizeof(HInstructionMapListElement));
+  MemCopy(array_, other->array_,
+          array_size_ * sizeof(HInstructionMapListElement));
+  MemCopy(lists_, other->lists_,
+          lists_size_ * sizeof(HInstructionMapListElement));
 }
 
 
 void HInstructionMap::Kill(SideEffects changes) {
   if (!present_depends_on_.ContainsAnyOf(changes)) return;
   present_depends_on_.RemoveAll();
   for (int i = 0; i < array_size_; ++i) {
     HInstruction* instr = array_[i].instr;
     if (instr != NULL) {
       // Clear list of collisions first, so we know if it becomes empty.
@@ skipping 106 matching lines @@
       zone->NewArray<HInstructionMapListElement>(new_size);
   memset(new_lists, 0, sizeof(HInstructionMapListElement) * new_size);
 
   HInstructionMapListElement* old_lists = lists_;
   int old_size = lists_size_;
 
   lists_size_ = new_size;
   lists_ = new_lists;
 
   if (old_lists != NULL) {
-    OS::MemCopy(
-        lists_, old_lists, old_size * sizeof(HInstructionMapListElement));
+    MemCopy(lists_, old_lists, old_size * sizeof(HInstructionMapListElement));
   }
   for (int i = old_size; i < lists_size_; ++i) {
     lists_[i].next = free_list_head_;
     free_list_head_ = i;
   }
 }
 
 
 void HInstructionMap::Insert(HInstruction* instr, Zone* zone) {
   ASSERT(instr != NULL);
@@ skipping 23 matching lines @@
 HSideEffectMap::HSideEffectMap() : count_(0) {
   memset(data_, 0, kNumberOfTrackedSideEffects * kPointerSize);
 }
 
 
 HSideEffectMap::HSideEffectMap(HSideEffectMap* other) : count_(other->count_) {
   *this = *other;  // Calls operator=.
 }
 
 
-HSideEffectMap& HSideEffectMap::operator= (const HSideEffectMap& other) {
+HSideEffectMap& HSideEffectMap::operator=(const HSideEffectMap& other) {
   if (this != &other) {
-    OS::MemCopy(data_, other.data_, kNumberOfTrackedSideEffects * kPointerSize);
+    MemCopy(data_, other.data_, kNumberOfTrackedSideEffects * kPointerSize);
   }
   return *this;
 }
 
 
 void HSideEffectMap::Kill(SideEffects side_effects) {
   for (int i = 0; i < kNumberOfTrackedSideEffects; i++) {
     if (side_effects.ContainsFlag(GVNFlagFromInt(i))) {
       if (data_[i] != NULL) count_--;
       data_[i] = NULL;
@@ skipping 574 matching lines @@
                                                       dominated);
         successor_map->Kill(side_effects_on_all_paths);
         successor_dominators->Kill(side_effects_on_all_paths);
       }
     }
     current = next;
   }
 }
 
 } }  // namespace v8::internal