Checkpoint IGEN version of mips sim
authorAndrew Cagney <cagney@redhat.com>
Fri, 24 Oct 1997 06:38:44 +0000 (06:38 +0000)
committerAndrew Cagney <cagney@redhat.com>
Fri, 24 Oct 1997 06:38:44 +0000 (06:38 +0000)
sim/mips/mips.igen

index 347c37ff73b45eb3c0a480b128c5dd48a368f65b..b4ea9f08d4a867bde80fb464049c861c29da85d1 100644 (file)
 :option:16:insn-bit-size:16
 :option:16:hi-bit-nr:15
 :option:16:insn-specifying-widths:true
-:option:16:gen-delayed-branch:true
+:option:16:gen-delayed-branch:false
 
 // IGEN config - mipsI..
 :option:32:insn-bit-size:32
 :option:32:hi-bit-nr:31
 :option:32:insn-specifying-widths:true
-:option:32:gen-delayed-branch:true
+:option:32:gen-delayed-branch:false
 
 
 // Generate separate simulators for each target
-:option::multi-sim:true
+// :option::multi-sim:true
 
 
 // Models known by this simulator
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] == GPR[RT])
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
 }
 
 
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] == GPR[RT])
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
   else
-    NULLIFY_NIA ();
+    NULLIFY_NEXT_INSTRUCTION ();
 }
 
 
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] >= 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
 }
 
 
   address_word offset = EXTEND16 (OFFSET) << 2;
   RA = (CIA + 8);
   if (GPR[RS] >= 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
 }
 
 
   /* NOTE: The branch occurs AFTER the next instruction has been
      executed */
   if (GPR[RS] >= 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
   else
-    NULLIFY_NIA ();
+    NULLIFY_NEXT_INSTRUCTION ();
 }
 
 
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] >= 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
   else
-    NULLIFY_NIA ();
+    NULLIFY_NEXT_INSTRUCTION ();
 }
 
 
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] > 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
 }
 
 
   /* NOTE: The branch occurs AFTER the next instruction has been
      executed */
   if (GPR[RS] > 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
   else
-    NULLIFY_NIA ();
+    NULLIFY_NEXT_INSTRUCTION ();
 }
 
 
   /* NOTE: The branch occurs AFTER the next instruction has been
      executed */
   if (GPR[RS] <= 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
 }
 
 
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] <= 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
   else
-    NULLIFY_NIA ();
+    NULLIFY_NEXT_INSTRUCTION ();
 }
 
 
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] < 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
 }
 
 
   /* NOTE: The branch occurs AFTER the next instruction has been
      executed */
   if (GPR[RS] < 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
 }
 
 
   address_word offset = EXTEND16 (OFFSET) << 2;
   RA = (CIA + 8);
   if (GPR[RS] < 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
   else
-    NULLIFY_NIA ();
+    NULLIFY_NEXT_INSTRUCTION ();
 }
 
 
   /* NOTE: The branch occurs AFTER the next instruction has been
      executed */
   if (GPR[RS] < 0)
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
   else
-    NULLIFY_NIA ();
+    NULLIFY_NEXT_INSTRUCTION ();
 }
 
 
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] != GPR[RT])
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
 }
 
 
 {
   address_word offset = EXTEND16 (OFFSET) << 2;
   if (GPR[RS] != GPR[RT])
-    DSPC = (PC + offset);
+    DELAY_SLOT (PC + offset);
   else
-    NULLIFY_NIA ();
+    NULLIFY_NEXT_INSTRUCTION ();
 }
 
 
 *tx19:
 // end-sanitize-tx19
 {
-  /* NOTE: The region used is that of the delay slot and NOT the
+  /* NOTE: The region used is that of the delay slot NIA and NOT the
      current instruction */
-  address_word region = cia.dp & MASK (63, 28);
-  DSPC = region | (INSTR_INDEX << 2);
+  address_word region = (NIA & MASK (63, 28));
+  DELAY_SLOT (region | (INSTR_INDEX << 2));
 }
 
 
 {
   /* NOTE: The region used is that of the delay slot and NOT the
      current instruction */
-  address_word region = cia.dp & MASK (63, 28);
+  address_word region = (NIA & MASK (63, 28));
   GPR[31] = CIA + 8;
-  DSPC = region | (INSTR_INDEX << 2);
+  DELAY_SLOT (region | (INSTR_INDEX << 2));
 }
 
 
 {
   address_word temp = GPR[RS];
   GPR[RD] = CIA + 8;
-  DSPC = temp;
+  DELAY_SLOT (temp);
 }
 
 
 *tx19:
 // end-sanitize-tx19
 {
-  DSPC = GPR[RS];
+  DELAY_SLOT (GPR[RS]);
 }
 
 
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    uword64 vaddr = ((uword64)op1 + offset);
-    uword64 paddr;
+    address_word vaddr = ((uword64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressLoad();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressLoad();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 1) != 0)
       SignalExceptionAddressLoad();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 1) != 0)
       SignalExceptionAddressLoad();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressLoad();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressLoad();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressLoad();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressLoad();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressLoad();
   int hint = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressStore();
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressStore();
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressStore();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressStore();
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 1) != 0)
       SignalExceptionAddressStore();
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressStore();
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressStore();
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
       int condition = (PREVCOC1() == boolean);
       /* NOTE: The branch occurs AFTER the next instruction has been executed */
       if (condition) {
-       DSPC = (PC + offset);
+       DELAY_SLOT (PC + offset);
       }
       else if (likely) {
-       NULLIFY_NIA ();
+       NULLIFY_NEXT_INSTRUCTION ();
       }
     }
   }
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + op2);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + op2);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressLoad();
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-   unsigned64 vaddr = ((unsigned64)op1 + op2);
-   unsigned64 paddr;
+   address_word vaddr = ((unsigned64)op1 + op2);
+   address_word paddr;
    int uncached;
    if ((vaddr & 3) != 0)
     SignalExceptionAddressLoad();
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + (unsigned64)op2);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + (unsigned64)op2);
+    address_word paddr;
     int uncached;
     if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
       Prefetch(uncached,paddr,vaddr,isDATA,fs);
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + op2);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + op2);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressStore();
   signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-   unsigned64 vaddr = ((unsigned64)op1 + op2);
