/*
    pro_table.c

    $Revision: 1.1.1.1 $				$Date: 2002/05/02 03:29:20 $
*/

#include <bstring.h>
#include <stdlib.h>
#include <string.h>
#include <libXlate.h>

#include "xlateTypes.h"

#define CHECKALLOC(ptr, table, line) \
    if (ptr == NULL) { \
        if (table != NULL) \
	    table->tb_errorLine = line; \
	return TB_STATUS_ALLOC_FAIL; \
    }


/*
    This routine returns a handle for the table to be created.
    The user specifies the tableKind, and a pointer to the old
    table coming in, in oldTable.  The new table created will
    be composed with the oldTable.  makeDebug specifies whether
    a debugging table should be created.  is_64Bit specifies
    whether the table is for a 64-bit object.  For 64-bit objects,
    upper32BitsNew and upper32BitsOld specify the top 32-bits of
    all new and old address resp.  This is possible because
    Ragnarok guarantees that no text section will cross a 32-bit
    address boundary.

    The routine zeros out the Xlate_Table_Pro_s struct malloced.
    Right now, we are assuming that oldTable is always NULL.  For
    this reason, the tb_putDebug field is set FALSE, and the table
    being built is put into the main table.  If makeDebug is true,
    we set the hd_version of tb_headerDebug to indicate that the
    debugging table is a copy of the main table.
*/
Elf32_Sword
xlate_pro_init (
    Xlate_Table_Pro	*retTable,
    Xlate_TableKind 	tableKind, 
    void 		*oldTable,
    Elf32_Word		makeDebug,
    Elf32_Word		is64Bit,
    Elf32_Word		upper32BitsNew,
    Elf32_Word		upper32BitsOld
)
{
    Xlate_Table_Pro	newTable;

    *retTable = NULL;

    if (tableKind != TK_general && 
	tableKind != TK_preserve_size &&
	tableKind != TK_preserve_order)
	return TB_STATUS_BAD_TABLEKIND;

    if (oldTable != NULL)
	return TB_STATUS_NOT_YET_IMPLEMENT;

    newTable = (Xlate_Table_Pro)malloc(sizeof(struct Xlate_Table_Pro_s));
    CHECKALLOC(newTable, newTable, __LINE__);
    bzero(newTable, sizeof(struct Xlate_Table_Pro_s));

    newTable->tb_oldTable = oldTable;
    newTable->tb_makeDebug = makeDebug;
    newTable->tb_putDebug = FALSE;

    newTable->tb_header.hd_version = TB_TABLE_VERSION_MAIN;
    newTable->tb_header.hd_tableKind = tableKind;
    newTable->tb_header.hd_is64Bit = is64Bit;
    newTable->tb_header.hd_upper32BitsNew = upper32BitsNew;
    newTable->tb_header.hd_upper32BitsOld = upper32BitsOld;
    newTable->tb_header.hd_blockSize = TB_BLOCK_SIZE;

    if (makeDebug) {
	newTable->tb_headerDebug.hd_version = TB_TABLE_VERSION_COPY;
    }

    *retTable = newTable;
    return TB_STATUS_NO_ERROR;
}


/*
    This routine is used to add miscellaneous
    information about the translation to the
    appropriate table.  The information must
    be added before xlate_pro_disk_header() or 
    its debugging table counterpart has been
    called.
*/
Elf32_Sword
xlate_pro_add_info (
    Xlate_Table_Pro	table,
    Elf32_Sword		dataMoved,
    Elf32_Word		startupFwa,
    Elf32_Word		startupLwa,
    Elf32_Word		oldTextExists,
    Elf32_Word		oldTextAlloc
)
{
    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

    if (table->tb_putDebug) {
	if (table->tb_memoryReqRetDebug) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_ADD_TOO_LATE;
	}
	    
	table->tb_headerDebug.hd_dataMoved = dataMoved;
	table->tb_headerDebug.hd_startupFwa = startupFwa;
	table->tb_headerDebug.hd_startupLwa = startupLwa;
	table->tb_headerDebug.hd_oldTextExists = oldTextExists;
	table->tb_headerDebug.hd_oldTextAlloc = oldTextAlloc;
    }
    else {
	if (table->tb_memoryReqRet) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_ADD_TOO_LATE;
	}

	table->tb_header.hd_dataMoved = dataMoved;
	table->tb_header.hd_startupFwa = startupFwa;
	table->tb_header.hd_startupLwa = startupLwa;
	table->tb_header.hd_oldTextExists = oldTextExists;
	table->tb_header.hd_oldTextAlloc = oldTextAlloc;
    }

    return TB_STATUS_NO_ERROR;
}


