Archipelago » qemu

    int has_movcal;

    env->movcal_backup_tail = &(env->movcal_backup);

    /* This code tries to make movcal emulation sufficiently

       accurate for Linux purposes.  This instruction writes

       memory, and prior to that, always allocates a cache line.

       It is used in two contexts:

       - in memcpy, where data is copied in blocks, the first write

       of to a block uses movca.l for performance.

       - in arch/sh/mm/cache-sh4.c, movcal.l + ocbi combination is used

       to flush the cache. Here, the data written by movcal.l is never

       written to memory, and the data written is just bogus.

       To simulate this, we simulate movcal.l, we store the value to memory,

       but we also remember the previous content. If we see ocbi, we check

       if movcal.l for that address was done previously. If so, the write should

       not have hit the memory, so we restore the previous content.

       When we see an instruction that is neither movca.l

       nor ocbi, the previous content is discarded.

       To optimize, we only try to flush stores when we're at the start of

       TB, or if we already saw movca.l in this TB and did not flush stores

       yet.  */

    if (ctx->has_movcal)

	{

	  int opcode = ctx->opcode & 0xf0ff;

	  if (opcode != 0x0093 /* ocbi */

	      && opcode != 0x00c3 /* movca.l */)

	      {

		  gen_helper_discard_movcal_backup ();

		  ctx->has_movcal = 0;

	      }

	}

        {

            TCGv val = tcg_temp_new();

            tcg_gen_qemu_ld32u(val, REG(B11_8), ctx->memidx);

            gen_helper_movcal (REG(B11_8), val);            

            tcg_gen_qemu_st32(REG(0), REG(B11_8), ctx->memidx);

        }

        ctx->has_movcal = 1;

	    gen_helper_ocbi (REG(B11_8));

    ctx.has_movcal = (tb->flags & TB_FLAG_PENDING_MOVCA);