Ejemplo n.º 1
0
static void
handle_pread (char *own_buf, int *new_packet_len)
{
  int fd, ret, len, offset, bytes_sent;
  char *p, *data;

  p = own_buf + strlen ("vFile:pread:");

  if (require_int (&p, &fd)
      || require_comma (&p)
      || require_valid_fd (fd)
      || require_int (&p, &len)
      || require_comma (&p)
      || require_int (&p, &offset)
      || require_end (p))
    {
      hostio_packet_error (own_buf);
      return;
    }

  data = xmalloc (len);
#ifdef HAVE_PREAD
  ret = pread (fd, data, len, offset);
#else
  ret = -1;
#endif
  /* If we have no pread or it failed for this file, use lseek/read.  */
  if (ret == -1)
    {
      ret = lseek (fd, offset, SEEK_SET);
      if (ret != -1)
	ret = read (fd, data, len);
    }

  if (ret == -1)
    {
      hostio_error (own_buf);
      free (data);
      return;
    }

  bytes_sent = hostio_reply_with_data (own_buf, data, ret, new_packet_len);

  /* If we were using read, and the data did not all fit in the reply,
     we would have to back up using lseek here.  With pread it does
     not matter.  But we still have a problem; the return value in the
     packet might be wrong, so we must fix it.  This time it will
     definitely fit.  */
  if (bytes_sent < ret)
    bytes_sent = hostio_reply_with_data (own_buf, data, bytes_sent,
					 new_packet_len);

  free (data);
}
Ejemplo n.º 2
0
static void
handle_setfs (char *own_buf)
{
  char *p;
  int pid;

  /* If the target doesn't have any of the in-filesystem-of methods
     then there's no point in GDB sending "vFile:setfs:" packets.  We
     reply with an empty packet (i.e. we pretend we don't understand
     "vFile:setfs:") and that should stop GDB sending any more.  */
  if (the_target->multifs_open == NULL
      && the_target->multifs_unlink == NULL
      && the_target->multifs_readlink == NULL)
    {
      own_buf[0] = '\0';
      return;
    }

  p = own_buf + strlen ("vFile:setfs:");

  if (require_int (&p, &pid)
      || pid < 0
      || require_end (p))
    {
      hostio_packet_error (own_buf);
      return;
    }

  hostio_fs_pid = pid;

  hostio_reply (own_buf, 0);
}
Ejemplo n.º 3
0
static void
handle_fstat (char *own_buf, int *new_packet_len)
{
  int fd, bytes_sent;
  char *p;
  struct stat st;
  struct fio_stat fst;

  p = own_buf + strlen ("vFile:fstat:");

  if (require_int (&p, &fd)
      || require_valid_fd (fd)
      || require_end (p))
    {
      hostio_packet_error (own_buf);
      return;
    }

  if (fstat (fd, &st) == -1)
    {
      hostio_error (own_buf);
      return;
    }

  host_to_fileio_stat (&st, &fst);

  bytes_sent = hostio_reply_with_data (own_buf,
				       (char *) &fst, sizeof (fst),
				       new_packet_len);

  /* If the response does not fit into a single packet, do not attempt
     to return a partial response, but simply fail.  */
  if (bytes_sent < sizeof (fst))
    write_enn (own_buf);
}
Ejemplo n.º 4
0
static void
handle_close (char *own_buf)
{
  int fd, ret;
  char *p;
  struct fd_list **open_fd_p, *old_fd;

  p = own_buf + strlen ("vFile:close:");

  if (require_int (&p, &fd)
      || require_valid_fd (fd)
      || require_end (p))
    {
      hostio_packet_error (own_buf);
      return;
    }

  ret = close (fd);

  if (ret == -1)
    {
      hostio_error (own_buf);
      return;
    }

  open_fd_p = &open_fds;
  while (*open_fd_p && (*open_fd_p)->fd != fd)
    open_fd_p = &(*open_fd_p)->next;

  old_fd = *open_fd_p;
  *open_fd_p = (*open_fd_p)->next;
  free (old_fd);

  hostio_reply (own_buf, ret);
}
Ejemplo n.º 5
0
static void
handle_open (char *own_buf)
{
  char filename[HOSTIO_PATH_MAX];
  char *p;
  int fileio_flags, fileio_mode, flags, fd;
  mode_t mode;
  struct fd_list *new_fd;

  p = own_buf + strlen ("vFile:open:");

  if (require_filename (&p, filename)
      || require_comma (&p)
      || require_int (&p, &fileio_flags)
      || require_comma (&p)
      || require_int (&p, &fileio_mode)
      || require_end (p)
      || fileio_to_host_openflags (fileio_flags, &flags)
      || fileio_to_host_mode (fileio_mode, &mode))
    {
      hostio_packet_error (own_buf);
      return;
    }

  /* We do not need to convert MODE, since the fileio protocol
     uses the standard values.  */
  if (hostio_fs_pid != 0 && the_target->multifs_open != NULL)
    fd = the_target->multifs_open (hostio_fs_pid, filename,
				   flags, mode);
  else
    fd = open (filename, flags, mode);

  if (fd == -1)
    {
      hostio_error (own_buf);
      return;
    }

  /* Record the new file descriptor.  */
  new_fd = xmalloc (sizeof (struct fd_list));
  new_fd->fd = fd;
  new_fd->next = open_fds;
  open_fds = new_fd;

  hostio_reply (own_buf, fd);
}
Ejemplo n.º 6
0
static void
handle_pwrite (char *own_buf, int packet_len)
{
  int fd, ret, len, offset;
  char *p, *data;

  p = own_buf + strlen ("vFile:pwrite:");

  if (require_int (&p, &fd)
      || require_comma (&p)
      || require_valid_fd (fd)
      || require_int (&p, &offset)
      || require_comma (&p)
      || require_data (p, packet_len - (p - own_buf), &data, &len))
    {
      hostio_packet_error (own_buf);
      return;
    }

#ifdef HAVE_PWRITE
  ret = pwrite (fd, data, len, offset);
#else
  ret = -1;
#endif
  /* If we have no pwrite or it failed for this file, use lseek/write.  */
  if (ret == -1)
    {
      ret = lseek (fd, offset, SEEK_SET);
      if (ret != -1)
	ret = write (fd, data, len);
    }

  if (ret == -1)
    {
      hostio_error (own_buf);
      free (data);
      return;
    }

  hostio_reply (own_buf, ret);
  free (data);
}
Ejemplo n.º 7
0
static void
handle_open (char *own_buf)
{
  char filename[PATH_MAX];
  char *p;
  int fileio_flags, mode, flags, fd;
  struct fd_list *new_fd;

  p = own_buf + strlen ("vFile:open:");

  if (require_filename (&p, filename)
      || require_comma (&p)
      || require_int (&p, &fileio_flags)
      || require_comma (&p)
      || require_int (&p, &mode)
      || require_end (p)
      || fileio_open_flags_to_host (fileio_flags, &flags))
    {
      hostio_packet_error (own_buf);
      return;
    }

  /* We do not need to convert MODE, since the fileio protocol
     uses the standard values.  */
  fd = open (filename, flags, mode);

  if (fd == -1)
    {
      hostio_error (own_buf);
      return;
    }

  /* Record the new file descriptor.  */
  new_fd = xmalloc (sizeof (struct fd_list));
  new_fd->fd = fd;
  new_fd->next = open_fds;
  open_fds = new_fd;

  hostio_reply (own_buf, fd);
}
Ejemplo n.º 8
0
static void
handle_pread (char *own_buf, int *new_packet_len)
{
  int fd, ret, len, offset, bytes_sent;
  char *p, *data;
  static int max_reply_size = -1;

  p = own_buf + strlen ("vFile:pread:");

  if (require_int (&p, &fd)
      || require_comma (&p)
      || require_valid_fd (fd)
      || require_int (&p, &len)
      || require_comma (&p)
      || require_int (&p, &offset)
      || require_end (p))
    {
      hostio_packet_error (own_buf);
      return;
    }

  /* Do not attempt to read more than the maximum number of bytes
     hostio_reply_with_data can fit in a packet.  We may still read
     too much because of escaping, but this is handled below.  */
  if (max_reply_size == -1)
    {
      sprintf (own_buf, "F%x;", PBUFSIZ);
      max_reply_size = PBUFSIZ - strlen (own_buf);
    }
  if (len > max_reply_size)
    len = max_reply_size;

  data = xmalloc (len);
#ifdef HAVE_PREAD
  ret = pread (fd, data, len, offset);
#else
  ret = -1;
#endif
  /* If we have no pread or it failed for this file, use lseek/read.  */
  if (ret == -1)
    {
      ret = lseek (fd, offset, SEEK_SET);
      if (ret != -1)
	ret = read (fd, data, len);
    }

  if (ret == -1)
    {
      hostio_error (own_buf);
      free (data);
      return;
    }

  bytes_sent = hostio_reply_with_data (own_buf, data, ret, new_packet_len);

  /* If we were using read, and the data did not all fit in the reply,
     we would have to back up using lseek here.  With pread it does
     not matter.  But we still have a problem; the return value in the
     packet might be wrong, so we must fix it.  This time it will
     definitely fit.  */
  if (bytes_sent < ret)
    bytes_sent = hostio_reply_with_data (own_buf, data, bytes_sent,
					 new_packet_len);

  free (data);
}
Ejemplo n.º 9
0
void generate_first_pass() {
    int tok = 0, i = 0;
    unsigned short temp = 0;
    int  label_pc = -1;

    while( (tok=yylex()) ) {
        switch(tok) {
        case LODD:
            emit_label_op(12, "LODD", "0000");
            break;
        case STOD:
            emit_label_op(12, "STOD", "0001");
            break;
        case ADDD:
            emit_label_op(12, "ADDD", "0010");
            break;
        case SUBD:
            emit_label_op(12, "SUBD", "0011");
            break;
        case JPOS:
            emit_label_op(12, "JPOS", "0100");
            break;
        case JZER:
            emit_label_op(12, "JZER", "0101");
            break;
        case JUMP:
            emit_label_op(12, "JUMP", "0110");
            break;
        case LOCO:
            emit_label_op(12, "LOCO", "0111");
            break;
        case LODL:
            emit_int_op(12, "LODL", "1000");
            break;
        case STOL:
            emit_int_op(12, "STOL", "1001");
            break;
        case ADDL:
            emit_int_op(12, "ADDL", "1010");
            break;
        case SUBL:
            emit_int_op(12, "SUBL", "1011");
            break;
        case JNEG:
            emit_label_op(12, "JNEG", "1100");
            break;
        case JNZE:
            emit_label_op(12, "JNZE", "1101");
            break;
        case CALL:
            emit_label_op(12, "CALL", "1110");
            break;
        case PSHI:
            emit_fixed_op( 0, "PSHI", "1111000");
            break;
        case POPI:
            emit_fixed_op( 0, "POPI", "1111001");
            break;
        case PUSH:
            emit_fixed_op( 0, "PUSH", "1111010");
            break;
        case  POP:
            emit_fixed_op( 0,  "POP", "1111011");
            break;
        case RETN:
            emit_fixed_op( 0, "RETN", "1111100");
            break;
        case SWAP:
            emit_fixed_op( 0, "SWAP", "1111101");
            break;
        case INSP:
            emit_int_op( 8, "INSP", "11111100");
            break;
        case DESP:
            emit_int_op( 8, "DESP", "11111110");
            break;
        case HALT:
            emit_fixed_op( 0, "HALT", "11111111");
            break;

        case INTEG:
            str_16(yytext);
            fprintf(p1,"%d  %.16s\n", pc, cstr_16);
            break;

        case LABEL:
            if (label_pc == pc) {   /* for < lbx: lby: >   */
                fprintf(p1,"%d  U0000000000000000    %s\n", pc, yytext);
                break;
            }
            search_sym_table(yytext);
            update_sym_table(yytext);
            label_pc = pc;
            pc--;
            break;

        case LOC:
            require_int(12, ".LOC");
            if((temp = ((unsigned short)atoi(yytext) )) < pc) {
                fprintf(stderr,"Bad operand after .LOC is %s, TOO SMALL !\n",yytext);
                exit(1);
            }
            pc = temp - 1;
            break;

        case STR:
            i=1;
            do {
                if(*(yytext+i) == '\"') {
                    bstr_16(0);
                    fprintf(p1,"%d  %.16s\n", pc, cstr_16);
                    break;
                }
                temp = (unsigned short)*(yytext+i++);
                if(*(yytext+i) != '\"') {
                    temp = (temp | ((unsigned short)*(yytext+i) << 8));
                }
                bstr_16(temp);
                fprintf(p1,"%d  %.16s\n", pc, cstr_16);
            } while (*(yytext+i++) != '\"' && ++pc);
            break;

        case JUNK:
            fprintf(stderr,"Unrecognized token is %s\n",yytext);
            exit(26);

        default:
            fprintf(stderr,"Default case, unrecoverable error\n");
            exit(26);
        }
        pc++;
    }
}
Ejemplo n.º 10
0
void emit_int_op(char n, const char *op, const char* code) {
    require_int(n, op);
    fprintf(p1,"%d  %s%.*s\n", pc, code, n, cstr_16);
}