/*

	EVENTS.C

	Utility routines for reading events sections.

*/

#include <elf_abi.h>
#include <elf_mips.h>
#include <sys/types.h>
#include <sys/syssgi.h>
#include "leb128.h"
#include "events.h"

		/*
		 * just return 0 until we write the 
		 * routine to return the raw compressed
		 * number.
		 */
#define	event_raw_leb(_ptr, _len) 0


	/*******************************************************
		Function: event_get_word64

		Put the next 8 bytes of data into an unsigned
		64 bit double word. This only works for big endian.

	 *******************************************************/
__uint64_t
event_get_word64(char *p)
{
__uint64_t i;
union {
    __uint64_t u;
    char a[8];
}x;

    for (i = 0; i < 8; i++)
	x.a[i] = p[i];
	
    return(x.u);
}


	/*******************************************************
		Function: event_get_word32

		Put the next 4 bytes of data into an unsigned
		32 bit word. This only works for big endian.

	 *******************************************************/
__uint32_t
event_get_word32(char *p)
{
__uint32_t i;
union {
    __uint32_t u;
    char a[4];
}x;

    for (i = 0; i<4; i++)
	x.a[i] = p[i];
	
    return(x.u);
}

	/*******************************************************
		Function: event_get_word16

		Put the next 2 bytes of data into an unsigned
		16 bit word. This only works for big endian.

	 *******************************************************/
unsigned short
event_get_word16(char *p)
{
__uint32_t i;
union {
    unsigned short u;
    char a[2];
}x;

    for (i = 0; i<2; i++)
	x.a[i] = p[i];
	
    return(x.u);
}

	/*******************************************************
		Function: event_get_next_rec

		Get information from the events section record
		pointed to by p_event and return a pointer to the
		next record.

	 *******************************************************/
