528 #define space_before             (MallocCushion + sizeof(double))

   532 

   529 #define space_after              MallocCushion

   533 static void verify_memory(void* ptr) {

   530 #define size_addr_from_base(p)   (size_t*)(p + space_before - sizeof(size_t))

   534   GuardedMemory guarded(ptr);

   531 #define size_addr_from_obj(p)    ((size_t*)p - 1)

   535   if (!guarded.verify_guards()) {

   532 // MallocCushion: size of extra cushion allocated around objects with +UseMallocOnly

   536     tty->print_cr("## nof_mallocs = " UINT64_FORMAT ", nof_frees = " UINT64_FORMAT, os::num_mallocs, os::num_frees);

   533 // NB: cannot be debug variable, because these aren't set from the command line until

   537     tty->print_cr("## memory stomp:");

   534 // *after* the first few allocs already happened

   538     guarded.print_on(tty);

   535 #define MallocCushion            16

   539     fatal("memory stomping error");

   536 #else

   540   }

   537 #define space_before             0

   541 }

   538 #define space_after              0

   542 

   539 #define size_addr_from_base(p)   should not use w/o ASSERT

   540 #define size_addr_from_obj(p)    should not use w/o ASSERT

   541 #define MallocCushion            0

   542 #endif

   543 #define paranoid                 0  /* only set to 1 if you suspect checking code has bug */

   544 

   545 #ifdef ASSERT

   546 inline size_t get_size(void* obj) {

   547   size_t size = *size_addr_from_obj(obj);

   548   if (size < 0) {

   549     fatal(err_msg("free: size field of object #" PTR_FORMAT " was overwritten ("

   550                   SIZE_FORMAT ")", obj, size));

   551   }

   552   return size;

   553 }

   554 

   555 u_char* find_cushion_backwards(u_char* start) {

   556   u_char* p = start;

   557   while (p[ 0] != badResourceValue || p[-1] != badResourceValue ||

   558          p[-2] != badResourceValue || p[-3] != badResourceValue) p--;

   559   // ok, we have four consecutive marker bytes; find start

   560   u_char* q = p - 4;

   561   while (*q == badResourceValue) q--;

   562   return q + 1;

   563 }

   564 

   565 u_char* find_cushion_forwards(u_char* start) {

   566   u_char* p = start;

   567   while (p[0] != badResourceValue || p[1] != badResourceValue ||

   568          p[2] != badResourceValue || p[3] != badResourceValue) p++;

   569   // ok, we have four consecutive marker bytes; find end of cushion

   570   u_char* q = p + 4;

   571   while (*q == badResourceValue) q++;

   572   return q - MallocCushion;

   573 }

   574 

   575 void print_neighbor_blocks(void* ptr) {

   576   // find block allocated before ptr (not entirely crash-proof)

   577   if (MallocCushion < 4) {

   578     tty->print_cr("### cannot find previous block (MallocCushion < 4)");

   579     return;

   580   }

   581   u_char* start_of_this_block = (u_char*)ptr - space_before;

   582   u_char* end_of_prev_block_data = start_of_this_block - space_after -1;

   583   // look for cushion in front of prev. block

   584   u_char* start_of_prev_block = find_cushion_backwards(end_of_prev_block_data);

   585   ptrdiff_t size = *size_addr_from_base(start_of_prev_block);

   586   u_char* obj = start_of_prev_block + space_before;

   587   if (size <= 0 ) {

   588     // start is bad; may have been confused by OS data in between objects

   589     // search one more backwards

   590     start_of_prev_block = find_cushion_backwards(start_of_prev_block);

   591     size = *size_addr_from_base(start_of_prev_block);

   592     obj = start_of_prev_block + space_before;

   593   }

   594 

   595   if (start_of_prev_block + space_before + size + space_after == start_of_this_block) {

   596     tty->print_cr("### previous object: " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", obj, size);

   597   } else {

   598     tty->print_cr("### previous object (not sure if correct): " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", obj, size);

   599   }

   600 

   601   // now find successor block

   602   u_char* start_of_next_block = (u_char*)ptr + *size_addr_from_obj(ptr) + space_after;

   603   start_of_next_block = find_cushion_forwards(start_of_next_block);

   604   u_char* next_obj = start_of_next_block + space_before;

   605   ptrdiff_t next_size = *size_addr_from_base(start_of_next_block);

   606   if (start_of_next_block[0] == badResourceValue &&

   607       start_of_next_block[1] == badResourceValue &&

   608       start_of_next_block[2] == badResourceValue &&

   609       start_of_next_block[3] == badResourceValue) {

   610     tty->print_cr("### next object: " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", next_obj, next_size);

   611   } else {

   612     tty->print_cr("### next object (not sure if correct): " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", next_obj, next_size);

   613   }

   614 }

   615 

   616 

   617 void report_heap_error(void* memblock, void* bad, const char* where) {

   618   tty->print_cr("## nof_mallocs = " UINT64_FORMAT ", nof_frees = " UINT64_FORMAT, os::num_mallocs, os::num_frees);

   619   tty->print_cr("## memory stomp: byte at " PTR_FORMAT " %s object " PTR_FORMAT, bad, where, memblock);

   620   print_neighbor_blocks(memblock);

   621   fatal("memory stomping error");

   622 }

   623 

   624 void verify_block(void* memblock) {

   625   size_t size = get_size(memblock);

   626   if (MallocCushion) {

   627     u_char* ptr = (u_char*)memblock - space_before;

   628     for (int i = 0; i < MallocCushion; i++) {

   629       if (ptr[i] != badResourceValue) {

   630         report_heap_error(memblock, ptr+i, "in front of");

   631       }

   632     }

   633     u_char* end = (u_char*)memblock + size + space_after;

   634     for (int j = -MallocCushion; j < 0; j++) {

   635       if (end[j] != badResourceValue) {

   636         report_heap_error(memblock, end+j, "after");

   637       }

   638     }

   639   }

   640 }

   689   const size_t alloc_size = size + space_before + space_after;

   591 #ifndef ASSERT

   690 

   592   const size_t alloc_size = size;

   593 #else

   594   const size_t alloc_size = GuardedMemory::get_total_size(size);

   706   if (ptr == NULL) return NULL;

   610   if (ptr == NULL) {

   707   if (MallocCushion) {

   611     return NULL;

   708     for (u_char* p = ptr; p < ptr + MallocCushion; p++) *p = (u_char)badResourceValue;

   612   }

   709     u_char* end = ptr + space_before + size;

   613   // Wrap memory with guard

   710     for (u_char* pq = ptr+MallocCushion; pq < end; pq++) *pq = (u_char)uninitBlockPad;

   614   GuardedMemory guarded(ptr, size);

   711     for (u_char* q = end; q < end + MallocCushion; q++) *q = (u_char)badResourceValue;

   615   ptr = guarded.get_user_ptr();

   712   }

   616 #endif

   713   // put size just before data

   617   if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) {

   714   *size_addr_from_base(ptr) = size;

   618     tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);

   715 #endif

   716   u_char* memblock = ptr + space_before;

   717   if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {

   718     tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);

   721   debug_only(if (paranoid) verify_block(memblock));

   621   debug_only(if (paranoid) verify_memory(ptr));

   722   if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);

   622   if (PrintMalloc && tty != NULL) {

   723 

   623     tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);

   724   // we do not track MallocCushion memory

   624   }

   725     MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller);

   625 

   726 

   626   // we do not track guard memory

   727   return memblock;

   627   MemTracker::record_malloc((address)ptr, size, memflags, caller == 0 ? CALLER_PC : caller);

   628 

   629   return ptr;

   746     return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));

   648     return os::malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));

   752   verify_block(memblock);

   654   verify_memory(memblock);

   754   if (size == 0) return NULL;

   656   if (size == 0) {

   657     return NULL;

   658   }

   756   void* ptr = malloc(size, memflags, caller == 0 ? CALLER_PC : caller);

   660   void* ptr = os::malloc(size, memflags, caller == 0 ? CALLER_PC : caller);

   757   if (PrintMalloc) tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr);

   661   if (PrintMalloc) {

   662     tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr);

   663   }

   760     memcpy(ptr, memblock, MIN2(size, get_size(memblock)));

   666     GuardedMemory guarded(memblock);

   761     if (paranoid) verify_block(ptr);

   667     memcpy(ptr, memblock, MIN2(size, guarded.get_user_size()));

   668     if (paranoid) verify_memory(ptr);

   766     free(memblock);

   673     os::free(memblock);

   781   verify_block(memblock);

   689   verify_memory(memblock);

   783   // Added by detlefs.

   691 

   784   if (MallocCushion) {

   692   GuardedMemory guarded(memblock);

   785     u_char* ptr = (u_char*)memblock - space_before;

   693   size_t size = guarded.get_user_size();

   786     for (u_char* p = ptr; p < ptr + MallocCushion; p++) {

   694   inc_stat_counter(&free_bytes, size);

   787       guarantee(*p == badResourceValue,

   695   memblock = guarded.release_for_freeing();

   788                 "Thing freed should be malloc result.");

   696   if (PrintMalloc && tty != NULL) {

   789       *p = (u_char)freeBlockPad;

   790     }

   791     size_t size = get_size(memblock);

   792     inc_stat_counter(&free_bytes, size);

   793     u_char* end = ptr + space_before + size;

   794     for (u_char* q = end; q < end + MallocCushion; q++) {

   795       guarantee(*q == badResourceValue,

   796                 "Thing freed should be malloc result.");

   797       *q = (u_char)freeBlockPad;

   798     }

   799     if (PrintMalloc && tty != NULL)

   801   } else if (PrintMalloc && tty != NULL) {

   698   }

   802     // tty->print_cr("os::free %p", memblock);

   699 #endif

   803     fprintf(stderr, "os::free " PTR_FORMAT "\n", (uintptr_t)memblock);

   700   MemTracker::record_free(trackp, memflags);

   804   }

   701 

   805 #endif

   702   ::free(memblock);

   806   MemTracker::record_free((address)memblock, memflags);

   807 

   808   ::free((char*)memblock - space_before);