/*
    This routine is used to add information about the translation
    of register in the transformation process.  This routine if
    called, should be called before xlate_pro_disk_header() or its
    debugging counterpart.
*/
Elf32_Sword
xlate_pro_add_reg_info (
    Xlate_Table_Pro	table,
    Dwarf_Small		op,
    Dwarf_Unsigned	val1,
    Dwarf_Unsigned	val2
)
{
    unsigned char	regAssemble[1024];
    Elf32_Sword		regAssembleSize;
    Elf32_Sword		leb128_length;
    Dwarf_Unsigned	delta;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

    if (table->tb_putDebug) {
	if (table->tb_memoryReqRetDebug) {
    	    table->tb_errorLine = __LINE__;
    	    return TB_STATUS_ADD_TOO_LATE;
	}
    }
    else {
	if (table->tb_memoryReqRet) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_ADD_TOO_LATE;
	}
    }

    regAssemble[0] = op;
    switch (op) {
	case DW_CFA_advance_loc :
	    delta = val1 >> 2;
	    if (delta > 0x3f) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }

	    regAssemble[0] |= delta;
	    regAssembleSize = 1;
	    break;

	case DW_CFA_offset :
	    if (val1 > 0x3f) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }

	    regAssemble[0] |= val1;
	    leb128_length = 
		_xlate_leb128_unsigned_encode(val1, &regAssemble[1]);
	    regAssembleSize = 1 + leb128_length;
	    break;

	case DW_CFA_restore:
	    if (val1 > 0x3f) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }

	    regAssemble[0] |= val1;
	    regAssembleSize = 1;
	    break;

	case DW_CFA_set_loc :
	    memcpy(&regAssemble[1], &val1, sizeof(Dwarf_Unsigned));
	    regAssembleSize = 1 + sizeof(Dwarf_Unsigned);
	    break;

	case DW_CFA_advance_loc1 :
	    delta = val1 >> 2;
	    if (delta > 0xff) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }

	    regAssemble[1] = delta;
	    regAssembleSize = 2;
	    break;

	case DW_CFA_advance_loc2 :
	    delta = val1 >> 2;
	    if (delta > 0xffff) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }

	    regAssemble[1] = delta;
	    regAssemble[2] = delta >> 8;
	    regAssembleSize = 3;
	    break;

	case DW_CFA_advance_loc4 :
	    delta = val1 >> 2;
	    if (delta > 0xffffffff) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }

	    regAssemble[1] = delta;
	    delta >>= 8;
	    regAssemble[2] = delta;
	    delta >>= 8;
	    regAssemble[3] = delta;
	    delta >>= 8;
	    regAssemble[4] = delta;
	    regAssembleSize = 5;
	    break;

	case DW_CFA_offset_extended :
	case DW_CFA_def_cfa :
	    if (val1 >= DW_FRAME_LAST_REG_NUM) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }
	    leb128_length =
		_xlate_leb128_unsigned_encode(val1, &regAssemble[1]);
	    regAssembleSize = 1 + leb128_length;

	    leb128_length = _xlate_leb128_unsigned_encode((val2 >> 2), 
		&regAssemble[regAssembleSize]);
	    regAssembleSize += leb128_length;
	    break;

	case DW_CFA_restore_extended :
	case DW_CFA_undefined :
	case DW_CFA_same_value :
	case DW_CFA_def_cfa_register :
	    if (val1 >= DW_FRAME_LAST_REG_NUM) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }
	    leb128_length =
		_xlate_leb128_unsigned_encode(val1, &regAssemble[1]);
	    regAssembleSize = 1 + leb128_length;
	    break;

	case DW_CFA_register :
	    if (val1 >= DW_FRAME_LAST_REG_NUM) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }
	    leb128_length =
		_xlate_leb128_unsigned_encode(val1, &regAssemble[1]);
	    regAssembleSize = 1 + leb128_length;

	    if (val2 >= DW_FRAME_LAST_REG_NUM) {
		table->tb_errorLine = __LINE__;
		return TB_STATUS_BAD_REG_VAL;
	    }
	    leb128_length = _xlate_leb128_unsigned_encode(val2, 
		&regAssemble[regAssembleSize]);
	    regAssembleSize += leb128_length;
	    break;

	case DW_CFA_remember_state :
	case DW_CFA_restore_state :
	case DW_CFA_nop :
	    regAssembleSize = 1;
	    break;

	case DW_CFA_def_cfa_offset :
	    leb128_length =
		_xlate_leb128_unsigned_encode((val1 >> 2), &regAssemble[1]);
	    regAssembleSize = 1 + leb128_length;
	    break;

	default :
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_BAD_REG_OP;
    }

    if (table->tb_regInfoOffset + regAssembleSize >= table->tb_regInfoSize) {
	table->tb_regInfoSize += TB_REGINFO_SIZE;
	table->tb_regInfo = realloc(table->tb_regInfo, table->tb_regInfoSize);
	CHECKALLOC(table->tb_regInfo, table, __LINE__);
    }

    memcpy(table->tb_regInfo + table->tb_regInfoOffset, regAssemble, 
	regAssembleSize);
    table->tb_regInfoOffset += regAssembleSize;

    return TB_STATUS_NO_ERROR;
}


