Simulator: base_insn and insn in decode.c

[Ronald Hecht]

Hello again,

i found another problem in decode. c. As I have variable instruction 
size, decode.c does not handle base_insn and insn in the right way. The 
file looks like this:

const IDESC *
proc8bf_decode (SIM_CPU *current_cpu, IADDR pc,
              CGEN_INSN_INT base_insn, CGEN_INSN_INT entire_insn,
              ARGBUF *abuf)
{
  /* Result of decoder.  */
  PROC8BF_INSN_TYPE itype;

  {
    CGEN_INSN_INT insn = base_insn;

    {
      unsigned int val = (((insn >> 0) & (63 << 0)));
      switch (val)
      {
      case 0 :
        if ((entire_insn & 0xff) == 0x0)
          { itype = PROC8BF_INSN_NOP; goto extract_sfmt_nop; }
        itype = PROC8BF_INSN_X_INVALID; goto extract_sfmt_empty;
      case 1 :
        if ((entire_insn & 0xff) == 0x1)
          { itype = PROC8BF_INSN_LDA; goto extract_sfmt_lda; }
        itype = PROC8BF_INSN_X_INVALID; goto extract_sfmt_empty;
      case 2 :
        if ((entire_insn & 0xff) == 0x2)
          { itype = PROC8BF_INSN_LDC; goto extract_sfmt_ldc; }
        itype = PROC8BF_INSN_X_INVALID; goto extract_sfmt_empty;
 
<snip>

I have given the first instruction byte as base_insn and entire_insn is 
the complete instruction. The location of the base instruction depends 
on the instruction size. So the calculation

      unsigned int val = (((insn >> 0) & (63 << 0)));

is not correct. If I remove the if-statement around the goto 
extract_sfmt_<insn> everything works correct. The simulatior does the 
right things.

By the way: I found it a bit confusing to write mloop.in. It was 
difficult to handle different size instructions. I did it this way:

xextract-pbb)

# Inputs:  current_cpu, pc, sc, max_insns, FAST_P
# Outputs: sc, pc
# sc must be left pointing past the last created entry.
# pc must be left pointing past the last created entry.
# If the pbb is terminated by a cti insn, SET_CTI_VPC(sc) must be called
# to record the vpc of the cti insn.
# SET_INSN_COUNT(n) must be called to record number of real insns.

cat <<EOF
{
  const IDESC *idesc;
  int icount = 0;

  while (max_insns > 0)
    {
      CGEN_INSN_INT insn;
      CGEN_INSN_INT base_insn = GETIMEMUQI (current_cpu, pc);
      idesc = @cpu@_decode(current_cpu, pc, base_insn, base_insn, 
&sc->argbuf);
      switch (idesc->length) {
      case 1 : break;
      case 2 :
    insn = base_insn * 256 + GETIMEMUQI (current_cpu, pc + 1);
    break;
      case 3 :
    insn = base_insn * 256 * 256 + GETIMEMUQI (current_cpu, pc + 1) * 
256 + GETIMEMUQI (current_cpu, pc + 2);
    break;
      }
      idesc = @cpu@_decode(current_cpu, pc, base_insn, insn, &sc->argbuf);
      @cpu@_fill_argbuf (current_cpu, &sc->argbuf, idesc, pc, FAST_P);
      if (! FAST_P) {
    int trace_p = PC_IN_TRACE_RANGE_P (current_cpu, pc);
    int profile_p = PC_IN_PROFILE_RANGE_P (current_cpu, pc);
    @cpu@_fill_argbuf_tp (current_cpu, &sc->argbuf, trace_p, profile_p);
      }
      ++sc;
      --max_insns;
      ++icount;
      pc += idesc->length;
      if (IDESC_CTI_P (idesc))
    {
      SET_CTI_VPC (sc - 1);
      break;
    }
    }
 
 Finish:
  SET_INSN_COUNT (icount);
}
EOF

;;

Is there an easier way to write this down?

Ronald