/* This file has been modified by Data General Corporation, November 1989. */

/*
This file provides an abstract interface to "tdesc" information.
      It is designed to be used in a uniform manner by several kinds
      of debuggers:
         (1) code in live debugged process (e.g., a traceback routine)
         (2) a separate-process debugger debugging a live process
         (3) a separate-process debugger debugging a memory dump

      Dcontext model notes
         * captures machine context
            * partial: excludes memory
         * frames
            * kinds
         * make one for starters, chain in reverse order to previous ones
         * representation: pointer to opaque
            * alloc/free protocol

      Overall model
         * access functions
         * handle
         * error handling
*/



typedef int dc_boolean_t;   /* range 0 .. 1 */
#define DC_FALSE 0
#define DC_TRUE 1


typedef int dc_tristate_t;  /* range 0 .. 2 */
#define DC_NO 0
#define DC_YES 1
#define DC_MAYBE 2


/*
   A word is 32 bits of information.  In memory, a word is word-aligned.

   A common and important use of dc_word_t is to represent values in the
   target process, including (byte) addresses in the target process.
   In this case, C arithmetic can be used to simulate machine address
   arithmetic on the target.  (Unsigned arithmetic is actually modulus
   arithmetic.)
*/
typedef unsigned int dc_word_t;


/* These bit operations number bits from 0 at the least significant end. */
#define bit_test(word,bit) ((word) & (1 << (bit)))    /* returns 0 or other */
#define bit_value(word,bit) (((word) >> (bit)) & 1)   /* returns 0 or 1 */
#define bit_set(word,bit) ((word) |= (1 << (bit)))
#define bit_clear(word,bit) ((word) &= ~(1 << (bit)))
#define bit_assign(word, bit, bool) \
   if (bool) bit_set(word, bit); else bit_clear(word, bit)


/*----------------*/


/* The exactness of locations may not be certainly known. */
typedef dc_tristate_t dc_exactness_t;


/*
   The model includes five kinds of contexts.  Because each context
   has an associated region and frame, these describe region kinds
   and frame kinds as well.
   [more description needed]
   Currently, only call contexts exist.
*/

typedef int dc_kind_t;   /* range 0 .. 4 */
#define DC_CALL_KIND          0
#define DC_SAVE_KIND          1
#define DC_EXCEPTION_KIND     2
#define DC_PROTECTION_KIND    3
#define DC_SPECIAL_KIND       4
#define DC_NUM_KINDS          5

#define DC_MIO_ENTRY_POINT            (1<< 0)
#define DC_MIO_PROLOGUE_END           (1<< 1)
#define DC_MIO_EPILOGUE_START         (1<< 2)
#define DC_MIO_IMPLICIT_PROLOGUE_END  (1<<16)
#define DC_MIO_LITERAL_ENTRY_POINT    (1<<17)
#define DC_MIO_LITERAL_EPILOGUE_START (1<<18)

#define DC_MII_PRECEDING_TDESC_END   (1<<0)
#define DC_MII_FOLLOWING_TDESC_START (1<<1)

typedef struct dc_debug_info {
   unsigned int         protocol;            /* 1 for this structure */
   dc_word_t               tdesc_ptr;
   unsigned int         text_words_count;
   dc_word_t               text_words_ptr;
   unsigned int         data_words_count;
   dc_word_t               data_words_ptr;
} dc_debug_info_t;


typedef struct tdesc_hdr {
   unsigned int         map_protocol;        /* 1 for this structure */
   unsigned int         end;                 /* address beyond end */
} tdesc_hdr_t;


typedef struct tdesc_chunk_hdr {
   int                  zeroes : 8;
   int                  info_length : 22;
   int                  info_alignment : 2;
   unsigned int         info_protocol;
   dc_word_t               start_address;
   dc_word_t               end_address;
} tdesc_chunk_hdr_t;


typedef struct tdesc_chunk_info1 {
   int                  variant : 8;         /* 1 for this structure */
   int                  register_save_mask : 17;
   int                  pad1 : 1;
   int                  return_address_info_discriminant : 1;
   int                  frame_address_register : 5;
   unsigned int         frame_address_offset;
   unsigned int         return_address_info;
   unsigned int         register_save_offset;
} tdesc_chunk_info1_t;


typedef struct tdesc_chunk1 {
   tdesc_chunk_hdr_t    hdr;
   tdesc_chunk_info1_t  info;
} tdesc_chunk1_t;


typedef struct dc_mstate {
   dc_word_t reg[32];                      /* general registers */
   dc_word_t xip;
   dc_word_t nip;
   dc_word_t fip;
   dc_word_t fpsr;
   dc_word_t fpcr;
   dc_word_t psr;
} dc_mstate_t;


typedef struct dc_map_info_in {
   dc_word_t flags;
   dc_word_t preceding_tdesc_end;
   dc_word_t following_tdesc_start;
} dc_map_info_in_t;


typedef struct dc_map_info_out {
   dc_word_t flags;
   dc_word_t entry_point;
   dc_word_t prologue_end;
   dc_word_t epilogue_start;
} dc_map_info_out_t;


#if 0

   void error_fcn (env, continuable, message)
      dc_word_t env;                       /* environment (arbitrary datum) */
      dc_boolean_t continuable;            /* whether error function may return */
      char *message;                    /* string (no trailing newline) */

   /* In the future, we probably want the error_fcn to be: */
   void error_fcn (env, continuable, code, ...)
      dc_word_t env;                       /* environment (arbitrary datum) */
      dc_boolean_t continuable;            /* whether error function may return */
      int code;                         /* error code */
      ...                               /* parameters to message associated
                                           with the code */

   void read_fcn (env, memory, length, buffer)
      dc_word_t env;                       /* environment (arbitrary datum) */
      dc_word_t memory;                    /* start address in image */
      int length;                       /* in bytes */
      char *buffer;                     /* start address of buffer */
      /* There are no alignment assumptions for the read function. */

   void write_fcn (env, memory, length, buffer)
      dc_word_t env;                       /* environment (arbitrary datum) */
      dc_word_t memory;                    /* start address in image */
      int length;                       /* in bytes */
      char *buffer;                     /* start address of buffer */
      /* There are no alignment assumptions for the write function. */
      /* The write function is optional.  It must be provided if changes
         to writable registers are to be made. */

   void exec_fcn (env, mstate)
      dc_word_t env;                       /* environment (arbitrary datum) */
      dc_mstate_t *mstate;              /* machine state (read-write) */
      /* The execute function is optional.  It would be used (in the future)
         by the implementation of a procedurally specified tdesc mechanism. */

#endif

/*----------------*/


#ifndef NULL
#define NULL ((void *) 0)
#endif

extern char *malloc();
extern char *calloc();
extern void qsort();


/*
   At initialization, create a tdesc table from the tdesc info.
   A tdesc table is simply a sorted array of tdesc elements.
   A tdesc element is the last 6 words of the tdesc chunk.
   We require that all tdesc chunks have info protocol 1.
*/

typedef struct tdesc_elem {
   dc_word_t start_address;
   dc_word_t end_address;
   tdesc_chunk_info1_t info;
} tdesc_elem_t;

