src/share/vm/opto/memnode.cpp

@@ -3557,11 +3557,11 @@
   int old_subword = 0, old_long = 0, new_int = 0, new_long = 0;
 
   intptr_t ti_limit = (TrackedInitializationLimit * HeapWordSize);
   intptr_t size_limit = phase->find_intptr_t_con(size_in_bytes, ti_limit);
   size_limit = MIN2(size_limit, ti_limit);
-  size_limit = align_size_up(size_limit, BytesPerLong);
+  size_limit = align_up(size_limit, BytesPerLong);
   int num_tiles = size_limit / BytesPerLong;
 
   // allocate space for the tile map:
   const int small_len = DEBUG_ONLY(true ? 3 :) 30; // keep stack frames small
   jlong  tiles_buf[small_len];

@@ -3788,11 +3788,11 @@
       return st_off;            // we found a complete word init
     }
 
     // update the map:
 
-    intptr_t this_int_off = align_size_down(st_off, BytesPerInt);
+    intptr_t this_int_off = align_down(st_off, BytesPerInt);
     if (this_int_off != int_map_off) {
       // reset the map:
       int_map = 0;
       int_map_off = this_int_off;
     }

@@ -3802,11 +3802,11 @@
     if ((int_map & FULL_MAP) == FULL_MAP) {
       return this_int_off;      // we found a complete word init
     }
 
     // Did this store hit or cross the word boundary?
-    intptr_t next_int_off = align_size_down(st_off + st_size, BytesPerInt);
+    intptr_t next_int_off = align_down(st_off + st_size, BytesPerInt);
     if (next_int_off == this_int_off + BytesPerInt) {
       // We passed the current int, without fully initializing it.
       int_map_off = next_int_off;
       int_map >>= BytesPerInt;
     } else if (next_int_off > this_int_off + BytesPerInt) {

@@ -3892,11 +3892,11 @@
         //   z's_done      12  16  16  16    12  16    12
         //   z's_needed    12  16  16  16    16  16    16
         //   zsize          0   0   0   0     4   0     4
         if (next_full_store < 0) {
           // Conservative tack:  Zero to end of current word.
-          zeroes_needed = align_size_up(zeroes_needed, BytesPerInt);
+          zeroes_needed = align_up(zeroes_needed, BytesPerInt);
         } else {
           // Zero to beginning of next fully initialized word.
           // Or, don't zero at all, if we are already in that word.
           assert(next_full_store >= zeroes_needed, "must go forward");
           assert((next_full_store & (BytesPerInt-1)) == 0, "even boundary");

@@ -3905,11 +3905,11 @@
       }
 
       if (zeroes_needed > zeroes_done) {
         intptr_t zsize = zeroes_needed - zeroes_done;
         // Do some incremental zeroing on rawmem, in parallel with inits.
-        zeroes_done = align_size_down(zeroes_done, BytesPerInt);
+        zeroes_done = align_down(zeroes_done, BytesPerInt);
         rawmem = ClearArrayNode::clear_memory(rawctl, rawmem, rawptr,
                                               zeroes_done, zeroes_needed,
                                               phase);
         zeroes_done = zeroes_needed;
         if (zsize > InitArrayShortSize && ++big_init_gaps > 2)

@@ -3938,11 +3938,11 @@
         (int)val->basic_type() < (int)T_OBJECT) {
       assert(st_off >= last_tile_end, "tiles do not overlap");
       assert(st_off >= last_init_end, "tiles do not overwrite inits");
       last_tile_end = MAX2(last_tile_end, next_init_off);
     } else {
-      intptr_t st_tile_end = align_size_up(next_init_off, BytesPerLong);
+      intptr_t st_tile_end = align_up(next_init_off, BytesPerLong);
       assert(st_tile_end >= last_tile_end, "inits stay with tiles");
       assert(st_off      >= last_init_end, "inits do not overlap");
       last_init_end = next_init_off;  // it's a non-tile
     }
     #endif //ASSERT

@@ -3951,11 +3951,11 @@
   remove_extra_zeroes();        // clear out all the zmems left over
   add_req(inits);
 
   if (!(UseTLAB && ZeroTLAB)) {
     // If anything remains to be zeroed, zero it all now.
-    zeroes_done = align_size_down(zeroes_done, BytesPerInt);
+    zeroes_done = align_down(zeroes_done, BytesPerInt);
     // if it is the last unused 4 bytes of an instance, forget about it
     intptr_t size_limit = phase->find_intptr_t_con(size_in_bytes, max_jint);
     if (zeroes_done + BytesPerLong >= size_limit) {
       AllocateNode* alloc = allocation();
       assert(alloc != NULL, "must be present");