Fix up the Code Coverage support

Manual patch of #909

Change coverage data to be stored in a separate hash table per
MonoDomain, so that we can throw away coverage data when a domain is
unloaded.
Support for resetting (zeroing) coverage stats for one/all methods.
Support for getting coverage stats for all methods.
Also fixed PPDB support to provide column information to
mono_ppdb_lookup_location.

Author: joncham

mono/metadata/debug-internals.h

@@ -106,9 +106,6 @@ mono_debug_free_method_async_debug_info (MonoDebugMethodAsyncInfo *info);
 gboolean
 mono_debug_image_has_debug_info (MonoImage *image);
 
-MonoDebugSourceLocation *
-mono_debug_lookup_source_location_by_il (MonoMethod *method, guint32 il_offset, MonoDomain *domain);
-
 char*
 mono_debug_image_get_sourcelink (MonoImage *image);
 

mono/metadata/domain.c

@@ -486,6 +486,7 @@ mono_domain_create (void)
 #endif
 
 	mono_debug_domain_create (domain);
+	mono_profiler_coverage_domain_init (domain);
 
 #ifdef ENABLE_NETCORE
 	mono_alc_create_default (domain);
@@ -1326,6 +1327,8 @@ mono_domain_free (MonoDomain *domain, gboolean force)
 
 	if (domain == mono_root_domain)
 		mono_root_domain = NULL;
+
+	mono_profiler_coverage_domain_free (domain);
 #else
 	g_assert_not_reached ();
 #endif

mono/metadata/mono-debug.h

@@ -205,6 +205,9 @@ mono_debug_method_lookup_location (MonoDebugMethodInfo *minfo, int il_offset);
 MONO_API MonoDebugSourceLocation *
 mono_debug_lookup_source_location (MonoMethod *method, uint32_t address, MonoDomain *domain);
 
+MONO_API MonoDebugSourceLocation*
+mono_debug_lookup_source_location_by_il (MonoMethod* method, uint32_t il_offset, MonoDomain* domain);
+
 MONO_API int32_t
 mono_debug_il_offset_from_address (MonoMethod *method, MonoDomain *domain, uint32_t native_offset);
 

mono/metadata/profiler-private.h

@@ -51,7 +51,7 @@ typedef struct {
 
 	gboolean code_coverage;
 	mono_mutex_t coverage_mutex;
-	GHashTable *coverage_hash;
+	MonoDomainCoverage* coverage_domains;
 
 	MonoProfilerHandle sampling_owner;
 	MonoSemType sampling_semaphore;
@@ -116,7 +116,18 @@ mono_profiler_installed (void)
 }
 
 gboolean mono_profiler_coverage_instrumentation_enabled (MonoMethod *method);