typedef tdesc_elem_t *tdesc_table_t;

void dc_correct_cr_data();

int dc_compare_tdesc_elems (elem1, elem2)
   char *elem1, *elem2;
{
   dc_word_t s1, s2, e1, e2;
   s1 = ((tdesc_elem_t *) elem1)->start_address;
   s2 = ((tdesc_elem_t *) elem2)->start_address;
   if (s1 < s2) return -1;
   if (s1 > s2) return  1;
   e1 = ((tdesc_elem_t *) elem1)->end_address;
   e2 = ((tdesc_elem_t *) elem2)->end_address;
   if (e1 < e2) return -1;
   if (e1 > e2) return  1;
   return 0;
}


typedef struct handle_info {
   dc_word_t debug_info_ptr;
   void (*error_fcn)();
   dc_word_t error_env;
   void (*read_fcn)();
   dc_word_t read_env;
   void (*write_fcn)();                 /* NULL => absent */
   dc_word_t write_env;
   void (*exec_fcn)();                  /* NULL => absent */
   dc_word_t exec_env;
   void (*map_fcn)();                  /* NULL => absent */
   dc_word_t map_env;
   tdesc_table_t tdesc_table;
   int tdesc_table_size;
} handle_info_t;

typedef handle_info_t *dc_handle_t;


/*
   Errors detected in this module are funnelled through dc_error or dc_warn,
   as appropriate.  Both routines call dc_exception, which invokes the error
   handler supplied by the user.

   Currently, dc_exception substitutes parameters into the message given
   it and passes the resulting string to the user error handler.
   In the future, dc_exception should simply pass an error code and
   the parameters on to the user error handler.
*/

#include <varargs.h>
extern int vsprintf();

/* Exit status for exception-processing machinery failure */
#define DC_EXCEPTION_FAILURE    250

void dc_exception(continuable, args)
   dc_boolean_t continuable;
   va_list args;
{
   dc_handle_t handle;
   char *format;
   char buffer[1024];

   handle = va_arg(args, dc_handle_t);
   format = va_arg(args, char *);
   (void) vsprintf(buffer, format, args);
   (*(handle->error_fcn)) (handle->error_env, continuable, buffer);
   if (!continuable)
      exit(DC_EXCEPTION_FAILURE);  /* User error handler should never return in this case. */
}


void dc_error(va_alist)  /* (handle, format, args... ) */
   va_dcl
{
   va_list args;

   va_start(args);
   dc_exception(DC_FALSE, args);
   va_end(args);
}


void dc_warn(va_alist)  /* (handle, format, args... ) */
   va_dcl
{
   va_list args;

   va_start(args);
   dc_exception(DC_TRUE, args);
   va_end(args);
}



#define MALLOC_FAILURE_MESSAGE "Heap space exhausted (malloc failed)."
#define CALLOC_FAILURE_MESSAGE "Heap space exhausted (Calloc failed)."


/* Commonize memory allocation call so failure diagnosis is easier */

char* dc_malloc( handle, size )
    dc_handle_t handle;
    int         size;
{
    char* space = malloc( size );
    if (space == (char *)NULL)
        dc_error( handle, MALLOC_FAILURE_MESSAGE );

    return space;
}


/* Commonize memory allocation call so failure diagnosis is easier */

char* dc_calloc( handle,nelem, size )
    dc_handle_t handle;
    int         nelem;
    int		size;
{
    char* space = calloc( nelem, size );
    if (space == (char *)NULL)
        dc_error( handle, CALLOC_FAILURE_MESSAGE );

    return space;
}


dc_word_t dc_read_word (handle, address)
   dc_handle_t handle;
   dc_word_t address;
{
   dc_word_t word;
   (*(handle->read_fcn)) (handle->read_env, address,
                          sizeof(dc_word_t), (char *)(&(word)));
   return word;
}


void dc_write_word (handle, address, value)
   dc_handle_t handle;
   dc_word_t address;
   dc_word_t value;
{
   dc_word_t word;
   word = value;
   if (handle->write_fcn) {
      (*(handle->write_fcn)) (handle->write_env, address,
                              sizeof(dc_word_t), (char *)(&(word)));
   } else {
      dc_error (handle, "Writing is disabled.");
   }
}


void dc_write_masked_word (handle, address, mask, value)
   dc_handle_t handle;
   dc_word_t address;
   dc_word_t mask;
   dc_word_t value;
{
   dc_write_word (handle, address,
      (value & mask) | (dc_read_word(handle, address) & ~mask));
}


