/**

 * $Id: target.c 931 2008-10-31 02:57:59Z nkeynes $

 * 

 * Target code-generation support - provides a generic harness around the raw

 * (machine-specific) code emitter.

 *

 * Copyright (c) 2009 Nathan Keynes.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#include <stdlib.h>

#include "lxdream.h"

#include "xlat/xir.h"

#include "xlat/machine.h"

#define DEFAULT_FIXUP_TABLE_SIZE 4096

#define ALIGN32(p) p += ((-(uintptr_t)p)&0x03)

#define ALIGN64(p) p += ((-(uintptr_t)p)&0x07)

/**

 * Currently we use a single static target_data so that we can reuse the 

 * allocated memory (and we only do one codegen at a time anyway). However

 * we keep this private so that other modules can't assume there's only one TD.

 */

static struct target_data TD; 

/**

 * Add a new fixup without setting a target value

 */

static target_fixup_t target_add_fixup( target_data_t td, int type, void *location ) 

{

    if( td->fixup_table_posn == td->fixup_table_size ) {

        td->fixup_table_size <<= 1;

        td->fixup_table = realloc(td->fixup_table, td->fixup_table_size * sizeof(struct target_fixup_struct));

        assert( td->fixup_table != NULL );

    }

    target_fixup_t fixup = &td->fixup_table[td->fixup_table_posn++];

    fixup->fixup_type = type | TARGET_FIXUP_CONST32;

    fixup->fixup_offset = ((uint8_t *)location) - (uint8_t *)&td->block->code[0];

    return fixup;

}    

void target_add_const32_fixup( target_data_t td, int mode, void *location, uint32_t i )

{

    target_add_fixup(td, mode|TARGET_FIXUP_CONST32, location)->value.i = i;

}

void target_add_const64_fixup( target_data_t td, int mode, void *location, uint64_t q )

{

    target_add_fixup(td, mode|TARGET_FIXUP_CONST64, location)->value.q = q;

}

void target_add_raise_fixup( target_data_t td, int type, void *location, xir_op_t *exc )

{

    target_add_fixup(td, mode|TARGET_FIXUP_RAISE, location)->value.exc = exc;

}

void target_add_raiseext_fixup( target_data_t td, int type, void *location, xir_op_t *exc )

{

    target_add_fixup(td, mode|TARGET_FIXUP_RAISEEXT, location)->value.exc = exc;

}

void target_add_offset_fixup( target_data_t td, int type, void *location, uint32_t off )

{

    target_add_fixup(td, mode|TARGET_FIXUP_OFFSET, location)->target_offset = off;

}

void target_add_pointer_fixup( target_data_t td, int type, void *location, void *p )

{

    target_add_fixup(td, mode|TARGET_FIXUP_POINTER, location)->value.p = p;

}

void target_ensure_space( target_data_t td, int space_required )

{

    uint8_t *oldstart = td->block->code;

    uint32_t new_size = (td->xlat_output - oldstart) + space_required;

    if( new_size < td->block->size ) {

        xlat_current_block = xlat_extend_block( xlat_output - oldstart + MAX_INSTRUCTION_SIZE );

        eob = xlat_current_block->code + xlat_current_block->size;

        td->block = xlat_extend_block( new_size );

        xlat_output = td->block->code + (xlat_output - oldstart);        

    }

}

/**

 * Generate the exception table and exception bodies from the fixup data

 * Note that this may add additional constants to the fixup table.

 */

static void target_gen_exception_table( )

{

    int exc_size = 0, num_raiseext = 0;

    for( target_fixup_t fixup = &TD.fixup_table[0]; fixup != &TD.fixup_table[TD.fixup_table_posn]; fixup++ ) {

        int type = 

        switch(TARGET_FIXUP_TARGET(fixup->type)) {

        case TARGET_FIXUP_RAISEEXT:

            num_raiseext++;

            /* fallthrough */

        case TARGET_FIXUP_RAISE:

            exc_size += TD.get_code_size(fixup->value.exc, NULL);

        }

    }

    ALIGN64(TD.xlat_output);

    target_ensure_space( td, exc_size + num_raiseext*sizeof(struct xlat_exception_record) );

    uint8_t *blockstart = &TD.block->code[0];

    struct xlat_exception_record *exc_record = (struct xlat_exception_record *)TD.xlat_output;

    TD.block->exc_table_offset = TD.xlat_output - blockstart;

    TD.block->exc_table_size = num_raiseext;

    TD.xlat_output += (num_raiseext*sizeof(struct xlat_exception_record));

    for( target_fixup_t fixup = &TD.fixup_table[0]; fixup != &td_fixup_table[TD.fixup_table_posn]; fixup++ ) {

        switch( TARGET_FIXUP_TARGET(fixup->type) ) {

        case TARGET_FIXUP_RAISEEXT:

            exc_record->xlat_pc_offset = fixup->fixup_offset + 4;

            exc_record->xlat_exc_offset = TD.xlat_output - blockstart;

            /* fallthrough */

        case TARGET_FIXUP_RAISE:

            fixup->target_offset = TD.xlat_output - blockstart;

            TD.codegen( td, fixup->value.exc, NULL );

        }

    }

}

