mini2udi.c

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

Mini_bkpt_set(m_space, address, pass_count, type, break_id)
  INT32        m_space;
  ADDR32          address;
  INT32        pass_count;
  INT32        type;
  int       *break_id;
{
  UDIResource	addr;
  UDIError	UDIretval;


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

  if (type == BKPT_29000)
     type = (UDIBreakType) UDIBreakFlagExecute;
  else if (type == BKPT_29050)
     type = (UDIBreakType) (MONBreakFlagHardware | UDIBreakFlagExecute);
  else if (type == BKPT_29050_BTE_0)
     type = (UDIBreakType) (MONBreakFlagHardware | UDIBreakFlagExecute);
  else if (type == BKPT_29050_BTE_1)
     type = (UDIBreakType) (MONBreakTranslationEnabled | MONBreakFlagHardware | UDIBreakFlagExecute);

  if ((UDIretval = UDISetBreakpoint(addr,
			   (UDIInt32) pass_count,
			   (UDIBreakType) type,
			   (BreakIdType *) break_id)) <= TIPFAILURE) {
     PrintErrorMessage (UDIretval);
     return (FAILURE);
  } else if (UDIretval == SUCCESS) {
     return(SUCCESS);
  } else {
     udi_warning(UDIretval);
     return(FAILURE);
  }
}

/* Query   (get status)  Breakpoints   */

INT32
/**********************************************Mini_bkpt_stat   */
Mini_bkpt_stat(break_id, address, m_space, pass_count, 
	       bkpt_type, current_cnt)
  int       break_id;
  INT32       *m_space;
  ADDR32      *address;
  INT32       *pass_count;
  INT32       *bkpt_type;
  INT32       *current_cnt;
{
  UDIError	UDIretval;
  UDIResource	addr;

  if ((UDIretval = UDIQueryBreakpoint ((BreakIdType) break_id,
				&addr,
				(UDIInt32 *)pass_count,
				(UDIBreakType *) bkpt_type,
				(UDIInt32 *) current_cnt)) <= TIPFAILURE) {
    PrintErrorMessage (UDIretval);
    return (FAILURE);
  } else if (UDIretval == SUCCESS) {
    *address = addr.Offset;
    *m_space = xlate_mspace_udi2mon(addr.Space);
    if (*bkpt_type & MONBreakFlagHardware)
	*bkpt_type = BKPT_29050;
    return(SUCCESS);
  } else {
     if (UDIretval == UDIErrorNoMoreBreakIds)
	return ((INT32) MONBreakNoMore);
     else if (UDIretval == UDIErrorInvalidBreakId)
	return ((INT32) MONBreakInvalid);
     else {
       udi_warning(UDIretval);
       return(FAILURE);
     }
  };
}

/* Kill    Target     */

INT32
/**********************************************Mini_break   */
Mini_break()
{

  UDIStop();
  return (SUCCESS);
}

/* Obtain Target configuration and resynchronize with target  */

UDIInt32
/**********************************************Mini_config_req   */
Mini_config_req(target_config, versions)
  TARGET_CONFIG  *target_config;
  VERSIONS_ETC	 *versions;
{
  UDIError	UDIretval;
  UDIMemoryRange	DFEMemRange[MONMaxMemRanges];
  UDIUInt32	ChipVersions[MONMaxChips];
  UDIInt	NumRanges, NumChips;
  UDIInt	i;

  NumRanges = (UDIInt) MONMaxMemRanges;
  NumChips  = (UDIInt) MONMaxChips;

  if ((UDIretval = UDIGetTargetConfig(
			   (UDIMemoryRange *) &DFEMemRange[0],
			   (UDIInt *) &NumRanges, /* 3 -> I, D, R */
			   (UDIUInt32 *) &ChipVersions[0],
			   (UDIInt *) &NumChips)) <= TIPFAILURE) {
      PrintErrorMessage (UDIretval);
      return(FAILURE);
  } else if ((UDIretval == SUCCESS) || (UDIretval == UDIErrorIncomplete)) {
      if (UDIretval == UDIErrorIncomplete) {
        fprintf(stderr, "Ignoring: ");
        if (io_config.echo_mode == (INT32) TRUE) {
           fprintf(io_config.echo_file, "Ignoring: ");
	   fflush (io_config.echo_file);
	}
	udi_warning(UDIretval);
      };
      i = (UDIInt) 0;
      while ((i < (UDIInt) MONMaxMemRanges) && (i < NumRanges)) {
	   switch ((int) DFEMemRange[i].Space) {
	     case  UDI29KDRAMSpace:
		target_config->D_mem_start = (ADDR32) DFEMemRange[i].Offset;
		target_config->D_mem_size = (INT32) DFEMemRange[i].Size;
		break;
	     case	 UDI29KIROMSpace:
		target_config->ROM_start = (ADDR32) DFEMemRange[i].Offset;
		target_config->ROM_size = (INT32) DFEMemRange[i].Size;
		break;
	     case	 UDI29KIRAMSpace:
		target_config->I_mem_start = (ADDR32) DFEMemRange[i].Offset;
		target_config->I_mem_size = (INT32) DFEMemRange[i].Size;
		break;
	     default: /* don't care, so ignore it */
		break;
	   };
	   i = i + (UDIInt) 1;
      } /* end while */
      i = (UDIInt) 0;
      while ((i < (UDIInt) MONMaxChips) && (i < NumChips)) {
	   switch (i) {
	      case	0:  /* cpu */
		target_config->processor_id = (UINT32) ChipVersions[i];
		break;
	      case	1:  /* coprocessor */
		target_config->coprocessor = (UINT32) ChipVersions[i];
		if (target_config->coprocessor == (UINT32) UDI29KChipNotPresent)
		   target_config->coprocessor = (UINT32) -1; /* MONDFE's */
		break;
	      default:  /* ignore */
		break;
	   };
	   i = i + (UDIInt) 1;
      } /* end while */
      return(SUCCESS);
  } else {
      udi_warning(UDIretval);
      return(FAILURE);
  }
}


