update with changes done in the past few weeks, maily remapping from new to original addresses

Author: patrikcerbak

src/hotspot/share/gc/g1/c2/g1BarrierSetC2.cpp

@@ -485,7 +485,7 @@ void G1BarrierSetC2::post_barrier(GraphKit* kit,
         Node* mapped;
         if (SanitizeGC) {
           mapped = __ make_leaf_call(mapNewAddrToOriginalAddr_Type(), CAST_FROM_FN_PTR(address,
-            SanitizerGCMapper::mapNewAddrToOriginalAddr), "mapNewAddrToOriginalAddr", card_adr)->in(0);
+            SanitizerGCMapper::mapNewAddrToOriginalAddr), "mapNewAddrToOriginalAddr", card_adr)->in(0);//->lookup(3); SANITIZE TODO
         } else {
           mapped = card_adr;
         }

src/hotspot/share/gc/g1/customMapper.cpp

@@ -3,6 +3,8 @@
 ptrdiff_t SanitizerGCMapper::movedRegionOffset = 0;
 const void* SanitizerGCMapper::movedRegionStart = nullptr;
 const void* SanitizerGCMapper::movedRegionEnd = nullptr;
+const void* SanitizerGCMapper::originalRegionStart = nullptr;
+const void* SanitizerGCMapper::originalRegionEnd = nullptr;
 
 // Since we can't use void* for pointer arithmetic, we need another pointer
 // type, whose base element size is the unit for movedRegionOffset. We must use
@@ -12,23 +14,34 @@ const void* SanitizerGCMapper::movedRegionEnd = nullptr;
 using byte_ptr = const char*;
 
 void SanitizerGCMapper::initializeMapping(const void* originalRegionStart,
-        const void* movedRegionStart, const void* movedRegionEnd) {
+        const void* originalRegionEnd, const void* movedRegionStart, const void* movedRegionEnd) {
     SanitizerGCMapper::movedRegionOffset =
             static_cast<byte_ptr>(originalRegionStart) -
             static_cast<byte_ptr>(movedRegionStart);
     SanitizerGCMapper::movedRegionStart = movedRegionStart;
     SanitizerGCMapper::movedRegionEnd = movedRegionEnd;
+    SanitizerGCMapper::originalRegionStart = originalRegionStart;
+    SanitizerGCMapper::originalRegionEnd = originalRegionEnd;
 }
 
 const void* SanitizerGCMapper::mapNewAddrToOriginalAddr(const void* newAddr) {
     if (movedRegionOffset != 0 &&
-            newAddr >= movedRegionStart && newAddr < movedRegionEnd) {
+            newAddr >= movedRegionStart && newAddr <= movedRegionEnd) { // TODO
         return static_cast<byte_ptr>(newAddr) + movedRegionOffset;
     }
 
     return newAddr;
 }
 
+const void* SanitizerGCMapper::mapOriginalAddrToNewAddr(const void* originalAddr) {
+    if (movedRegionOffset != 0 &&
+            originalAddr >= originalRegionStart && originalAddr <= originalRegionEnd) {
+        return static_cast<byte_ptr>(originalAddr) - movedRegionOffset;
+            }
+
+    return originalAddr;
+}
+
 void SanitizerGCMapper::testPrint(void* newAddr) {
     printf("---+++%p\n", newAddr);
 }

src/hotspot/share/gc/g1/customMapper.hpp

@@ -9,17 +9,26 @@ class SanitizerGCMapper {
     static ptrdiff_t movedRegionOffset;
     static const void* movedRegionStart;
     static const void* movedRegionEnd;
+    static const void* originalRegionStart;
+    static const void* originalRegionEnd;
 
 public:
     static void initializeMapping(const void* originalRegionStart,
-            const void* movedRegionStart, const void* movedRegionEnd);
+            const void* originalRegionEnd, const void* movedRegionStart, const void* movedRegionEnd);
     static const void* mapNewAddrToOriginalAddr(const void* newAddr);