/*
    This routine gets a new block to store the table 
    being built in.  It also zeros out the remaining
    bytes of the current block.
*/
static Elf32_Sword
getNewBlock (
    Xlate_Table_Pro	table,
    Elf32_Word		useDebug,
    Elf32_Word		newAddress,
    Elf32_Word		oldAddress
)
{
    Block_s		*newBlock;
    Elf32_Sword		blockSize;
    Elf32_Sword		blockOffset;

    newBlock = (Block_s *)malloc(sizeof(Block_s));
    CHECKALLOC(newBlock, table, __LINE__);

    newBlock->bk_firstNewAddr = newAddress;
    newBlock->bk_firstOldAddr = oldAddress;
    newBlock->bk_numEntries = 0;
    newBlock->bk_next = NULL;

    if (useDebug) {
    	blockSize = table->tb_headerDebug.hd_blockSize;

        if (table->tb_blockHeadDebug == NULL) {
	    table->tb_blockHeadDebug = table->tb_blockTailDebug = newBlock;
        }
        else {
            blockOffset = table->tb_blockOffsetDebug;
	    while (blockOffset < blockSize)
	    	table->tb_blockTailDebug->bk_data[blockOffset++] = 0;

	    table->tb_blockTailDebug->bk_next = newBlock;
	    table->tb_blockTailDebug = newBlock;
        }
        table->tb_blockOffsetDebug = 0;

        table->tb_headerDebug.hd_numBlocks++;
    }
    else {
	blockSize = table->tb_header.hd_blockSize;

	if (table->tb_blockHead == NULL) {
	    table->tb_blockHead = table->tb_blockTail = newBlock;
	}
	else {
            blockOffset = table->tb_blockOffset;
	    while (blockOffset < blockSize)
	    	table->tb_blockTail->bk_data[blockOffset++] = 0;

	    table->tb_blockTail->bk_next = newBlock;
	    table->tb_blockTail = newBlock;
	}
	table->tb_blockOffset = 0;

	table->tb_header.hd_numBlocks++;
    }

    newBlock->bk_data = malloc(blockSize);
    CHECKALLOC(newBlock->bk_data, table, __LINE__);
    return TB_STATUS_NO_ERROR;
}