dc_handle_t dc_initiate (debug_info_ptr,
			 error_fcn, error_env,
                         read_fcn, read_env,
                         write_fcn, write_env,
                         exec_fcn, exec_env,
                         map_fcn, map_env)
   dc_word_t debug_info_ptr;
   void (*error_fcn)();
   dc_word_t error_env;
   void (*read_fcn)();
   dc_word_t read_env;
   void (*write_fcn)();                 /* NULL => absent */
   dc_word_t write_env;
   void (*exec_fcn)();                  /* NULL => absent */
   dc_word_t exec_env;
   void (*map_fcn)();                  /* NULL => absent */
   dc_word_t map_env;
   /* write_fcn may be given as NULL if no writing is required. */
   /* exec_fcn may be given as NULL if no execution is required.
      Currently, no execution is required.  It would be if the
      implementation needed to invoke procedures in the debugged process. */
{
   dc_handle_t handle;
   unsigned int debug_info_protocol;
   dc_debug_info_t debug_info;
   unsigned int tdesc_map_protocol;
   tdesc_hdr_t tdesc_hdr;
   dc_word_t tdesc_info_start;
   dc_word_t tdesc_info_end;
   dc_word_t tdesc_info_length;

   /* Set up handle enough for dc_error. */
   handle = (dc_handle_t) malloc(sizeof(handle_info_t));
   /* Cant use dc_malloc() as handle is being created ... */
   /* if (handle == NULL) (*error_fcn)( error_env, MALLOC_FAILURE_MESSAGE ) */
   handle->error_fcn = error_fcn;
   handle->error_env = error_env;
   handle->read_fcn = read_fcn;
   handle->read_env = read_env;
   handle->write_fcn = write_fcn;
   handle->write_env = write_env;
   handle->exec_fcn = exec_fcn;
   handle->exec_env = exec_env;
/****************************************************************/
/* BUG 9/19/89 Found by hls.  Map functions not initialized.    */
/****************************************************************/
   handle->map_fcn = map_fcn;
   handle->map_env = map_env;
   handle->debug_info_ptr = debug_info_ptr;
   handle->tdesc_table = (tdesc_table_t)NULL;

   /* Find tdesc info. */
   if (debug_info_ptr) {
      (*read_fcn) (read_env, debug_info_ptr, sizeof(unsigned int),
		   (char *)(&debug_info_protocol));
      if (debug_info_protocol != 1)
	 dc_error (handle, "Unrecognized debug info protocol: %d",
		   debug_info_protocol);
      (*read_fcn) (read_env, debug_info_ptr, sizeof(dc_debug_info_t),
		   (char *)(&debug_info));
      (*read_fcn) (read_env, debug_info.tdesc_ptr, sizeof(unsigned int),
		   (char *)(&tdesc_map_protocol));
      if (tdesc_map_protocol != 1)
	 dc_error (handle, "Unrecognized tdesc map protocol: %d",
		   tdesc_map_protocol);
      (*read_fcn) (read_env, debug_info.tdesc_ptr, sizeof(tdesc_hdr_t),
		   (char *)(&tdesc_hdr));
      tdesc_info_start = debug_info.tdesc_ptr + sizeof(tdesc_hdr_t);
      tdesc_info_end = tdesc_hdr.end;
      tdesc_info_length = tdesc_info_end - tdesc_info_start;

      /* Create tdesc table from tdesc info. */
      {
	 /* Over-allocate in order to avoid second pass over tdesc info. */
	 tdesc_table_t tt = (tdesc_table_t) dc_malloc(handle, tdesc_info_length);
	 dc_word_t p = tdesc_info_start;
	 dc_word_t q = tdesc_info_end - sizeof(tdesc_chunk1_t);
	 int n = 0;
	 tdesc_chunk1_t chunk;
	 dc_word_t start_address, end_address;
	 int i;

	 for (; p <= q; ) {
	    (*read_fcn) (read_env, p, sizeof(tdesc_chunk1_t), (char *)(&chunk));
	    if (chunk.hdr.zeroes != 0) {
	       /* Skip padding. */
	       p += sizeof(dc_word_t);
	       continue;
	    }
	    if (chunk.hdr.info_protocol != 1) {
	       dc_warn (handle, "Unrecognized tdesc info protocol: %d",
			 chunk.hdr.info_protocol);
	       goto next_chunk;
	    }
	    if (chunk.hdr.info_length != 16) {
	       dc_warn (handle, "Incorrect tdesc info length: %d",
			 chunk.hdr.info_length);
	       goto next_chunk;
	    }
	    if (chunk.hdr.info_alignment > 2) {
	       dc_warn (handle, "Incorrect tdesc info alignment: %d",
			 chunk.hdr.info_alignment);
	       goto next_chunk;
	    }
	    start_address = chunk.hdr.start_address;
	    end_address = chunk.hdr.end_address;
	    if ((start_address&3)!=0) {
	       dc_warn (handle,
		  "Tdesc start address is not word-aligned: %#.8X",
		  start_address);
	       goto next_chunk;
	    }
	    if ((end_address&3)!=0) {
	       dc_warn (handle,
		  "Tdesc end address is not word-aligned: %#.8X",
		  end_address);
	       goto next_chunk;
	    }
	    if (start_address > end_address) {
		     /* Note that the range may be null. */
	       dc_warn (handle,
		  "Tdesc start address (%#.8X) follows end address (%#.8X).",
		  start_address, end_address);
	       goto next_chunk;
	    }
	    if (chunk.info.variant != 1) {
	       dc_warn (handle, "Invalid tdesc chunk variant: %d",
		  chunk.info.variant);
	       goto next_chunk;
	    }
	    if (chunk.info.pad1 != 0) {
	       dc_warn (handle, "Tdesc chunk padding is not zero.");
	       goto next_chunk;
	    }
	    if (chunk.info.return_address_info_discriminant != 0) {
	       if ((chunk.info.return_address_info & 3) != 0) {
		  dc_warn (handle,
		     "Tdesc return address offset is not word-aligned: %#.8X",
		     chunk.info.return_address_info);
		  goto next_chunk;
	       }
	    } else {
	       if ((chunk.info.return_address_info & ~31) != 0) {
		  dc_warn (handle,
		     "Invalid tdesc return address register: %d",
		     chunk.info.return_address_info);
		  goto next_chunk;
	       }
	    }
	    if ((chunk.info.register_save_offset & 3) != 0) {
	       dc_warn (handle,
		  "Tdesc register save offset is not word-aligned: %#.8X",
		  chunk.info.register_save_offset);
	       goto next_chunk;
	    }

	    tt[n].start_address = start_address;
	    tt[n].end_address = end_address;
	    tt[n].info = chunk.info;
	    n++;

   next_chunk:
	    p += sizeof(tdesc_chunk1_t);
	 }
	 /* Leftover (less than a tdesc_chunk1_t in size) is padding or
	    in error.  Ignore it in either case. */

	 if (n != 0) {

		 /* Sort table by start address. */
		 qsort ((char *)tt, n, sizeof(tdesc_elem_t), dc_compare_tdesc_elems);

		 /* Check for overlap among tdesc chunks. */
		 for (i=0; i<(n-1); i++) {
		    if (tt[i].end_address > tt[i+1].start_address)
		       dc_error (handle, "Text chunks overlap.");
		 }
	 }

	 /* Finish setting up handle. */
	 handle->tdesc_table = tt;
	 handle->tdesc_table_size = n;
      }
   } else {
      handle->tdesc_table_size = 0;
   }

   return (dc_handle_t) handle;
}


void dc_terminate (handle)
   dc_handle_t handle;
{
   if (((dc_handle_t)handle)->tdesc_table) {
      free((char *)(((dc_handle_t)handle)->tdesc_table));
   }
   free((char *)handle);
}



/*

   Dcontext Model

   For each interesting register (word-sized piece of machine state),
   a word of value information is kept.  This word may
   be either the value of the register, or the address in
   subject memory where the value can be found (and changed).  In
   addition, the register may be invalid (in which case the value
   information is undefined).  These three cases are encoded for
   a given register in the same-numbered bit of two words of flags:

      flags[0] bit  flags[1] bit  meaning
      ------------  ------------  -------
            0             0       register is invalid; info is undefined
            0             1       register is readable; info is value
            1             0       register is writable; info is address
            1             1       (reserved)

   The general registers (r0-r31) are handled by reg_info and
   reg_flags.  The bit number for a register is that register's number.
   The other registers are grouped together for convenience and are
   handled by aux_info and aux_flags.  The bit numbers for these
   registers are:

      bit number     register
      ----------     --------
           0         location
           1         SXIP
           2         SNIP
           3         SFIP
           4         FPSR
           5         FPCR

   The SXIP, SNIP, and SFIP are the exception-time values of the
   XIP, NIP, and FIP registers.  They are valid only in the topmost frame.
   (That is, in any context obtained from dc_previous_context, they
   are invalid.)

   "location" is a pseudo-register of this model and represents the
   location of the context.  It is always valid.  It also has an
   exactness associated with it.  The location and its exactness of a
   context obtained from dc_previous_context are taken from the
   return address and its exactness of the context given as an argument
   to dc_previous_context.

   The following model is recommended for dealing with the partial
   redundancy between location and the SXIP, SNIP, and SFIP values
   in the topmost frame.  The location should be set to either the
   SNIP or SXIP value, and its exactness should be set to DC_NO.  A
   change to the register whose value the location is set to should
   be accompanied by an identical change to the location.

   The PSR is handled separately, because it is a diverse collection
   of flags.  The PSR, as a whole, is always valid.  A separate
   psr_ind flag tells whether the psr_info data is a value or
   an address.  Each bit of the PSR has its own pair of flag bits to
   mark validity and writability.

*/