/** 

 * Generate constant table from the fixup data.

 */

static void target_gen_constant_table( )

{

    int numconst32=0, numconst64=0;

    /* Determine table size */

    for( target_fixup_t fixup = &TD.fixup_table[0]; fixup != &td_fixup_table[TD.fixup_table_posn]; fixup++ ) {

        int type = TARGET_FIXUP_TARGET(fixup->type);

        if( type == TARGET_FIXUP_CONST32 ) {

            numconst32++;

        } else if( type == TARGET_FIXUP_CONST64 ) {

            numconst64++;

        }

    }

    if( numconst64 != 0 ) {

        ALIGN64(TD.xlat_output);

    } else if( numconst32 != 0 ) {

        ALIGN32(TD.xlat_output);

    } else {

        return; /* no constants */

    }

    target_ensure_space( td, numconst64*8 + numconst32*4 );

    uint8_t *blockstart = &TD.block->code[0];

    /* TODO: Merge reused constant values */

    uint64_t *const64p = (uint64_t *)TD.xlat_output;

    uint32_t *const32p = (uint32_t *)(TD.xlat_output + numconst64*8);

    TD.xlat_output += (numconst64*8 + numconst32*4);

    for( target_fixup_t fixup = &TD.fixup_table[0]; fixup != &td_fixup_table[TD.fixup_table_posn]; fixup++ ) {

        switch(TARGET_FIXUP_TARGET(fixup->type)) {

        case TARGET_FIXUP_CONST32:

            fixup->target_offset =  ((uint8_t *)const32p) - blockstart;  

            *const32p++ = fixup->value.i;

            break;

        case TARGET_FIXUP_CONST64:

            fixup->target_offset =  ((uint8_t *)const64p) - blockstart;  

            *const64p++ = fixup->value.q;

            break;

        }

    }

}

/**

 * Apply all target fixups - assumes exceptions + constants have already been

 * generated.

 */

static void target_apply_fixups( )

{

    for( target_fixup_t fixup = &TD.fixup_table[0]; fixup != &TD.fixup_table[TD.fixup_table_posn]; fixup++ ) {

        void *target;

        if( TARGET_FIXUP_TARGET(fixup->type) == TARGET_FIXUP_POINTER ) {

            target = fixup->value.p;

        } else {

            target = &TD.block->code[fixup->target_offset];

        }

        uint32_t *loc = (uint32_t *)TD.block->code[fixup->fixup_offset];

        uint64_t *loc64 = (uint64_t *)TD.block->code[fixup->fixup_offset];

        switch(TARGET_FIXUP_MODE(fixup->fixup_type)) {

        case TARGET_FIXUP_REL32:

            *loc += (uint8_t *)target - (uint8_t *)(loc+1);

            break;

        case TARGET_FIXUP_REL64:

            *loc64 += (uint8_t *)target - (uint8_t *)(loc64+1);

            break;

        case TARGET_FIXUP_ABS32:

            *loc += (uint32_t)target;

            break;

        case TARGET_FIXUP_ABS64:

            *loc64 += (uint64_t)target;

            break;

        }

    }

}

void target_codegen( xlat_target_machine_t machine, source_data_t sd )

{

    /* Setup the target data struct */

    TD.mach = machine;

    TD.src = sd->machine;

    TD.block = xlat_start_block( sd->pc_start );

    TD.xlat_output = &TD.block->code[0];

    if( TD.fixup_table == NULL ) {

        if( TD.fixup_table == NULL ) {

            TD.fixup_table_size = DEFAULT_FIXUP_TABLE_SIZE;

            TD.fixup_table = malloc( td->fixup_table_size * sizeof(struct target_fixup_struct) );

            assert( TD.fixup_table != NULL );

        }

    }

    TD.fixup_table_posn = 0;

    uint32_t code_size = machine->get_code_size(sd->ir_begin,sd->ir_end);

    target_ensure_space(&TD, code_size);

    machine->codegen(&TD, sd->begin, sd->end);

    target_gen_exception_table();

    target_gen_constant_table();

    target_apply_fixups();

    xlat_commit_block( TD.xlat_output - &TD.block->code[0], sd->pc_end-sd->pc_start );

    return &TD.block->code[0];

}