-   unsigned64 paddr;
+   address_word vaddr = ((unsigned64)op1 + op2);
+   address_word paddr;
    int uncached;
    if ((vaddr & 3) != 0)
     SignalExceptionAddressStore();
   int hint = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = (op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = (op1 + offset);
+    address_word paddr;
     int uncached;
     if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
       CacheOp(hint,vaddr,paddr,instruction);
 // to http://www.sgi.com/MIPS/arch/MIPS16/mips16.pdf.
 
 
+// FIXME: Instead of having the code for mips16 instructions here.
+// these instructions should instead call the corresponding 32bit
+// instruction (or a function implementing that instructions code).
+
+
 // Load and Store Instructions
 
 
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 1) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 1) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressLoad();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     {
       if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 1) != 0)
       SignalExceptionAddressStore();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressStore();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressStore();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 3) != 0)
       SignalExceptionAddressStore();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressStore();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressStore();
   if (have_extendval)
     SignalException (ReservedInstruction, instruction);
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 7) != 0)
       SignalExceptionAddressStore();
   unsigned32 instruction = instruction_0;
   unsigned_word op1 = (instruction >> 0) & 0x7ff;
   {
-    unsigned64 paddr;
+    address_word paddr;
     int uncached;
     if (AddressTranslation (PC &~ (unsigned64) 1, isINSTRUCTION, isLOAD, &paddr, &uncached, isTARGET, isREAL))
       {
        so we just truncate it to 32 bits here.  */
     op1 = VL4_8(op1);
     /* NOTE: The jump occurs AFTER the next instruction has been executed */
-    DSPC = op1;
+    DELAY_SLOT op1;
     JALDELAYSLOT();
   }
 }
        so we just truncate it to 32 bits here.  */
     op1 = VL4_8(op1);
     /* NOTE: The jump occurs AFTER the next instruction has been executed */
-    DSPC = op1;
+    DELAY_SLOT op1;
     DELAYSLOT();
   }
 }
        so we just truncate it to 32 bits here.  */
     op1 = VL4_8(op1);
     /* NOTE: The jump occurs AFTER the next instruction has been executed */
-    DSPC = op1;
+    DELAY_SLOT op1;
     DELAYSLOT();
   }
 }
        so we just truncate it to 32 bits here.  */
     op1 = VL4_8(op1);
     /* NOTE: The jump occurs AFTER the next instruction has been executed */
-    DSPC = op1;
+    DELAY_SLOT op1;
     DELAYSLOT();
   }
 }
        so we just truncate it to 32 bits here.  */
     op1 = VL4_8(op1);
     /* NOTE: The jump occurs AFTER the next instruction has been executed */
-    DSPC = op1;
+    DELAY_SLOT op1;
     /* JALDELAYSLOT(); FIXME */
   }
 }
   int destreg = ((instruction >> 16) & 0x0000001F);
   signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 15) != 0)
       SignalExceptionAddressLoad();
   signed_word rt_reg = GPR[RT];
   signed_word rt_reg1 = GPR1[RT];
   {
-    unsigned64 vaddr = ((unsigned64)op1 + offset);
-    unsigned64 paddr;
+    address_word vaddr = ((unsigned64)op1 + offset);
+    address_word paddr;
     int uncached;
     if ((vaddr & 15) != 0)
       SignalExceptionAddressStore();