/* The following value means "other", because state is stored in 2 bits. */
#define DC_RESERVED 3


#define RSTATE(flags, bit) \
   ((bit_value((flags)[0], bit) << 1) + bit_value((flags)[1], bit))

#define REG_STATE(dcontext, reg) RSTATE(dcontext->reg_flags, reg)
#define AUX_STATE(dcontext, reg) RSTATE(dcontext->aux_flags, reg)
#define PSR_STATE(dcontext, reg) RSTATE(dcontext->psr_flags, reg)


#define SET_INVALID(flags, bit) \
   { bit_clear ((flags)[0], bit); bit_clear ((flags)[1], bit); }

#define SET_READABLE(flags, bit) \
   { bit_clear ((flags)[0], bit); bit_set   ((flags)[1], bit); }

#define SET_WRITABLE(flags, bit) \
   { bit_set   ((flags)[0], bit); bit_clear ((flags)[1], bit); }

#define ASSIGN_RSTATE(to_flags, to_bit, from_flags, from_bit) \
   { bit_assign ((to_flags)[0], to_bit, bit_value((from_flags)[0], from_bit));\
     bit_assign ((to_flags)[1], to_bit, bit_value((from_flags)[1], from_bit));}


#define CHECK_REG_READ(dcontext, reg) \
   if (REG_STATE(dcontext, reg) == DC_INVALID) \
      dc_error (dcontext->handle, \
         "General register %d is not readable.", reg)

#define CHECK_REG_WRITE(dcontext, reg) \
   if (REG_STATE(dcontext, reg) != DC_WRITABLE) \
      dc_error (dcontext->handle, \
         "General register %d is not writable.", reg)

#define CHECK_AUX_READ(dcontext, reg) \
   if (AUX_STATE(dcontext, reg) == DC_INVALID) \
      dc_error (dcontext->handle, \
         "Auxiliary register %d is not readable.", reg)

#define CHECK_AUX_WRITE(dcontext, reg) \
   if (AUX_STATE(dcontext, reg) != DC_WRITABLE) \
      dc_error (dcontext->handle, \
         "Auxiliary register %d is not writable.", reg)



#define DC_REG_RA   1
#define DC_REG_FP  30
#define DC_REG_SP  31
#define DC_NUM_REG 32

#define DC_AUX_LOC  0
   /* DC_AUX_LOC must be first, with value 0 */
#define DC_AUX_SXIP 1
#define DC_AUX_SNIP 2
#define DC_AUX_SFIP 3
#define DC_AUX_FPSR 4
#define DC_AUX_FPCR 5
#define DC_NUM_AUX  6



#define CHECK_REG(dcontext, reg) \
   if ((reg < 0) || (reg >= DC_NUM_REG)) \
      dc_error (dcontext->handle, \
         "Bad general register number: %d", reg)

#define CHECK_AUX(dcontext, reg) \
   if ((reg < 1) || (reg >= DC_NUM_AUX)) \
      dc_error (dcontext->handle, \
         "Bad auxiliary register number: %d", reg)
   /* CHECK_AUX is not used for location pseudo-register. */

#define CHECK_BIT(dcontext, bit) \
   if ((bit < 0) || (bit >= 32)) \
      dc_error (dcontext->handle, \
         "Bad bit number: %d", bit)



typedef struct cr_value {
   int reg;
   unsigned int off;
 } dc_cr_value_t;

#define DC_UNDEF 32

/*
   A "dc_cr_value" represents an execution-time value symbolically, in
   terms of the initial value of a register (the value on entry to
   the procedure being analyzed) and a known offset.  A value with
   a 'reg' field value of 0 through 31 represents the value obtained
   by summing (using 32-bit modulus arithmetic) the initial value of
   register 'reg' and the value 'off'.  Note that the value (0,k)
   represents the constant value k, that (31,0) represents the CFA, and
   that (1,0) represents the return address.  A value with a 'reg' field
   of DC_UNDEF represents an indeterminable value; in this case the
   'off' field is undefined.  Other values of 'reg' are erroneous.
*/

typedef struct cr_data {
   dc_cr_value_t reg_val[DC_NUM_REG];
   dc_word_t saved;
   dc_word_t how;
   unsigned int where[DC_NUM_REG];
} dc_cr_data_t;

/*
   'cr_data' collects all the information needed to represent the
   symbolic machine state during code reading.

   The 'reg_val' array gives the current dc_cr_value for each register.
   
   The 'saved', 'how', and 'where' fields combine to describe what
   registers have been saved, and where.  The 'saved' and 'how' fields
   are implicitly bit arrays over 0..31, where the numbering is from
   0 on the right.  (Hence, 1<<r gives the mask for register r.)
   If saved[r] is 0, the register is not saved, and how[r] and where[r]
   are undefined.  If saved[r] is 1, then how[r] tells whether register r
   was saved in another register (how[r]==0) or in the frame (how[r]==1).
   In the former case, where[r] gives the register number; in the latter
   case, where[r] gives the frame position.
*/


typedef int dc_register_state_t;    /* range 0 to 2 */

#define DC_INVALID  0
#define DC_READABLE 1
#define DC_WRITABLE 2




typedef struct dcontext_info {
   dc_handle_t handle;                     /* environment of context */
   dc_word_t reg_info[DC_NUM_REG];
   dc_word_t reg_flags[2];
   dc_word_t aux_info[DC_NUM_AUX];
   dc_word_t aux_flags[2];
   dc_exactness_t loc_exact;
   dc_word_t psr_info;                     /* value or address */
   dc_word_t psr_ind;                      /* DC_TRUE iff address */
   dc_word_t psr_flags[2];                 /* per-PSR-bit flags */
   unsigned int code_reading;		       /* no tdesc therefore must read code*/
	 union {
	   tdesc_elem_t *tdesc_elem_ptr;       /* locates tdesc chunk */
	   dc_cr_data_t *cr_data_ptr;          /* or code reading data */
	 } info_ptr;
} dcontext_info_t;

typedef dcontext_info_t *dc_dcontext_t;

dc_word_t dc_get_value (handle, info, flags, pos)
   dc_handle_t handle;
   dc_word_t info[];
   dc_word_t flags[2];
   int pos;
   /* Assumes either DC_READABLE or DC_WRITABLE. */
{
   if (bit_test(flags[0], pos)) {
      /* DC_WRITABLE case */
      return dc_read_word(handle, info[pos]);
   } else {
      /* DC_READABLE case */
      return info[pos];
   }
}

void dc_set_value (handle, info, flags, pos, value)
   dc_handle_t handle;
   dc_word_t info[];
   dc_word_t flags[2];
   int pos;
   dc_word_t value;
   /* Assumes DC_WRITABLE. */
{
   dc_write_word(handle, info[pos], value);
}


#define GET_REG_VALUE(dcontext, reg) \
   dc_get_value(dcontext->handle, dcontext->reg_info, dcontext->reg_flags, reg)

#define SET_REG_VALUE(dcontext, reg, value) \
   dc_set_value(dcontext->handle, dcontext->reg_info, dcontext->reg_flags, reg, \
      value)

