Fix roslyn install with AOT disabled.

[mono-project.git] / mono / metadata / sgen-bridge.c

/*
 * sgen-bridge.c: Simple generational GC.
 *
 * Copyright 2011 Novell, Inc (http://www.novell.com)
 * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
 * Copyright 2001-2003 Ximian, Inc
 * Copyright 2003-2010 Novell, Inc.
 *
 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
 */

#include "config.h"

#ifdef HAVE_SGEN_GC

#include <stdlib.h>

#include "sgen/sgen-gc.h"
#include "sgen-bridge-internals.h"
#include "sgen/sgen-hash-table.h"
#include "sgen/sgen-qsort.h"
#include "utils/mono-logger-internals.h"

typedef enum {
        BRIDGE_PROCESSOR_INVALID,
        BRIDGE_PROCESSOR_OLD,
        BRIDGE_PROCESSOR_NEW,
        BRIDGE_PROCESSOR_TARJAN,
        BRIDGE_PROCESSOR_DEFAULT = BRIDGE_PROCESSOR_TARJAN
} BridgeProcessorSelection;

// Bridge processor type pending / in use
static BridgeProcessorSelection bridge_processor_selection = BRIDGE_PROCESSOR_DEFAULT;
// Most recently requested callbacks
static MonoGCBridgeCallbacks pending_bridge_callbacks;
// Configuration to be passed to bridge processor after init
static SgenBridgeProcessorConfig bridge_processor_config;
// Currently-in-use callbacks
MonoGCBridgeCallbacks bridge_callbacks;

// Bridge processor state
static SgenBridgeProcessor bridge_processor;
// This is used for a special debug feature
static SgenBridgeProcessor compare_to_bridge_processor;

volatile gboolean bridge_processing_in_progress = FALSE;

// FIXME: The current usage pattern for this function is unsafe. Bridge processing could start immediately after unlock
void
mono_gc_wait_for_bridge_processing (void)
{
        if (!bridge_processing_in_progress)
                return;

        mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_BRIDGE waiting for bridge processing to finish");

        sgen_gc_lock ();
        sgen_gc_unlock ();
}

void
mono_gc_register_bridge_callbacks (MonoGCBridgeCallbacks *callbacks)
{
        if (callbacks->bridge_version != SGEN_BRIDGE_VERSION)
                g_error ("Invalid bridge callback version. Expected %d but got %d\n", SGEN_BRIDGE_VERSION, callbacks->bridge_version);

        // Defer assigning to bridge_callbacks until we have the gc lock.
        // Note: This line is unsafe if we are on a separate thread from the one the runtime was initialized on.
        pending_bridge_callbacks = *callbacks;

        // If sgen has started, will assign bridge callbacks and init bridge
        sgen_init_bridge ();
}

static BridgeProcessorSelection
bridge_processor_name (const char *name)
{
        if (!strcmp ("old", name)) {
                return BRIDGE_PROCESSOR_OLD;
        } else if (!strcmp ("new", name)) {
                return BRIDGE_PROCESSOR_NEW;
        } else if (!strcmp ("tarjan", name)) {
                return BRIDGE_PROCESSOR_TARJAN;
        } else {
                return BRIDGE_PROCESSOR_INVALID;
        }
}

static gboolean
bridge_processor_started ()
{
        return bridge_processor.reset_data != NULL;
}

// Initialize a single bridge processor
static void
init_bridge_processor (SgenBridgeProcessor *processor, BridgeProcessorSelection selection)
{
        memset (processor, 0, sizeof (SgenBridgeProcessor));

        switch (selection) {
                case BRIDGE_PROCESSOR_OLD:
                        sgen_old_bridge_init (processor);
                        break;
                case BRIDGE_PROCESSOR_NEW:
                        sgen_new_bridge_init (processor);
                        break;
                case BRIDGE_PROCESSOR_TARJAN:
                        sgen_tarjan_bridge_init (processor);
                        break;
                default:
                        g_assert_not_reached ();
        }
}

/*
 * Initializing the sgen bridge consists of setting the bridge callbacks,
 * and initializing the bridge processor. Init should follow these rules:
 *
 *   - Init happens only after sgen is initialized (because we don't
 *     know which bridge processor to initialize until then, and also
 *     to allow bridge processor init to interact with sgen if it wants)
 *
 *   - Init happens only after mono_gc_register_bridge_callbacks is called
 *
 *   - Init should not happen concurrently with a GC (because a GC will
 *     call sgen_need_bridge_processing at various times)
 *
 *   - Initializing the bridge processor should happen only once
 *
 * We call sgen_init_bridge when the callbacks are set, and also when sgen
 * is done initing. Actual initialization then only occurs if it is ready.
 */