+    static const void* mapOriginalAddrToNewAddr(const void *newAddr);
+
     static void testPrint(void* newAddr);
     template <typename T> static inline void remapAddress(T &addr) {
       if (SanitizeGC) {
         addr = (T) mapNewAddrToOriginalAddr(addr);
       }
     }
+    template <typename T> static inline void reverseRemapAddress(T &addr) {
+        if (SanitizeGC) {
+            addr = (T) mapOriginalAddrToNewAddr(addr);
+        }
+    }
 };
 
 #endif //CUSTOMMAPPER_H

src/hotspot/share/gc/g1/g1BiasedArray.hpp

@@ -29,6 +29,7 @@
 #include "memory/memRegion.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/powerOfTwo.hpp"
+#include "customMapper.hpp"
 
 // Implements the common base functionality for arrays that contain provisions
 // for accessing its elements using a biased index.
@@ -129,6 +130,7 @@ class G1BiasedMappedArray : public G1BiasedMappedArrayBase {
   // Return the element of the given array that covers the given word in the
   // heap. Assumes the index is valid.
   T get_by_address(HeapWord* value) const {
+    SanitizerGCMapper::remapAddress(value);
     idx_t biased_index = ((uintptr_t)value) >> this->shift_by();
     this->verify_biased_index(biased_index);
     return biased_base()[biased_index];

src/hotspot/share/gc/g1/g1ConcurrentMarkBitMap.inline.hpp

@@ -38,7 +38,13 @@ inline bool G1CMBitMap::iterate(G1CMBitMapClosure* cl, MemRegion mr) {
          "Given MemRegion from " PTR_FORMAT " to " PTR_FORMAT " not contained in heap area",
          p2i(mr.start()), p2i(mr.end()));
 
+  // TODO SANITIZE
+  // HeapWord* end = mr.end();
+  // SanitizerGCMapper::remapAddress(end);
   BitMap::idx_t const end_offset = addr_to_offset(mr.end());
+
+  // HeapWord* start = mr.start();
+  // SanitizerGCMapper::remapAddress(start);
   BitMap::idx_t offset = _bm.find_first_set_bit(addr_to_offset(mr.start()), end_offset);
 
   while (offset < end_offset) {

src/hotspot/share/gc/g1/g1HeapRegion.cpp

@@ -76,7 +76,7 @@ void G1HeapRegion::move_this_region() {
   }
 
   HeapWord* new_end = new_bottom + GrainWords;
-  SanitizerGCMapper::initializeMapping(_bottom, new_bottom, new_end);
+  SanitizerGCMapper::initializeMapping(_bottom, _end, new_bottom, new_end);
   _bottom = new_bottom;
   _top = new_bottom;
   _end = new_end;

src/hotspot/share/gc/g1/g1HeapRegionManager.cpp

@@ -118,13 +118,13 @@ G1HeapRegion* HeapRegionManager::allocate_free_region(HeapRegionType type, uint
 
   if (SanitizeGC) {
     // SANITIZER, printing of bottom, top and end
-    printf("index: %d, _bottom: %p, _top: %p, _end: %p\n", hr->hrm_index(), hr->bottom(), hr->top(), hr->end());
+    printf("REGION WITH INDEX: %d, _bottom: %p, _end: %p\n", hr->hrm_index(), hr->bottom(), hr->end());
 
     // SANITIZER, moving the first region to different address
     if (!wasFirstTaken) {
       hr->move_this_region();
-      printf("region with index %d was moved here:\n", hr->hrm_index());
-      printf("    index: %d, _bottom: %p, _top: %p, _end: %p\n", hr->hrm_index(), hr->bottom(), hr->top(), hr->end());
+      printf("    %d was moved here:\n", hr->hrm_index());
+      printf("    index: %d, _bottom: %p, _end: %p\n", hr->hrm_index(), hr->bottom(), hr->end());
 
       wasFirstTaken = true;
     }
@@ -716,19 +716,21 @@ void HeapRegionManager::verify() {
     num_committed++;
     G1HeapRegion* hr = _regions.get_by_index(i);
     guarantee(hr != nullptr, "invariant: i: %u", i);
-    guarantee(!prev_committed || hr->bottom() == prev_end,
+    HeapWord* hr_bottom = hr->bottom();
+    SanitizerGCMapper::remapAddress(hr_bottom);
+    guarantee(!prev_committed || hr_bottom == prev_end,
               "invariant i: %u " HR_FORMAT " prev_end: " PTR_FORMAT,
               i, HR_FORMAT_PARAMS(hr), p2i(prev_end));
     guarantee(hr->hrm_index() == i,
               "invariant: i: %u hrm_index(): %u", i, hr->hrm_index());
     // Asserts will fire if i is >= _length
-    HeapWord* addr = hr->bottom();
-    guarantee(addr_to_region(addr) == hr, "sanity");
+    guarantee(addr_to_region(hr_bottom) == hr, "sanity");
     // We cannot check whether the region is part of a particular set: at the time
     // this method may be called, we have only completed allocation of the regions,
     // but not put into a region set.
     prev_committed = true;
     prev_end = hr->end();
+    SanitizerGCMapper::remapAddress(prev_end);
   }
   for (uint i = _allocated_heapregions_length; i < reserved_length(); i++) {
     guarantee(_regions.get_by_index(i) == nullptr, "invariant i: %u", i);

src/hotspot/share/gc/g1/g1HeapVerifier.cpp

@@ -246,6 +246,7 @@ class VerifyRegionClosure: public HeapRegionClosure {
   }
 
   bool do_heap_region(G1HeapRegion* r) {
+    // TODO SANITIZE
     guarantee(!r->has_index_in_opt_cset(), "Region %u still has opt collection set index %u", r->hrm_index(), r->index_in_opt_cset());
     guarantee(!r->is_young() || r->rem_set()->is_complete(), "Remembered set for Young region %u must be complete, is %s", r->hrm_index(), r->rem_set()->get_state_str());
     // Humongous and old regions regions might be of any state, so can't check here.

src/hotspot/share/gc/shared/cardTable.cpp

@@ -212,13 +212,21 @@ void CardTable::clear_MemRegion(MemRegion mr) {
   // Be conservative: only clean cards entirely contained within the
   // region.
   CardValue* cur;
-  if (mr.start() == _whole_heap.start()) {
-    cur = byte_for(mr.start());
+
+  HeapWord* start = mr.start();
+  SanitizerGCMapper::remapAddress(start);
+
+  if (start == _whole_heap.start()) {
+    cur = byte_for(start);
   } else {
-    assert(mr.start() > _whole_heap.start(), "mr is not covered.");
-    cur = byte_after(mr.start() - 1);
+    assert(start > _whole_heap.start(), "mr is not covered.");
+    cur = byte_after(start - 1);
   }
-  CardValue* last = byte_after(mr.last());
+
+  HeapWord* mr_last = mr.last();
+  SanitizerGCMapper::remapAddress(mr_last);
+
+  CardValue* last = byte_after(mr_last);
   memset(cur, clean_card, pointer_delta(last, cur, sizeof(CardValue)));
 }
 

src/hotspot/share/gc/shared/markBitMap.cpp

@@ -51,6 +51,7 @@ void MarkBitMap::do_clear(MemRegion mr, bool large) {
          "Given range from " PTR_FORMAT " to " PTR_FORMAT " is completely outside the heap",
          p2i(mr.start()), p2i(mr.end()));
   // convert address range into offset range
+  // TODO SANITIZE, maybe needs remapping
   size_t beg = addr_to_offset(intersection.start());
   size_t end = addr_to_offset(intersection.end());
   if (large) {