#define GET_AUX_VALUE(dcontext, reg) \
   dc_get_value(dcontext->handle, dcontext->aux_info, dcontext->aux_flags, reg)

#define SET_AUX_VALUE(dcontext, reg, value) \
   dc_set_value(dcontext->handle, dcontext->aux_info, dcontext->aux_flags, reg, \
      value)



void dc_check_dcontext (dc)
   dc_dcontext_t dc;
   /* Check consistency of information supplied to make a dcontext. */
{
   int i;

   if ((REG_STATE(dc, 0) != DC_READABLE) || (dc->reg_info[0] != 0))
      dc_error (dc->handle, "Register 0 is misspecified");
   for (i = 1; i < DC_NUM_REG; i++)
      if (REG_STATE(dc, i) == DC_RESERVED)
         dc_error (dc->handle,
            "State for general register %d is incorrect", i);
   for (i = 0; i < DC_NUM_AUX; i++)
      if (AUX_STATE(dc, i) == DC_RESERVED)
         dc_error (dc->handle,
            "State for auxiliary register %d is incorrect", i);
   if (AUX_STATE(dc, DC_AUX_LOC) == DC_INVALID)
      dc_error (dc->handle, "Location is specified as invalid");
   if (GET_AUX_VALUE(dc, DC_AUX_LOC) == 0)
      dc_error (dc->handle, "Location is zero.");
   if (dc->loc_exact >= 3)
      dc_error (dc->handle, "Location exactness is incorrectly specified: %d",
         dc->loc_exact);
   if (dc->psr_ind >= 2)
      dc_error (dc->handle,
         "PSR indirection flag is incorrectly specified: %d",
         dc->psr_ind);
   for (i = 0; i < 32; i++)
      if (PSR_STATE(dc, i) == DC_RESERVED)
         dc_error (dc->handle, "State for PSR bit %d is incorrect", i);
}



tdesc_elem_t * dc_tdesc_lookup (loc, tt, tt_size, map_info_in_ptr)
   dc_word_t loc;
   tdesc_table_t tt;
   int tt_size;
   dc_map_info_in_t *map_info_in_ptr;
   /* Return address of tdesc_elem_t for given location, or NULL if
      there is no tdesc chunk for the location.
   */
{
   int l = 0;
   int h = tt_size;
   int m;

   if (tt_size == 0) {
      map_info_in_ptr->flags = 0;
      return (tdesc_elem_t *)NULL;
   }
   for (;;) {
      m = (l + h) / 2;
      if (m == l) break;
      if (loc >= tt[m].start_address)
         l = m;
      else
         h = m;
   }
   if (loc >= tt[m].end_address) {
      map_info_in_ptr->preceding_tdesc_end = tt[m].end_address;
      if (m+1 < tt_size) {
	 map_info_in_ptr->following_tdesc_start = tt[m+1].start_address;
	 map_info_in_ptr->flags = DC_MII_PRECEDING_TDESC_END |
	                          DC_MII_FOLLOWING_TDESC_START;
      } else {
	 map_info_in_ptr->flags = DC_MII_PRECEDING_TDESC_END;
      }
      return (tdesc_elem_t *)NULL;
   } else if (loc < tt[m].start_address) {
      map_info_in_ptr->following_tdesc_start = tt[m].start_address;
      map_info_in_ptr->flags = DC_MII_FOLLOWING_TDESC_START;
      return (tdesc_elem_t *)NULL;
   } else {
      return (&tt[m]);
   }
}



dc_dcontext_t dc_make_dcontext (handle,
                                reg_info, reg_flags,
                                aux_info, aux_flags, loc_exact,
                                psr_info, psr_ind, psr_flags)
   dc_handle_t handle;
   dc_word_t reg_info[DC_NUM_REG];
   dc_word_t reg_flags[2];
   dc_word_t aux_info[DC_NUM_AUX];
   dc_word_t aux_flags[2];
   dc_exactness_t loc_exact;
   dc_word_t psr_info;
   dc_boolean_t psr_ind;
   dc_word_t psr_flags[2];
{
   dc_dcontext_t dc = (dc_dcontext_t) dc_malloc (handle, sizeof(dcontext_info_t));
   int i;
   dc_map_info_in_t map_info_in;

   /* Fill in supplied content. */
   dc->handle = ((dc_handle_t)handle);
   for (i = 0; i < DC_NUM_REG; i++) dc->reg_info[i]  = reg_info[i];
   for (i = 0; i < 2; i++)       dc->reg_flags[i] = reg_flags[i];
   for (i = 0; i < DC_NUM_AUX; i++) dc->aux_info[i]  = aux_info[i];
   for (i = 0; i < 2; i++)       dc->aux_flags[i] = aux_flags[i];
   dc->loc_exact = loc_exact;
   dc->psr_info = psr_info;
   dc->psr_ind = psr_ind;
   for (i = 0; i < 2; i++)       dc->psr_flags[i] = psr_flags[i];

   dc_check_dcontext(dc);

   /* Find tdesc information for the text chunk. */
   {
/***************************************************************/
/* BUG 8/16/89 Found by hls.  Not zeroing EV bits of location. */
/*                            SHOULD USE dc_location()!        */
/*      dc_word_t loc = GET_AUX_VALUE(dc, DC_AUX_LOC);         */
/***************************************************************/
      dc_word_t loc = GET_AUX_VALUE(dc, DC_AUX_LOC) & ~3;
      tdesc_elem_t *tep =
         dc_tdesc_lookup(loc, ((dc_handle_t)handle)->tdesc_table,
             ((dc_handle_t)handle)->tdesc_table_size,&map_info_in);
      if (tep) {
		 dc->code_reading = 0;
         dc->info_ptr.tdesc_elem_ptr = tep;
      } else {
	  dc->code_reading = 1;
	  if (!dc->handle->map_fcn) {
	      dc_error (dc->handle, "No tdesc information for %#.8X and no map function supplied.",loc);
	  }
/****************************************************************/
/* BUG 9/18/89 Found by hls.  Not using dc_malloc()             */
/* dc->info_ptr.cr_data_ptr= (dc_cr_data_t *)malloc(sizeof(dc_cr_data_t )); */
/****************************************************************/
	  dc->info_ptr.cr_data_ptr= (dc_cr_data_t *)dc_calloc(dc->handle,1,sizeof(dc_cr_data_t ));
	  dc_read_code(loc,dc,map_info_in,dc->info_ptr.cr_data_ptr);
      }
   }

   return (dc_dcontext_t) dc;
}



void dc_free_dcontext (dcontext)
   dc_dcontext_t dcontext;
{
/****************************************************************/
/* BUG 9/19/89 Found by hls.  Freeing non-pointer value.        */
/*	  free((char *)dcontext->code_reading);                 */
/****************************************************************/
   if (dcontext->code_reading)
	  free((char *)dcontext->info_ptr.cr_data_ptr);
   free((char *)dcontext);
}



dc_register_state_t dc_location_state (dcontext)
   dc_dcontext_t dcontext;
{
   return AUX_STATE(((dc_dcontext_t)dcontext), DC_AUX_LOC);
}