void
sgen_init_bridge ()
{
        if (sgen_gc_initialized ()) {
                // This lock is not initialized until the GC is
                sgen_gc_lock ();

                bridge_callbacks = pending_bridge_callbacks;

                // If a bridge was registered but there is no bridge processor yet
                if (bridge_callbacks.cross_references && !bridge_processor_started ()) {
                        init_bridge_processor (&bridge_processor, bridge_processor_selection);

                        if (bridge_processor.set_config)
                                bridge_processor.set_config (&bridge_processor_config);

                        // Config is no longer needed so free its memory
                        free (bridge_processor_config.dump_prefix);
                        bridge_processor_config.dump_prefix = NULL;
                }

                sgen_gc_unlock ();
        }
}

void
sgen_set_bridge_implementation (const char *name)
{
        BridgeProcessorSelection selection = bridge_processor_name (name);

        if (selection == BRIDGE_PROCESSOR_INVALID)
                g_warning ("Invalid value for bridge processor implementation, valid values are: 'new', 'old' and 'tarjan'.");
        else if (bridge_processor_started ())
                g_warning ("Cannot set bridge processor implementation once bridge has already started");
        else
                bridge_processor_selection = selection;
}

gboolean
sgen_is_bridge_object (GCObject *obj)
{
        if ((obj->vtable->gc_bits & SGEN_GC_BIT_BRIDGE_OBJECT) != SGEN_GC_BIT_BRIDGE_OBJECT)
                return FALSE;
        return bridge_callbacks.is_bridge_object (obj);
}

gboolean
sgen_need_bridge_processing (void)
{
        return bridge_callbacks.cross_references != NULL;
}

static gboolean
compare_bridge_processors (void)
{
        return compare_to_bridge_processor.reset_data != NULL;
}

/* Dispatch wrappers */
void
sgen_bridge_reset_data (void)
{
        bridge_processor.reset_data ();
        if (compare_bridge_processors ())
                compare_to_bridge_processor.reset_data ();
}

void
sgen_bridge_processing_stw_step (void)
{
        /*
         * bridge_processing_in_progress must be set with the world
         * stopped.  If not there would be race conditions.
         */
        bridge_processing_in_progress = TRUE;

        bridge_processor.processing_stw_step ();
        if (compare_bridge_processors ())
                compare_to_bridge_processor.processing_stw_step ();
}

static gboolean
is_bridge_object_dead (GCObject *obj, void *data)
{
        SgenHashTable *table = (SgenHashTable *)data;
        unsigned char *value = (unsigned char *)sgen_hash_table_lookup (table, obj);
        if (!value)
                return FALSE;
        return !*value;
}

static void
null_weak_links_to_dead_objects (SgenBridgeProcessor *processor, int generation)
{
        int i, j;
        int num_sccs = processor->num_sccs;
        MonoGCBridgeSCC **api_sccs = processor->api_sccs;
        SgenHashTable alive_hash = SGEN_HASH_TABLE_INIT (INTERNAL_MEM_BRIDGE_ALIVE_HASH_TABLE, INTERNAL_MEM_BRIDGE_ALIVE_HASH_TABLE_ENTRY, 1, mono_aligned_addr_hash, NULL);

        for (i = 0; i < num_sccs; ++i) {
                unsigned char alive = api_sccs [i]->is_alive ? 1 : 0;
                for (j = 0; j < api_sccs [i]->num_objs; ++j) {
                        /* Build hash table for nulling weak links. */
                        sgen_hash_table_replace (&alive_hash, api_sccs [i]->objs [j], &alive, NULL);

                        /* Release for finalization those objects we no longer care. */
                        if (!api_sccs [i]->is_alive)
                                sgen_mark_bridge_object (api_sccs [i]->objs [j]);
                }
        }

        /* Null weak links to dead objects. */
        sgen_null_links_if (is_bridge_object_dead, &alive_hash, GENERATION_NURSERY, FALSE);
        sgen_null_links_if (is_bridge_object_dead, &alive_hash, GENERATION_NURSERY, TRUE);
        if (generation == GENERATION_OLD) {
                sgen_null_links_if (is_bridge_object_dead, &alive_hash, GENERATION_OLD, FALSE);
                sgen_null_links_if (is_bridge_object_dead, &alive_hash, GENERATION_OLD, TRUE);
        }

        sgen_hash_table_clean (&alive_hash);
}