/* Copy memory and registers    */


INT32
/**********************************************Mini_copy   */
Mini_copy(src_space, src_addr, dst_space, dst_addr, byte_count, size, dir)
  INT32        src_space,
               dst_space;
  ADDR32       src_addr,
               dst_addr;
  INT32      	 byte_count;
  INT16		size;
  INT32		 dir;
{
  UDIError	UDIretval;
  UDIResource	from, to;
  UDICount	count_done;

  from.Space = xlate_mspace_mon2udi(src_space);
  from.Offset = src_addr;
  to.Space = xlate_mspace_mon2udi(dst_space);
  to.Offset = dst_addr;

  if ((UDIretval = UDICopy (from,
			    to,
			    (UDICount) byte_count,
			    (UDISizeT) size,
			    &count_done,
			    (UDIBool) dir)) <= TIPFAILURE) {
      PrintErrorMessage (UDIretval);
      return (FAILURE);
  } else if (UDIretval == SUCCESS) {
      return(SUCCESS);
  } else {
     udi_warning(UDIretval);
     return(FAILURE);
  }
}

/* Fill memory and registers    */


/* fill_count if greater than 4 should be a multiple of 4 */
INT32
/**********************************************Mini_fill   */
Mini_fill(m_space, start, fill_count, pattern_count, pattern)
  INT32        m_space;
  ADDR32          start;
  INT32        fill_count,
                  pattern_count;
  BYTE           *pattern;
{
  UDIBool         host_endian;
  UDIResource	from;
  UDICount	count_done;
  UDIError	UDIretval;
  
  host_endian = FALSE;

  from.Offset = start;
  from.Space = xlate_mspace_mon2udi (m_space);

  if (fill_count == (INT32) 1) { /* takes only one write */
     if ((UDIretval = UDIWrite((UDIHostMemPtr) pattern,
			       from,
			       (UDICount) fill_count,
			       (UDISizeT) pattern_count, /* a byte at a time */
			       (UDICount *) &count_done,
			       host_endian)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (FAILURE);
     } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
     } else {
        udi_warning(UDIretval);
        return(FAILURE);
     };
  } else {
     /* Handle arbitrary length strings to Data memory separately */
     if ((pattern_count > (INT32) 4) && 
			       ((int) (pattern_count % 4) != (int) 0)){
	if (from.Space != UDI29KDRAMSpace)
	  return (FAILURE);
	return((INT32) FillString(from, (UDIHostMemPtr) pattern,
			   (UDISizeT) pattern_count, (UDICount) fill_count));
     } else {
	return((INT32) FillWords(from, (UDIHostMemPtr) pattern, 
			   (UDISizeT) pattern_count, (UDICount) fill_count));
     }
  };
}

/* Initiate a wait and get target status  */

INT32
/**********************************************Mini_get_target_stats   */
Mini_get_target_stats(maxtime, target_status)
INT32	maxtime;
INT32  *target_status;
{
  UDIPId	pid;
  UDIError	UDIretval;
  UDIInt32	udiwait_code;

  if (maxtime == (INT32) -1) {
    udiwait_code = (UDIInt32) UDIWaitForever;
  } else {
    udiwait_code = (UDIInt32) maxtime;
  };
  if ((UDIretval = UDIWait ((UDIInt32) udiwait_code,
			    &pid,
			    (UDIUInt32 *) target_status)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (SUCCESS);  /* considered non-fatal */
  } else if (UDIretval == SUCCESS) {
	CurrentPID = (UDIPId) pid; /* useful when reconnecting */
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  };
}


INT32
/**********************************************Mini_go   */
Mini_go()
{
  UDIError	UDIretval;

  if ((UDIretval = UDIExecute()) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
        return (FAILURE);
  } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  };
}

