Encoding:

POOL32A

000000

000 0000 0011 0100 1101

POOL32AXf

111100

Format:

IRET

microMIPS, MCU ASE

Interrupt Return with automated interrupt epilogue handling

Purpose:

Interrupt Return with automated interrupt epilogue handling

Optionally jump directly to another interrupt vector without returning to original return address.

Description:

IRET automates some of the operations that are required when returning from an interrupt handler and can be used in place of the ERET instruction at the end of interrupt handlers. IRET is only appropriate when using Shadow Register

Sets and the EIC Interrupt mode. The automated operations of this instruction can be used to reverse the effects of the automated operations of the Auto-Prologue feature.

If the EIC interrupt mode and the Interrupt Chaining feature are used, the IRET instruction can be used to shorten the time between returning from the current interrupt handler and handling the next requested interrupt.

If the Automated Prologue feature is disabled, then IRET behaves exactly like ERET.

If either the Status_ERL or Status_BEV bits are set, then IRET behaves exactly like ERET.

If Interrupt Chaining is disabled:

Interrupts are disabled. COP0 Status, SRSCtl, and EPC registers are restored from the stack. GPR 29 is incremented for the stack frame size. IRET then clears execution and instruction hazards, conditionally restores

SRSCtl_CSS from SRSCtl_PSS, and returns at the completion of interrupt processing to the interrupted instruction

pointed to by the EPC register.

If Interrupt Chaining is enabled:

Interrupts are disabled. COP0 Status register is restored from the stack. The priority output of the External Interrupt Controller is compared with the IPL field of the Status register.

If Status_IPL has a higher priority than or equal to the External Interrupt Controller value:

COP0 SRSCtl and EPC registers are restored from the stack. GPR 29 is incremented for the stack frame size.

IRET then clears execution and instruction hazards, conditionally restores SRSCtl_CSS from SRSCtl_PSS, and returns to the interrupted instruction pointed to by the EPC register at the completion of interrupt processing.

If Status_IPL has a lower priority than the External Interrupt Controller value:

The value of GPR 29 is first saved to a temporary register then GPR 29 is incremented for the stack frame size. The EIC is signalled that the next pending interrupt has been accepted. This signalling will update the

Cause_RIPL and SRSCtl_EICSS fields from the EIC output values. The SRSCtl_EICSS field is copied to the

SRSCtl_CSS field, while the Cause_RIPL field is copied to the Status_IPL field. The saved temporary register is

copied to the GPR 29 of the current SRS. The KSU and EXL fields of the Status register are optionally set to zero. No barrier for execution hazards or instruction hazards is created. IRET finishes by jumping to the interrupt vector driven by the EIC.

IRET does not execute the next instruction (i.e., it has no delay slot).

Restrictions:

The operation of the processor is UNDEFINED if IRET is executed in the delay slot of a branch or jump instruction.

The operation ofthe processor is UNDEFINED ifIRET is executed when either Shadow Register Sets are not enabled, or when the EIC interrupt mode is not enabled.

An IRET placed between an LL and SC instruction will always cause the SC to fail.

The effective addresses used for stack transactions must be naturally-aligned. If either of the two least-significant bits of the address is non-zero, an Address Error exception occurs.

IRET implements a software barrier that resolves all execution and instruction hazards created by Coprocessor 0 state changes

(for Release 2 implementations,referto the SYNCIinstruction for additionalinformation on resolving instruction hazards created by writing the instruction stream). The effects of this barrier begin with the instruction fetch and decode of the instruction at the PC to which the IRET returns.

In a Release 2 implementation, IRET does not restore SRSCtl_CSSfrom SRSCtl_PSSif Status_BEV= 1 or Status_ERL= 1, because any exception that sets StatusERL to 1 (Reset, Soft Reset, NMI, or cache error) does not save SRSCtlCSS in

SRSCtl_PSS. If software sets Status_ERLto 1,it must be aware of the operation of an IRET that may be subsequently executed.

The stack memory transactions behave as individual LW operations with respectto exception reporting. BadVAddr would report the faulting address for an unaligned access, and the faulting word address for unprivileged access, TLB