static void
free_callback_data (SgenBridgeProcessor *processor)
{
        int i;
        int num_sccs = processor->num_sccs;
        int num_xrefs = processor->num_xrefs;
        MonoGCBridgeSCC **api_sccs = processor->api_sccs;
        MonoGCBridgeXRef *api_xrefs = processor->api_xrefs;

        for (i = 0; i < num_sccs; ++i) {
                sgen_free_internal_dynamic (api_sccs [i],
                                sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * api_sccs [i]->num_objs,
                                INTERNAL_MEM_BRIDGE_DATA);
        }
        sgen_free_internal_dynamic (api_sccs, sizeof (MonoGCBridgeSCC*) * num_sccs, INTERNAL_MEM_BRIDGE_DATA);

        sgen_free_internal_dynamic (api_xrefs, sizeof (MonoGCBridgeXRef) * num_xrefs, INTERNAL_MEM_BRIDGE_DATA);

        processor->num_sccs = 0;
        processor->api_sccs = NULL;
        processor->num_xrefs = 0;
        processor->api_xrefs = NULL;
}

static int
compare_xrefs (const void *a_ptr, const void *b_ptr)
{
        const MonoGCBridgeXRef *a = (const MonoGCBridgeXRef *)a_ptr;
        const MonoGCBridgeXRef *b = (const MonoGCBridgeXRef *)b_ptr;

        if (a->src_scc_index < b->src_scc_index)
                return -1;
        if (a->src_scc_index > b->src_scc_index)
                return 1;

        if (a->dst_scc_index < b->dst_scc_index)
                return -1;
        if (a->dst_scc_index > b->dst_scc_index)
                return 1;

        return 0;
}

/*
static void
dump_processor_state (SgenBridgeProcessor *p)
{
        int i;

        printf ("------\n");
        printf ("SCCS %d\n", p->num_sccs);
        for (i = 0; i < p->num_sccs; ++i) {
                int j;
                MonoGCBridgeSCC *scc = p->api_sccs [i];
                printf ("\tSCC %d:", i);
                for (j = 0; j < scc->num_objs; ++j) {
                        MonoObject *obj = scc->objs [j];
                        printf (" %p", obj);
                }
                printf ("\n");
        }

        printf ("XREFS %d\n", p->num_xrefs);
        for (i = 0; i < p->num_xrefs; ++i)
                printf ("\t%d -> %d\n", p->api_xrefs [i].src_scc_index, p->api_xrefs [i].dst_scc_index);

        printf ("-------\n");
}
*/