dc_exactness_t dc_location_exactness (dcontext)
   dc_dcontext_t dcontext;
{
   return ((dc_dcontext_t)dcontext)->loc_exact;
}


dc_word_t dc_location (dcontext)
   dc_dcontext_t dcontext;
   /* Return high 30 bits only. */
{
   /* Don't need: CHECK_AUX_READ (((dc_dcontext_t)dcontext), DC_AUX_LOC); */
   return GET_AUX_VALUE (((dc_dcontext_t)dcontext), DC_AUX_LOC) & ~3;
}


dc_boolean_t dc_location_in_text_chunk( dcontext, value )
   dc_dcontext_t dcontext;
   dc_word_t value;
{
   /* Check that new location is still within same text chunk. */
   tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
/********************************************************************/
/* Bug in predicate -- LS adjusted according to OCS documentation.. */
/*  if ((value < tep->start_address) || (value >= tep->end_address))*/
/********************************************************************/
   if ((value >= tep->start_address) && (value < tep->end_address))
        return DC_TRUE;
    else
        return DC_FALSE;

}


void dc_set_location (dcontext, value)
   dc_dcontext_t dcontext;
   dc_word_t value;
   /* Set high 30 bits only. */
{
   if (dc_location_in_text_chunk( dcontext, value ) != DC_TRUE)
      dc_warn (((dc_dcontext_t)dcontext)->handle,
         "New location is not in same text chunk.");

   CHECK_AUX_WRITE (((dc_dcontext_t)dcontext), DC_AUX_LOC);
   dc_write_masked_word (((dc_dcontext_t)dcontext)->handle,
      ((dc_dcontext_t)dcontext)->aux_info[DC_AUX_LOC], ~3, value);
}



dc_register_state_t dc_general_register_state (dcontext, reg)
   dc_dcontext_t dcontext;
   int reg;
{
   CHECK_REG (((dc_dcontext_t)dcontext), reg);
   return REG_STATE(((dc_dcontext_t)dcontext), reg);
}


dc_word_t dc_general_register (dcontext, reg)
   dc_dcontext_t dcontext;
   int reg;
{
   CHECK_REG (((dc_dcontext_t)dcontext), reg);
   CHECK_REG_READ (((dc_dcontext_t)dcontext), reg);
   return GET_REG_VALUE(((dc_dcontext_t)dcontext), reg);
}


void dc_set_general_register (dcontext, reg, value)
   dc_dcontext_t dcontext;
   int reg;
   dc_word_t value;
{
   CHECK_REG (((dc_dcontext_t)dcontext), reg);
   CHECK_REG_WRITE (((dc_dcontext_t)dcontext), reg);
   SET_REG_VALUE (((dc_dcontext_t)dcontext), reg, value);
}



dc_register_state_t dc_auxiliary_register_state (dcontext, reg)
   dc_dcontext_t dcontext;
   int reg;
{
   CHECK_AUX (((dc_dcontext_t)dcontext), reg);
   return AUX_STATE(((dc_dcontext_t)dcontext), reg);
}


dc_word_t dc_auxiliary_register (dcontext, reg)
   dc_dcontext_t dcontext;
   int reg;
{
   CHECK_AUX (((dc_dcontext_t)dcontext), reg);
   CHECK_AUX_READ (((dc_dcontext_t)dcontext), reg);
   return GET_AUX_VALUE(((dc_dcontext_t)dcontext), reg);
}


void dc_set_auxiliary_register (dcontext, reg, value)
   dc_dcontext_t dcontext;
   int reg;
   dc_word_t value;
{
   CHECK_AUX (((dc_dcontext_t)dcontext), reg);
   CHECK_AUX_WRITE (((dc_dcontext_t)dcontext), reg);
   SET_AUX_VALUE (((dc_dcontext_t)dcontext), reg, value);
}



dc_register_state_t dc_psr_register_bit_state (dcontext, bit)
   dc_dcontext_t dcontext;
   int bit;
{
   CHECK_BIT (((dc_dcontext_t)dcontext), bit);
   return PSR_STATE(((dc_dcontext_t)dcontext), bit);
}


dc_word_t dc_psr_register (dcontext)
   dc_dcontext_t dcontext;
{
   if (((dc_dcontext_t)dcontext)->psr_ind) {
      return dc_read_word(((dc_dcontext_t)dcontext)->handle,
                       ((dc_dcontext_t)dcontext)->psr_info);
   } else {
      return ((dc_dcontext_t)dcontext)->psr_info;
   }
}


void dc_set_psr_register (dcontext, mask, value)
   dc_dcontext_t dcontext;
   dc_word_t mask;
   dc_word_t value;
   /* Set bits of PSR corresponding to 1 bits in mask. */
{
   if (((dc_dcontext_t)dcontext)->psr_ind) {
      if (((((dc_dcontext_t)dcontext)->psr_flags[0] & mask) != mask) ||
          ((((dc_dcontext_t)dcontext)->psr_flags[1] & mask) != 0))
         dc_error (((dc_dcontext_t)dcontext)->handle,
            "Some PSR bits specified are not writable.");
      dc_write_masked_word (((dc_dcontext_t)dcontext)->handle,
                         ((dc_dcontext_t)dcontext)->psr_info, mask, value);
   } else {
      dc_error (((dc_dcontext_t)dcontext)->handle, "PSR is not writable.");
   }
}



dc_word_t dc_frame_address (dcontext)
   dc_dcontext_t dcontext;
{
  if (!dcontext->code_reading) {
	 tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
	 return dc_general_register(dcontext,
		tep->info.frame_address_register) + tep->info.frame_address_offset;
  } else {
	 if (dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_FP].reg == DC_REG_SP) {
		return (dc_general_register(dcontext,DC_REG_FP)
			- dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_FP].off);
	 }
	 if (dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_SP].reg == DC_REG_SP) {
		return (dc_general_register(dcontext,DC_REG_SP)
			- dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_SP].off);
	 }
     dc_error (((dc_dcontext_t)dcontext)->handle, "Cannot locate frame pointer.");
  }
}



dc_kind_t dc_context_kind (dcontext)
   dc_dcontext_t dcontext;
{
   return DC_CALL_KIND;
}




/* operations valid for call contexts only */


dc_register_state_t dc_return_address_state (dcontext)
   dc_dcontext_t dcontext;
{
   tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
   int reg;

   if (!dcontext->code_reading) {
	  if (tep->info.return_address_info_discriminant) {
	 	 return DC_WRITABLE;
	  } else {
		 return REG_STATE(((dc_dcontext_t)dcontext), tep->info.return_address_info);
	  }
   } else {
	  reg= DC_REG_RA;
	  if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,DC_REG_RA)) {
		if (bit_test(dcontext->info_ptr.cr_data_ptr->how,DC_REG_RA)) {
		   return DC_WRITABLE;
		} else {
		   reg= dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA];
		}
	  }
		return REG_STATE(((dc_dcontext_t)dcontext),reg);

	  
   }
}


dc_exactness_t dc_return_address_exactness (dcontext)
   dc_dcontext_t dcontext;
{
   return DC_MAYBE;
}