INT32
/**********************************************Mini_init   */
Mini_init(txt_start, txt_end, dat_start, dat_end, 
	  entry_point, m_stack, r_stack,
	  arg_string)
  ADDR32          txt_start,
                  txt_end,
                  dat_start,
                  dat_end;
  ADDR32          entry_point;
  INT32        m_stack,
                  r_stack;
  char		*arg_string;
{
  UDIMemoryRange	ProcessMemory[MONMaxProcessMemRanges];
  UDIInt	NumRanges;
  UDIResource	Entry;
  CPUSizeT	StackSizes[MONMaxStacks];
  UDIInt	NumStacks;
  UDIError	UDIretval;

  NumRanges = (UDIInt) MONMaxProcessMemRanges;
  NumStacks = (UDIInt) MONMaxStacks;
  ProcessMemory[0].Space = (CPUSpace) UDI29KIRAMSpace;
  ProcessMemory[0].Offset = (CPUOffset) txt_start;
  ProcessMemory[0].Size = (CPUSizeT) (txt_end - txt_start);
  ProcessMemory[1].Space = (CPUSpace) UDI29KDRAMSpace;
  ProcessMemory[1].Offset = (CPUOffset) dat_start;
  ProcessMemory[1].Size = (CPUSizeT) (dat_end - dat_start);
  Entry.Offset = entry_point;
  Entry.Space = xlate_mspace_mon2udi((INT32) I_MEM);
  StackSizes[0] = (CPUSizeT) r_stack;
  StackSizes[1] = (CPUSizeT) m_stack;

  if ((UDIretval = UDIInitializeProcess (&ProcessMemory[0],
					 (UDIInt) NumRanges,
					 Entry,
					 &StackSizes[0],
					 (UDIInt) NumStacks,
					 arg_string)) <= TIPFAILURE) {
        PrintErrorMessage (UDIretval);
	return (FAILURE);
  } else if (UDIretval == SUCCESS) {
	return(SUCCESS);
  } else {
        udi_warning(UDIretval);
        return(FAILURE);
  };
}


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

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

  if ((UDIretval = UDIRead (from,
			    (UDIHostMemPtr) buffer,
			    (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);
  }
}

/* 
 * Reset target processor   
 */
INT32
/**********************************************Mini_reset_processor   */
Mini_reset_processor()
{
  UDIMemoryRange	ProcessMemory[MONMaxProcessMemRanges];
  UDIInt	NumRanges;
  UDIResource	Entry;
  CPUSizeT	StackSizes[MONMaxStacks];
  UDIInt	NumStacks;
  UDIError	UDIretval;
  UDIPId	CurrentPID;
  UDIUInt32	StopReason;


  NumRanges = (UDIInt) MONMaxProcessMemRanges;
  NumStacks = (UDIInt) MONMaxStacks;
  ProcessMemory[0].Space = (CPUSpace) UDI29KIRAMSpace;
  ProcessMemory[0].Offset = (CPUOffset) 0;
  ProcessMemory[0].Size = (CPUSizeT) 0;
  ProcessMemory[0].Space = (CPUSpace) UDI29KIRAMSpace;
  ProcessMemory[0].Offset = (CPUOffset) 0;
  ProcessMemory[0].Size = (CPUSizeT) 0;
  Entry.Offset = 0;
  Entry.Space = xlate_mspace_mon2udi((INT32) I_MEM);
  StackSizes[0] = (CPUSizeT) 0;
  StackSizes[1] = (CPUSizeT) 0;

  if ((UDIretval = UDIWait((UDIInt32) 0, &CurrentPID, &StopReason))
							 <= TIPFAILURE) {
       PrintErrorMessage (UDIretval);
      return(FAILURE);
  } else if (UDIretval != SUCCESS) {
      udi_warning(UDIretval);
      return(FAILURE);
  };
  /* set PID to ProcProcessor */
  if (( UDIretval = UDISetCurrentProcess((UDIPId) UDIProcessProcessor))
							   <= TIPFAILURE) {
       PrintErrorMessage (UDIretval);
      return(FAILURE);
  } else if (UDIretval != SUCCESS) {
      udi_warning(UDIretval);
      return(FAILURE);
  };
  /* Successful */
  /* call InitializeProcess. Paramters ignored. */
  if ((UDIretval = UDIInitializeProcess (&ProcessMemory[0],