static gboolean
sgen_compare_bridge_processor_results (SgenBridgeProcessor *a, SgenBridgeProcessor *b)
{
        int i;
        SgenHashTable obj_to_a_scc = SGEN_HASH_TABLE_INIT (INTERNAL_MEM_BRIDGE_DEBUG, INTERNAL_MEM_BRIDGE_DEBUG, sizeof (int), mono_aligned_addr_hash, NULL);
        SgenHashTable b_scc_to_a_scc = SGEN_HASH_TABLE_INIT (INTERNAL_MEM_BRIDGE_DEBUG, INTERNAL_MEM_BRIDGE_DEBUG, sizeof (int), g_direct_hash, NULL);
        MonoGCBridgeXRef *a_xrefs, *b_xrefs;
        size_t xrefs_alloc_size;

        // dump_processor_state (a);
        // dump_processor_state (b);

        if (a->num_sccs != b->num_sccs)
                g_error ("SCCS count expected %d but got %d", a->num_sccs, b->num_sccs);
        if (a->num_xrefs != b->num_xrefs)
                g_error ("SCCS count expected %d but got %d", a->num_xrefs, b->num_xrefs);

        /*
         * First we build a hash of each object in `a` to its respective SCC index within
         * `a`.  Along the way we also assert that no object is more than one SCC.
         */
        for (i = 0; i < a->num_sccs; ++i) {
                int j;
                MonoGCBridgeSCC *scc = a->api_sccs [i];

                g_assert (scc->num_objs > 0);

                for (j = 0; j < scc->num_objs; ++j) {
                        GCObject *obj = scc->objs [j];
                        gboolean new_entry = sgen_hash_table_replace (&obj_to_a_scc, obj, &i, NULL);
                        g_assert (new_entry);
                }
        }

        /*
         * Now we check whether each of the objects in `b` are in `a`, and whether the SCCs
         * of `b` contain the same sets of objects as those of `a`.
         *
         * While we're doing this, build a hash table to map from `b` SCC indexes to `a` SCC
         * indexes.
         */
        for (i = 0; i < b->num_sccs; ++i) {
                MonoGCBridgeSCC *scc = b->api_sccs [i];
                MonoGCBridgeSCC *a_scc;
                int *a_scc_index_ptr;
                int a_scc_index;
                int j;
                gboolean new_entry;

                g_assert (scc->num_objs > 0);
                a_scc_index_ptr = (int *)sgen_hash_table_lookup (&obj_to_a_scc, scc->objs [0]);
                g_assert (a_scc_index_ptr);
                a_scc_index = *a_scc_index_ptr;

                //g_print ("A SCC %d -> B SCC %d\n", a_scc_index, i);

                a_scc = a->api_sccs [a_scc_index];
                g_assert (a_scc->num_objs == scc->num_objs);

                for (j = 1; j < scc->num_objs; ++j) {
                        a_scc_index_ptr = (int *)sgen_hash_table_lookup (&obj_to_a_scc, scc->objs [j]);
                        g_assert (a_scc_index_ptr);
                        g_assert (*a_scc_index_ptr == a_scc_index);
                }

                new_entry = sgen_hash_table_replace (&b_scc_to_a_scc, GINT_TO_POINTER (i), &a_scc_index, NULL);
                g_assert (new_entry);
        }

        /*
         * Finally, check that we have the same xrefs.  We do this by making copies of both
         * xref arrays, and replacing the SCC indexes in the copy for `b` with the
         * corresponding indexes in `a`.  Then we sort both arrays and assert that they're
         * the same.
         *
         * At the same time, check that no xref is self-referential and that there are no
         * duplicate ones.
         */

        xrefs_alloc_size = a->num_xrefs * sizeof (MonoGCBridgeXRef);
        a_xrefs = (MonoGCBridgeXRef *)sgen_alloc_internal_dynamic (xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG, TRUE);
        b_xrefs = (MonoGCBridgeXRef *)sgen_alloc_internal_dynamic (xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG, TRUE);

        memcpy (a_xrefs, a->api_xrefs, xrefs_alloc_size);
        for (i = 0; i < b->num_xrefs; ++i) {
                MonoGCBridgeXRef *xref = &b->api_xrefs [i];
                int *scc_index_ptr;

                g_assert (xref->src_scc_index != xref->dst_scc_index);

                scc_index_ptr = (int *)sgen_hash_table_lookup (&b_scc_to_a_scc, GINT_TO_POINTER (xref->src_scc_index));
                g_assert (scc_index_ptr);
                b_xrefs [i].src_scc_index = *scc_index_ptr;

                scc_index_ptr = (int *)sgen_hash_table_lookup (&b_scc_to_a_scc, GINT_TO_POINTER (xref->dst_scc_index));
                g_assert (scc_index_ptr);
                b_xrefs [i].dst_scc_index = *scc_index_ptr;
        }

        qsort (a_xrefs, a->num_xrefs, sizeof (MonoGCBridgeXRef), compare_xrefs);
        qsort (b_xrefs, a->num_xrefs, sizeof (MonoGCBridgeXRef), compare_xrefs);

        for (i = 0; i < a->num_xrefs; ++i) {
                g_assert (a_xrefs [i].src_scc_index == b_xrefs [i].src_scc_index);
                g_assert (a_xrefs [i].dst_scc_index == b_xrefs [i].dst_scc_index);
        }

        sgen_hash_table_clean (&obj_to_a_scc);
        sgen_hash_table_clean (&b_scc_to_a_scc);
        sgen_free_internal_dynamic (a_xrefs, xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG);
        sgen_free_internal_dynamic (b_xrefs, xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG);

        return TRUE;
}

void
sgen_bridge_processing_finish (int generation)
{
        bridge_processor.processing_build_callback_data (generation);
        if (compare_bridge_processors ())
                compare_to_bridge_processor.processing_build_callback_data (generation);

        if (bridge_processor.num_sccs == 0) {
                g_assert (bridge_processor.num_xrefs == 0);
                goto after_callback;
        }

        bridge_callbacks.cross_references (bridge_processor.num_sccs, bridge_processor.api_sccs,
                        bridge_processor.num_xrefs, bridge_processor.api_xrefs);

        if (compare_bridge_processors ())
                sgen_compare_bridge_processor_results (&bridge_processor, &compare_to_bridge_processor);

        null_weak_links_to_dead_objects (&bridge_processor, generation);

        free_callback_data (&bridge_processor);
        if (compare_bridge_processors ())
                free_callback_data (&compare_to_bridge_processor);

 after_callback:
        bridge_processor.processing_after_callback (generation);
        if (compare_bridge_processors ())
                compare_to_bridge_processor.processing_after_callback (generation);

        mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_BRIDGE: Complete, was running for %.2fms", mono_time_since_last_stw () / 10000.0f);

        bridge_processing_in_progress = FALSE;
}