-MonoProfilerCoverageInfo *mono_profiler_coverage_alloc (MonoMethod *method, guint32 entries);
+MonoProfilerCoverageInfo *mono_profiler_coverage_alloc (MonoDomain* domain, MonoMethod *method, guint32 entries);
+
+struct _MonoDomainCoverage
+{
+	MonoDomain* domain;
+	GHashTable* coverage_hash;
+	mono_mutex_t mutex;
+	MonoDomainCoverage* next;
+};
+
+void mono_profiler_coverage_domain_init (MonoDomain* domain);
+void mono_profiler_coverage_domain_free (MonoDomain* domain);
 
 struct _MonoProfilerCallContext {
 	/*

mono/metadata/profiler.c

@@ -263,7 +263,6 @@ mono_profiler_enable_coverage (void)
 		return FALSE;
 
 	mono_os_mutex_init (&mono_profiler_state.coverage_mutex);
-	mono_profiler_state.coverage_hash = g_hash_table_new (NULL, NULL);
 
 	if (!mono_debug_enabled ())
 		mono_debug_init (MONO_DEBUG_FORMAT_MONO);
@@ -294,17 +293,89 @@ mono_profiler_set_coverage_filter_callback (MonoProfilerHandle handle, MonoProfi
 }
 
 static void
-coverage_lock (void)
+coverage_domains_lock (void)
 {
 	mono_os_mutex_lock (&mono_profiler_state.coverage_mutex);
 }
 
 static void
-coverage_unlock (void)
+coverage_domains_unlock (void)
 {
 	mono_os_mutex_unlock (&mono_profiler_state.coverage_mutex);
 }
 
+static MonoDomainCoverage*
+get_coverage_for_domain (MonoDomain* domain)
+{
+	coverage_domains_lock ();
+	MonoDomainCoverage* cov = mono_profiler_state.coverage_domains;
+	while (cov)
+	{
+		if (cov->domain == domain)
+			break;
+		cov = cov->next;
+	}
+	coverage_domains_unlock ();
+	return cov;
+}
+
+void
+mono_profiler_coverage_domain_init (MonoDomain* domain)
+{
+	if (!mono_profiler_state.code_coverage)
+		return;
+
+	MonoDomainCoverage* cov = g_new0 (MonoDomainCoverage, 1);
+	cov->domain = domain;
+	cov->coverage_hash = g_hash_table_new (NULL, NULL);
+	mono_os_mutex_init (&cov->mutex);
+
+	coverage_domains_lock ();
+	cov->next = mono_profiler_state.coverage_domains;
+	mono_profiler_state.coverage_domains = cov;
+	coverage_domains_unlock ();
+}
+
+void
+mono_profiler_coverage_domain_free (MonoDomain* domain)
+{
+	if (!mono_profiler_state.code_coverage)
+		return;
+
+	coverage_domains_lock ();
+
+	MonoDomainCoverage* cov = mono_profiler_state.coverage_domains;
+	MonoDomainCoverage** prev = &mono_profiler_state.coverage_domains;
+	while (cov)
+	{
+		if (cov->domain == domain)
+			break;
+
+		prev = &cov->next;
+		cov = cov->next;
+	}
+
+	if (cov != NULL)
+	{
+		*prev = cov->next;
+
+		GHashTableIter iter;
+		g_hash_table_iter_init (&iter, cov->coverage_hash);
+
+		MonoProfilerCoverageInfo* info;
+		while (g_hash_table_iter_next (&iter, NULL, (gpointer*)&info))
+			g_free (info);
+
+		g_hash_table_destroy (cov->coverage_hash);
+
+		mono_os_mutex_destroy (&cov->mutex);
+
+		g_free (cov);
+	}
+
+	coverage_domains_unlock ();
+}
+
 /**
  * mono_profiler_get_coverage_data:
  *
@@ -328,11 +399,13 @@ mono_profiler_get_coverage_data (MonoProfilerHandle handle, MonoMethod *method,
 	if ((method->flags & METHOD_ATTRIBUTE_ABSTRACT) || (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) || (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) || (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
 		return FALSE;
 
-	coverage_lock ();
+	MonoDomainCoverage* domain = get_coverage_for_domain (mono_domain_get ());
+
+	mono_os_mutex_lock (&domain->mutex);
 
-	MonoProfilerCoverageInfo *info = (MonoProfilerCoverageInfo*)g_hash_table_lookup (mono_profiler_state.coverage_hash, method);
+	MonoProfilerCoverageInfo *info = (MonoProfilerCoverageInfo*)g_hash_table_lookup (domain->coverage_hash, method);
 
-	coverage_unlock ();
+	mono_os_mutex_unlock (&domain->mutex);
 
 	MonoMethodHeaderSummary header;
 
@@ -417,6 +490,133 @@ mono_profiler_get_coverage_data (MonoProfilerHandle handle, MonoMethod *method,
 
 	return TRUE;
 }
+
+
+typedef struct
+{
+	MonoProfilerCoverageCallback cb;
+	MonoProfilerHandle handle;
+} InvokeCallbackInfo;
+
+static void invoke_coverage_callback_for_hashtable_entry (gpointer key, gpointer value, gpointer user_data)
+{
+	InvokeCallbackInfo* invokeInfo = (InvokeCallbackInfo*)user_data;
+	MonoMethod* method = (MonoMethod*)key;
+	MonoProfilerCoverageInfo* info = (MonoProfilerCoverageInfo*)value;
+
+	MonoError error;
+	MonoMethodHeader* header = mono_method_get_header_checked (method, &error);
+	mono_error_assert_ok (&error);
+
+	guint32 size;
+
+	const unsigned char* start = mono_method_header_get_code (header, &size, NULL);
+	const unsigned char* end = start + size;
+	MonoDebugMethodInfo* minfo = mono_debug_lookup_method (method);
+
+	for (guint32 i = 0; i < info->entries; i++) {
+		guchar* cil_code = info->data[i].cil_code;
+
+		if (cil_code && cil_code >= start && cil_code < end) {
+			guint32 offset = cil_code - start;
+
+			MonoProfilerCoverageData data = {
+				.method = method,
+				.il_offset = offset,
+				.counter = info->data[i].count,
+				.line = 1,
+				.column = 1,
+			};
+
+			if (minfo) {
+				MonoDebugSourceLocation* loc = mono_debug_method_lookup_location (minfo, offset);
+
+				if (loc) {
+					data.file_name = g_strdup (loc->source_file);
+					data.line = loc->row;
+					data.column = loc->column;
+
+					mono_debug_free_source_location (loc);
+				}
+			}
+
+			invokeInfo->cb (invokeInfo->handle->prof, &data);
+
+			g_free ((char*)data.file_name);
+		}
+	}
+
+	mono_metadata_free_mh (header);
+}
+
+mono_bool
+mono_profiler_get_all_coverage_data (MonoProfilerHandle handle, MonoProfilerCoverageCallback cb)
+{
+	if (!mono_profiler_state.code_coverage)
+		return FALSE;
+
+	InvokeCallbackInfo info;
+	info.cb = cb;
+	info.handle = handle;
+
+	MonoDomainCoverage* domain = get_coverage_for_domain (mono_domain_get ());
+
+	mono_os_mutex_lock (&domain->mutex);
+
+	g_hash_table_foreach (domain->coverage_hash, invoke_coverage_callback_for_hashtable_entry, &info);
+
+	mono_os_mutex_unlock (&domain->mutex);
+
+	return TRUE;
+}
+
+mono_bool
+mono_profiler_reset_coverage (MonoMethod* method)
+{
+	if (!mono_profiler_state.code_coverage)
+		return FALSE;
+
+	if ((method->flags & METHOD_ATTRIBUTE_ABSTRACT) || (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) || (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) || (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
+		return FALSE;
+
+	MonoDomainCoverage* domain = get_coverage_for_domain (mono_domain_get ());
+
+	mono_os_mutex_lock (&domain->mutex);
+
+	MonoProfilerCoverageInfo* info = g_hash_table_lookup (domain->coverage_hash, method);
+
+	mono_os_mutex_unlock (&domain->mutex);
+
+	if (!info)
+		return TRUE;
+
+	for (guint32 i = 0; i < info->entries; i++)
+		info->data[i].count = 0;
+
+	return TRUE;
+}
+
+static void reset_coverage_for_hashtable_entry (gpointer key, gpointer value, gpointer user_data)
+{
+	MonoProfilerCoverageInfo* info = (MonoProfilerCoverageInfo*)value;
+
+	for (guint32 i = 0; i < info->entries; i++)
+		info->data[i].count = 0;
+}
+
+void mono_profiler_reset_all_coverage ()
+{
+	if (!mono_profiler_state.code_coverage)
+		return;
+
+	MonoDomainCoverage* domain = get_coverage_for_domain (mono_domain_get ());
+
+	mono_os_mutex_lock (&domain->mutex);
+
+	g_hash_table_foreach (domain->coverage_hash, reset_coverage_for_hashtable_entry, NULL);
+
+	mono_os_mutex_unlock (&domain->mutex);
+}
 #endif
 
 gboolean
@@ -435,23 +635,25 @@ mono_profiler_coverage_instrumentation_enabled (MonoMethod *method)
 }
 
 MonoProfilerCoverageInfo *
-mono_profiler_coverage_alloc (MonoMethod *method, guint32 entries)
+mono_profiler_coverage_alloc (MonoDomain* domain, MonoMethod *method, guint32 entries)
 {
 	if (!mono_profiler_state.code_coverage)
 		return NULL;
 
 	if (!mono_profiler_coverage_instrumentation_enabled (method))
 		return NULL;
 
-	coverage_lock ();
+	MonoDomainCoverage* covdomain = get_coverage_for_domain (domain);
+
+	mono_os_mutex_lock (&covdomain->mutex);
 
 	MonoProfilerCoverageInfo *info = g_malloc0 (sizeof (MonoProfilerCoverageInfo) + sizeof (MonoProfilerCoverageInfoEntry) * entries);
 
 	info->entries = entries;
 
-	g_hash_table_insert (mono_profiler_state.coverage_hash, method, info);
+	g_hash_table_insert (covdomain->coverage_hash, method, info);
 
-	coverage_unlock ();
+	mono_os_mutex_unlock (&covdomain->mutex);
 
 	return info;
 }
@@ -860,21 +1062,6 @@ mono_profiler_cleanup (void)
 		g_free (cur);
 	}
 
-	if (mono_profiler_state.code_coverage) {
-		mono_os_mutex_destroy (&mono_profiler_state.coverage_mutex);
-
-		GHashTableIter iter;
-
-		g_hash_table_iter_init (&iter, mono_profiler_state.coverage_hash);
-
-		MonoProfilerCoverageInfo *info;
-
-		while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info))
-			g_free (info);
-
-		g_hash_table_destroy (mono_profiler_state.coverage_hash);
-	}
-
 	if (mono_profiler_state.sampling_owner)
 		mono_os_sem_destroy (&mono_profiler_state.sampling_semaphore);
 }

mono/metadata/profiler.h

@@ -50,13 +50,20 @@ typedef struct {
 	uint32_t column;
 } MonoProfilerCoverageData;
 
+typedef struct _MonoDomainCoverage MonoDomainCoverage;
+
 typedef mono_bool (*MonoProfilerCoverageFilterCallback) (MonoProfiler *prof, MonoMethod *method);
 typedef void (*MonoProfilerCoverageCallback) (MonoProfiler *prof, const MonoProfilerCoverageData *data);
 
 MONO_API mono_bool mono_profiler_enable_coverage (void);
 MONO_API void mono_profiler_set_coverage_filter_callback (MonoProfilerHandle handle, MonoProfilerCoverageFilterCallback cb);
 #ifndef RUNTIME_IL2CPP
 MONO_API mono_bool mono_profiler_get_coverage_data (MonoProfilerHandle handle, MonoMethod *method, MonoProfilerCoverageCallback cb);
+
+MONO_API mono_bool mono_profiler_get_all_coverage_data (MonoProfilerHandle handle, MonoProfilerCoverageCallback cb);
+
+MONO_API mono_bool mono_profiler_reset_coverage (MonoMethod* method);
+MONO_API void mono_profiler_reset_all_coverage (void);
 #endif
 
 typedef enum {

mono/mini/interp/transform.c

@@ -8307,7 +8307,7 @@ generate (MonoMethod *method, MonoMethodHeader *header, InterpMethod *rtm, MonoG
 	rtm->data_items = td->data_items;
 
 	if (td->prof_coverage)
-		td->coverage_info = mono_profiler_coverage_alloc (method, header->code_size);
+		td->coverage_info = mono_profiler_coverage_alloc (rtm->domain, method, header->code_size);
 
 	interp_method_compute_offsets (td, rtm, mono_method_signature_internal (method), header, error);
 	goto_if_nok (error, exit);