// Allocate _preorders[] array void reallocate_preorders() { if ( _max_preorder < C->unique() ) { _preorders = REALLOC_RESOURCE_ARRAY(uint, _preorders, _max_preorder, C->unique()); _max_preorder = C->unique(); } memset(_preorders, 0, sizeof(uint) * _max_preorder); }
int OopRecorder::allocate_index(jobject h) { assert(!_complete, "cannot allocate more elements after size query"); if (_handles_arena == NULL) _nesting.check(); if (_handles_size == 0) { _handles_size = 100; if (_handles_arena == NULL) _handles = NEW_RESOURCE_ARRAY(jobject, _handles_size); else _handles = (jobject*) _handles_arena->Amalloc(_handles_size * sizeof(jobject)); } else if (_handles_length == _handles_size) { // Expand int new_handles_size = _handles_size * 2; if (_handles_arena == NULL) _handles = REALLOC_RESOURCE_ARRAY(jobject, _handles, _handles_size, new_handles_size); else _handles = (jobject*)_handles_arena->Arealloc(_handles, _handles_size * sizeof(jobject), new_handles_size * sizeof(jobject)); _handles_size = new_handles_size; } assert(_handles_size > _handles_length, "There must be room for after expanding"); _handles[_handles_length++] = h; // indexing uses 1 as an origin--0 means null return _handles_length; }
// Check to grow _preorders[] array for the case when build_loop_tree_impl() // adds new nodes. void check_grow_preorders( ) { if ( _max_preorder < C->unique() ) { uint newsize = _max_preorder<<1; // double size of array _preorders = REALLOC_RESOURCE_ARRAY(uint, _preorders, _max_preorder, newsize); memset(&_preorders[_max_preorder],0,sizeof(uint)*(newsize-_max_preorder)); _max_preorder = newsize; } }
void UnionFind::extend( uint from_idx, uint to_idx ) { _nesting.check(); if( from_idx >= _max ) { uint size = 16; while( size <= from_idx ) size <<=1; _indices = REALLOC_RESOURCE_ARRAY( uint, _indices, _max, size ); _max = size; } while( _cnt <= from_idx ) _indices[_cnt++] = 0; _indices[from_idx] = to_idx; }
void ExceptionHandlerTable::add_entry(HandlerTableEntry entry) { _nesting.check(); if (_length >= _size) { // not enough space => grow the table (amortized growth, double its size) guarantee(_size > 0, "no space allocated => cannot grow the table since it is part of nmethod"); int new_size = _size * 2; _table = REALLOC_RESOURCE_ARRAY(HandlerTableEntry, _table, _size, new_size); _size = new_size; } assert(_length < _size, "sanity check"); _table[_length++] = entry; }
void ImplicitExceptionTable::append( uint exec_off, uint cont_off ) { assert( (sizeof(implicit_null_entry) >= 4) || (exec_off < 65535), "" ); assert( (sizeof(implicit_null_entry) >= 4) || (cont_off < 65535), "" ); uint l = len(); if (l == _size) { uint old_size_in_elements = _size*2; if (_size == 0) _size = 4; _size *= 2; uint new_size_in_elements = _size*2; _data = REALLOC_RESOURCE_ARRAY(uint, _data, old_size_in_elements, new_size_in_elements); } *(adr(l) ) = exec_off; *(adr(l)+1) = cont_off; _len = l+1; };
address JvmtiClassFileReconstituter::writeable_address(size_t size) { size_t used_size = _buffer_ptr - _buffer; if (size + used_size >= _buffer_size) { // compute the new buffer size: must be at least twice as big as before // plus whatever new is being used; then convert to nice clean block boundary size_t new_buffer_size = (size + _buffer_size*2 + 1) / initial_buffer_size * initial_buffer_size; // VM goes belly-up if the memory isn't available, so cannot do OOM processing _buffer = REALLOC_RESOURCE_ARRAY(u1, _buffer, _buffer_size, new_buffer_size); _buffer_size = new_buffer_size; _buffer_ptr = _buffer + used_size; } u1* ret_ptr = _buffer_ptr; _buffer_ptr += size; return ret_ptr; }
void CodeSection::expand_locs(int new_capacity) { if (_locs_start == NULL) { initialize_locs(new_capacity); return; } else { int old_count = locs_count(); int old_capacity = locs_capacity(); if (new_capacity < old_capacity * 2) new_capacity = old_capacity * 2; relocInfo* locs_start; if (_locs_own) { locs_start = REALLOC_RESOURCE_ARRAY(relocInfo, _locs_start, old_capacity, new_capacity); } else { locs_start = NEW_RESOURCE_ARRAY(relocInfo, new_capacity); Copy::conjoint_jbytes(_locs_start, locs_start, old_capacity * sizeof(relocInfo)); _locs_own = true; } _locs_start = locs_start; _locs_end = locs_start + old_count; _locs_limit = locs_start + new_capacity; } }