[sgen] Flags bit field instead of individual args for OS alloc funcs.

11 files changed, 53 insertions, 37 deletions

diff --git a/mono/metadata/sgen-cardtable.c b/mono/metadata/sgen-cardtable.c
index 6d9906cc28c..a8fd7611806 100644
--- a/mono/metadata/sgen-cardtable.c
+++ b/mono/metadata/sgen-cardtable.c
@@ -655,10 +655,10 @@ sgen_card_tables_collect_stats (gboolean begin)
 void
 sgen_card_table_init (SgenRemeberedSet *remset)
 {
-	sgen_cardtable = sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, TRUE, FALSE, "card table");
+	sgen_cardtable = sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "card table");
 
 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
-	sgen_shadow_cardtable = sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, TRUE, FALSE, "shadow card table");
+	sgen_shadow_cardtable = sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "shadow card table");
 #endif
 
 #ifdef HEAVY_STATISTICS
diff --git a/mono/metadata/sgen-debug.c b/mono/metadata/sgen-debug.c
index 5496ca97846..935bce40811 100644
--- a/mono/metadata/sgen-debug.c
+++ b/mono/metadata/sgen-debug.c
@@ -364,7 +364,7 @@ sgen_check_whole_heap (void)
 {
 	/*setup valid_nursery_objects*/
 	if (!valid_nursery_objects)
-		valid_nursery_objects = sgen_alloc_os_memory (DEFAULT_NURSERY_SIZE, TRUE, FALSE, "debugging data");
+		valid_nursery_objects = sgen_alloc_os_memory (DEFAULT_NURSERY_SIZE, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging data");
 	valid_nursery_object_count = 0;
 	sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data, setup_mono_sgen_scan_area_with_callback, NULL, FALSE);
 
diff --git a/mono/metadata/sgen-internal.c b/mono/metadata/sgen-internal.c
index b6b0c3c54f7..ddefdaae762 100644
--- a/mono/metadata/sgen-internal.c
+++ b/mono/metadata/sgen-internal.c
@@ -121,7 +121,7 @@ sgen_alloc_internal_dynamic (size_t size, int type, gboolean assert_on_failure)
 	void *p;
 
 	if (size > allocator_sizes [NUM_ALLOCATORS - 1]) {
-		p = sgen_alloc_os_memory (size, TRUE, FALSE, NULL);
+		p = sgen_alloc_os_memory (size, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, NULL);
 		if (!p)
 			sgen_assert_memory_alloc (NULL, description_for_type (type));
 		return p;
@@ -143,7 +143,7 @@ sgen_free_internal_dynamic (void *addr, size_t size, int type)
 		return;
 
 	if (size > allocator_sizes [NUM_ALLOCATORS - 1]) {
-		sgen_free_os_memory (addr, size, FALSE);
+		sgen_free_os_memory (addr, size, SGEN_ALLOC_INTERNAL);
 		return;
 	}
 
diff --git a/mono/metadata/sgen-los.c b/mono/metadata/sgen-los.c
index f9f9a4ef9c1..f794d0b2912 100644
--- a/mono/metadata/sgen-los.c
+++ b/mono/metadata/sgen-los.c
@@ -244,7 +244,7 @@ get_los_section_memory (size_t size)
 	if (!sgen_memgov_try_alloc_space (LOS_SECTION_SIZE, SPACE_LOS))
 		return NULL;
 
-	section = sgen_alloc_os_memory_aligned (LOS_SECTION_SIZE, LOS_SECTION_SIZE, TRUE, TRUE, NULL);
+	section = sgen_alloc_os_memory_aligned (LOS_SECTION_SIZE, LOS_SECTION_SIZE, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, NULL);
 
 	if (!section)
 		return NULL;
@@ -323,7 +323,7 @@ sgen_los_free_object (LOSObject *obj)
 		size += sizeof (LOSObject);
 		size += pagesize - 1;
 		size &= ~(pagesize - 1);
-		sgen_free_os_memory (obj, size, TRUE);
+		sgen_free_os_memory (obj, size, SGEN_ALLOC_HEAP);
 		sgen_memgov_release_space (size, SPACE_LOS);
 	} else {
 		free_los_section_memory (obj, size + sizeof (LOSObject));
@@ -351,7 +351,7 @@ sgen_los_alloc_large_inner (MonoVTable *vtable, size_t size)
 
 #ifdef LOS_DUMMY
 	if (!los_segment)
-		los_segment = sgen_alloc_os_memory (LOS_SEGMENT_SIZE, TRUE, TRUE, NULL);
+		los_segment = sgen_alloc_os_memory (LOS_SEGMENT_SIZE, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, NULL);
 	los_segment_index = ALIGN_UP (los_segment_index);
 
 	obj = (LOSObject*)(los_segment + los_segment_index);
@@ -372,7 +372,7 @@ sgen_los_alloc_large_inner (MonoVTable *vtable, size_t size)
 		alloc_size += pagesize - 1;
 		alloc_size &= ~(pagesize - 1);
 		if (sgen_memgov_try_alloc_space (alloc_size, SPACE_LOS)) {
-			obj = sgen_alloc_os_memory (alloc_size, TRUE, TRUE, NULL);
+			obj = sgen_alloc_os_memory (alloc_size, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, NULL);
 			if (obj)
 				obj->huge_object = TRUE;
 		}
@@ -423,7 +423,7 @@ sgen_los_sweep (void)
 				prev->next = next;
 			else
 				los_sections = next;
-			sgen_free_os_memory (section, LOS_SECTION_SIZE, TRUE);
+			sgen_free_os_memory (section, LOS_SECTION_SIZE, SGEN_ALLOC_HEAP);
 			sgen_memgov_release_space (LOS_SECTION_SIZE, SPACE_LOS);
 			section = next;
 			--los_num_sections;
diff --git a/mono/metadata/sgen-major-copying.c b/mono/metadata/sgen-major-copying.c
index d1737a6b787..e52c26903c3 100644
--- a/mono/metadata/sgen-major-copying.c
+++ b/mono/metadata/sgen-major-copying.c
@@ -98,9 +98,9 @@ static void*
 major_alloc_heap (mword nursery_size, mword nursery_align, int the_nursery_bits)
 {
 	if (nursery_align)
-		nursery_start = sgen_alloc_os_memory_aligned (nursery_size, nursery_align, TRUE, TRUE, "nursery");
+		nursery_start = sgen_alloc_os_memory_aligned (nursery_size, nursery_align, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "nursery");
 	else
-		nursery_start = sgen_alloc_os_memory (nursery_size, TRUE, TRUE, "nursery");
+		nursery_start = sgen_alloc_os_memory (nursery_size, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "nursery");
 
 	nursery_end = nursery_start + nursery_size;
 	nursery_bits = the_nursery_bits;
@@ -129,7 +129,7 @@ alloc_major_section (void)
 	GCMemSection *section;
 	int scan_starts;
 
-	section = sgen_alloc_os_memory_aligned (MAJOR_SECTION_SIZE, MAJOR_SECTION_SIZE, TRUE, TRUE, "major heap section");
+	section = sgen_alloc_os_memory_aligned (MAJOR_SECTION_SIZE, MAJOR_SECTION_SIZE, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "major heap section");
 	section->next_data = section->data = (char*)section + SGEN_SIZEOF_GC_MEM_SECTION;
 	g_assert (!((mword)section->data & 7));
 	section->size = MAJOR_SECTION_SIZE - SGEN_SIZEOF_GC_MEM_SECTION;
@@ -157,7 +157,7 @@ free_major_section (GCMemSection *section)
 	DEBUG (3, fprintf (gc_debug_file, "Freed major section %p (%p-%p)\n", section, section->data, section->end_data));
 	sgen_free_internal_dynamic (section->scan_starts,
 			(section->size + SGEN_SCAN_START_SIZE - 1) / SGEN_SCAN_START_SIZE * sizeof (char*), INTERNAL_MEM_SCAN_STARTS);
-	sgen_free_os_memory (section, MAJOR_SECTION_SIZE, TRUE);
+	sgen_free_os_memory (section, MAJOR_SECTION_SIZE, SGEN_ALLOC_HEAP);
 
 	--num_major_sections;
 }
diff --git a/mono/metadata/sgen-marksweep.c b/mono/metadata/sgen-marksweep.c
index dd9a2983faa..61a93ef26ea 100644
--- a/mono/metadata/sgen-marksweep.c
+++ b/mono/metadata/sgen-marksweep.c
@@ -311,7 +311,7 @@ major_alloc_heap (mword nursery_size, mword nursery_align, int the_nursery_bits)
 	if (nursery_align)
 		g_assert (nursery_align % MS_BLOCK_SIZE == 0);
 
-	nursery_start = sgen_alloc_os_memory_aligned (alloc_size, nursery_align ? nursery_align : MS_BLOCK_SIZE, TRUE, TRUE, "heap");
+	nursery_start = sgen_alloc_os_memory_aligned (alloc_size, nursery_align ? nursery_align : MS_BLOCK_SIZE, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "heap");
 	ms_heap_start = nursery_start + nursery_size;
 	ms_heap_end = ms_heap_start + major_heap_size;
 
@@ -336,9 +336,9 @@ major_alloc_heap (mword nursery_size, mword nursery_align, int the_nursery_bits)
 {
 	char *start;
 	if (nursery_align)
-		start = sgen_alloc_os_memory_aligned (nursery_size, nursery_align, TRUE, TRUE, "nursery");
+		start = sgen_alloc_os_memory_aligned (nursery_size, nursery_align, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "nursery");
 	else
-		start = sgen_alloc_os_memory (nursery_size, TRUE, TRUE, "nursery");
+		start = sgen_alloc_os_memory (nursery_size, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "nursery");
 
 	return start;
 }
@@ -389,7 +389,7 @@ ms_get_empty_block (void)
 
  retry:
 	if (!empty_blocks) {
-		p = sgen_alloc_os_memory_aligned (MS_BLOCK_SIZE * MS_BLOCK_ALLOC_NUM, MS_BLOCK_SIZE, TRUE, TRUE, "major heap section");
+		p = sgen_alloc_os_memory_aligned (MS_BLOCK_SIZE * MS_BLOCK_ALLOC_NUM, MS_BLOCK_SIZE, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "major heap section");
 
 		for (i = 0; i < MS_BLOCK_ALLOC_NUM; ++i) {
 			block = p;
@@ -1708,7 +1708,7 @@ major_have_computer_minor_collection_allowance (void)
 
 	while (num_empty_blocks > section_reserve) {
 		void *next = *(void**)empty_blocks;
-		sgen_free_os_memory (empty_blocks, MS_BLOCK_SIZE, TRUE);
+		sgen_free_os_memory (empty_blocks, MS_BLOCK_SIZE, SGEN_ALLOC_HEAP);
 		empty_blocks = next;
 		/*
 		 * Needs not be atomic because this is running
diff --git a/mono/metadata/sgen-memory-governor.c b/mono/metadata/sgen-memory-governor.c
index d237de8d3c8..7fff99a6b73 100644
--- a/mono/metadata/sgen-memory-governor.c
+++ b/mono/metadata/sgen-memory-governor.c
@@ -302,13 +302,17 @@ sgen_assert_memory_alloc (void *ptr, const char *assert_description)
  * This must not require any lock.
  */
 void*
-sgen_alloc_os_memory (size_t size, int activate, gboolean is_heap_memory, const char *assert_description)
+sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description)
 {
-	void *ptr = mono_valloc (0, size, prot_flags_for_activate (activate));
+	void *ptr;
+
+	g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
+
+	ptr = mono_valloc (0, size, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 	sgen_assert_memory_alloc (ptr, assert_description);
 	if (ptr) {
 		SGEN_ATOMIC_ADD_P (total_alloc, size);
-		if (is_heap_memory)
+		if (flags & SGEN_ALLOC_HEAP)
 			MONO_GC_HEAP_ALLOC ((mword)ptr, size);
 	}
 	return ptr;
@@ -316,13 +320,17 @@ sgen_alloc_os_memory (size_t size, int activate, gboolean is_heap_memory, const
 
 /* size must be a power of 2 */
 void*
-sgen_alloc_os_memory_aligned (size_t size, mword alignment, gboolean activate, gboolean is_heap_memory, const char *assert_description)
+sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description)
 {
-	void *ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (activate));
+	void *ptr;
+
+	g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
+
+	ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 	sgen_assert_memory_alloc (ptr, assert_description);
 	if (ptr) {
 		SGEN_ATOMIC_ADD_P (total_alloc, size);
-		if (is_heap_memory)
+		if (flags & SGEN_ALLOC_HEAP)
 			MONO_GC_HEAP_ALLOC ((mword)ptr, size);
 	}
 	return ptr;
@@ -332,11 +340,13 @@ sgen_alloc_os_memory_aligned (size_t size, mword alignment, gboolean activate, g
  * Free the memory returned by sgen_alloc_os_memory (), returning it to the OS.
  */
 void
-sgen_free_os_memory (void *addr, size_t size, gboolean is_heap_memory)
+sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags)
 {
+	g_assert (!(flags & ~SGEN_ALLOC_HEAP));
+
 	mono_vfree (addr, size);
 	SGEN_ATOMIC_ADD_P (total_alloc, -size);
-	if (is_heap_memory)
+	if (flags & SGEN_ALLOC_HEAP)
 		MONO_GC_HEAP_FREE ((mword)addr, size);
 }
 
diff --git a/mono/metadata/sgen-memory-governor.h b/mono/metadata/sgen-memory-governor.h
index 7140bf7313b..98f5a03eee2 100644
--- a/mono/metadata/sgen-memory-governor.h
+++ b/mono/metadata/sgen-memory-governor.h
@@ -44,10 +44,16 @@ mword sgen_get_minor_collection_allowance (void) MONO_INTERNAL;
 gboolean sgen_need_major_collection (mword space_needed) MONO_INTERNAL;
 
 
+typedef enum {
+	SGEN_ALLOC_INTERNAL = 0,
+	SGEN_ALLOC_HEAP = 1,
+	SGEN_ALLOC_ACTIVATE = 2
+} SgenAllocFlags;
+
 /* OS memory allocation */
-void* sgen_alloc_os_memory (size_t size, int activate, gboolean is_heap_memory, const char *assert_description) MONO_INTERNAL;
-void* sgen_alloc_os_memory_aligned (size_t size, mword alignment, gboolean activate, gboolean is_heap_memory, const char *assert_description) MONO_INTERNAL;
-void sgen_free_os_memory (void *addr, size_t size, gboolean is_heap_memory) MONO_INTERNAL;
+void* sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description) MONO_INTERNAL;
+void* sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description) MONO_INTERNAL;
+void sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags) MONO_INTERNAL;
 
 /* Error handling */
 void sgen_assert_memory_alloc (void *ptr, const char *assert_description) MONO_INTERNAL;
diff --git a/mono/metadata/sgen-nursery-allocator.c b/mono/metadata/sgen-nursery-allocator.c
index b165f12dd61..fe0d4845530 100644
--- a/mono/metadata/sgen-nursery-allocator.c
+++ b/mono/metadata/sgen-nursery-allocator.c
@@ -911,7 +911,7 @@ sgen_init_nursery_allocator (void)
 {
 	sgen_register_fixed_internal_mem_type (INTERNAL_MEM_FRAGMENT, sizeof (SgenFragment));
 #ifdef NALLOC_DEBUG
-	alloc_records = sgen_alloc_os_memory (sizeof (AllocRecord) * ALLOC_RECORD_COUNT, TRUE, "debugging memory");
+	alloc_records = sgen_alloc_os_memory (sizeof (AllocRecord) * ALLOC_RECORD_COUNT, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging memory");
 #endif
 }
 
diff --git a/mono/metadata/sgen-pinned-allocator.c b/mono/metadata/sgen-pinned-allocator.c
index 661f597f8aa..31d3cd678df 100644
--- a/mono/metadata/sgen-pinned-allocator.c
+++ b/mono/metadata/sgen-pinned-allocator.c
@@ -219,7 +219,7 @@ alloc_pinned_chunk (SgenPinnedAllocator *alc)
 	int offset;
 	int size = SGEN_PINNED_CHUNK_SIZE;
 
-	chunk = sgen_alloc_os_memory_aligned (size, size, TRUE, TRUE, "pinned chunk");
+	chunk = sgen_alloc_os_memory_aligned (size, size, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "pinned chunk");
 	chunk->block.role = MEMORY_ROLE_PINNED;
 
 	sgen_update_heap_boundaries ((mword)chunk, ((mword)chunk + size));
@@ -331,7 +331,7 @@ sgen_alloc_pinned (SgenPinnedAllocator *alc, size_t size)
 		LargePinnedMemHeader *mh;
 
 		size += sizeof (LargePinnedMemHeader);
-		mh = sgen_alloc_os_memory (size, TRUE, TRUE, "large pinned object");
+		mh = sgen_alloc_os_memory (size, SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE, "large pinned object");
 		mh->magic = LARGE_PINNED_MEM_HEADER_MAGIC;
 		mh->size = size;
 		/* FIXME: do a CAS here */
@@ -385,7 +385,7 @@ sgen_free_pinned (SgenPinnedAllocator *alc, void *addr, size_t size)
 	g_assert (mh->size == size + sizeof (LargePinnedMemHeader));
 	/* FIXME: do a CAS */
 	large_pinned_bytes_alloced -= mh->size;
-	sgen_free_os_memory (mh, mh->size, TRUE);
+	sgen_free_os_memory (mh, mh->size, SGEN_ALLOC_HEAP);
 }
 
 void
diff --git a/mono/metadata/sgen-protocol.c b/mono/metadata/sgen-protocol.c
index 75ae316704e..7eb62e97434 100644
--- a/mono/metadata/sgen-protocol.c
+++ b/mono/metadata/sgen-protocol.c
@@ -66,7 +66,7 @@ binary_protocol_flush_buffers_rec (BinaryProtocolBuffer *buffer)
 	g_assert (buffer->index > 0);
 	fwrite (buffer->buffer, 1, buffer->index, binary_protocol_file);
 
-	sgen_free_os_memory (buffer, sizeof (BinaryProtocolBuffer), FALSE);
+	sgen_free_os_memory (buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL);
 }
 
 void
@@ -94,12 +94,12 @@ binary_protocol_get_buffer (int length)
 	if (buffer && buffer->index + length <= BINARY_PROTOCOL_BUFFER_SIZE)
 		return buffer;
 
-	new_buffer = sgen_alloc_os_memory (sizeof (BinaryProtocolBuffer), TRUE, FALSE, "debugging memory");
+	new_buffer = sgen_alloc_os_memory (sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging memory");
 	new_buffer->next = buffer;
 	new_buffer->index = 0;
 
 	if (InterlockedCompareExchangePointer ((void**)&binary_protocol_buffers, new_buffer, buffer) != buffer) {
-		sgen_free_os_memory (new_buffer, sizeof (BinaryProtocolBuffer), FALSE);
+		sgen_free_os_memory (new_buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL);
 		goto retry;
 	}