udip2iss.c

gdb for adsp develop

     count_done is set to the number of objects success-
     fully transferred.
*/
UDIError UDICopy(from, to, count, size, count_done, direction )
UDIResource	from;		/* in -- destination address on target */
UDIResource	to;		/* in -- source address on target */
UDICount	count;		/* in -- count of objects to be transferred */
UDISize		size;		/* in -- size of each object */
UDICount	*count_done;	/* out - count actually transferred */
UDIBool		direction;	/* in -- high-to-low or reverse */
{
}

/***************************************************************** UDI_EXECUTE
     UDIExecute() continues execution  of  the  default
     process from the current PC.
*/
UDIError UDIExecute()
{
}

/******************************************************************** UDI_STEP
     UDIStep()  specifies  a  number  of  "instruction"
     steps  to  make.  The step can be further qualified
     to state whether CALLs  should  or  should  not  be
     stepped over; whether TRAPs should or should not be
     stepped over; and whether stepping should halt when
     the PC gets outside a certain range.  The semantics
     of UDIStep imply that progress  is  made;  ie;  at
     least  one  instruction is executed before traps or
     interrupts are handled.
*/
UDIError UDIStep(steps, steptype, range)
UINT32	      steps;          /* in -- number of steps */
UDIStepType   steptype;       /* in -- type of stepping to be done */
UDIRange      range;          /* in -- range if StepInRange is TRUE */
{
}

/******************************************************************** UDI_STOP
     UDIStop() stops the default process
*/
UDIError UDIStop(stop_pc)
UDIResource	*stop_pc;	/* out -- value of PC where we stopped */
{
}

/******************************************************************** UDI_WAIT
     UDIWait() returns the state of the target  proces-
     sor.  The TIP is expected to return when the target
     state is no longer RUNNING  or  when  maxtime  mil-
     liseconds have elapsed; whichever comes first.  The
     special maxtime value UDI_WAIT_FOREVER  essentially
     means  that  the  DFE blocks until the target is no
     longer RUNNING.  On completion; pid is used to  re-
     port  which  process  stopped (necessary for multi-
     process targets).  On completion; stop_pc is usual-
     ly set to the PC where execution stopped.

     The return status STDIN_NEEDED allows  the  TIP  to
     tell  the DFE that the target program is requesting
     input  and  the  TIP's  own  internal   buffer   of
     charcters is empty.  The DFE can inform the user of
     this situation if it desires.

     Possible states are:
	     NOT EXECUTING
             RUNNING
             STOPPED (due to UDIStop)
             BREAK   (breakpoint hit)
             STEPPED (completed number of steps requested by UDIStep)
             WAITING (wait mode bit set)
             HALTED  (at a halt instruction)
             WARNED  (not executing because WARN line asserted)
             TRAPPED (invalid trap taken; indicates trap number)
             STDOUT_READY (stopped waiting for stdout to be output)
             STDERR_READY (stopped waiting for stderr to be output)
             STDIN_NEEDED (stopped waiting for stdin to be supplied)
*/
UDIError UDIWait(maxtime, pid, stop_reason)
INT32      maxtime;        /* in -- maximum time to wait for completion */
UDIPID     *pid;           /* out -- pid of process which stopped if any */
UINT32     *stop_reason;   /* out -- PC where process stopped */
{
}

/********************************************************** UDI_SET_BREAKPOINT
     UDISetBreakpoint() sets a breakpoint  at  an  ad-
     dress  and  uses  the  passcount  to state how many
     times that instruction should  be  hit  before  the
     break  occurs.   The  passcount  continues to count
     down; even if a different breakpoint is hit and  is
     reinitialized  only when this breakpoint is hit.  A
     passcount value of 0 indicates a non-sticky  break-
     point  that  will  be  removed  whenever  execution
     stops.
*/
UDIError UDISetBreakpoint (addr, passcount, type)
UDIResource	addr;		/* in -- where breakpoint gets set */
INT32		passcount;	/* in -- passcount for breakpoint  */
UDIBreakType	type;		/* in -- breakpoint type */
{
}