MonoGCBridgeObjectKind
sgen_bridge_class_kind (MonoClass *klass)
{
        return bridge_processor.class_kind (klass);
}

void
sgen_bridge_register_finalized_object (GCObject *obj)
{
        bridge_processor.register_finalized_object (obj);
        if (compare_bridge_processors ())
                compare_to_bridge_processor.register_finalized_object (obj);
}

void
sgen_bridge_describe_pointer (GCObject *obj)
{
        if (bridge_processor.describe_pointer)
                bridge_processor.describe_pointer (obj);
}

static void
set_dump_prefix (const char *prefix)
{
        if (bridge_processor_config.dump_prefix)
                free (bridge_processor_config.dump_prefix);
        bridge_processor_config.dump_prefix = strdup (prefix);
}

/* Test support code */
static const char *bridge_class;

static MonoGCBridgeObjectKind
bridge_test_bridge_class_kind (MonoClass *klass)
{
        if (!strcmp (bridge_class, klass->name))
                return GC_BRIDGE_TRANSPARENT_BRIDGE_CLASS;
        return GC_BRIDGE_TRANSPARENT_CLASS;
}

static gboolean
bridge_test_is_bridge_object (MonoObject *object)
{
        return TRUE;
}

static void
bridge_test_cross_reference (int num_sccs, MonoGCBridgeSCC **sccs, int num_xrefs, MonoGCBridgeXRef *xrefs)
{
        int i;
        for (i = 0; i < num_sccs; ++i) {
                int j;
        //      g_print ("--- SCC %d\n", i);
                for (j = 0; j < sccs [i]->num_objs; ++j) {
        //              g_print ("  %s\n", sgen_safe_name (sccs [i]->objs [j]));
                        if (i & 1) /*retain half of the bridged objects */
                                sccs [i]->is_alive = TRUE;
                }
        }
        for (i = 0; i < num_xrefs; ++i) {
                g_assert (xrefs [i].src_scc_index >= 0 && xrefs [i].src_scc_index < num_sccs);
                g_assert (xrefs [i].dst_scc_index >= 0 && xrefs [i].dst_scc_index < num_sccs);
        //      g_print ("%d -> %d\n", xrefs [i].src_scc_index, xrefs [i].dst_scc_index);
        }
}

static MonoClassField *mono_bridge_test_field;

enum {
        BRIDGE_DEAD,
        BRIDGE_ROOT,
        BRIDGE_SAME_SCC,
        BRIDGE_XREF,
};

static gboolean
test_scc (MonoGCBridgeSCC *scc, int i)
{
        int status = BRIDGE_DEAD;
        mono_field_get_value (scc->objs [i], mono_bridge_test_field, &status);
        return status > 0;
}

static void
mark_scc (MonoGCBridgeSCC *scc, int value)
{
        int i;
        for (i = 0; i < scc->num_objs; ++i) {
                if (!test_scc (scc, i)) {
                        int status = value;
                        mono_field_set_value (scc->objs [i], mono_bridge_test_field, &status);
                }
        }
}