/*
    This routine adds a new range entry to the table.
    The table should be an order preserving table,
    such as for pixie.
*/
Elf32_Sword
xlate_pro_add_range_PO (
    Xlate_Table_Pro	table,
    Elf32_Word		newAddress,
    Elf32_Word		oldAddress
)
{
    Elf32_Word		newRange;
    char		newRangeBuf[BUFSIZ];
    Elf32_Sword		newRangeLength;
    Elf32_Word		oldRange;
    char		oldRangeBuf[BUFSIZ];
    Elf32_Sword		oldRangeLength;
    Elf32_Sword		retStatus;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

        /* New and old addresses specified should always be ascending. */
    if (newAddress <= table->tb_prevNewAddr ||
	oldAddress <= table->tb_prevOldAddr) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_BAD_ADD_ADDR;
    }

	/* Check that the addresses specified are word-aligned. */
    if ((newAddress & 0x3 != 0) || (oldAddress & 0x3 != 0)) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_ADDR_UNALIGNED;
    }

	/* Store ranges in units of instructions, not bytes. */
    newRange = newAddress - table->tb_prevNewAddr;
    oldRange = oldAddress - table->tb_prevOldAddr;
    newRangeLength = 
	_xlate_leb128_unsigned_encode((newRange >> 2), newRangeBuf);
    oldRangeLength = 
	_xlate_leb128_unsigned_encode((oldRange >> 2), oldRangeBuf);

    if (table->tb_putDebug) {
    	if (table->tb_headerDebug.hd_tableKind != TK_preserve_order) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_BAD_TABLEKIND;
        }

        if (table->tb_blockHeadDebug == NULL || 
	    (table->tb_blockOffsetDebug + newRangeLength + oldRangeLength >= 
	    table->tb_headerDebug.hd_blockSize)) {
	    retStatus = getNewBlock(table, TRUE, newAddress, oldAddress);
	    if (retStatus != TB_STATUS_NO_ERROR)
	        return retStatus;
        }

        strncpy(table->tb_blockTailDebug->bk_data + table->tb_blockOffsetDebug,
	    newRangeBuf, newRangeLength);
        table->tb_blockOffsetDebug += newRangeLength;
        strncpy(table->tb_blockTailDebug->bk_data + table->tb_blockOffsetDebug,
	    oldRangeBuf, oldRangeLength);
        table->tb_blockOffsetDebug += oldRangeLength;

        table->tb_headerDebug.hd_numEntries++;
        table->tb_blockTailDebug->bk_numEntries++;
    }
    else {
    	if (table->tb_header.hd_tableKind != TK_preserve_order) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_BAD_TABLEKIND;
        }

	if (table->tb_blockHead == NULL ||
	    (table->tb_blockOffset + newRangeLength + oldRangeLength >=
	    table->tb_header.hd_blockSize)) {
	    retStatus = getNewBlock(table, FALSE, newAddress, oldAddress);
	    if (retStatus != TB_STATUS_NO_ERROR)
		return retStatus;
	}

	strncpy(table->tb_blockTail->bk_data + table->tb_blockOffset,
	    newRangeBuf, newRangeLength);
	table->tb_blockOffset += newRangeLength;
	strncpy(table->tb_blockTail->bk_data + table->tb_blockOffset,
	    oldRangeBuf, oldRangeLength);
	table->tb_blockOffset += oldRangeLength;

	table->tb_header.hd_numEntries++;
	table->tb_blockTail->bk_numEntries++;
    }

    table->tb_prevNewAddr = newAddress;
    table->tb_prevOldAddr = oldAddress;
    return TB_STATUS_NO_ERROR;
}


/*
    This routine adds a new range entry to the table.
    The table must be size preserving, such as for cord.
*/
Elf32_Sword
xlate_pro_add_range_PS (
    Xlate_Table_Pro	table,
    Elf32_Word		newAddress,
    Elf32_Word		oldAddress
)
{
    Elf32_Word		newRange;
    char		newRangeBuf[BUFSIZ];
    Elf32_Sword		newRangeLength;
    Elf32_Sword		oldAddrDiff;
    char		oldAddrDiffBuf[BUFSIZ];
    Elf32_Sword		oldAddrDiffLength;
    Elf32_Sword		retStatus;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

	/* New addresses must be in ascending order. */
    if (newAddress <= table->tb_prevNewAddr) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_BAD_ADD_ADDR;
    }

	/* New and old addresses should be word-aligned. */
    if ((newAddress & 0x3 != 0) || (oldAddress & 0x3 != 0)) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_ADDR_UNALIGNED;
    }

	/* The numbers in the table are in units of instructions, not bytes. */
    newRange = newAddress - table->tb_prevNewAddr;
    oldAddrDiff = oldAddress - table->tb_prevOldAddr;
    newRangeLength = 
	_xlate_leb128_unsigned_encode((newRange >> 2), newRangeBuf);
    oldAddrDiffLength = 
    	_xlate_leb128_signed_encode((oldAddrDiff >> 2), oldAddrDiffBuf);

    if (table->tb_putDebug) {
    	if (table->tb_headerDebug.hd_tableKind != TK_preserve_size) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_BAD_TABLEKIND;
        }

    	if (table->tb_headerDebug.hd_oldAddrLow == 0) {
	    table->tb_headerDebug.hd_oldAddrLow = oldAddress;
	    table->tb_headerDebug.hd_oldAddrHigh = oldAddress;
        }
        else {
	    table->tb_headerDebug.hd_oldAddrLow = 
		oldAddress < table->tb_headerDebug.hd_oldAddrLow ?
	        oldAddress : table->tb_headerDebug.hd_oldAddrLow;
	    table->tb_headerDebug.hd_oldAddrHigh = 
		oldAddress > table->tb_headerDebug.hd_oldAddrHigh ?
	        oldAddress : table->tb_headerDebug.hd_oldAddrHigh;
        }

    	if (table->tb_blockHeadDebug == NULL || 
	    (table->tb_blockOffsetDebug + newRangeLength + oldAddrDiffLength >= 
	    table->tb_headerDebug.hd_blockSize)) {
	    retStatus = getNewBlock(table, TRUE, newAddress, oldAddress);
	    if (retStatus != TB_STATUS_NO_ERROR)
	        return retStatus;
        }

        strncpy(table->tb_blockTailDebug->bk_data + table->tb_blockOffsetDebug,
	    newRangeBuf, newRangeLength);
        table->tb_blockOffsetDebug += newRangeLength;
        strncpy(table->tb_blockTailDebug->bk_data + table->tb_blockOffsetDebug,
	    oldAddrDiffBuf, oldAddrDiffLength);
        table->tb_blockOffsetDebug += oldAddrDiffLength;

        table->tb_headerDebug.hd_numEntries++;
        table->tb_blockTailDebug->bk_numEntries++;
    }
    else {
    	if (table->tb_header.hd_tableKind != TK_preserve_size) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_BAD_TABLEKIND;
        }

    	if (table->tb_header.hd_oldAddrLow == 0) {
	    table->tb_header.hd_oldAddrLow = oldAddress;
	    table->tb_header.hd_oldAddrHigh = oldAddress;
        }
        else {
	    table->tb_header.hd_oldAddrLow = 
		oldAddress < table->tb_header.hd_oldAddrLow ?
	        oldAddress : table->tb_header.hd_oldAddrLow;
	    table->tb_header.hd_oldAddrHigh = 
		oldAddress > table->tb_header.hd_oldAddrHigh ?
	        oldAddress : table->tb_header.hd_oldAddrHigh;
        }

	if (table->tb_blockHead == NULL ||
	    (table->tb_blockOffset + newRangeLength + oldAddrDiffLength >=
	    table->tb_header.hd_blockSize)) {
	    retStatus = getNewBlock(table, FALSE, newAddress, oldAddress);
	    if (retStatus != TB_STATUS_NO_ERROR)
		return retStatus;
	}

	strncpy(table->tb_blockTail->bk_data + table->tb_blockOffset,
	    newRangeBuf, newRangeLength);
	table->tb_blockOffset += newRangeLength;
	strncpy(table->tb_blockTail->bk_data + table->tb_blockOffset,
	    oldAddrDiffBuf, oldAddrDiffLength);
	table->tb_blockOffset += oldAddrDiffLength;

	table->tb_header.hd_numEntries++;
	table->tb_blockTail->bk_numEntries++;
    }

    table->tb_prevNewAddr = newAddress;
    table->tb_prevOldAddr = oldAddress;
    return TB_STATUS_NO_ERROR;
}