/******************************************************** UDI_QUERY_BREAKPOINT
*/
UDIError UDIQueryBreakpoint (addr, count)
UDIResource	addr;		/* in -- where breakpoint gets set */
UINT32		*count;		/* out - passcount for breakpoint  */
{
}

/******************************************************** UDI_CLEAR_BREAKPOINT
     UDIClearBreakpoint() is used to  clear  a  break-
     point.
*/
UDIError UDIClearBreakpoint (addr)
UDIResource	addr;	/* in -- which breakpoint to clear */
{
}

/************************************************************** UDI_GET_STDOUT
     UDIGetStdout()  is  called   when   a   call   to
     UDIWait()  returns  with  the status STDOUT_READY.
     The parameter "buf" specifies the DFE's buffer  ad-
     dress  which  is  expected to be filled by the TIP.
     The parameter "bufsize" specifies the size of  this
     buffer.  On return; count_done is set to the number
     of bytes actually written to buf.  The  DFE  should
     keep  calling  UDIGetStdout() until count_done is
     less than bufsize.
*/
UDIError UDIGetStdout(buf, bufsize, count_done)
UDIHostMemPtr	buf;		/* out -- buffer to be filled */
CPUSizeT	bufsize;	/* in -- buffer size in bytes */
CPUSizeT	*count_done;	/* out -- number of bytes written to buf */
{
}

/************************************************************** UDI_GET_STDERR
     UDIGetStderr()  is  called   when   a   call   to
     UDIWait()  returns  with  the status STDERR_READY.
     In   other    respects    it    is    similar    to
     UDIGetStdout().
*/
UDIError UDIGetStderr(buf, bufsize, count)
UDIHostMemPtr buf;	/* out -- buffer to be filled */
UINT32	bufsize;	/* in  -- buffer size in bytes */
INT32	*count;		/* out -- number of bytes written to buf */
{
}

/*************************************************************** UDI_PUT_STDIN
     UDIPutStdin() is called whenever the DFE wants to
     deliver an input character to the TIP.  This may be
     in response to a status STDIN_NEEDED but  need  not
     be.   (Some  target  operating  systems  will never
     block for input).  Any buffering and  line  editing
     of  the  stdin  characters is done under control of
     the TIP.
*/
INT32	UDIPutStdin (buf, bufsize, count)
UDIHostMemPtr buf;	/* out - buffer to be filled */
UINT32	bufsize;	/* in -- buffer size in bytes */
INT32	*count;		/* out - number of bytes written to buf */
{
}

/*************************************************************** UDI_PUT_TRANS
     UDIPutTrans() is used to feed input to  the  pass-
     thru  mode.   The  parameter "buf" is points to the
     input data in DFE memory.   The  parameter  "count"
     specifies the number of bytes.
*/
INT32	UDIPutTrans (buf, count)
UDIHostMemPtr	buf;	/* in -- buffer address containing input data */
CPUSizeT	count;	/* in -- number of bytes in buf */
{
}

/*************************************************************** UDI_GET_TRANS
     UDIGetTrans() is used to get output lines from the
     pass-thru mode The parameter "buf" specifies to the
     buffer to be filled in DFE space.  "bufsize" speci-
     fies the size of the buffer and; on return, "count"
     is set to the number of bytes put  in  the  buffer.
     The DFE should continue to call UDIGetTrans() un-
     til count is less than bufsize.  Other possible re-
     turn values are:
             EOF -- leave transparent mode
             UDI_GET_INPUT -- host should get  some  in-
     put;                                  then     call
     UDIPutTrans().
*/
INT32	UDIGetTrans (buf, bufsize, count)
UDIHostMemPtr	buf;		/* out -- buffer to be filled */
CPUSizeT	bufsize;	/* in  -- size of buf */
CPUSizeT	*count;		/* out -- number of bytes in buf */
{
}