static void
bridge_test_cross_reference2 (int num_sccs, MonoGCBridgeSCC **sccs, int num_xrefs, MonoGCBridgeXRef *xrefs)
{
        int i;
        gboolean modified;

        if (!mono_bridge_test_field) {
                mono_bridge_test_field = mono_class_get_field_from_name (mono_object_get_class (sccs[0]->objs [0]), "__test");
                g_assert (mono_bridge_test_field);
        }

        /*We mark all objects in a scc with live objects as reachable by scc*/
        for (i = 0; i < num_sccs; ++i) {
                int j;
                gboolean live = FALSE;
                for (j = 0; j < sccs [i]->num_objs; ++j) {
                        if (test_scc (sccs [i], j)) {
                                live = TRUE;
                                break;
                        }
                }
                if (!live)
                        continue;
                for (j = 0; j < sccs [i]->num_objs; ++j) {
                        if (!test_scc (sccs [i], j)) {
                                int status = BRIDGE_SAME_SCC;
                                mono_field_set_value (sccs [i]->objs [j], mono_bridge_test_field, &status);
                        }
                }
        }

        /*Now we mark the transitive closure of reachable objects from the xrefs*/
        modified = TRUE;
        while (modified) {
                modified = FALSE;
                /* Mark all objects that are brought to life due to xrefs*/
                for (i = 0; i < num_xrefs; ++i) {
                        MonoGCBridgeXRef ref = xrefs [i];
                        if (test_scc (sccs [ref.src_scc_index], 0) && !test_scc (sccs [ref.dst_scc_index], 0)) {
                                modified = TRUE;
                                mark_scc (sccs [ref.dst_scc_index], BRIDGE_XREF);
                        }
                }
        }

        /* keep everything in memory, all we want to do is test persistence */
        for (i = 0; i < num_sccs; ++i)
                sccs [i]->is_alive = TRUE;
}

/* This bridge keeps all peers with __test > 0 */
static void
bridge_test_positive_status (int num_sccs, MonoGCBridgeSCC **sccs, int num_xrefs, MonoGCBridgeXRef *xrefs)
{
        int i;

        if (!mono_bridge_test_field) {
                mono_bridge_test_field = mono_class_get_field_from_name (mono_object_get_class (sccs[0]->objs [0]), "__test");
                g_assert (mono_bridge_test_field);
        }

        /*We mark all objects in a scc with live objects as reachable by scc*/
        for (i = 0; i < num_sccs; ++i) {
                int j;
                for (j = 0; j < sccs [i]->num_objs; ++j) {
                        if (test_scc (sccs [i], j)) {
                                sccs [i]->is_alive = TRUE;
                                break;
                        }
                }
        }
}


static void
register_test_bridge_callbacks (const char *bridge_class_name)
{
        MonoGCBridgeCallbacks callbacks;
        callbacks.bridge_version = SGEN_BRIDGE_VERSION;
        callbacks.bridge_class_kind = bridge_test_bridge_class_kind;
        callbacks.is_bridge_object = bridge_test_is_bridge_object;

        switch (bridge_class_name [0]) {
        case '2':
                bridge_class = bridge_class_name + 1;
                callbacks.cross_references = bridge_test_cross_reference2;
                break;
        case '3':
                bridge_class = bridge_class_name + 1;
                callbacks.cross_references = bridge_test_positive_status;
                break;
        default:
                bridge_class = bridge_class_name;
                callbacks.cross_references = bridge_test_cross_reference;
        }
        mono_gc_register_bridge_callbacks (&callbacks);
}

gboolean
sgen_bridge_handle_gc_param (const char *opt)
{
        g_assert (!bridge_processor_started ());

        if (!strcmp (opt, "bridge-require-precise-merge")) {
                bridge_processor_config.scc_precise_merge = TRUE;
        } else {
                return FALSE;
        }

        return TRUE;
}

gboolean
sgen_bridge_handle_gc_debug (const char *opt)
{
        g_assert (!bridge_processor_started ());

        if (g_str_has_prefix (opt, "bridge=")) {
                opt = strchr (opt, '=') + 1;
                register_test_bridge_callbacks (g_strdup (opt));
        } else if (!strcmp (opt, "enable-bridge-accounting")) {
                bridge_processor_config.accounting = TRUE;
        } else if (g_str_has_prefix (opt, "bridge-dump=")) {
                char *prefix = strchr (opt, '=') + 1;
                set_dump_prefix(prefix);
        } else if (g_str_has_prefix (opt, "bridge-compare-to=")) {
                const char *name = strchr (opt, '=') + 1;
                BridgeProcessorSelection selection = bridge_processor_name (name);

                if (selection != BRIDGE_PROCESSOR_INVALID) {
                        // Compare processor doesn't get config
                        init_bridge_processor (&compare_to_bridge_processor, selection);
                } else {
                        g_warning ("Invalid bridge implementation to compare against - ignoring.");
                }
        } else {
                return FALSE;
        }
        return TRUE;
}

void
sgen_bridge_print_gc_debug_usage (void)
{
        fprintf (stderr, "  bridge=<class-name>\n");
        fprintf (stderr, "  enable-bridge-accounting\n");
        fprintf (stderr, "  bridge-dump=<filename-prefix>\n");
        fprintf (stderr, "  bridge-compare-to=<implementation>\n");
}

#endif