/*
    This routine adds a new range entry to the table.
    The table must be for general ranges.
*/
Elf32_Sword
xlate_pro_add_range_GE (
    Xlate_Table_Pro	table,
    Elf32_Word		newAddress,
    Elf32_Sword		newRange,
    Elf32_Word		oldAddress,
    Elf32_Sword		oldRange
)
{
    char		newRangeBuf[BUFSIZ];
    Elf32_Sword		newRangeLength;
    Elf32_Sword		oldAddrDiff;
    char		oldAddrDiffBuf[BUFSIZ];
    Elf32_Sword		oldAddrDiffLength;
    char		rangeDiffBuf[BUFSIZ];
    Elf32_Sword		rangeDiffLength;
    Elf32_Sword		retStatus;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

	/* New addresses must always be in ascending order. */
    if (newAddress <= table->tb_prevNewAddr) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_BAD_ADD_ADDR;
    }

	/* New and old addresses must be word-aligned. */
    if ((newAddress & 0x3 != 0) || (oldAddress & 0x3 != 0)) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_ADDR_UNALIGNED;
    }

	/* The ranges must also be multiples of a word, and not bytes. */
    if ((newRange == 0) || (newRange & 0x3 != 0) || (oldRange & 0x3 != 0)) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_RANGE_BAD;
    }

	/* Numbers in the table are in units of instructions, not bytes. */
    newRangeLength = 
	_xlate_leb128_unsigned_encode((newRange >> 2), newRangeBuf);
    oldAddrDiff = oldAddress - table->tb_prevOldAddr;
    oldAddrDiffLength = 
    	_xlate_leb128_signed_encode((oldAddrDiff >> 2), oldAddrDiffBuf);
    rangeDiffLength = 
	_xlate_leb128_unsigned_encode((newRange - oldRange) >> 2, rangeDiffBuf);

    if (table->tb_putDebug) {
    	if (table->tb_headerDebug.hd_tableKind != TK_general) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_BAD_TABLEKIND;
        }

    	if (table->tb_headerDebug.hd_oldAddrLow == 0) {
	    table->tb_headerDebug.hd_oldAddrLow = oldAddress;
	    table->tb_headerDebug.hd_oldAddrHigh = oldAddress;
        }
        else {
	    table->tb_headerDebug.hd_oldAddrLow = 
		oldAddress < table->tb_headerDebug.hd_oldAddrLow ?
	        oldAddress : table->tb_headerDebug.hd_oldAddrLow;
	    table->tb_headerDebug.hd_oldAddrHigh = 
		oldAddress > table->tb_headerDebug.hd_oldAddrHigh ?
	        oldAddress : table->tb_headerDebug.hd_oldAddrHigh;
        }

        if (table->tb_blockHeadDebug == NULL || 
	    (table->tb_blockOffsetDebug + newRangeLength + oldAddrDiffLength +
	    rangeDiffLength >= table->tb_headerDebug.hd_blockSize)) {
	    retStatus = getNewBlock(table, TRUE, newAddress, oldAddress);
	    if (retStatus != TB_STATUS_NO_ERROR)
	        return retStatus;
        }

        strncpy(table->tb_blockTailDebug->bk_data + table->tb_blockOffsetDebug,
	    newRangeBuf, newRangeLength);
        table->tb_blockOffsetDebug += newRangeLength;
        strncpy(table->tb_blockTailDebug->bk_data + table->tb_blockOffsetDebug,
	    oldAddrDiffBuf, oldAddrDiffLength);
        table->tb_blockOffsetDebug += oldAddrDiffLength;
	strncpy(table->tb_blockTailDebug->bk_data + table->tb_blockOffsetDebug,
	    rangeDiffBuf, rangeDiffLength);
	table->tb_blockOffsetDebug += rangeDiffLength;

        table->tb_headerDebug.hd_numEntries++;
        table->tb_blockTailDebug->bk_numEntries++;
    }
    else {
    	if (table->tb_header.hd_tableKind != TK_general) {
	    table->tb_errorLine = __LINE__;
	    return TB_STATUS_BAD_TABLEKIND;
        }

    	if (table->tb_header.hd_oldAddrLow == 0) {
	    table->tb_header.hd_oldAddrLow = oldAddress;
	    table->tb_header.hd_oldAddrHigh = oldAddress;
        }
        else {
	    table->tb_header.hd_oldAddrLow = 
		oldAddress < table->tb_header.hd_oldAddrLow ?
	        oldAddress : table->tb_header.hd_oldAddrLow;
	    table->tb_header.hd_oldAddrHigh = 
		oldAddress > table->tb_header.hd_oldAddrHigh ?
	        oldAddress : table->tb_header.hd_oldAddrHigh;
        }

	if (table->tb_blockHead == NULL ||
	    (table->tb_blockOffset + newRangeLength + oldAddrDiffLength +
	    rangeDiffLength >= table->tb_header.hd_blockSize)) {
	    retStatus = getNewBlock(table, FALSE, newAddress, oldAddress);
	    if (retStatus != TB_STATUS_NO_ERROR)
		return retStatus;
	}

	strncpy(table->tb_blockTail->bk_data + table->tb_blockOffset,
	    newRangeBuf, newRangeLength);
	table->tb_blockOffset += newRangeLength;
	strncpy(table->tb_blockTail->bk_data + table->tb_blockOffset,
	    oldAddrDiffBuf, oldAddrDiffLength);
	table->tb_blockOffset += oldAddrDiffLength;
	strncpy(table->tb_blockTail->bk_data + table->tb_blockOffset,
	    rangeDiffBuf, rangeDiffLength);
	table->tb_blockOffset += rangeDiffLength;

	table->tb_header.hd_numEntries++;
	table->tb_blockTail->bk_numEntries++;
    }

    table->tb_prevNewAddr = newAddress + newRange - 4;
    table->tb_prevOldAddr = oldAddress + oldRange - 4;
    return TB_STATUS_NO_ERROR;
}