char *
event_get_next_rec(
	char *p_event,		    /* pointer into section */
	__uint32_t offset,		    /* current offset into text section */
	Full_Events *p_full) /* information from record */
{
int temp_offset;     /* used for EK_FCALL_LOCAL */
unsigned char type, ubyte;
unsigned short ushort;
short sshort;
__uint32_t uword;
__int32_t incr;
char *p_last;

    p_full->fevnt_arg1 = 0;
    p_full->fevnt_arg2 = 0;
    p_full->fevnt_arg3 = 0;
    p_full->fevnt_pre_arg1 = 0;
    p_full->fevnt_pre_arg2 = 0;
    p_full->fevnt_pre_arg3 = 0;

    type = *p_event++;
    
		/*
		 * Increment the current offset by the lower 7 bits
		 * of the first byte multiplied by 4.
		 */
    if (type & EK_INCR_LOC) {
	p_full->fevnt_pre_arg1 = (type & 0x7f);
	p_full->fevnt_arg1 = (type & 0x7f) << 2;
	offset += (type & 0x7f) << 2;
	p_full->fevnt_type = EK_INCR_LOC;
	p_full->fevnt_offset = offset;
	return (p_event);
    }

    p_last = p_event;
    
    switch((int)type) {

		/*
		 * Resets the offset. The first argument is
		 * a 32 bit offset from the beginning of the
		 * text section this events section is representing.
		 * The second argument is a 16 bit offset to where
		 * the next EK_ADDR_RESET record is.
		 */
	case EK_ADDR_RESET:

	    offset = event_get_word32(p_event);
	    p_full->fevnt_arg1 = offset;
	    p_full->fevnt_pre_arg1 = offset;
	    p_event += 4;

	    ushort = event_get_word16(p_event);
	    p_full->fevnt_arg2 = ushort;
	    p_full->fevnt_pre_arg2 = ushort;
	    p_event += 2;
	    break;

		/*
		 * Increment the current offset. The increment is
		 * an unsigned LEB128 value and is multiplied by 4
		 * after decompression.
		 */
	case EK_INCR_LOC_EXT:

	    p_event = uncompress_u4(p_event, &uword);
	    p_full->fevnt_arg1 = uword<<2;
	    offset += uword<<2;
	    p_full->fevnt_pre_arg1 = event_raw_leb(p_last, p_event-p_last);
	    break;

		/*
		 * Increment the current offset. The increment is
		 * an unsigned LEB128 value.
		 */
	case EK_INCR_LOC_UNALIGNED: 
	    p_event = uncompress_u4(p_event, &uword);
	    p_full->fevnt_arg1 = uword;
	    offset += uword;
	    p_full->fevnt_pre_arg1 = event_raw_leb(p_last, p_event-p_last);
	    break;


		/*
		 * 16 bit argument is the lower half of the
		 * displacement from gp for a 2 part gp prolog.
		 */
	case EK_GP_PROLOG_HI:	/* fall through */

		/*
		 * 16 bit argument is the upper half of the
		 * displacement from gp for a 2 part gp prolog.
		 */
	case EK_GP_PROLOG_LO:	/* fall through */

		/*
		 * 16 bit argument is the offset from the
		 * base page for a 2 part gp page + offset.
		 */
	case EK_GOT_PAGE:   /* fall through */

		/*
		 * 16 bit argument is the displacement from the
		 * gp for a got page entry for a 2 part gp page + offset.
		 */
	case EK_GOT_OFST:

		/*
		 * 16 bit argument is the LO part of the 32bit address.
		 */
	case EK_HI:	/* fall through */

		/*
		 * 16 bit argument is the HI part of the 32bit address.
		 */
	case EK_LO:	/* fall through */

#if 0
	case EK_CK_UNUSED_16BIT_0:
	case EK_CK_UNUSED_16BIT_1:
	case EK_CK_UNUSED_16BIT_2:
	case EK_CK_UNUSED_16BIT_3:
	case EK_CK_UNUSED_16BIT_4:
#endif

	    sshort = (short)event_get_word16(p_event);
	    p_full->fevnt_arg1 = sshort;
	    p_full->fevnt_pre_arg1 = sshort;
	    p_event += 2;
	    break;

		/*
		 * For each of the following 4 cases, the argument is 
		 * the full 64bit address.
		 */
	case EK_64_HIGHEST:
	case EK_64_HIGHER:
	case EK_64_HIGH:
	case EK_64_LOW:
#if 0
	case EK_CK_UNUSED_64BIT_0:
	case EK_CK_UNUSED_64BIT_1:
	case EK_CK_UNUSED_64BIT_2:
	case EK_CK_UNUSED_64BIT_3:
	case EK_CK_UNUSED_64BIT_4:
#endif

	    p_full->fevnt_arg1 = event_get_word64(p_event);
	    p_full->fevnt_pre_arg1 = p_full->fevnt_arg1;
	    p_event += 8;
	    break;

		/* 
		 * argument1 - 1 byte flag
		 * argument2 - 32bit address
		 * argument2 - ULEB128 value
		 */
	case EK_SWITCH_32:
	    p_full->fevnt_arg1 = *p_event++;
	    p_full->fevnt_arg2 = event_get_word32 (p_event);
	    p_event += 4;
	    p_event = uncompress_u4 (p_event, &uword);
	    p_full->fevnt_arg3 = uword;
	    break;

		/* 
		 * argument1 - 1 byte flag
		 * argument2 - 64bit address
		 * argument2 - ULEB128 value
		 */
	case EK_SWITCH_64:
	    p_full->fevnt_arg1 = *p_event++;
	    p_full->fevnt_arg2 = event_get_word64 (p_event);
	    p_event += 8;
	    p_event = uncompress_u4 (p_event, &uword);
	    p_full->fevnt_arg3 = uword;
	    break;

		/*
		 * Specifies the alignment for the current location.
		 * The length is an unsigned LEB128 value.
		 * The alignment is a one byte field with a number in the
		 * range of 0 to 63.
		 */
	case CK_ALIGN:
	    p_event = uncompress_u4(p_event, &uword);
	    p_full->fevnt_arg1 = uword;
	    p_full->fevnt_pre_arg1 = event_raw_leb(p_last, p_event-p_last);
	    ubyte = *p_event++;
	    p_full->fevnt_arg2 = ubyte;
	    break;

	case CK_DEFAULT:	/* Default dat type for section. */
	    ubyte = *p_event++;
	    p_full->fevnt_arg2 = ubyte;
	    break;

	case CK_INSTR:		/* Executable instructions. */
	case CK_DATA:		/* Non-address data. */
	case CK_SADDR_32:	/* Simple 32-bit address data. */
	case CK_GADDR_32:	/* GP-relative 32-bit address data. */
	case CK_CADDR_32:	/* Complex 32-bit address data. */
	case CK_SADDR_64:	/* Simple 64-bit address data. */
	case CK_GADDR_64:	/* relative 64-bit address data. */
	case CK_CADDR_64:	/* Complex 64-bit address data. */
	case CK_NO_XFORM:	/* No transformations of instructions allowed. */
	case CK_NO_REORDER:	/* No reordering of instructions allowed. */
	case EK_FCALL_MULT:
	case EK_FCALL_MULT_PARTIAL:
#if 0
	case EK_CK_UNUSED_ULEB128_0:
	case EK_CK_UNUSED_ULEB128_1:
	case EK_CK_UNUSED_ULEB128_2:
	case EK_CK_UNUSED_ULEB128_3:
	case EK_CK_UNUSED_ULEB128_4:
	case EK_CK_UNUSED_ULEB128_5:
	case EK_CK_UNUSED_ULEB128_6:
	case EK_CK_UNUSED_ULEB128_7:
	case EK_CK_UNUSED_ULEB128_8:
	case EK_CK_UNUSED_ULEB128_9:
#endif
	    p_event = uncompress_u4(p_event, &uword);
	    p_full->fevnt_arg1 = uword;
	    p_full->fevnt_pre_arg1 = event_raw_leb(p_last, p_event-p_last);
	    break;

	case EK_BB_START: /* hard to find basic block start */
	case EK_NULL:	/* padding record */
	case EK_ENTRY:	/* Marks an entry point into the subprogram. */
	case EK_EXIT:	/* Marks final exit points of a subprogram. */
	case EK_PEND:	/* Marks the last instruction of a subprogram. */
	case EK_GPREL:  /* Marks a GP-relative reference. */
#if 0
	case EK_CK_UNUSED_NONE_0:
	case EK_CK_UNUSED_NONE_1:
	case EK_CK_UNUSED_NONE_2:
	case EK_CK_UNUSED_NONE_3:
	case EK_CK_UNUSED_NONE_4:
#endif
	    break;

		/*
		 * argument1 - 4 byte unsigned
		 */
	case EK_IF_ENTRY:
	case EK_FCALL_LOCAL:

#if 0
	case EK_CK_UNUSED_32BIT_0:
	case EK_CK_UNUSED_32BIT_1:
	case EK_CK_UNUSED_32BIT_2:
#endif

	    temp_offset = event_get_word32(p_event);
	    p_full->fevnt_arg1 = temp_offset;
	    p_full->fevnt_pre_arg1 = temp_offset;
	    p_event += 4;
	    break;

	case EK_FCALL_EXTERN_BIG:
	    ushort = event_get_word16(p_event);
	    p_full->fevnt_arg1 = ushort;
	    p_full->fevnt_pre_arg1 = ushort;
	    p_event += 2;
	    ushort = event_get_word16(p_event);
	    p_full->fevnt_arg2 = ushort;
	    p_full->fevnt_pre_arg2 = ushort;
	    p_event += 2;
	    break;

		/*
		 * argument1 - 2 byte unsigned
		 */
	case EK_FCALL_EXTERN:
	    ushort = event_get_word16(p_event);
	    p_full->fevnt_arg1 = ushort;
	    p_full->fevnt_pre_arg1 = ushort;
	    p_event += 2;
	    break;

	default:
	    /* TODO: Print an error message here. */
	    break;
    }

    p_full->fevnt_offset = offset;
    p_full->fevnt_type = type;

    return(p_event);
}

	/*******************************************************
		Function: event_find_record

		starting at the given point in the section 
		pointed to by p_event, find the next events
		section record of the given type. 

		It is assumed that the current offset comming 
		into this routine will be stored in p_full.
		
		Returns EK_NULL if type not found.

	 *******************************************************/
__uint32_t 
event_find_record(
	char *p_event,		    /* pointer into the events section */
	Full_Events *p_full,	    /* structure for events record info */
	__uint32_t type, 	    /* event section type */
	char *p_end)		    /* end of the current events section */
{

    while (p_event < p_end) {
	p_event = event_get_next_rec(p_event, p_full->fevnt_offset, p_full);
	if (p_full->fevnt_type == type)
	    return((__uint32_t)type);
	 
    }
    
    return (EK_NULL);
}