--- a/src/hotspot/share/gc/shared/cardTable.cpp	Wed Mar 13 12:30:20 2019 -0700
+++ b/src/hotspot/share/gc/shared/cardTable.cpp	Wed Mar 13 21:01:56 2019 +0100
@@ -109,12 +109,12 @@
   // then add it to _byte_map_base, i.e.
   //
   //   _byte_map = _byte_map_base + (uintptr_t(low_bound) >> card_shift)
-  _byte_map = (jbyte*) heap_rs.base();
+  _byte_map = (CardValue*) heap_rs.base();
   _byte_map_base = _byte_map - (uintptr_t(low_bound) >> card_shift);
   assert(byte_for(low_bound) == &_byte_map[0], "Checking start of map");
   assert(byte_for(high_bound-1) <= &_byte_map[_last_valid_index], "Checking end of map");
 
-  jbyte* guard_card = &_byte_map[_guard_index];
+  CardValue* guard_card = &_byte_map[_guard_index];
   HeapWord* guard_page = align_down((HeapWord*)guard_card, _page_size);
   _guard_region = MemRegion(guard_page, _page_size);
   os::commit_memory_or_exit((char*)guard_page, _page_size, _page_size,
@@ -145,7 +145,7 @@
   _cur_covered_regions++;
   _covered[res].set_start(base);
   _covered[res].set_word_size(0);
-  jbyte* ct_start = byte_for(base);
+  CardValue* ct_start = byte_for(base);
   HeapWord* ct_start_aligned = align_down((HeapWord*)ct_start, _page_size);
   _committed[res].set_start(ct_start_aligned);
   _committed[res].set_word_size(0);
@@ -302,7 +302,7 @@
 #endif
 
     // The default of 0 is not necessarily clean cards.
-    jbyte* entry;
+    CardValue* entry;
     if (old_region.last() < _whole_heap.start()) {
       entry = byte_for(_whole_heap.start());
     } else {
@@ -312,8 +312,8 @@
       "The guard card will be overwritten");
     // This line commented out cleans the newly expanded region and
     // not the aligned up expanded region.
-    // jbyte* const end = byte_after(new_region.last());
-    jbyte* const end = (jbyte*) new_end_for_commit;
+    // CardValue* const end = byte_after(new_region.last());
+    CardValue* const end = (CardValue*) new_end_for_commit;
     assert((end >= byte_after(new_region.last())) || collided || guarded,
       "Expect to be beyond new region unless impacting another region");
     // do nothing if we resized downward.
@@ -330,7 +330,7 @@
     }
 #endif
     if (entry < end) {
-      memset(entry, clean_card, pointer_delta(end, entry, sizeof(jbyte)));
+      memset(entry, clean_card, pointer_delta(end, entry, sizeof(CardValue)));
     }
   }
   // In any case, the covered size changes.
@@ -344,7 +344,7 @@
   log_trace(gc, barrier)("    byte_for(start): " INTPTR_FORMAT "  byte_for(last): " INTPTR_FORMAT,
                          p2i(byte_for(_covered[ind].start())),  p2i(byte_for(_covered[ind].last())));
   log_trace(gc, barrier)("    addr_for(start): " INTPTR_FORMAT "  addr_for(last): " INTPTR_FORMAT,
-                         p2i(addr_for((jbyte*) _committed[ind].start())),  p2i(addr_for((jbyte*) _committed[ind].last())));
+                         p2i(addr_for((CardValue*) _committed[ind].start())),  p2i(addr_for((CardValue*) _committed[ind].last())));
 
   // Touch the last card of the covered region to show that it
   // is committed (or SEGV).
@@ -357,8 +357,8 @@
 void CardTable::dirty_MemRegion(MemRegion mr) {
   assert(align_down(mr.start(), HeapWordSize) == mr.start(), "Unaligned start");
   assert(align_up  (mr.end(),   HeapWordSize) == mr.end(),   "Unaligned end"  );
-  jbyte* cur  = byte_for(mr.start());
-  jbyte* last = byte_after(mr.last());
+  CardValue* cur  = byte_for(mr.start());
+  CardValue* last = byte_after(mr.last());
   while (cur < last) {
     *cur = dirty_card;
     cur++;
@@ -368,15 +368,15 @@
 void CardTable::clear_MemRegion(MemRegion mr) {
   // Be conservative: only clean cards entirely contained within the
   // region.
-  jbyte* cur;
+  CardValue* cur;
   if (mr.start() == _whole_heap.start()) {
     cur = byte_for(mr.start());
   } else {
     assert(mr.start() > _whole_heap.start(), "mr is not covered.");
     cur = byte_after(mr.start() - 1);
   }
-  jbyte* last = byte_after(mr.last());
-  memset(cur, clean_card, pointer_delta(last, cur, sizeof(jbyte)));
+  CardValue* last = byte_after(mr.last());
+  memset(cur, clean_card, pointer_delta(last, cur, sizeof(CardValue)));
 }
 
 void CardTable::clear(MemRegion mr) {
@@ -387,8 +387,8 @@
 }
 
 void CardTable::dirty(MemRegion mr) {
-  jbyte* first = byte_for(mr.start());
-  jbyte* last  = byte_after(mr.last());
+  CardValue* first = byte_for(mr.start());
+  CardValue* last  = byte_after(mr.last());
   memset(first, dirty_card, last-first);
 }
 
@@ -398,7 +398,7 @@
   for (int i = 0; i < _cur_covered_regions; i++) {
     MemRegion mri = mr.intersection(_covered[i]);
     if (!mri.is_empty()) {
-      jbyte *cur_entry, *next_entry, *limit;
+      CardValue *cur_entry, *next_entry, *limit;
       for (cur_entry = byte_for(mri.start()), limit = byte_for(mri.last());
            cur_entry <= limit;
            cur_entry  = next_entry) {
@@ -424,7 +424,7 @@
   for (int i = 0; i < _cur_covered_regions; i++) {
     MemRegion mri = mr.intersection(_covered[i]);
     if (!mri.is_empty()) {
-      jbyte* cur_entry, *next_entry, *limit;
+      CardValue* cur_entry, *next_entry, *limit;
       for (cur_entry = byte_for(mri.start()), limit = byte_for(mri.last());
            cur_entry <= limit;
            cur_entry  = next_entry) {
@@ -474,13 +474,12 @@
 }
 
 #ifndef PRODUCT
-void CardTable::verify_region(MemRegion mr,
-                                      jbyte val, bool val_equals) {
-  jbyte* start    = byte_for(mr.start());
-  jbyte* end      = byte_for(mr.last());
+void CardTable::verify_region(MemRegion mr, CardValue val, bool val_equals) {
+  CardValue* start    = byte_for(mr.start());
+  CardValue* end      = byte_for(mr.last());
   bool failures = false;
-  for (jbyte* curr = start; curr <= end; ++curr) {
-    jbyte curr_val = *curr;
+  for (CardValue* curr = start; curr <= end; ++curr) {
+    CardValue curr_val = *curr;
     bool failed = (val_equals) ? (curr_val != val) : (curr_val == val);
     if (failed) {
       if (!failures) {