/*
    This routine returns the information needed by
    the user to obtain the main table.  It returns
    the number of bytes needed for the complete main
    table, the number of blocks the user needs to get.

    This routine also sets the first and last, new
    and old addresses in the header.
*/
Elf32_Sword
xlate_pro_disk_header (
    Xlate_Table_Pro	table,
    Elf32_Sword		*totalMemoryReq,
    Elf32_Sword		*numBlocks
)
{
    Header_s		*header;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

    if (table->tb_memoryReqRet) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_ALREADY_DONE;
    }
    table->tb_memoryReqRet = TRUE;

    header = &table->tb_header;

    if (table->tb_blockHead == NULL) {
	header->hd_newAddrLow = 0;
	header->hd_newAddrHigh = 0;
	header->hd_oldAddrLow = 0;
	header->hd_oldAddrHigh = 0;
    }
    else {
	if (header->hd_tableKind == TK_preserve_order) {
     	    header->hd_oldAddrLow = table->tb_blockHead->bk_firstOldAddr;
    	    header->hd_oldAddrHigh = table->tb_prevOldAddr;
        }

    	header->hd_newAddrLow = table->tb_blockHead->bk_firstNewAddr;
	header->hd_newAddrHigh = table->tb_prevNewAddr;
    }

    if (!table->tb_putDebug) 
	header->hd_regInfoSize = table->tb_regInfoOffset;

    *totalMemoryReq = sizeof(Header_s) + header->hd_regInfoSize +
        (header->hd_numBlocks * (sizeof(BlockHeader_s) + header->hd_blockSize));
    *numBlocks = header->hd_numBlocks + (header->hd_regInfoSize == 0 ? 1 : 2);
    return TB_STATUS_NO_ERROR;
}


