67 char *old_allocation = ptr;
72 uint32_t requested_size = size;
85 char *result =
nullptr;
102 result = HeapReAlloc(
g_crtHeapHandle, 0, old_allocation, requested_size);
116 if (count >= requested_size)
117 count = requested_size;
127 result = old_allocation;
144 if (heap_copy_bytes >= requested_size)
145 heap_copy_bytes = requested_size;
157 }
while (retry_requested);
266 uint32_t free_size_class;
270 uint32_t merged_size = next_size;
271 struct CRT_HeapFreeBlock *next_block = (
void *)((
char *)block_header + next_size);
272 int32_t next_block_size = next_block->
size_flags;
276 free_size_class = (next_block_size >> 4) - 1;
281 if (next_block->
next == next_block->
prev)
293 if (next_high_class_count == 1)
306 if (next_low_class_count == 1)
317 next_size += next_block_size;
318 next_free_successor->
prev = next_free_predecessor;
319 merged_size = next_size;
322 int32_t merged_size_class = (next_size >> 4) - 1;
330 if (!previous_block_allocated)
335 free_size_class = (prev_size_flags >> 4) - 1;
342 next_size += prev_size_flags;
343 merged_size = next_size;
344 merged_size_class = (next_size >> 4) - 1;
349 if (free_size_class != (uint32_t)merged_size_class)
351 if (previous_block->
next == previous_block->
prev)
363 if (previous_high_class_count == 1)
376 if (previous_low_class_count == 1)
385 block_header = previous_block;
388 if (previous_block_allocated || free_size_class != (uint32_t)merged_size_class)
390 block_header->
next = page_map_local->
pages[page_index].
bins[merged_size_class].
next;
392 struct CRT_HeapFreeBlock *merged_bin_sentinel = (
void *)((
char *)&page_map_local->
pages[page_index].
bins[merged_size_class] - 4);
394 block_header->
prev = merged_bin_sentinel;
395 merged_bin_sentinel->
next = block_header;
396 block_header->
next->
prev = block_header;
398 if (block_header->
next == block_header->
prev)
406 if (!merged_class_count)
414 if (!merged_class_count)
421 next_size = merged_size;
426 *(uint32_t *)(next_size + (
char *)block_header - 4) = next_size;
432 if (allocated_count != 1)
438 if (pending_empty_segment)
462 if (!pending_empty_segment || release_candidate->
free_page_bitmap != 0xffffffff)
463 remaining_segment = segment;
473 remaining_segment = segment;
477 remaining_segment -= 1;
493 uint32_t high_class_mask;
494 uint32_t low_class_mask;
504 high_class_mask = 0xffffffff;
510 if (segment < end_segment)
514 segment = &segment[1];
516 if (segment >= end_segment)
521 if (segment == end_segment)
525 bool found_wrapped_class;
529 found_wrapped_class = segment != cached_segment;
531 if (segment >= cached_segment)
536 found_wrapped_class = segment != cached_segment;
541 segment = &segment[1];
544 if (!found_wrapped_class)
546 bool found_free_page;
550 found_free_page = segment != end_segment;
552 if (segment >= end_segment)
557 found_free_page = segment != end_segment;
562 segment = &segment[1];
565 if (!found_free_page)
569 bool found_wrapped_free_page;
573 found_wrapped_free_page = segment != cached_segment;
575 if (segment >= cached_segment)
580 found_wrapped_free_page = segment != cached_segment;
585 segment = &segment[1];
588 if (!found_wrapped_free_page)
608 int32_t selected_page = page_index;
616 uint32_t eligible_high_classes;
625 page_index = selected_page;
628 int32_t size_class = 0;
631 if (!eligible_class_bits)
639 eligible_class_bits <<= 1;
645 uint32_t remainder_bytes = free_block->
size_flags - rounded_size;
646 int32_t remainder_class = (remainder_bytes >> 4) - 1;
651 if (remainder_class != size_class)
653 if (free_block->
next == free_block->
prev)
665 if (previous_high_class_count == 1)
678 if (previous_low_class_count == 1)
691 free_block->
prev = remainder_bin_sentinel;
692 remainder_bin_sentinel->
next = free_block;
693 free_block->
next->
prev = free_block;
695 if (free_block->
next == free_block->
prev)
703 if (!previous_remainder_class_count)
713 if (!previous_remainder_class_count)
726 *(uint32_t *)(remainder_bytes + (
char *)free_block - 4) = remainder_bytes;
743 return &alloc_header->
next;
862 struct CRT_HeapFreeBlock *block_header = (
void *)((
char *)user_ptr + old_block_size -
sizeof(uint32_t));
863 int32_t next_block_size_flags = block_header->
size_flags;
865 if (rounded_new_size > old_block_size)
867 if ((uint8_t)next_block_size_flags &
CRT_HEAP_BLOCK_ALLOCATED || rounded_new_size > next_block_size_flags + old_block_size)
870 int32_t next_size_class = (next_block_size_flags >> 4) - 1;
877 if (block_header->
next == block_header->
prev)
889 if (grow_high_class_count == 1)
902 if (grow_low_class_count == 1)
910 int32_t grow_remainder_bytes = next_block_size_flags + old_block_size - rounded_new_size;
911 void *grown_user_pointer;
913 if (grow_remainder_bytes <= 0)
914 grown_user_pointer = user_ptr;
917 int32_t grow_remainder_class = (grow_remainder_bytes >> 4) - 1;
922 struct CRT_HeapFreeBlock *grow_bin_sentinel = (
void *)((
char *)&page_map->
pages[page_index].
bins[grow_remainder_class] -
sizeof(uint32_t));
923 struct CRT_HeapFreeBlock *grow_remainder = (
void *)((
char *)user_ptr + rounded_new_size -
sizeof(uint32_t));
925 grow_remainder->
next = grow_bin_sentinel->
next;
926 grow_remainder->
prev = grow_bin_sentinel;
927 (grow_bin_sentinel)->
next = grow_remainder;
928 grow_remainder->
next->
prev = grow_remainder;
930 if (grow_remainder->
next == grow_remainder->
prev)
936 uint32_t *grow_page_bitmap;
941 if (!grow_remainder_class_count)
950 if (!grow_remainder_class_count)
954 grow_class_bit = (uint8_t)grow_remainder_class;
960 grown_user_pointer = user_ptr;
961 *(uint32_t *)((
char *)grown_user_pointer + rounded_new_size - 4) = grow_remainder_bytes;
962 *(uint32_t *)(grow_remainder_bytes + (
char *)grown_user_pointer + rounded_new_size - 4 - 4) = grow_remainder_bytes;
968 else if (rounded_new_size < old_block_size)
970 new_size = old_block_size - rounded_new_size;
973 struct CRT_HeapFreeBlock *shrink_remainder_header = (
void *)((
char *)user_ptr + rounded_new_size -
sizeof(uint32_t));
975 user_ptr = shrink_remainder_header;
977 int32_t shrink_remainder_class = (new_size >> 4) - 1;
986 int32_t shrink_next_class = (next_block_size_flags >> 4) - 1;
991 if (block_header->
next == block_header->
prev)
1003 if (shrink_high_class_count == 1)
1016 if (shrink_low_class_count == 1)
1020 shrink_remainder_header = user_ptr;
1026 uint32_t coalesced_remainder_size = new_size + next_block_size_flags;
1028 new_size = coalesced_remainder_size;
1029 shrink_remainder_class = (coalesced_remainder_size >> 4) - 1;
1035 struct CRT_HeapFreeBlock *shrink_bin_sentinel = (
void *)((
char *)&page_map->
pages[page_index].
bins[shrink_remainder_class] -
sizeof(uint32_t));
1037 shrink_remainder_header->
next = page_map->
pages[page_index].
bins[shrink_remainder_class].
next;
1038 shrink_remainder_header->
prev = shrink_bin_sentinel;
1039 shrink_bin_sentinel->
next = shrink_remainder_header;
1040 shrink_remainder_header->
next->
prev = shrink_remainder_header;
1042 if (shrink_remainder_header->
next == shrink_remainder_header->
prev)
1044 char shrink_remainder_class_count = page_map->
free_count_by_class[shrink_remainder_class];
1048 uint32_t *shrink_page_bitmap;
1049 char shrink_class_bit;
1053 if (!shrink_remainder_class_count)
1061 if (!shrink_remainder_class_count)
1065 shrink_class_bit = (uint8_t)shrink_remainder_class;
1071 shrink_remainder_header->
size_flags = new_size;
1072 *(uint32_t *)((
char *)shrink_remainder_header + new_size - 4) = new_size;
struct CRT_HeapPageState pages[0x20]
struct CRT_HeapFreeList bins[0x40]