Access to Direct-Store Segments

The 604e supports both memory-mapped and I/O-mapped access to I/O devices. In addition to the high-performance bus protocol for memory-mapped I/O accesses, the 604e provides the ability to map memory areas to the direct-store interface (SR[T] = 1) with the following two kinds of operations:

• Direct-store operations. These operations are considered to address the noncoherent and noncacheable direct-store; therefore, the 604e does not maintain coherency for these operations, and the cache is bypassed completely.

• Memory-forced direct-store operations. These operations are considered to address memory space and are therefore subject to the same coherency control as memory accesses. These operations are global memory references within the 604e and are considered to be noncacheable.

Cache behavior (write-back, cache-inhibition, and enforcement of MESI coherency) for these operations is determined by the settings of the WIM bits.

(n/a) Snoop- EIEIO

xx1 10000 (n/a) ARTRY No-op I Snoop-

ICBI

xx1 01101 (n/a) (None) No-op VAL Snoop-

ICBI

xx1 01101 (n/a) (None) Invalidate entry in icache I Snoop-

RWNITC

xx1 01011 None (None) No-op I Snoop- RWNITC xx1 01011 Yes SHD No-op E S Snoop- RWNITC xx1 01011 (n/a) SHD No-op M Snoop- RWNITC

xx1 01011 (n/a) ARTRY&SHD Attempt to write cache block back to main memory; if successful, mark cache block E.

Note: It is possible for a snoop invalidate operation that invalidates both the cache block and the reservation

to preempt the operation and cause the 604e to generate a “read atomic” operation instead. It is also possible that between the time that the lwarx instruction hits in the cache and the lwarx reservation set is broadcast that a flush snoop operation can remove the cache block from the cache without canceling the reservation. In this case, the lwarx broadcast still occurs even through the cache block is not in the data cache.

Table 3-6. Cache Actions (Continued)

Cache WIM MESI State Action Bus Operation Bus WIM TT0-4 Rsv’n Snoop Response Action

Chapter 4

Exceptions

40

The OEA portion of the PowerPC architecture defines the mechanism by which PowerPC processors implement exceptions (referred to as interrupts in the architecture specification). Exception conditions may be defined at other levels of the architecture. For example, the UISA defines conditions that may cause floating-point exceptions; the OEA defines the mechanism by which the exception is taken.

PowerPC exception mechanism allows the processor to change to supervisor state as a result of external signals, errors, or unusual conditions arising in the execution of instructions. When exceptions occur, information about the state of the processor is saved to certain registers and the processor begins execution at an address (exception vector) predetermined for each exception. Processing of exceptions begins in supervisor mode. Although multiple exception conditions can map to a single exception vector, a more specific condition may be determined by examining a register associated with the exception—for example, the DSISR and the floating-point status and control register (FPSCR). Additionally, certain exception conditions can be explicitly enabled or disabled by software.

The PowerPC architecture requires that exceptions be taken in program order; therefore, although a particular implementation may recognize exception conditions out of order, they are handled strictly in order with respect to the instruction stream. When an instruction- caused exception is recognized, any unexecuted instructions that appear earlier in the instruction stream, including any that have not yet entered the execute state, are required to complete before the exception is taken. For example, if a single instruction encounters multiple exception conditions, those exceptions are taken and handled sequentially. Likewise, exceptions that are asynchronous and precise are recognized when they occur, but are not handled until all instructions currently in the execute stage successfully complete execution and report their results.

Note that exceptions can occur while an exception handler routine is executing, and multiple exceptions can become nested. It is up to the exception handler to save the states if it is desired to allow control to ultimately return to the excepting program.

In many cases, after the exception handler handles an exception, there is an attempt to execute the instruction that caused the exception. Instruction execution continues until the next exception condition is encountered. This method of recognizing and handling exception conditions sequentially guarantees that the machine state is recoverable and processing can resume without losing instruction results.

To prevent the loss of state information, exception handlers must save the information stored in SRR0 and SRR1 soon after the exception is taken to prevent this information from being lost due to another exception being taken.

In this chapter, the following terminology is used to describe the various stages of exception processing:

Recognition Exception recognition occurs when the condition that can cause an exception is identified by the processor.

Taken An exception is said to be taken when control of instruction execution is passed to the exception handler; that is, the context is saved and the instruction at the appropriate vector offset is fetched and the exception handler routine is begun in supervisor mode. Handling Exception handling is performed by the software linked to the

appropriate vector offset. Exception handling is begun in supervisor- level (referred to as privileged state in the architecture specification). Note that the PowerPC architecture documentation refers to exceptions as interrupts. In this book, the term interrupt is reserved to refer to asynchronous exceptions, and sometimes to the event that causes the exception to be taken. Also, the PowerPC architecture uses the word exception to refer to IEEE-defined floating-point exceptions, conditions that may cause a program exception to be taken (See Section 4.5.7, “Program Exception (0x00700).) The occurrence of these IEEE exceptions may in fact not cause an exception to be taken. IEEE-defined exceptions are referred to as IEEE floating-point exceptions or floating-point exceptions.