/*
    This routine is the same as xlate_pro_disk_header()
    except that it returns the debugging table.  It
    also returns an error if tb_makeDebug is not set for
    the table.
*/
Elf32_Sword
xlate_pro_disk_header_debug (
    Xlate_Table_Pro	table,
    Elf32_Sword		*totalMemoryReq,
    Elf32_Sword		*numBlocks
)
{
    Header_s		*header;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

    if (!table->tb_makeDebug) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_NO_DEBUG;
    }

    if (table->tb_memoryReqRetDebug) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_ALREADY_DONE;
    }
    table->tb_memoryReqRetDebug = TRUE;

    header = &table->tb_headerDebug;

    if (table->tb_blockHeadDebug == NULL) {
	header->hd_newAddrLow = 0;
	header->hd_newAddrHigh = 0;
	header->hd_oldAddrLow = 0;
	header->hd_oldAddrHigh = 0;
    }
    else if (table->tb_putDebug) {
	table->tb_errorLine = __LINE__;
	return TB_STATUS_NOT_YET_IMPLEMENT;
    }
    else {
	if (header->hd_tableKind == TK_preserve_order) {
     	    header->hd_oldAddrLow = table->tb_blockHeadDebug->bk_firstOldAddr;
    	    header->hd_oldAddrHigh = table->tb_prevOldAddr;
        }

    	header->hd_newAddrLow = table->tb_blockHeadDebug->bk_firstNewAddr;
	header->hd_newAddrHigh = table->tb_prevNewAddr;
    }

    if (table->tb_putDebug)
	header->hd_regInfoSize = table->tb_regInfoOffset;

    *totalMemoryReq = sizeof(Header_s) + header->hd_regInfoSize +
	(header->hd_numBlocks * (sizeof(BlockHeader_s) + header->hd_blockSize));
    *numBlocks = header->hd_numBlocks + (header->hd_regInfoSize == 0 ? 1 : 2);
    return TB_STATUS_NO_ERROR;
}


/*
    This routine returns the blocks of data comprising
    the disk representation of the main table sequentially.
    On the first call, it returns a copy of the header,
    and thereafter the data blocks.
*/
Elf32_Sword
xlate_pro_disk_next_block (
    Xlate_Table_Pro	table,
    void		**data,
    Elf32_Sword		*dataSize
)
{
    Header_s		*headerRet;
    Header_s		*header;
    BlockHeader_s	*blockHeader;
    Block_s		*blockRet;
    Block_s		*block;
    Elf32_Sword		i;
    Elf32_Sword		headerSize;
    char		*regInfo;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

    if (!table->tb_headerRet) {
	table->tb_headerRet = TRUE;

    	header = &table->tb_header;
	headerSize = sizeof(Header_s) + 
	    header->hd_numBlocks * sizeof(BlockHeader_s);
	headerRet = (Header_s *)malloc(headerSize);
	CHECKALLOC(headerRet, table, __LINE__);
	memcpy(headerRet, header, sizeof(Header_s));

	block = table->tb_blockHead;
	blockHeader = (BlockHeader_s *)(headerRet + 1);
	for (i = 0; i < header->hd_numBlocks; i++) {
	    blockHeader->bh_firstNewAddr = block->bk_firstNewAddr;
	    blockHeader->bh_firstOldAddr = block->bk_firstOldAddr;
	    blockHeader->bh_numEntries = block->bk_numEntries;

	    block = block->bk_next;
	    blockHeader++;
	}

	*data = headerRet;
	*dataSize = headerSize;
	return TB_STATUS_NO_ERROR;
    }

    blockRet = (table->tb_blockRet == NULL) ? 
	table->tb_blockHead : table->tb_blockRet->bk_next;
    if (blockRet == NULL) {

	    /* Return the Register Info Block at the very end. */
	if (!table->tb_putDebug && table->tb_regInfo != NULL) {
	    regInfo = malloc(table->tb_regInfoOffset);
	    CHECKALLOC(regInfo, table, __LINE__);
	    memcpy(regInfo, table->tb_regInfo, table->tb_regInfoOffset);

	    *data = regInfo;
	    *dataSize = table->tb_regInfoOffset;

	    free(table->tb_regInfo);
	    table->tb_regInfo = NULL;
	    table->tb_regInfoOffset = 0;
	    table->tb_regInfoSize = 0;

	    return TB_STATUS_NO_ERROR;
	}

    	table->tb_errorLine = __LINE__;
    	return TB_STATUS_NO_MORE_BLOCKS;
    }
    table->tb_blockRet = blockRet;

    *data = blockRet->bk_data;
    *dataSize = table->tb_header.hd_blockSize;
    return TB_STATUS_NO_ERROR;
}


