pa_stub.c

俄罗斯高人Mamaich的Pocket gcc编译器（运行在PocketPC上）的全部源代码。

     int may_fault;
{
  unsigned char ch;
  int           check_addr,
                new_addr;

  check_addr = 0;

  while (count-- > 0)
    {
      if (may_fault)
      { new_addr = ((int) (mem+3)) & 0xFFFFFFF8;
        if (new_addr != check_addr)
        { check_addr = new_addr;
          if (pdc_call(OPT_PDC_ADD_VALID,0,check_addr)) return 0;
        }
      }
      ch = *mem++;
      *buf++ = hexchars[ch >> 4];
      *buf++ = hexchars[ch & 0xf];
    }

  *buf = 0;

  return buf;
}

/* convert the hex array pointed to by buf into binary to be placed in mem
 * return a pointer to the character AFTER the last byte written */

static unsigned char *
hex2mem(buf, mem, count, may_fault)
     unsigned char *buf;
     unsigned char *mem;
     int count;
     int may_fault;
{
  int          i;
  unsigned int ch;
  int          check_addr,
               new_addr;

  check_addr = 0;

  for (i=0; i<count; i++)
    {
      ch = hex(*buf++) << 4;
      ch |= hex(*buf++);
      if (may_fault)
      { new_addr = ((int)(mem+3)) & 0xFFFFFFF8;
        if (new_addr != check_addr)
        { check_addr = new_addr;
          if (pdc_call(OPT_PDC_ADD_VALID,0,check_addr)) return 0;
        }
      }
      *mem++ = ch;
    }

  return mem;
}

/* Set up exception handlers for traceing and breakpoints */

void
set_debug_traps()
{ 
  unsigned int	R_addr[33];
  unsigned int	*Raddr_ptr;
  
  setup_vectors();
 
  /* get cache params for use by flush_i_cache */
  RADDR_ALIGN(Raddr_ptr,R_addr);

  if (pdc_call(OPT_PDC_CACHE,0,Raddr_ptr,0))
    i_cache_params[0] = -1;
  else
    i_cache_params[0] = R_addr[0];

  i_cache_params[1] = Raddr_ptr[1];
  i_cache_params[2] = Raddr_ptr[2];
  i_cache_params[3] = Raddr_ptr[3];
  i_cache_params[4] = Raddr_ptr[4];
  i_cache_params[5] = Raddr_ptr[5];

  /* In case GDB is started before us, ack any packets (presumably
     "$?#xx") sitting there.  */

  putDebugChar ('+');

  initialized = 1;
}


/* Convert the PA-RISC hardware trap number to a unix signal number. */

static int
computeSignal(tt)
     int tt;
{
  struct hard_trap_info *ht;

  for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
    if (ht->tt == tt)
      return ht->signo;

  return SIGHUP;		/* default for things we don't know about */
}

/*
 * While we find nice hex chars, build an int.
 * Return number of chars processed.
 */

static int
hexToInt(ptr, intValue)
     unsigned char **ptr;
     int *intValue;
{
  int numChars = 0;
  int hexValue;

  *intValue = 0;

  while (**ptr)
    {
      hexValue = hex(**ptr);
      if (hexValue < 0)
	break;

      *intValue = (*intValue << 4) | hexValue;
      numChars ++;

      (*ptr)++;
    }

  return (numChars);
}

void
flush_i_cache()

{
  unsigned int addr,count,loop;

  if (i_cache_params[0] <= 0) return;

  addr = i_cache_params[2];
  for (count = 0; count < i_cache_params[4]; count++)
    { for ( loop = 0; loop < i_cache_params[5]; loop++) FICE(addr);
      addr = addr + i_cache_params[3];
    }
}

/*
 * This function does all command procesing for interfacing to gdb.
   return of 0 will execute DEBUG_GO (continue)
   return of 1 will execute DEBUG_SS (single step)
 */

