rename old/new -> src/dst

Author: vitalybuka

compiler-rt/test/asan/TestCases/copy_container_annotations.cpp

@@ -60,62 +60,62 @@ static size_t CountUnpoisoned(std::deque<int> &poison_states, size_t n) {
   return result;
 }
 
-void TestNonOverlappingContainers(size_t capacity, size_t off_old,
-                                  size_t off_new, bool poison_old,
-                                  bool poison_new) {
-  size_t old_buffer_size = capacity + off_old + kGranularity * 2;
-  size_t new_buffer_size = capacity + off_new + kGranularity * 2;
-
-  std::unique_ptr<char[]> old_buffer =
-      std::make_unique<char[]>(old_buffer_size);
-  std::unique_ptr<char[]> new_buffer =
-      std::make_unique<char[]>(new_buffer_size);
-
-  char *old_buffer_end = old_buffer.get() + old_buffer_size;
-  char *new_buffer_end = new_buffer.get() + new_buffer_size;
-  char *old_beg = old_buffer.get() + off_old;
-  char *new_beg = new_buffer.get() + off_new;
-  char *old_end = old_beg + capacity;
-  char *new_end = new_beg + capacity;
+void TestNonOverlappingContainers(size_t capacity, size_t off_src,
+                                  size_t off_dst, bool poison_src,
+                                  bool poison_dst) {
+  size_t src_buffer_size = capacity + off_src + kGranularity * 2;
+  size_t dst_buffer_size = capacity + off_dst + kGranularity * 2;
+
+  std::unique_ptr<char[]> src_buffer =
+      std::make_unique<char[]>(src_buffer_size);
+  std::unique_ptr<char[]> dst_buffer =
+      std::make_unique<char[]>(dst_buffer_size);
+
+  char *src_buffer_end = src_buffer.get() + src_buffer_size;
+  char *dst_buffer_end = dst_buffer.get() + dst_buffer_size;
+  char *src_beg = src_buffer.get() + off_src;
+  char *dst_beg = dst_buffer.get() + off_dst;
+  char *src_end = src_beg + capacity;
+  char *dst_end = dst_beg + capacity;
 
   for (int i = 0; i < 35; i++) {
-    if (poison_old)
-      __asan_poison_memory_region(old_buffer.get(), old_buffer_size);
-    if (poison_new)
-      __asan_poison_memory_region(new_buffer.get(), new_buffer_size);
+    if (poison_src)
+      __asan_poison_memory_region(src_buffer.get(), src_buffer_size);
+    if (poison_dst)
+      __asan_poison_memory_region(dst_buffer.get(), dst_buffer_size);
 
-    RandomPoison(old_beg, old_end);
-    std::deque<int> poison_states = GetPoisonedState(old_beg, old_end);
-    __sanitizer_copy_contiguous_container_annotations(old_beg, old_end, new_beg,
-                                                      new_end);
+    RandomPoison(src_beg, src_end);
+    std::deque<int> poison_states = GetPoisonedState(src_beg, src_end);
+    __sanitizer_copy_contiguous_container_annotations(src_beg, src_end, dst_beg,
+                                                      dst_end);
 
-    // If old_buffer were poisoned, expected state of memory before old_beg
+    // If src_buffer were poisoned, expected state of memory before src_beg
     // is undetermined.
     // If old buffer were not poisoned, that memory should still be unpoisoned.
     char *cur;
-    if (!poison_old) {
-      for (cur = old_buffer.get(); cur < old_beg; ++cur) {
+    if (!poison_src) {
+      for (cur = src_buffer.get(); cur < src_beg; ++cur) {
         assert(!__asan_address_is_poisoned(cur));
       }
     }
     for (size_t i = 0; i < poison_states.size(); ++i) {
-      assert(__asan_address_is_poisoned(&old_beg[i]) == poison_states[i]);
+      assert(__asan_address_is_poisoned(&src_beg[i]) == poison_states[i]);
     }
-    // Memory after old_end should be the same as at the beginning.
-    for (cur = old_end; cur < old_buffer_end; ++cur) {
-      assert(__asan_address_is_poisoned(cur) == poison_old);
+    // Memory after src_end should be the same as at the beginning.
+    for (cur = src_end; cur < src_buffer_end; ++cur) {
+      assert(__asan_address_is_poisoned(cur) == poison_dst);
     }
 
-    // If new_buffer were not poisoned, memory before new_beg should never
+    // If dst_buffer were not poisoned, memory before dst_beg should never
     // be poisoned. Otherwise, its state is undetermined.
-    if (!poison_new) {
-      for (cur = new_buffer.get(); cur < new_beg; ++cur) {
+    if (!poison_dst) {
+      for (cur = dst_buffer.get(); cur < dst_beg; ++cur) {
         assert(!__asan_address_is_poisoned(cur));
       }
     }
 
     char *next;
-    for (cur = new_beg; cur + kGranularity <= new_end; cur = next) {
+    for (cur = dst_beg; cur + kGranularity <= dst_end; cur = next) {
       next = RoundUp(cur + 1);
       size_t unpoisoned = CountUnpoisoned(poison_states, next - cur);
       if (unpoisoned > 0) {
@@ -125,72 +125,72 @@ void TestNonOverlappingContainers(size_t capacity, size_t off_old,
         assert(__asan_address_is_poisoned(cur + unpoisoned));
       }
     }
-    // [cur; new_end) is not checked yet.
-    // If new_buffer were not poisoned, it cannot be poisoned.
-    // If new_buffer were poisoned, it should be same as earlier.
-    if (cur < new_end) {
-      size_t unpoisoned = CountUnpoisoned(poison_states, new_end - cur);
+    // [cur; dst_end) is not checked yet.
+    // If dst_buffer were not poisoned, it cannot be poisoned.
+    // If dst_buffer were poisoned, it should be same as earlier.
+    if (cur < dst_end) {
+      size_t unpoisoned = CountUnpoisoned(poison_states, dst_end - cur);
       if (unpoisoned > 0) {
         assert(!__asan_address_is_poisoned(cur + unpoisoned - 1));
       }
-      if (cur + unpoisoned < new_end && poison_new) {
+      if (cur + unpoisoned < dst_end && poison_dst) {
         assert(__asan_address_is_poisoned(cur + unpoisoned));
       }
     }
-    // Memory annotations after new_end should be unchanged.
-    for (cur = new_end; cur < new_buffer_end; ++cur) {
-      assert(__asan_address_is_poisoned(cur) == poison_new);
+    // Memory annotations after dst_end should be unchanged.
+    for (cur = dst_end; cur < dst_buffer_end; ++cur) {
+      assert(__asan_address_is_poisoned(cur) == poison_dst);
     }
   }
 
-  __asan_unpoison_memory_region(old_buffer.get(), old_buffer_size);
-  __asan_unpoison_memory_region(new_buffer.get(), new_buffer_size);
+  __asan_unpoison_memory_region(src_buffer.get(), src_buffer_size);
+  __asan_unpoison_memory_region(dst_buffer.get(), dst_buffer_size);
 }
 
-void TestOverlappingContainers(size_t capacity, size_t off_old, size_t off_new,
-                               bool poison_whole, bool poison_new) {
-  size_t buffer_size = capacity + off_old + off_new + kGranularity * 3;
+void TestOverlappingContainers(size_t capacity, size_t off_src, size_t off_dst,
+                               bool poison_whole, bool poison_dst) {
+  size_t buffer_size = capacity + off_src + off_dst + kGranularity * 3;
 
   // Use unique_ptr with a custom deleter to manage the buffer
   std::unique_ptr<char[]> buffer = std::make_unique<char[]>(buffer_size);
 
   char *buffer_end = buffer.get() + buffer_size;
-  char *old_beg = buffer.get() + kGranularity + off_old;
-  char *new_beg = buffer.get() + kGranularity + off_new;
-  char *old_end = old_beg + capacity;
-  char *new_end = new_beg + capacity;
+  char *src_beg = buffer.get() + kGranularity + off_src;
+  char *dst_beg = buffer.get() + kGranularity + off_dst;
+  char *src_end = src_beg + capacity;
+  char *dst_end = dst_beg + capacity;
 
   for (int i = 0; i < 35; i++) {
     if (poison_whole)
       __asan_poison_memory_region(buffer.get(), buffer_size);
-    if (poison_new)
-      __asan_poison_memory_region(new_beg, new_end - new_beg);
+    if (poison_dst)
+      __asan_poison_memory_region(dst_beg, dst_end - dst_beg);
 
-    RandomPoison(old_beg, old_end);
-    auto poison_states = GetPoisonedState(old_beg, old_end);
-    __sanitizer_copy_contiguous_container_annotations(old_beg, old_end, new_beg,
-                                                      new_end);
+    RandomPoison(src_beg, src_end);
+    auto poison_states = GetPoisonedState(src_beg, src_end);
+    __sanitizer_copy_contiguous_container_annotations(src_beg, src_end, dst_beg,
+                                                      dst_end);
     // This variable is used only when buffer ends in the middle of a granule.
-    bool can_modify_last_granule = __asan_address_is_poisoned(new_end);
+    bool can_modify_last_granule = __asan_address_is_poisoned(dst_end);
 
     // If whole buffer were poisoned, expected state of memory before first container
     // is undetermined.
     // If old buffer were not poisoned, that memory should still be unpoisoned.
     char *cur;
     if (!poison_whole) {
-      for (cur = buffer.get(); cur < old_beg && cur < new_beg; ++cur) {
+      for (cur = buffer.get(); cur < src_beg && cur < dst_beg; ++cur) {
         assert(!__asan_address_is_poisoned(cur));
       }
     }
 
     // Memory after end of both containers should be the same as at the beginning.
-    for (cur = (old_end > new_end) ? old_end : new_end; cur < buffer_end;
+    for (cur = (src_end > dst_end) ? src_end : dst_end; cur < buffer_end;
          ++cur) {
       assert(__asan_address_is_poisoned(cur) == poison_whole);
     }
 
     char *next;
-    for (cur = new_beg; cur + kGranularity <= new_end; cur = next) {
+    for (cur = dst_beg; cur + kGranularity <= dst_end; cur = next) {
       next = RoundUp(cur + 1);
       size_t unpoisoned = CountUnpoisoned(poison_states, next - cur);
       if (unpoisoned > 0) {
@@ -200,15 +200,15 @@ void TestOverlappingContainers(size_t capacity, size_t off_old, size_t off_new,
         assert(__asan_address_is_poisoned(cur + unpoisoned));
       }
     }
-    // [cur; new_end) is not checked yet, if container ends in the middle of a granule.
+    // [cur; dst_end) is not checked yet, if container ends in the middle of a granule.
     // It can be poisoned, only if non-container bytes in that granule were poisoned.
     // Otherwise, it should be unpoisoned.
-    if (cur < new_end) {
-      size_t unpoisoned = CountUnpoisoned(poison_states, new_end - cur);
+    if (cur < dst_end) {
+      size_t unpoisoned = CountUnpoisoned(poison_states, dst_end - cur);
       if (unpoisoned > 0) {
         assert(!__asan_address_is_poisoned(cur + unpoisoned - 1));
       }
-      if (cur + unpoisoned < new_end && can_modify_last_granule) {
+      if (cur + unpoisoned < dst_end && can_modify_last_granule) {
         assert(__asan_address_is_poisoned(cur + unpoisoned));
       }
     }
@@ -219,15 +219,15 @@ void TestOverlappingContainers(size_t capacity, size_t off_old, size_t off_new,
 
 int main(int argc, char **argv) {
   int n = argc == 1 ? 64 : atoi(argv[1]);
-  for (size_t off_old = 0; off_old < kGranularity + 2; off_old++) {
-    for (size_t off_new = 0; off_new < kGranularity + 2; off_new++) {
+  for (size_t off_src = 0; off_src < kGranularity + 2; off_src++) {
+    for (size_t off_dst = 0; off_dst < kGranularity + 2; off_dst++) {
       for (int capacity = 0; capacity <= n; capacity++) {
-        for (int poison_old = 0; poison_old < 2; ++poison_old) {
-          for (int poison_new = 0; poison_new < 2; ++poison_new) {
-            TestNonOverlappingContainers(capacity, off_old, off_new, poison_old,
-                                         poison_new);
-            TestOverlappingContainers(capacity, off_old, off_new, poison_old,
-                                      poison_new);
+        for (int poison_dst = 0; poison_dst < 2; ++poison_dst) {
+          for (int poison_dst = 0; poison_dst < 2; ++poison_dst) {
+            TestNonOverlappingContainers(capacity, off_src, off_dst, poison_dst,
+                                         poison_dst);
+            TestOverlappingContainers(capacity, off_src, off_dst, poison_dst,
+                                      poison_dst);
           }
         }
       }