writecode.c

这个是LINUX下的GDB调度工具的源码

char nx[] = "goto next;";

struct
{
  char *ftype;
  int decode;
  char *name;
  void (*func) ();
  char *arg;
  int size;

}

table[] =
{
  {
    nx, 1, "bld", bit, "dst = srcb; c = (srcb>>srca)&1;", 8
  }
  ,
  {
    nx, 1, "bild", bit, "dst = srcb; c = !((srcb>>srca)&1);", 8
  }
  ,
  {
    nx, 1, "band", bit, "dst = srcb; c = C &&((srcb>>srca)&1);", 8
  }
  ,
  {
    nx, 1, "biand", bit, "dst = srcb; c = C &&(!((srcb>>srca)&1));", 8
  }
  ,
  {
    nx, 1, "bior", bit, "dst = srcb; c = C ||(!((srcb>>srca)&1));", 8
  }
  ,
  {
    nx, 1, "bor", bit, "dst = srcb; c = C ||(((srcb>>srca)&1));", 8
  }
  ,
  {
    nx, 1, "bixor", bit, "dst = srcb; c = C ^(!((srcb>>srca)&1));", 8
  }
  ,
  {
    nx, 1, "bxor", bit, "dst = srcb; c = C ^(((srcb>>srca)&1));", 8
  }
  ,
  {
    nx, 1, "bnot", bit, "dst = srcb ^ (1<<srca);", 8
  }
  ,
  {
    nx, 1, "bclr", bit, "dst = srcb & ~(1<<srca);", 8
  }
  ,
  {
    nx, 1, "bset", bit, "dst = srcb | (1<<srca);", 8
  }
  ,
  {
    nx, 1, "bst", bit, "dst = (srcb & ~(1<<srca))| ((C)<<srca);", 8
  }
  ,
  {
    nx, 1, "bist", bit, "dst = (srcb & ~(1<<srca))| ((!C)<<srca);", 8
  }
  ,
  {
    nx, 1, "btst", bit, "dst = srcb; z = !((srcb>>srca)&1);", 8
  }
  ,
  {
    icf, 0, "dec", dec, 0, 0
  }
  ,
  {
    icf, 0, "inc", inc, 0, 0
  }
  ,
  {
    saf, 1, "orc", setf, "|", 0
  }
  ,
  {
    saf, 1, "xorc", setf, "^", 0
  }
  ,
  {
    saf, 1, "andc", setf, "&", 0
  }
  ,
  {
    nx, 1, "nop", nop, 0, 0
  }
  ,
  {
    nx, 1, "bra", bra, "1", 0
  }
  ,
  {
    nx, 1, "brn", bra, "0", 0
  }
  ,
  {
    nx, 1, "bhi", bra, "(C||Z)==0", 0
  }
  ,
  {
    nx, 1, "bls", bra, "(C||Z)==1", 0
  }
  ,
  {
    nx, 1, "bcs", bra, "C==1", 0
  }
  ,
  {
    nx, 1, "bcc", bra, "C==0", 0
  }
  ,
  {
    nx, 1, "bpl", bra, "N==0", 0
  }
  ,
  {
    nx, 1, "bmi", bra, "N==1", 0
  }
  ,
  {
    nx, 1, "bvs", bra, "V==1", 0
  }
  ,
  {
    nx, 1, "bvc", bra, "V==0", 0
  }
  ,
  {
    nx, 1, "bge", bra, "(N^V)==0", 0
  }
  ,
  {
    nx, 1, "bgt", bra, "(Z|(N^V))==0", 0
  }
  ,
  {
    nx, 1, "blt", bra, "(N^V)==1", 0
  }
  ,
  {
    nx, 1, "ble", bra, "(Z|(N^V))==1", 0
  }
  ,
  {
    nx, 1, "beq", bra, "Z==1", 0
  }
  ,
  {
    nx, 1, "bne", bra, "Z==0", 0
  }
  ,
  {
    nx, 1, "bsr", bsr, "", 0
  }
  ,
  {
    nx, 1, "jsr", jsr, 0, 0
  }
  ,
  {
    nx, 1, "jmp", jmp, 0, 0
  }
  ,
  {
    nx, 0, "rts", rts, 0, 0
  }
  ,
  {
    nx, 0, "rte", rte, 0, 0
  }
  ,
  {
    nx, 1, "andc", andc, 0, 0
  }
  ,
  {
    sf, 1, "shal", shal, 0, 0
  }
  ,
  {
    sf, 1, "shar", shar, 0, 0
  }
  ,
  {
    sf, 1, "shll", shll, 0, 0
  }
  ,
  {
    sf, 1, "shlr", shlr, 0, 0
  }
  ,
  {
    sf, 1, "rotxl", rotxl, 0, 0
  }
  ,
  {
    sf, 1, "rotxr", rotxr, 0, 0
  }
  ,
  {
    sf, 1, "rotl", rotl, 0, 0
  }
  ,
  {
    sf, 1, "rotr", rotr, 0, 0
  }
  ,
  {
    lf, 1, "xor", log, "^", 0
  }
  ,
  {
    lf, 1, "and", log, "&", 0
  }
  ,
  {
    lf, 1, "or", log, "|", 0
  }
  ,
  {
    lf, 1, "not", ulog, " ~", 0
  }
  ,
  {
    lf, 1, "neg", ulog, " - ", 0
  }
  ,
  {
    nx, 1, "adds", adds, "dst = srca + srcb", 0
  }
  ,
  {
    nx, 1, "subs", adds, "srca = -srca; dst = srcb + srca", 0
  }
  ,
  {
    af8, 1, "add.b", add, "dst = srca + srcb", 8
  }
  ,
  {
    af16, 1, "add.w", add, "dst = srca + srcb", 16
  }
  ,
  {
    af16, 1, "sub.w", add, "srca = -srca; dst = srcb + srca", 16
  }
  ,
  {
    af8, 1, "sub.b", add, "srca = -srca; dst = srcb + srca", 8
  }
  ,
  {
    af8, 1, "addx", addx, 0, 8
  }
  ,
  {
    af8, 1, "subx", subx, 0, 8
  }
  ,
  {
    af8, 0, "cmp.b", cmp, 0, 8
  }
  ,
  {
    af16, 0, "cmp.w", cmp, 0, 16
  }
  ,
  {
    nx, 1, "sleep", esleep, 0, 0
  }
  ,
  {
    nx, 0, "bpt", bpt, 0, 8
  }
  ,
  {
    nx, 0, "divxu", divxu, 0, 0
  }
  ,
  {
    nx, 0, "mulxu", mulxu, 0, 0
  }
  ,
  {
    mf8, 1, "mov.b", mov, 0, 8
  }
  ,
  {
    mf8, 1, "movtpe", mov, 0, 8
  }
  ,
  {
    mf8, 1, "movfpe", mov, 0, 8
  }
  ,
  {
    mf16, 1, "mov.w", mov, 0, 16
  }
  ,
  {
    0
  }
};

