--- old/src/hotspot/share/utilities/bitMap.cpp	2019-06-10 20:16:24.563591595 -0400
+++ new/src/hotspot/share/utilities/bitMap.cpp	2019-06-10 20:16:23.987560805 -0400
@@ -73,7 +73,6 @@
 
 template <class Allocator>
 BitMap::bm_word_t* BitMap::reallocate(const Allocator& allocator, bm_word_t* old_map, idx_t old_size_in_bits, idx_t new_size_in_bits, bool clear) {
-  verify_max_size_limited(new_size_in_bits);
   size_t old_size_in_words = calc_size_in_words(old_size_in_bits);
   size_t new_size_in_words = calc_size_in_words(new_size_in_bits);
 
@@ -175,8 +174,9 @@
 }
 
 #ifdef ASSERT
-void BitMap::verify_max_size_limited(idx_t bit) {
-  assert(bit <= max_size_in_bits(), "out of bounds: " SIZE_FORMAT, bit);
+void BitMap::verify_valid_size(idx_t size_in_bits) {
+  assert(size_in_bits <= max_size_in_bits(),
+         "out of bounds: " SIZE_FORMAT, size_in_bits);
 }
 
 void BitMap::verify_index(idx_t index) const {
@@ -233,17 +233,17 @@
 void BitMap::set_range(idx_t beg, idx_t end) {
   verify_range(beg, end);
 
-  idx_t beg_full_word = word_index_round_up(beg);
-  idx_t end_full_word = word_index(end);
+  idx_t beg_aligned = range_begin_align_up(beg);
+  idx_t end_aligned = range_end_align_down(end);
 
-  if (beg_full_word < end_full_word) {
+  if (beg_aligned < end_aligned) {
     // The range includes at least one full word.
-    set_range_within_word(beg, bit_index(beg_full_word));
-    set_range_of_words(beg_full_word, end_full_word);
-    set_range_within_word(bit_index(end_full_word), end);
+    set_range_within_word(beg, beg_aligned);
+    set_range_of_words(word_index(beg_aligned), word_index(end_aligned));
+    set_range_within_word(end_aligned, end);
   } else {
     // The range spans at most 2 partial words.
-    idx_t boundary = MIN2(bit_index(beg_full_word), end);
+    idx_t boundary = MIN2(beg_aligned, end);
     set_range_within_word(beg, boundary);
     set_range_within_word(boundary, end);
   }
@@ -252,62 +252,64 @@
 void BitMap::clear_range(idx_t beg, idx_t end) {
   verify_range(beg, end);
 
-  idx_t beg_full_word = word_index_round_up(beg);
-  idx_t end_full_word = word_index(end);
+  idx_t beg_aligned = range_begin_align_up(beg);
+  idx_t end_aligned = range_end_align_down(end);
 
-  if (beg_full_word < end_full_word) {
+  if (beg_aligned < end_aligned) {
     // The range includes at least one full word.
-    clear_range_within_word(beg, bit_index(beg_full_word));
-    clear_range_of_words(beg_full_word, end_full_word);
-    clear_range_within_word(bit_index(end_full_word), end);
+    clear_range_within_word(beg, beg_aligned);
+    clear_range_of_words(word_index(beg_aligned), word_index(end_aligned));
+    clear_range_within_word(end_aligned, end);
   } else {
     // The range spans at most 2 partial words.
-    idx_t boundary = MIN2(bit_index(beg_full_word), end);
+    idx_t boundary = MIN2(beg_aligned, end);
     clear_range_within_word(beg, boundary);
     clear_range_within_word(boundary, end);
   }
 }
 
-bool BitMap::is_small_range_of_words(idx_t beg_full_word, idx_t end_full_word) {
+bool BitMap::is_small_aligned_range(idx_t beg_aligned, idx_t end_aligned) {
   // There is little point to call large version on small ranges.
-  // Need to check carefully, keeping potential idx_t underflow in mind.
+  // Need to check carefully, keeping potential idx_t over/underflow in mind,
+  // because beg_aligned > end_aligned can occur when beg and end are in the
+  // same word.
   // The threshold should be at least one word.
   STATIC_ASSERT(small_range_words >= 1);
-  return (beg_full_word + small_range_words >= end_full_word);
+  return word_index(beg_aligned) + small_range_words >= word_index(end_aligned);
 }
 
 void BitMap::set_large_range(idx_t beg, idx_t end) {
   verify_range(beg, end);
 
-  idx_t beg_full_word = word_index_round_up(beg);
-  idx_t end_full_word = word_index(end);
+  idx_t beg_aligned = range_begin_align_up(beg);
+  idx_t end_aligned = range_end_align_down(end);
 
-  if (is_small_range_of_words(beg_full_word, end_full_word)) {
+  if (is_small_aligned_range(beg_aligned, end_aligned)) {
     set_range(beg, end);
     return;
   }
 
   // The range includes at least one full word.
-  set_range_within_word(beg, bit_index(beg_full_word));
-  set_large_range_of_words(beg_full_word, end_full_word);
-  set_range_within_word(bit_index(end_full_word), end);
+  set_range_within_word(beg, beg_aligned);
+  set_large_range_of_words(word_index(beg_aligned), word_index(end_aligned));
+  set_range_within_word(end_aligned, end);
 }
 
 void BitMap::clear_large_range(idx_t beg, idx_t end) {
   verify_range(beg, end);
 
-  idx_t beg_full_word = word_index_round_up(beg);
-  idx_t end_full_word = word_index(end);
+  idx_t beg_aligned = range_begin_align_up(beg);
+  idx_t end_aligned = range_end_align_down(end);
 
-  if (is_small_range_of_words(beg_full_word, end_full_word)) {
+  if (is_small_aligned_range(beg_aligned, end_aligned)) {
     clear_range(beg, end);
     return;
   }
 
   // The range includes at least one full word.
-  clear_range_within_word(beg, bit_index(beg_full_word));
-  clear_large_range_of_words(beg_full_word, end_full_word);
-  clear_range_within_word(bit_index(end_full_word), end);
+  clear_range_within_word(beg, beg_aligned);
+  clear_large_range_of_words(word_index(beg_aligned), word_index(end_aligned));
+  clear_range_within_word(end_aligned, end);
 }
 
 void BitMap::at_put(idx_t offset, bool value) {
@@ -348,21 +350,23 @@
 void BitMap::par_at_put_range(idx_t beg, idx_t end, bool value) {
   verify_range(beg, end);
 
-  idx_t beg_full_word = word_index_round_up(beg);
-  idx_t end_full_word = word_index(end);
+  idx_t beg_aligned = range_begin_align_up(beg);
+  idx_t end_aligned = range_end_align_down(end);
 
-  if (beg_full_word < end_full_word) {
+  if (beg_aligned < end_aligned) {
     // The range includes at least one full word.
-    par_put_range_within_word(beg, bit_index(beg_full_word), value);
+    par_put_range_within_word(beg, beg_aligned, value);
+    idx_t beg_full_word = word_index(beg_aligned);
+    idx_t end_full_word = word_index(end_aligned);
     if (value) {
       set_range_of_words(beg_full_word, end_full_word);
     } else {
       clear_range_of_words(beg_full_word, end_full_word);
     }
-    par_put_range_within_word(bit_index(end_full_word), end, value);
+    par_put_range_within_word(end_aligned, end, value);
   } else {
     // The range spans at most 2 partial words.
-    idx_t boundary = MIN2(bit_index(beg_full_word), end);
+    idx_t boundary = MIN2(beg_aligned, end);
     par_put_range_within_word(beg, boundary, value);
     par_put_range_within_word(boundary, end, value);
   }
@@ -380,22 +384,24 @@
 void BitMap::par_at_put_large_range(idx_t beg, idx_t end, bool value) {
   verify_range(beg, end);
 
-  idx_t beg_full_word = word_index_round_up(beg);
-  idx_t end_full_word = word_index(end);
+  idx_t beg_aligned = range_begin_align_up(beg);
+  idx_t end_aligned = range_end_align_down(end);
 
-  if (is_small_range_of_words(beg_full_word, end_full_word)) {
+  if (is_small_aligned_range(beg_aligned, end_aligned)) {
     par_at_put_range(beg, end, value);
     return;
   }
 
   // The range includes at least one full word.
-  par_put_range_within_word(beg, bit_index(beg_full_word), value);
+  par_put_range_within_word(beg, beg_aligned, value);
+  idx_t beg_full_word = word_index(beg_aligned);
+  idx_t end_full_word = word_index(end_aligned);
   if (value) {
     set_large_range_of_words(beg_full_word, end_full_word);
   } else {
     clear_large_range_of_words(beg_full_word, end_full_word);
   }
-  par_put_range_within_word(bit_index(end_full_word), end, value);
+  par_put_range_within_word(end_aligned, end, value);
 }
 
 inline bm_word_t tail_mask(idx_t tail_bits) {