dc_word_t dc_return_address (dcontext)
   dc_dcontext_t dcontext;
   /* Return high 30 bits only. */
{
   tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
   dc_word_t rai = tep->info.return_address_info;
   dc_word_t val;
   int reg;

   if (!dcontext->code_reading) {
	 if (tep->info.return_address_info_discriminant) {
		val = dc_read_word (((dc_dcontext_t)dcontext)->handle,
						 dc_frame_address(dcontext) + rai);
	 } else {
		val = dc_general_register (dcontext, rai);
	 }
   } else {
	  reg=DC_REG_RA;
	  if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,reg)) {
		  if (bit_test(dcontext->info_ptr.cr_data_ptr->how,reg)) {
			 val = dc_read_word (((dc_dcontext_t)dcontext)->handle,
						   dc_frame_address(dcontext) + 
						    (dcontext->info_ptr.cr_data_ptr->where[reg]));
		  } else {
			 reg= dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA];
			 val = dc_general_register (dcontext, reg);
		  }
	  } else {
		 val = dc_general_register (dcontext, reg);
	  }
   }
	 return val & ~3;
}


void dc_set_return_address (dcontext, value)
   dc_dcontext_t dcontext;
   dc_word_t value;
   /* Set high 30 bits only. */
{
  if (!dcontext->code_reading) {
	 tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
	 dc_word_t rai = tep->info.return_address_info;

	 if (tep->info.return_address_info_discriminant) {
		dc_write_masked_word (((dc_dcontext_t)dcontext)->handle,
		   dc_frame_address(dcontext) + rai, ~3, value);
	 } else {
      dc_set_general_register (dcontext, rai,
         (value & ~3) | (dc_general_register(dcontext, rai) & 3));
   }
 } else {
	if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,DC_REG_RA)) {
		if (bit_test(dcontext->info_ptr.cr_data_ptr->how,DC_REG_RA)) {
		   dc_write_masked_word (((dc_dcontext_t)dcontext)->handle,
		      dc_frame_address(dcontext)
			   + dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA], ~3, value);
		  } else {
			 dc_set_general_register( dcontext,
								  dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA]);
		  }
	  } else {
		  dc_set_general_register( dcontext,
							  dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA]);
	  }
   }
}



/* operations valid for save contexts only */

/* (none) */



/* operations valid for exception contexts only */


void dc_get_exception_info (dcontext, handler, datum)
   dc_dcontext_t dcontext;
   dc_word_t *handler;
   dc_word_t *datum;
{
   dc_error (((dc_dcontext_t)dcontext)->handle,
      "dc_get_exception_info is not yet implemented.");
}



/* operations valid for protection contexts only */


void dc_get_protection_info (dcontext, handler, datum)
   dc_dcontext_t dcontext;
   dc_word_t *handler;
   dc_word_t *datum;
{
   dc_error (((dc_dcontext_t)dcontext)->handle,
      "dc_get_protection_info is not yet implemented.");
}



/* operations valid for special contexts only */


void dc_get_special_info (dcontext, kind, datum)
   dc_dcontext_t dcontext;
   dc_word_t *kind;
   dc_word_t *datum;
{
   dc_error (((dc_dcontext_t)dcontext)->handle,
      "dc_get_special_info is not yet implemented.");
}



/* operations valid for all contexts (again) */


dc_dcontext_t dc_previous_dcontext (dcontext)
   dc_dcontext_t dcontext;
   /* Return NULL if there is no previous context. */
{
   dc_dcontext_t old = (dc_dcontext_t) dcontext;
   dcontext_info_t new;    /* to serve as temporary storage only */
   tdesc_elem_t *tep;
	dc_cr_data_t *cdp;
   dc_word_t cfa;
   int rsm;
   dc_word_t offset;
   dc_word_t rai;
   int r;

   if (dc_return_address_state((dc_dcontext_t)old) == DC_INVALID)
      dc_error (old->handle, "Return address is invalid.");

   if (dc_return_address((dc_dcontext_t)old) == 0)
      return (dc_dcontext_t)NULL;  /* end of the chain */

   /* Copy over old contents. */
   new = *old;

   cfa = dc_frame_address(old);
	/* Restore stack pointer. */
	new.reg_info[DC_REG_SP] = cfa;
	SET_READABLE (new.reg_flags, DC_REG_SP);

   /* Invalidate temporary registers. */
   for (r = 1; r <= 13; r++) SET_INVALID (new.reg_flags, r);

	if (!old->code_reading) {
		tep = old->info_ptr.tdesc_elem_ptr;
		/* Restore preserved registers. */
		rsm = tep->info.register_save_mask;
		offset = cfa + tep->info.register_save_offset;
		for (r = 14; r <= 30; r++) {
			if (bit_test(rsm, 30-r)) {
				new.reg_info[r] = offset;
				SET_WRITABLE (new.reg_flags, r);
				offset += sizeof(dc_word_t);
			}
		}

		/* Set location from old return address. */
		rai = tep->info.return_address_info;
		if (tep->info.return_address_info_discriminant) {
			new.aux_info[DC_AUX_LOC] = cfa + rai;
			SET_WRITABLE (new.aux_flags, DC_AUX_LOC);
		} else {
			new.aux_info[DC_AUX_LOC] = old->reg_info[rai];
			ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, old->reg_flags, rai);
		}
	} else {
		cdp = old->info_ptr.cr_data_ptr;
		
		/* Restore preserved registers. */
		for (r = 14; r <= 30; r++) { 
			if (bit_test(cdp->saved,r)) {
				if (bit_test(cdp->how,r)){ /* saved in the frame */
					new.reg_info[r] = cfa+cdp->where[r];
					SET_WRITABLE (new.reg_flags, r);
				} else { /* saved in the in a register */
					new.reg_info[r] = dc_general_register(old,cdp->where[r]);
					ASSIGN_RSTATE (new.aux_flags, r, old->reg_flags, cdp->where[r]);
				}
			}  /* not saved, therefore, already valid , no else*/
		}

		/* Set location from old return address. */
		if (bit_test(cdp->saved,DC_REG_RA)) {
			if (bit_test(cdp->how,DC_REG_RA)){ /* saved in the frame */
				new.aux_info[DC_AUX_LOC] = 
					new.reg_info[DC_REG_RA] = cfa+cdp->where[DC_REG_RA];
				SET_WRITABLE (new.reg_flags, DC_REG_RA);
				SET_WRITABLE (new.aux_flags, DC_AUX_LOC);
			} else { /* saved in the in a register */
				new.reg_info[DC_REG_RA] =
					new.aux_info[DC_AUX_LOC] =
							dc_general_register(old,cdp->where[DC_REG_RA]);
				ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, 
									old->reg_flags, cdp->where[DC_REG_RA]);
			}
		} else { /* not saved, therefore, already valid , set DC_AUX_LOC only*/
				new.aux_info[DC_AUX_LOC] =
						dc_general_register(old,DC_REG_RA);
				ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, 
									old->reg_flags, DC_REG_RA);
		}
	}

   /* Invalidate instruction pointers. */
   SET_INVALID (new.aux_flags, DC_AUX_SXIP);
   SET_INVALID (new.aux_flags, DC_AUX_SNIP);
   SET_INVALID (new.aux_flags, DC_AUX_SFIP);

   /* No change to FCR registers. */

   /* No change to PSR register. */

   return dc_make_dcontext ((dc_handle_t)new.handle,
                            new.reg_info, new.reg_flags,
                            new.aux_info, new.aux_flags, new.loc_exact,
                            new.psr_info, new.psr_ind, new.psr_flags);
}



