mini2udi.c

gdb是linux下的一个远程调试环境.能让你很方便地调试linux下的代码.

					 (UDIInt) NumRanges,
					 Entry,
					 &StackSizes[0],
					 (UDIInt) NumStacks,
					 (char *) 0)) <= TIPFAILURE) {
       PrintErrorMessage (UDIretval);
      return(FAILURE);
  } else if (UDIretval != SUCCESS) {
      udi_warning(UDIretval);
      return(FAILURE);
  };
  /* Successful */
  if (( UDIretval = UDISetCurrentProcess((UDIPId) CurrentPID))
							 <= TIPFAILURE) {
       PrintErrorMessage (UDIretval);
      return(FAILURE);
  } else if (UDIretval != SUCCESS) {
      udi_warning(UDIretval);
      return(FAILURE);
  };
  return (SUCCESS);
}

/* Write memory or registers to target  */
INT32
/**********************************************Mini_write_req   */
Mini_write_req(m_space, address, byte_count, size, count_done,
	       buffer, host_endian)
  INT32        m_space;
  ADDR32          address;
  INT32        byte_count;
  INT16		size;
  INT32       *count_done;
  BYTE           *buffer;
  INT32        host_endian;
{
  UDIError	UDIretval;
  UDIResource	to;

  to.Space = xlate_mspace_mon2udi(m_space);
  to.Offset = address;

  if ((UDIretval = UDIWrite((UDIHostMemPtr) buffer,
			    to,
			    (UDICount) byte_count,
			    (UDISizeT) size,
			    (UDICount *) count_done,
			    (UDIBool) host_endian)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
       return(FAILURE);
  } else if (UDIretval == SUCCESS) {
      return(SUCCESS);
  } else {
      udi_warning(UDIretval);
      return(FAILURE);
  }
}

INT32
Mini_stdin_mode_x(mode)
INT32	*mode;
{
  UDIError	UDIretval;

  if ((UDIretval = UDIStdinMode ((UDIMode *) mode)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (FAILURE);
  } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  };
}

INT32
/**********************************************Mini_put_stdin   */
Mini_put_stdin(buffer, bufsize, count)
  char       *buffer;
  INT32        bufsize;
  INT32       *count;
{
  UDIError	UDIretval;

  if ((UDIretval = UDIPutStdin ((UDIHostMemPtr) buffer,
				(UDISizeT) bufsize,
				(UDISizeT *) count)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (FAILURE);
  } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  };
}

/* Put characters to stdout   */


INT32
/**********************************************Mini_get_stdout   */
Mini_get_stdout(buffer, bufsize, count_done)
  char       *buffer;
  INT32       *count_done;
  INT32        bufsize;
{
  UDIError	UDIretval;

  if ((UDIretval = UDIGetStdout ((UDIHostMemPtr) buffer,
			 (UDISizeT) bufsize,
			 (UDISizeT *) count_done)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (FAILURE);
  } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  }
}

INT32
/**********************************************Mini_get_stderr   */
Mini_get_stderr(buffer, bufsize, count_done)
  char       *buffer;
  INT32       *count_done;
  INT32        bufsize;
{
  UDIError	UDIretval;
  if ((UDIretval = UDIGetStderr ((UDIHostMemPtr) buffer,
			 (UDISizeT) bufsize,
			 (UDISizeT *) count_done)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (FAILURE);
  } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  }
}

/* Step instructions   */


INT32
/**********************************************Mini_step   */
Mini_step(count)
INT32	count;
{
  UDIError	UDIretval;
  UDIRange	dummy_range;
  UDIStepType	step_type;

  dummy_range.Low = 0;
  dummy_range.High = 0xffffffff;

  step_type = UDIStepNatural;

  if ((UDIretval = UDIStep((UDIUInt32) count,
			   step_type,
			   dummy_range)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (FAILURE);
  } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  };
}

INT32
/***************************************************** Mini_put_trans */
Mini_put_trans(buffer)
char	*buffer;
{
  UDIError	UDIretval;
  UDISizeT	count;
  UDISizeT	*count_done;

  count = (UDISizeT) (strlen (buffer) + 1);
  if ((UDIretval = UDIPutTrans((UDIHostMemPtr) buffer,
			       (UDISizeT) count,
			       (UDISizeT *) count_done)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (FAILURE);
  } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  };
  
}


static CPUSpace
xlate_mspace_mon2udi(m_space)
INT32	m_space;
{
  switch(m_space) {
    case	LOCAL_REG:
	return((CPUSpace) UDI29KLocalRegs);
    case	ABSOLUTE_REG:
	return((CPUSpace) UDI29KGlobalRegs);
    case	GLOBAL_REG:
	return((CPUSpace) UDI29KGlobalRegs);
    case	SPECIAL_REG:
	return((CPUSpace) UDI29KSpecialRegs);
    case	TLB_REG:
	return((CPUSpace) UDI29KTLBRegs);
    case	COPROC_REG:
	return((CPUSpace) UDI29KAm29027Regs);
    case	I_MEM:
	return((CPUSpace) UDI29KIRAMSpace);
    case	D_MEM:
	return((CPUSpace) UDI29KDRAMSpace);
    case	I_ROM:
	return((CPUSpace) UDI29KIROMSpace);
    case	D_ROM:
	return((CPUSpace) UDI29KDRAMSpace);
    case	I_O:
	return((CPUSpace) UDI29KIOSpace);
    case	I_CACHE:
	return((CPUSpace) UDI29KICacheSpace);
    case	D_CACHE:
	return((CPUSpace) UDI29KDCacheSpace);
    case	PC_SPACE:
	return((CPUSpace) UDI29KPC);
    case	A_SPCL_REG:
	return((CPUSpace) UDI29KSpecialRegs);
    case	GENERIC_SPACE:
	return ((CPUSpace) UDI29KDRAMSpace);
    case	VERSION_SPACE:
	return ((CPUSpace) VERSION_SPACE);
    default:
	return((CPUSpace) FAILURE);
  };
}

static INT32
xlate_mspace_udi2mon(mspace)
CPUSpace  	mspace;
{
   switch(mspace) {
     case	UDI29KDRAMSpace:
	return((INT32) D_MEM);
     case	UDI29KIOSpace:
	return((INT32) I_O);
     case	UDI29KCPSpace0:
	return((INT32) FAILURE);
     case	UDI29KCPSpace1:
	return((INT32) FAILURE);
     case	UDI29KIROMSpace:
	return((INT32) I_ROM);
     case	UDI29KIRAMSpace:
	return((INT32) I_MEM);
     case	UDI29KLocalRegs:
	return((INT32) LOCAL_REG);
     case	UDI29KGlobalRegs:
	return((INT32) GLOBAL_REG);
     case	UDI29KRealRegs:
	return((INT32) GLOBAL_REG);
     case	UDI29KSpecialRegs:
	return((INT32) SPECIAL_REG);
     case	UDI29KTLBRegs:
	return((INT32) TLB_REG);
     case	UDI29KACCRegs:
	return((INT32) FAILURE);
     case	UDI29KICacheSpace:
	return((INT32) I_CACHE);
     case	UDI29KAm29027Regs:
	return((INT32) COPROC_REG);
     case	UDI29KPC:
	return((INT32) PC_SPACE);
     case	UDI29KDCacheSpace:
	return((INT32) D_CACHE);
     default:
	return(FAILURE);
   };
}

static
void udi_warning(num)
int	num;
{
  fprintf(stderr, "UDIERROR: %d : %s\n", num, udi_errmsg[num]);
  fflush(stderr);
  if (io_config.echo_mode == (INT32) TRUE) {
     fprintf(io_config.echo_file, "UDIERROR: %d :%s\n", num, udi_errmsg[num]);
     fflush (io_config.echo_file);
  }
}

static void
PrintErrorMessage(UDIretval)
UDIError	UDIretval;
{
    UDISizeT	ErrorMsgCnt;

    fprintf(stderr, "TIPERROR: %d :", UDIretval);
    fflush(stderr);
    if (io_config.echo_mode == (INT32) TRUE) {
       fprintf(io_config.echo_file, "TIPERROR: %d :", UDIretval);
       fflush(io_config.echo_file);
    }

    ErrorMsgCnt = (UDISizeT) 0;
    do {
       if (UDIGetErrorMsg(UDIretval, 
			     (UDISizeT) MONErrorMsgSize, 
			     MONErrorMsg, &ErrorMsgCnt) != UDINoError) {
	   fprintf(stderr, "TIPERROR: Could not get TIP error message.\n");
	   fflush(stderr);
	   return;
	}
       write (fileno(stderr), &MONErrorMsg[0], (int) ErrorMsgCnt);
       if (io_config.echo_mode == (INT32) TRUE)
          write (fileno(io_config.echo_file), &MONErrorMsg[0], (int) ErrorMsgCnt);
    } while (ErrorMsgCnt == (UDISizeT) MONErrorMsgSize);
    fprintf(stderr, "\n");
    if (io_config.echo_mode == (INT32) TRUE) {
       fprintf(io_config.echo_file, "\n");
       fflush(io_config.echo_file);
    }
    return;
}

static UDIError
FillWords(from, pattern, pattern_count, fill_count)
UDIResource	from;
UDIHostMemPtr	pattern;
UDISizeT	pattern_count;
UDICount	fill_count;
{
   UDICount	count_done;
   UDIBool	host_endian, direction;
   UDIError	UDIretval;
   UDIResource	to;

   INT32	isregspace = ISREG(xlate_mspace_udi2mon(from.Space));

   host_endian = FALSE;

        if ((UDIretval = UDIWrite((UDIHostMemPtr) pattern,
			       from,
			       (UDICount) 1,
			       (UDISizeT) pattern_count,
			       (UDICount *) &count_done,
			       host_endian)) <= TIPFAILURE) {
           PrintErrorMessage (UDIretval);
           return (FAILURE);
        } else if (UDIretval == SUCCESS) {  /* do copy */
	   fill_count = fill_count - 1; /* one less */
	   if (fill_count > (INT32) 0) { /* do copy */
	      if (isregspace)
	   	   to.Offset = from.Offset + (pattern_count/4);
	      else		
		   to.Offset = from.Offset + pattern_count;
	      to.Space = from.Space; /* already translated */
	      direction = TRUE; /* front to back */
	      if (pattern_count > (INT32) 4) { /* is a multiple of 4 also */
	         fill_count = (INT32) (fill_count * (pattern_count/4));
	         pattern_count = (INT32) 4;
	      };
	      if ((UDIretval = UDICopy (from,
			     to,
			     fill_count,
			     (UDISizeT) pattern_count,
			     (UDICount *) &count_done,
			     direction)) <= TIPFAILURE) {
                  PrintErrorMessage (UDIretval);
                  return (FAILURE);
	      } else if (UDIretval == SUCCESS) {
	         return(SUCCESS);
	      } else {
                 udi_warning(UDIretval);
                 return(FAILURE);
	      }
	   };
	   /* return if no more to copy */
	   return(SUCCESS);
        } else {
           udi_warning(UDIretval);
           return(FAILURE);
        };
}

static UDIError
FillString(from, pattern, pattern_count, fill_count)
UDIResource	from;
UDIHostMemPtr	pattern;
UDISizeT	pattern_count;
UDICount	fill_count;
{
   UDICount	count_done;
   UDIBool	host_endian, direction;
   UDIError	UDIretval;
   UDIResource	to;

   host_endian = FALSE;

        if ((UDIretval = UDIWrite((UDIHostMemPtr) pattern,
			       from,
			       (UDICount) pattern_count,
			       (UDISizeT) 1,
			       (UDICount *) &count_done,
			       host_endian)) <= TIPFAILURE) {
           PrintErrorMessage (UDIretval);
           return (FAILURE);
        } else if (UDIretval == SUCCESS) {  /* do copy */
	   fill_count = fill_count - 1; /* one less */
	   if (fill_count > (INT32) 0) { /* do copy */
	      to.Offset = from.Offset + pattern_count;
	      to.Space = from.Space; 
	      direction = TRUE; /* front to back */
	      if ((UDIretval = UDICopy (from,
			     to,
			     (UDICount) (fill_count*pattern_count),
			     (UDISizeT) 1,
			     (UDICount *) &count_done,
			     direction)) <= TIPFAILURE) {
                  PrintErrorMessage (UDIretval);
                  return (FAILURE);
	      } else if (UDIretval == SUCCESS) {
	         return(SUCCESS);
	      } else {
                 udi_warning(UDIretval);
                 return(FAILURE);
	      }
	   };
	   /* return if no more to copy */
	   return(SUCCESS);
        } else {
           udi_warning(UDIretval);
           return(FAILURE);
        };
}