/*
    This routine is identical to xlate_pro_disk_next_block()
    except that it is for the debugging table.
*/
Elf32_Sword
xlate_pro_disk_next_block_debug (
    Xlate_Table_Pro	table,
    void		**data,
    Elf32_Sword		*dataSize
)
{
    Header_s		*headerRet;
    Header_s		*header;
    BlockHeader_s	*blockHeader;
    Block_s		*blockRet;
    Block_s		*block;
    Elf32_Sword		i;
    Elf32_Sword		headerSize;
    char		*regInfo;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

    if (!table->tb_headerRetDebug) {
	table->tb_headerRetDebug = TRUE;

    	header = &table->tb_headerDebug;
	headerSize = sizeof(Header_s) +
	    header->hd_numBlocks * sizeof(BlockHeader_s);
	headerRet = (Header_s *)malloc(headerSize);
	CHECKALLOC(headerRet, table, __LINE__);
	memcpy(headerRet, header, sizeof(Header_s));

	block = table->tb_blockHeadDebug;
	blockHeader = (BlockHeader_s *)(headerRet + 1);
	for (i = 0; i < header->hd_numBlocks; i++) {
	    blockHeader->bh_firstNewAddr = block->bk_firstNewAddr;
	    blockHeader->bh_firstOldAddr = block->bk_firstOldAddr;
	    blockHeader->bh_numEntries = block->bk_numEntries;

	    block = block->bk_next;
	    blockHeader++;
	}

	*data = headerRet;
	*dataSize = headerSize;
	return TB_STATUS_NO_ERROR;
    }

    blockRet = (table->tb_blockRetDebug == NULL) ? 
	table->tb_blockHeadDebug : table->tb_blockRetDebug->bk_next;
    if (blockRet == NULL) {

	    /* Return the Register Info Block at the very end. */
	if (table->tb_putDebug && table->tb_regInfo != NULL) {
	    regInfo = malloc(table->tb_regInfoOffset);
	    CHECKALLOC(regInfo, table, __LINE__);
	    memcpy(regInfo, table->tb_regInfo, table->tb_regInfoOffset);

	    *data = regInfo;
	    *dataSize = table->tb_regInfoOffset;

	    free(table->tb_regInfo);
	    table->tb_regInfo = NULL;
	    table->tb_regInfoOffset = 0;
	    table->tb_regInfoSize = 0;

	    return TB_STATUS_NO_ERROR;
	}

    	table->tb_errorLine = __LINE__;
    	return TB_STATUS_NO_MORE_BLOCKS;
    }
    table->tb_blockRetDebug = blockRet;

    *data = blockRet->bk_data;
    *dataSize = table->tb_headerDebug.hd_blockSize;
    return TB_STATUS_NO_ERROR;
}


/*
    This routine deallocates all the memory that has not
    been given back to the user, and deallocates the
    handle.  table is invalid after this call.
*/
Elf32_Sword
xlate_pro_finish (
    Xlate_Table_Pro	table
)
{
    Block_s	*block;
    Block_s	*thisBlock;

    if (table == NULL) {
	return TB_STATUS_NULL_TABLE;
    }

    block = (table->tb_blockRet == NULL) ? 
	table->tb_blockHead : table->tb_blockRet->bk_next;
    while (block != NULL) {
    	free(block->bk_data);
    	thisBlock = block;
    	block = block->bk_next;
    	free(thisBlock);
    }

    block = (table->tb_blockRetDebug == NULL) ?
	table->tb_blockHeadDebug : table->tb_blockRetDebug->bk_next;
    while (block != NULL) {
	free(block->bk_data);
	thisBlock = block;
	block = block->bk_next;
	free(thisBlock);
    }

    if (table->tb_regInfo != NULL)
	free(table->tb_regInfo);
    free(table);
    return TB_STATUS_NO_ERROR;
}