Refill, and TLB Invalid exceptions. For TLB exceptions, the faulting word address would be reflected in the Context and EntryHi registers. The CacheError register would reflect the faulting word address for Cache Errors.

Operation:

if (( IntCtl_APE == 0) | (Status_ERL== 1) | (Status_BEV== 1))
   Act as ERET // read Operation section of ERET description
else
   temp = 0x4 + GPR[29]
   tempStatus = LoadStackWord(temp)
   ClearHazards()
   if ( (IntCtl_ICE == 0) |  ((IntCtl_ICE == 1) &
   (tempStatus_IPL>= EIC_{RIPL)) )}
      temp = 0x8 + GPR[29]
      tempSRSCtl = LoadStackWord(temp)
      temp = 0x0 + GPR[29]
      tempEPC = LoadStackWord(temp)
   endif
   Status = tempStatus
   if ( (IntCtl_ICE == 0) | ((IntCtl_ICE == 1) &
      (tempStatus_IPL>= EIC_{RIPL)) )}
      GPR[29] = GPR[29] + DecodedValue(IntCtl_StkDec)
      SRSCtl_PSS= tempSRSCtl_PSS
      SRSCtl_ESS= tempSRSCtl_ESS
      EPC = tempEPC
      temp = EPC
      Status_EXL= 0
      if (ArchitectureRevision >= 2) and (SRSCtl_HSS> 0) and (Status_BEV = 0) then
         SRSCtl_CSS= SRSCtl_PSS
      endif
      if IsMicroMIPSImplemented() then
         PC = temp_31..1 || 0
         ISAMode = temp₀
      else
      endif
      LLbit = 0
      Cause_IC= 0
      ClearHazards()
   else
      Cause_RIPL= EIC_RIPL
      SRSCtl_EICSS= EIC_SS
      temp29 = GPR[29]
      GPR[29] = GPR[29] + DecodedValue(IntCtl_StkDec)
      Status_IPL= Cause_RIPL
      SRSCtl_CSS= SRSCtl_EICSS
      NewShadowSet = SRSCtl_EICSS
      GPR[29] = temp29
      if (IntCtl_ClrEXL== 1)
         Status_EXL= 0
         Status_KSU= 0
      endif
      LLbit = 0
      Cause_IC= 1
      ClearHazards()
      PC = CalcIntrptAddress()
   endif
endif
function LoadStackWord(vaddr)
   if vAddr_1..0!= 0² then
      SignalException(AddressError)
   endif
   (pAddr, CCA) = AddressTranslation (vAddr, DATA, LOAD)
   memword = LoadMemory (CCA, WORD, pAddr, vAddr, DATA)
   LoadStackWord = memword
endfunction LoadStackWord
function CalcIntrptAddress()
   if StatusBEV == 1
      vectorBase = 0xBFC0.0200
   else
      if ( ArchitectureRevision >= 2)
         vectorBase = EBase_31..12|| 0¹¹)
      else
         vectorBase = 0x8000.0000
      endif
   endif
   if (Cause_IV == 0)
      vectorOffset = 0x180
   else
      if (Status_BEV = 1) or (IntCtl_VS = 0)
         vectorOffset = 0x200
      else
         if ( Config3_VEIC == 1 and EIC_Option == 1)
             VectorNum = Cause_RIPL
         elseif (Config3_VEIC == 1 and EIC_Option == 2)
             VectorNum = EIC_VectorNum
         elseif (Config3_VEIC == 0 )
         endif
         if (Config3_VEIC == 1 and EIC_Option == 3)
             vectorOffset = EIC_VectorOffset
         else
             vectorOffset = 0x200 + (VectorNum x (IntCtl_VS|| 0⁵))
         endif
      endif
   endif
   CalcIntrptAddress = vectorBase | vectorOffset
   if (Config3_ISAOnExec)
      CalcIntrptAddress = CalcIntrptAddress_31..1 || 1
   endif
endfunction CalcIntrptAddress

Exceptions:

Coprocessor Unusable Exception, TLB Refill, TLB Invalid, Address Error, Watch, Cache Error, Bus Error

Exceptions