static
void
edo (p)
     struct h8_opcode *p;
{
  int i;

  printf ("%s %s %s\n", cs, p->name, ce);

  for (i = 0; table[i].name; i++)
    {
      if (strcmp (table[i].name, p->name) == 0)
	{
	  printf ("{\n");
	  if (table[i].decode)
	    decode (p, 1, table[i].size);
	  printf ("cycles += %d;\n", p->time);
	  printf ("npc = pc + %d;\n", p->length / 2);
	  table[i].func (p, table[i].arg, table[i].size);
	  if (table[i].decode)
	    decode (p, 0, table[i].size);
	  if (table[i].ftype)
	    printf (table[i].ftype);
	  else
	    printf ("goto next;\n");
	  printf ("}\n");
	  return;
	}
    }
  printf ("%s not found %s\n", cs, ce);
  printf ("saved_state.exception = SIGILL;\n");
  printf ("break;\n");
}

static
int
owrite (i)
     int i;
{
  /* write if statements to select the right opcode */
  struct h8_opcode **p;
  int needand = 1;

  p = h8_opcodes_sorted[i];
  printf ("case 0x%03x:\n", i);

  if (p[1] == 0)
    {
      /* See if the next few also match */
      while (h8_opcodes_sorted[i + 1][0] == *p)
	{
	  i++;
	  printf ("case 0x%03x:\n", i);
	}

      /* Don't need any if's this is the only one */
      edo (*p);
    }
  else
    {
      while (*p)
	{
	  /* start two nibbles in since we know we match in the first byte */
	  int c;
	  int nib = 2;
	  int byte = 1;
	  int mask1[5];
	  int mask0[5];
	  int nibshift = 4;
	  int any = 0;

	  for (c = 0; c < 5; c++)
	    {
	      mask1[c] = 0;
	      mask0[c] = 0;
	    }
	  printf ("%s %x%x", cs, (*p)->data.nib[0], (*p)->data.nib[1]);
	  while ((c = (*p)->data.nib[nib]) != E)
	    {
	      if (c & B30)
		{
		  /* bit 3 must be zero */
		  mask0[byte] |= 0x8 << nibshift;
		  printf ("0");
		  any = 1;
		}
	      else if (c & B31)
		{
		  /* bit 3 must be one */
		  mask1[byte] |= 0x8 << nibshift;
		  printf ("8");
		  any = 1;
		}
	      else if (c <= HexF)
		{
		  mask0[byte] |= ((~c) & 0xf) << nibshift;
		  mask1[byte] |= (c & 0xf) << nibshift;
		  printf ("%x", c);
		  any = 1;
		}
	      else
		{
		  printf ("x");
		}
	      nib++;
	      if (nibshift == 4)
		{
		  nibshift = 0;
		}
	      else
		{
		  byte++;
		  nibshift = 4;
		}
	    }
	  printf ("*/\n");
	  if (any)
	    {
	      printf ("if (");
	      needand = 0;
	      for (c = 1; c < byte; c++)
		{
		  if (mask0[c] | mask1[c])
		    {
		      int sh;

		      if (needand)
			printf ("\n&&");
		      if (c & 1)
			sh = 0;
		      else
			sh = 8;
		      if (c / 2 == 0 && sh == 0)
			printf ("((b1&0x%x)==0x%x)", mask0[c] | mask1[c],
				mask1[c]);
		      else
			{
			  printf ("((pc[%d]&(0x%02x<<%d))==(0x%x<<%d))",
				  c / 2, mask0[c] | mask1[c], sh,
				  mask1[c], sh);
			}

		      needand = 1;
		    }
		}
	      printf (")\n");
	    }
	  edo (*p);
	  p++;

	}
    }
  return i;
}

static
void
remove_dups ()
{
  struct h8_opcode *s;
  struct h8_opcode *d;

  for (d = s = h8_opcodes; s->name; s++)
    {
      int doit = 1;

      if (strcmp (s->name, "push") == 0)
	doit = 0;
      if (strcmp (s->name, "bhs") == 0)
	doit = 0;
      if (strcmp (s->name, "blo") == 0)
	doit = 0;
      if (strcmp (s->name, "bt") == 0)
	doit = 0;
      if (strcmp (s->name, "bf") == 0)
	doit = 0;
      if (strcmp (s->name, "pop") == 0)
	doit = 0;
      if (doit)
	{
	  *d++ = *s;
	}
    }
  *d++ = *s++;
}

int
main ()
{
  int i;

  remove_dups ();
  init ();

  printf ("%s do the operation %s\n", cs, ce);
  printf ("switch (b0) \n{\n");
  for (i = 0; i < PTWO; i++)
    {
      i = owrite (i);
    }
  printf ("}\n");

  return 0;
}