#include <assert.h>
#include "regnaive.h"

typedef struct reg_alloc_t reg_alloc_t;
typedef struct reg_pool_t reg_pool_t;

#define MAX_REGISTERS (16)
#define MAX_SPILLS    (16)

static int
find_index (reg_alloc_t *ra, reg_t reg)
{
    int i;

    for (i = 0; i < ra->pool->n_registers; ++i)
    {
	if (ra->pool->registers[i] == reg)
	    return i;
    }

    assert (0);
    return -1;
}

void
reg_alloc_init (reg_alloc_t *ra,
		const reg_pool_t *reg_pool)
{
    int i;

    ra->pool = reg_pool;
    for (i = 0; i < ra->pool->n_registers; ++i)
    {
	ra->allocated[i] = FALSE;
	ra->clobbered[i] = FALSE;
    }
    ra->failed = FALSE;
}

/* This resurrects a register that has been freed, but is known
 * to still contain a useful value.
 */
reg_t
reg_alloc_alloc_preserve (reg_alloc_t *ra, reg_t reg)
{
    int idx = find_index (ra, reg);

    assert (!ra->allocated[idx]);

    ra->allocated[idx] = TRUE;
    ra->clobbered[idx] = TRUE;

    return reg;
}

reg_t
reg_alloc_alloc (reg_alloc_t *ra)
{
    int i;

    for (i = 0; i < ra->pool->n_registers; ++i)
    {
	if (!ra->allocated[i])
	{
	    ra->allocated[i] = TRUE;
	    ra->clobbered[i] = TRUE;

	    return ra->pool->registers[i];
	}
    }

    ra->failed = TRUE;
    return (reg_t)0;
}

void
reg_alloc_free (reg_alloc_t *ra, reg_t reg)
{
    int idx = find_index (ra, reg);

    assert (ra->allocated[idx]);

    ra->allocated[idx] = FALSE;
}

int
reg_alloc_failed (reg_alloc_t *ra)
{
    return ra->failed;
}

int
reg_alloc_clobbered (reg_alloc_t *ra, reg_t reg)
{
    int idx = find_index (ra, reg);

    return ra->clobbered[idx];
}