/* extensions for nonlocal goto */

#if 0

typedef
   struct label {
      ???
   } label_t;


label_t dc_make_label (dcontext, location)
   dc_dcontext_t dcontext;
   dc_word_t location;
{
}

#endif

/* procedure for reading code */

dc_read_code(loc,dc,map_info_in,cdp)
dc_word_t loc;
dc_dcontext_t dc;
dc_cr_data_t *cdp;
dc_map_info_in_t map_info_in;
{
dc_map_info_out_t map_info_out;
dc_word_t pc;
dc_boolean_t found_branch=DC_FALSE;
dc_word_t instr;

	(*dc->handle->map_fcn)(dc->handle->map_env,loc,map_info_in,&map_info_out);
	if (map_info_out.flags & DC_MIO_ENTRY_POINT 
		&& (!(map_info_in.flags & DC_MII_PRECEDING_TDESC_END)
		    || map_info_out.entry_point >= map_info_in.preceding_tdesc_end
			|| map_info_out.flags & DC_MIO_LITERAL_ENTRY_POINT)) {
	   dc_init_cr_data(cdp,(tdesc_elem_t *)NULL);
	   pc= map_info_out.entry_point;
	} else if (map_info_in.flags & DC_MII_PRECEDING_TDESC_END) { 
		/**/
		/* tdesc_lookup gets the tep for the preceeding tdesc information
		/* so we call it with one less than the preceding tdesc end since
		/* tdesc information is exclusive of the ending address
		/**/
	   dc_init_cr_data(cdp, 
					   dc_tdesc_lookup(map_info_in.preceding_tdesc_end-1, 
									((dc_handle_t)dc->handle)->tdesc_table,
             						((dc_handle_t)dc->handle)->tdesc_table_size,
									&map_info_in));
	   pc= map_info_in.preceding_tdesc_end;
	} else {
      dc_error (dc->handle, "Insufficient information for code reading.");
	}
	for (;;pc+=4) {
		if (pc==loc) {
		   return (DC_TRUE);
		}
		instr= dc_read_word(dc->handle,pc);
		found_branch= dc_decode_finds_branch(dc,instr);
		if ((map_info_out.flags & DC_MIO_PROLOGUE_END) 
			  && (pc==map_info_out.prologue_end)) {
			break;
		}
		if (found_branch) {
			if (DC_MIO_IMPLICIT_PROLOGUE_END & map_info_out.flags) {
				break;
			} else {
      			dc_error (dc->handle, "Found branch before end of prologue.");
			}
		}
	}
	if (!(map_info_out.flags & DC_MIO_LITERAL_EPILOGUE_START)
		 && (map_info_out.epilogue_start >= loc 
				|| !(map_info_out.flags & DC_MIO_EPILOGUE_START))) {
		return (DC_TRUE);
	}
	dc_correct_cr_data(cdp,dc->handle);
	for (pc=map_info_out.epilogue_start;pc<loc;pc+=4) {
		instr= dc_read_word(dc->handle,pc);
		if (dc_decode_finds_branch(dc,instr)) {
			return (DC_FALSE);
		}
	}
	return (DC_TRUE);

}



dc_init_cr_data(cdp,tep)
dc_cr_data_t *cdp;
tdesc_elem_t *tep;
{
int reg;
dc_word_t rai;
dc_word_t raid;
dc_word_t rsm;
dc_word_t frpos;

	if (tep){

	   /* Start off with all registers undefined and none saved. */
	   for (reg = 0; reg < DC_NUM_REG; reg++) {
		  cdp->reg_val[reg].reg = DC_UNDEF;
	   }
	   cdp->saved = 0;

	   /* Overwrite with what tdesc element says. */

	   cdp->reg_val[tep->info.frame_address_register].reg = DC_REG_SP;
	   cdp->reg_val[tep->info.frame_address_register].off =
				  - tep->info.frame_address_offset;

	   rai = tep->info.return_address_info;
	   raid = tep->info.return_address_info_discriminant;
	   if (raid || rai != DC_REG_RA) {
		  bit_set(cdp->saved,DC_REG_RA);
		  bit_assign(cdp->how,DC_REG_RA,raid);
		  cdp->where[DC_REG_RA] = rai;
	   }

	   rsm = tep->info.register_save_mask;
	   frpos = tep->info.register_save_offset;
	   for (reg = 14; reg <= 30; reg++) {
			if (bit_test(rsm, 30-reg)) {
				bit_set(cdp->saved,reg);
				bit_set(cdp->how,reg);
				cdp->where[reg] = frpos;
				frpos += sizeof(dc_word_t);
			} else {
					cdp->reg_val[reg].reg = reg;
					cdp->reg_val[reg].off = 0;
			}
	   }

	   cdp->reg_val[0].reg = 0;   /* guarantee what hardware does */
	   cdp->reg_val[0].off = 0;

	} else {
	   /* Each register has its own initial value. */
	   for (reg = 0; reg < DC_NUM_REG; reg++) {
		  cdp->reg_val[reg].reg = reg;
		  cdp->reg_val[reg].off = 0;
	   }
   /* No register is yet saved. */
   cdp->saved = 0;
   cdp->how = 0;
	}
}
void dc_correct_cr_data(cdp,handle)
dc_cr_data_t *cdp;
dc_handle_t handle;
{
long sr,r;
dc_word_t save_regs = 0;  /* registers used to save others */
   for (r = 1; r < DC_REG_SP; r++) {
      if (bit_test(cdp->saved,r) && !bit_test(cdp->how,r)) {
         sr = cdp->where[r];
         if (bit_test(save_regs,sr)) {
            dc_error(handle, "Same register used to save two others.");
	 }
         bit_set(save_regs,sr);
      }
   }
   for (r = 1; r < DC_REG_FP; r++) {
      if ((r < 14 || bit_test(cdp->saved,r)) && !bit_test(save_regs,r)) {
         cdp->reg_val[r].reg = DC_UNDEF;
      }
   }
   if (bit_test(cdp->saved,DC_REG_FP) &&
       cdp->reg_val[DC_REG_FP].reg == DC_REG_SP) {  /* is r30 the far? */
      cdp->reg_val[DC_REG_SP].reg = DC_UNDEF;  /* trash sp */
   } else if (cdp->reg_val[DC_REG_SP].reg == DC_REG_SP) { /* is r31 the far? */
      if (bit_test(cdp->saved,DC_REG_FP) && !bit_test(save_regs,DC_REG_FP)) {
         cdp->reg_val[DC_REG_FP].reg = DC_UNDEF;  /* trash r30 */
      }
   }
}