int
handle_exception (registers,tt)
  unsigned long *registers;
  int  tt;			/* Trap type */
{
  int sigval;
  int addr;
  int length;
  unsigned char *ptr;

  /* reply to host that an exception has occurred */
  sigval = computeSignal(tt);
  ptr = remcomOutBuffer;

  *ptr++ = 'T';
  *ptr++ = hexchars[sigval >> 4];
  *ptr++ = hexchars[sigval & 0xf];

/* could be lots of stuff here like PC and SP registers */

  *ptr++ = 0;

  putpacket(remcomOutBuffer);

  while (1)
    {
      remcomOutBuffer[0] = 0;

      getpacket(remcomInBuffer);
      switch (remcomInBuffer[0])
	{
	case '?':
	  remcomOutBuffer[0] = 'S';
	  remcomOutBuffer[1] = hexchars[sigval >> 4];
	  remcomOutBuffer[2] = hexchars[sigval & 0xf];
	  remcomOutBuffer[3] = 0;
	  break;

	case 'd':
	  /* toggle debug flag */
	  led_putnum (16);
	  break;

	case 'g':		/* return the value of the CPU registers */
	  {
	    ptr = remcomOutBuffer;
            /* GR0..GR31 SR0..SR7 CR0..CR31 specials */
	    ptr = mem2hex((char *)registers, ptr, NUMREGBYTES, 0);
            /* need to add floating point registers */
	  }
	  break;

	case 'G':	   /* set the value of the CPU registers - return OK */
	  {
	    ptr = &remcomInBuffer[1];
            /* GR0..GR31 SR0..SR7 CR0..CR31 specials */
	    hex2mem(ptr, (char *)registers, NUMREGBYTES, 0);
	    strcpy(remcomOutBuffer,"OK 1");
	  }
	  break;

	case 'm':	  /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
	  /* Try to read %x,%x.  */

	  ptr = &remcomInBuffer[1];

	  if (hexToInt(&ptr, &addr)
	      && *ptr++ == ','
	      && hexToInt(&ptr, &length))
	    {
	      if (mem2hex((char *)addr, remcomOutBuffer, length, 1))
		break;

	      strcpy (remcomOutBuffer, "E03");
	    }
	  else
	    strcpy(remcomOutBuffer,"E01");
	  break;

	case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
	  /* Try to read '%x,%x:'.  */

	  ptr = &remcomInBuffer[1];

	  if (hexToInt(&ptr, &addr)
	      && *ptr++ == ','
	      && hexToInt(&ptr, &length)
	      && *ptr++ == ':')
	    {
	      if (hex2mem(ptr, (char *)addr, length, 1))
		strcpy(remcomOutBuffer, "OK");
	      else
		strcpy(remcomOutBuffer, "E03");
	    }
	  else
	    strcpy(remcomOutBuffer, "E02");
	  break;

	case 'c':    /* cAA..AA    Continue at address AA..AA(optional) */
	  /* try to read optional parameter, pc unchanged if no parm */

	  ptr = &remcomInBuffer[1];
	  if (hexToInt(&ptr, &addr))
	    {
	      registers[PC] = addr;
	      registers[NPC] = addr + 4;
	    }

/* Need to flush the instruction cache here, as we may have deposited a
   breakpoint, and the icache probably has no way of knowing that a data ref to
   some location may have changed something that is in the instruction cache.
 */

	  flush_i_cache();
	  return 0;		/* execute GO */

	  /* kill the program */
	case 'k' :		/* do nothing */
	  break;

        case 's' :              /* single step */
	  /* try to read optional parameter, pc unchanged if no parm */

	  ptr = &remcomInBuffer[1];
	  if (hexToInt(&ptr, &addr))
	    {
	      registers[PC] = addr;
	      registers[NPC] = addr + 4;
	    }
/* Need to flush the instruction cache here, as we may have deposited a
   breakpoint, and the icache probably has no way of knowing that a data ref to
   some location may have changed something that is in the instruction cache.
 */
	  flush_i_cache();
	  return 1;		/* execute Single Step */
          break;

#if TESTING1
	case 't':		/* Test feature */
	  break;
#endif
	case 'r':		/* Reset */
	  break;

#if TESTING2
Disabled until we can unscrew this properly

	case 'b':	  /* bBB...  Set baud rate to BB... */
	  {
	    int baudrate;
	    extern void set_timer_3();

	    ptr = &remcomInBuffer[1];
	    if (!hexToInt(&ptr, &baudrate))
	      {
		strcpy(remcomOutBuffer,"B01");
		break;
	      }

	    /* Convert baud rate to uart clock divider */
	    switch (baudrate)
	      {
	      case 38400:
		baudrate = 16;
		break;
	      case 19200:
		baudrate = 33;
		break;
	      case 9600:
		baudrate = 65;
		break;
	      default:
		strcpy(remcomOutBuffer,"B02");
		goto x1;
	      }

	    putpacket("OK 2");	/* Ack before changing speed */
	    set_timer_3(baudrate); /* Set it */
	  }
x1:	  break;
#endif
	}			/* switch */

      /* reply to the request */
      putpacket(remcomOutBuffer);
    }
  print ("\r\nEscaped handle_exception\r\n");
}