US20020007450A1 - Line-oriented reorder buffer - Google Patents

Abstract

A reorder buffer is configured into multiple lines of storage, wherein a line of storage includes sufficient storage for instruction results regarding a predefined maximum number of concurrently dispatchable instructions. A line of storage is allocated whenever one or more instructions are dispatched. A microprocessor employing the reorder buffer is also configured with fixed, symmetrical issue positions. The symmetrical nature of the issue positions may increase the average number of instructions to be concurrently dispatched and executed by the microprocessor. The average number of unused locations within the line decreases as the average number of concurrently dispatched instructions increases. One particular implementation of the reorder buffer includes a future file. The future file comprises a storage location corresponding to each register within the microprocessor. The reorder buffer tag (or instruction result, if the instruction has executed) of the last instruction in program order to update the register is stored in the future file. The reorder buffer provides the value (either reorder buffer tag or instruction result) stored in the storage location corresponding to a register when the register is used as a source operand for another instruction. Another advantage of the future file for microprocessors which allow access and update to portions of registers is that narrow-to-wide dependencies are resolved upon completion of the instruction which updates the narrower register.

Description

CROSS REFERENCE TO RELATED APPLICATIONS
• This application is a continuation-in-part of copending patent application Ser. No. 08/377,843 filed Jan. 25, 1995 and copending patent application Ser. No. 08/476,879 filed Jun. 7, 1995.[0001]
BACKGROUND OF THE INVENTION
• 1. Field of the Invention[0002]
• This invention is related to the field of superscalar microprocessors and, more particularly, to reorder buffers within superscalar microprocessors.[0003]
• 2. Description of the Relevant Art[0004]
• Superscalar microprocessors achieve high performance by executing multiple instructions per clock cycle and by choosing the shortest possible clock cycle consistent with the design. As used herein, the term “clock cycle” refers to an interval of time accorded to various stages of an instruction processing pipeline within the microprocessor. Storage devices (e.g. registers and arrays) capture their values according to the clock cycle. For example, a storage device may capture a value according to a rising or falling edge of a clock signal defining the clock cycle. The storage device then stores the value until the subsequent rising or falling edge of the clock signal, respectively. The term “instruction processing pipeline” is used herein to refer to the logic circuits employed to process instructions in a pipelined fashion. Although the pipeline may be divided into any number of stages at which portions of instruction processing are performed, instruction processing generally comprises fetching the instruction, decoding the instruction, executing the instruction, and storing the execution results in the destination identified by the instruction.[0005]
• In order to increase performance, superscalar microprocessors often employ out of order execution. The instructions within a program are ordered, such that a first instruction is intended to be executed before a second instruction, etc. When the instructions are executed in the order specified, the intended functionality of the program is realized. However, instructions may be executed in any order as long as the original functionality is maintained. For example, a second instruction which does not depend upon a first instruction may be executed prior to the first instruction, even if the first instruction is prior to the second instruction in program order. A second instruction depends upon a first instruction if a result produced by the first instruction is employed as an operand of the second instruction. The second instruction is said to have a dependency upon the first instruction.[0006]
• Another hazard of out of order execution occurs when two instructions update the same destination storage location. If the instruction which is second in the original program sequence executes first, then that instruction must not update the destination until the first instruction has executed. Often, superscalar microprocessors employ a reorder buffer in order to correctly handle dependency checking and multiple updates to a destination, among other things. Instructions are stored into the reorder buffer in program order, typically as the instructions are dispatched to execution units (perhaps being stored in reservation stations associated therewith). The results of the instructions are stored into the destinations from the reorder buffer in program order. However, results may be provided to the reorder buffer in any order. The reorder buffer stores each result with the instruction which generated the result until that instruction is selected for storing its result into the destination.[0007]
• A reorder buffer is configured to store a finite number of instructions, defining a maximum number of instructions which may be concurrently outstanding within the superscalar microprocessor. Generally speaking, out of order execution occurs more frequently as the finite number is increased. For example, the execution of an instruction which is foremost within the reorder buffer in program order may be delayed. Instructions subsequently dispatched into the reorder buffer which are not dependent upon the delayed instruction may execute and store results in the buffer. Out of order execution may continue until the reorder buffer becomes full, at which point dispatch is suspended until instructions are deleted from the reorder buffer. Therefore, a larger number of storage locations within the reorder buffer generally leads to increased performance by allowing more instructions to be outstanding before instruction dispatch (and out of order execution) stalls.[0008]
• Unfortunately, larger reorder buffers complicate dependency checking. One or more source operands of an instruction to be dispatched may be destination operands of outstanding instructions within the reorder buffer. As used herein, a source operand of an instruction is a value to be operated upon by the instruction in order to produce a result. Conversely, a destination operand is the result of the instruction. Source and destination operands of an instruction are generally referred to as operand information. An instruction specifies the location storing the source operands and the location in which to store the destination operand. An operand may be stored in a register (a “register operand”) or a memory location (a “memory operand”). As used herein, a register is a storage location included within the microprocessor which is used to store instruction results. Registers may be specified as source or destination storage locations for an instruction.[0009]
• The locations from which to retrieve source operands for an instruction to be dispatched are compared to the locations designated for storing destination operands of instructions stored within the reorder buffer. If a dependency is detected and the corresponding instruction has executed, the result stored in the reorder buffer may be forwarded for use by the dispatching instruction. If the instruction has not yet executed, a tag identifying the instruction may be forwarded such that the result may be provided when the instruction is executed.[0010]
• When the number of instructions storable in the reorder buffer is large, the number of comparisons for performing dependency checking is also large. Generally speaking, the total number of comparisons which must be provided for is the number of possible operands of an instruction multiplied by the number of instructions which may be concurrently dispatched, further multiplied by the number of instructions which may be stored in the reorder buffer. Additionally, more than one destination operand within the reorder buffer may be stored within the storage location indicated for a source operand. Circuitry is therefore employed to detect the last of the destination operands indicated by the comparisons, in order to correctly detect the dependency (i.e. the instruction which stores a result into a storage location used for a source operand and which is nearest to the dispatching instruction in program order is the instruction upon which the dispatching instruction depends). It is desirable to reduce the complexity of dependency checking for reorder buffers.[0011]
• Still further, reorder buffers typically allocate a storage location for each instruction dispatched during a particular clock cycle. The number of storage locations allocated varies from clock cycle to clock cycle depending upon the number of instructions dispatched. Additionally, a variable number of instructions may be retired from the reorder buffer. Logic for allocating and deallocating storage locations is complicated by the variable nature of storage access, creating a larger and typically slower control unit used in the reorder buffer. A faster, simpler method for allocating reorder buffer storage is desired.[0012]
SUMMARY OF THE INVENTION
• The problems outlined above are in large part solved by a reorder buffer in accordance with the present invention. The reorder buffer is configured into multiple lines of storage, wherein a line of storage includes sufficient storage for instruction results and information regarding a predefined maximum number of concurrently dispatchable instructions. A line of storage is allocated whenever one or more instructions are dispatched. Advantageously, the amount of storage allocated is constant. Therefore, storage allocation logic depends only upon whether or not instructions are dispatched during a clock cycle. In particular, allocation logic is independent of the number of instructions dispatched during a clock cycle. Allocation logic may thereby be simplified, allowing for higher frequency applications.[0013]
• Similarly, instructions are retired from the reorder buffer after each of the instructions within a line of storage have provided results. The instructions within the line are retired simultaneously. Therefore, the amount of storage deallocated during a clock cycle is dependent only upon whether or not instructions are retired during the clock cycle, not upon the number of instructions retired. Advantageously, storage deallocation logic may be simplified as well.[0014]
• In one embodiment, a microprocessor employing the reorder buffer is also configured with fixed, symmetrical issue positions. The symmetrical nature of the issue positions may increase the average number of instructions to be concurrently dispatched and executed by the microprocessor. Since the issue positions are symmetrical, any random group of instructions executable by the issue positions may be dispatched to the issue positions. In contrast, asymmetrical issue positions may impose additional restrictions upon the concurrent dispatch and execution of instructions. Increasing the average number of concurrently dispatched instructions may be particularly beneficial when employed with the line-oriented reorder buffer, since a line of storage is allocated regardless of the number of instructions dispatched. The average number of unused locations within the line decreases as the average number of concurrently dispatched instructions increases.[0015]
• One particular implementation of the reorder buffer includes a future file for reducing dependency checking complexity. The future file replaces the large block of comparators and prioritization logic ordinarily employed by reorder buffers for dependency checking. The future file includes a storage location corresponding to each register within the microprocessor. The reorder buffer tag (or instruction result, if the instruction has executed) of the last instruction in program order to update the register is stored in the future file. The reorder buffer provides the value (either reorder buffer tag or instruction result) stored in the storage location corresponding to a register when the register is used as a source operand for another instruction.[0016]
• Another advantage of the future file for microprocessors which allow access and update to portions of registers is that narrow-to-wide dependencies are resolved upon completion of the instruction which updates the narrower register. Previously, the instruction which updates the narrower register might typically be retired prior to resolving the narrow-to-wide dependency. Generally, instruction retirement occurs subsequent to completion of the instruction. Performance of the microprocessor may be increased due to the earlier resolution of the narrow-to-wide dependencies.[0017]
• Broadly speaking, the present invention contemplates a reorder buffer comprising an instruction storage and a first control unit. The instruction storage includes multiple lines of storage, wherein each of the lines of storage is configured to store a predefined maximum number of instructions concurrently receivable by the reorder buffer. Coupled to the instruction storage, the first control unit is configured to allocate one of the lines of storage to one or more concurrently received instructions. One of the lines of storage is allocated regardless of a number of the concurrently received instructions.[0018]
• The present invention further contemplates an apparatus for reordering instructions which were executed out of order, comprising a first decode unit, a second decode unit, and a reorder buffer. The first decode unit is configured to decode and dispatch a first instruction. Similarly, the second decode unit is configured to decode and dispatch a second instruction concurrent with the first instruction. Coupled to both the first decode unit and the second decode unit, the reorder buffer is configured to allocate a line of storage to store instruction results corresponding to the first instruction and the second instruction upon dispatch of the first instruction and the second instruction. The line of storage is configured to store a maximum number of concurrently dispatchable instructions and is allocated regardless of a number of concurrently dispatched instructions provided at least one instruction is dispatched.[0019]
• The present invention still further contemplates a method for operating a reorder buffer. Up to a predefined maximum number of concurrently dispatched instructions are received into the reorder buffer. Upon receipt of the concurrently dispatched instructions, a fixed amount of storage is allocated for instruction results. The fixed amount of storage is sufficient to store the maximum number of concurrently dispatched instructions regardless of a number of concurrently dispatched instructions. The fixed amount of storage is subsequently deallocated upon receipt of an instruction result corresponding to each of the concurrently dispatched instructions.[0020]
• The present invention additionally contemplates a method for ordering instructions in a microprocessor employing out of order execution. Up to a maximum number of instructions are concurrently dispatched. A line of storage is allocated within a reorder buffer for storing instruction results corresponding to the instructions which are concurrently dispatched. The line of storage is configured to store a number of instruction results equal to the maximum number of instructions. The instructions are executed in a plurality of functional units. Upon execution, corresponding instruction results are provided to the reorder buffer. The line of storage is deallocated when each of the corresponding instruction results within the line of storage have been provided.[0021]
• The present invention also contemplates a superscalar microprocessor comprising a plurality of fixed, symmetrical issue positions and a reorder buffer. The plurality of fixed, symmetrical issue positions is coupled to receive instructions. An instruction received by one of the plurality of issue positions remains within that one of the plurality of issue positions until the instruction is executed therein. Coupled to receive operand information regarding a plurality of concurrently dispatched instructions from the plurality of fixed, symmetrical issue positions, the reorder buffer is configured to allocate storage for instruction results corresponding to the plurality of concurrently dispatched instructions.[0022]
• Furthermore, the present invention contemplates a superscalar microprocessor comprising a first and second decode unit, a first and second reservation station, and a reorder buffer. The first decode unit is configured to decode a first instruction. Similarly, the second decode unit is configured to decode a second instruction concurrently with the first decode unit decoding the first instruction. Coupled to receive the first instruction from the first decode unit, the first reservation station is configured to store the first instruction until the first instruction is executed. Likewise, the second reservation station is coupled to receive the second instruction from the second decode unit and to store the second instruction until the second instruction is executed. The reorder buffer is coupled to the first decode unit and the second decode unit, and receives an indication of the first instruction and the second instruction from the first decode unit and the second decode unit, respectively. Additionally, the reorder buffer is configured to allocate a line of storage to store a first instruction result corresponding to the first instruction and a second instruction result corresponding to the second instruction. The line of storage comprises a fixed amount of storage capable of storing instruction results corresponding to a maximum number of concurrently dispatchable instructions.[0023]
• Moreover, the present invention contemplates a reorder buffer comprising an instruction storage, a future file, and a control unit. The instruction storage is configured to store instruction results corresponding to instructions. The instruction results are stored in lines of storage, wherein a line of storage is configured to store instruction results corresponding to a maximum number of concurrently dispatchable instructions. A first line of storage is allocated upon dispatch of at least one instruction regardless of a number of instructions concurrently dispatched. The future file is configured to store a reorder buffer tag corresponding to a particular instruction. The particular instruction is last, in program order, of the instructions represented within the instruction storage having a particular register as a destination operand. Additionally, the future file is further configured to store a particular instruction result corresponding to the particular instruction when the particular instruction result is provided. Coupled to the instruction storage and the future file, the control unit is configured to allocate the first line of storage for at least one instruction. Still further, the control unit is configured to update the future file if the instruction has the particular register as a destination operand.[0024]
• The present invention yet further contemplates a reorder buffer comprising a future file, an instruction storage, and a control unit. The future file has a storage location for each register implemented by a microprocessor employing the reorder buffer. The storage location is divided into a first portion and a second portion, corresponding to a first portion and a second portion of the register, respectively. Each of the first and second portions of the storage location is configured to store a reorder buffer tag of an instruction which updates the corresponding portion the register. Additionally, each of the first and second portions of the storage location is configured to store data corresponding to an instruction result of the instruction identified by the reorder buffer tag, wherein the data replaces the reorder buffer tag when the data is provided. The instruction storage is configured to store instruction results corresponding to multiple instructions outstanding within the microprocessor. Coupled to the future file and the instruction storage, the control unit is configured to allocate storage within the instruction storage upon dispatch of at least one instruction. Still further, the control unit is configured to store a first reorder buffer tag into the first portion of the storage location if at least one instruction updates the first portion of the register. Similarly, the control unit is further configured to store the first reorder buffer tag into the second portion of the storage location if at least one instruction updates the second portion of the register.[0025]
• The present invention additionally contemplates a microprocessor comprising a reorder buffer and a register file. The reorder buffer includes a future file having a storage location for each register implemented by the microprocessor. The storage location is divided into a first portion and a second portion, wherein the first portion of the storage location corresponds to a first portion of the register and the second portion of the storage location corresponds to a second portion of the register. Each of the first portion of the storage location and the second portion of the storage location is configured to store a reorder buffer tag of an instruction which updates the first portion of the register and the second portion of the register, respectively. Still further, each of the first and second portions of the storage location is configured to store data corresponding to an instruction result of the instruction identified by the reorder buffer tag, respectively. The data replaces the reorder buffer tag when the data is provided. Coupled to the reorder buffer, the register file is configured to store a plurality of values corresponding to the registers implemented by the microprocessor. The reorder buffer updates the register file upon retirement of the instruction.[0026]
BRIEF DESCRIPTION OF THE DRAWINGS
• Other objects and advantages of the invention will become apparent upon reading the following detailed description and upon reference to the accompanying drawings in which:[0027]
• FIG. 1 is a block diagram of one embodiment of a microprocessor.[0028]
• FIG. 2 is a block diagram of one embodiment of two of the decode units shown in FIG. 1.[0029]
• FIG. 3 is a diagram highlighting interconnection between a decode unit, a load/store unit, an MROM unit, a floating point unit, a functional unit, a reservation station, and a register file shown in FIG. 1, according to one embodiment of the microprocessor.[0030]
• FIG. 4 is a block diagram of one embodiment of the reorder buffer shown in FIG. 1.[0031]
• FIG. 5 is a block diagram of a dispatch control unit and a FIFO buffer according to one embodiment of the reorder buffer shown in FIG. 4.[0032]
• FIG. 6 is an illustration of the result buses connected to portions of a line of storage depicted in FIG. 5, according to one embodiment of a line of storage.[0033]
• FIG. 7 is a block diagram of a portion of the dependency checking logic employed by one embodiment of the reorder buffer shown in FIG. 4.[0034]
• FIG. 8 is a table of information stored for each instruction within a line of storage according to one embodiment of the reorder buffer shown in FIG. 4.[0035]
• FIG. 9 is a table of information shared by the instructions within a line of storage according to one. embodiment of the reorder buffer shown in FIG. 4.[0036]
• FIG. 10 is a block diagram of a second embodiment of the reorder buffer shown in FIG. 1, including a future file.[0037]
• FIG. 11 is a flow chart illustrating update of the future file and the reorder buffer instruction storage shown in FIG. 10, according to one embodiment of the reorder buffer.[0038]
• FIG. 12 is a diagram illustrating one embodiment of a future file storage location.[0039]
• FIG. 13 is a block diagram of a computer system employing the microprocessor shown in FIG. 1.[0040]
• While the invention is susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that the drawings and detailed description thereto are not intended to limit the invention to the particular form disclosed, but on the contrary, the intention is to cover all modifications, equivalents and alternatives falling within the spirit and scope of the present invention as defined by the appended claims.[0041]
DETAILED DESCRIPTION OF THE INVENTION
• Turning now to FIG. 1, a block diagram of one embodiment of a[0042]microprocessor10 is shown.Microprocessor10 includes a prefetch/predecode unit12, abranch prediction unit14, aninstruction cache16, aninstruction alignment unit18, a plurality ofdecode units20A-20C, a plurality ofreservation stations22A-22C, a plurality offunctional units24A-24C, a load/store unit26, adata cache28, aregister file30, areorder buffer32, anMROM unit34, and a floating point unit (FPU)36. Elements referred to herein with a particular reference number followed by a letter will be collectively referred to by the reference number alone. For example, decodeunits20A-20C will be collectively referred to asdecode units20.
• Prefetch/[0043]predecode unit12 is coupled to receive instructions from a main memory subsystem (not shown), and is further coupled toinstruction cache16 andbranch prediction unit14. Similarly,branch prediction unit14 is coupled toinstruction cache16. Still further,branch prediction unit14 is coupled to decodeunits20 andfunctional units24.Instruction cache16 is further coupled toMROM unit34 andinstruction alignment unit18.Instruction alignment unit18 is in turn coupled to decodeunits20. Eachdecode unit20A-20C is coupled to load/store unit26 and torespective reservation stations22A-22C.Reservation stations22A-22C are further coupled to respectivefunctional units24A-24C. Additionally, decodeunits20 andreservation stations22 are coupled to registerfile30 and reorderbuffer32.Functional units24 are coupled to load/store unit26,register file30, and reorderbuffer32 as well.Data cache28 is coupled to load/store unit26 and to the main memory subsystem. Finally,MROM unit34 is coupled to decodeunits20 and toFPU36.
• Generally speaking, reorder[0044]buffer32 allocates a line of storage to store instruction information and instruction results for one or more instructions which are concurrently dispatched bymicroprocessor10. The line of storage is sufficient for storing such information and results for a maximum number of concurrently dispatchable instructions withinmicroprocessor10. The line of storage is allocated regardless of the number of instructions actually concurrently dispatched (as long as at least one instruction is dispatched). During subsequent clock cycles, different lines of storage are allocated to the subsequently dispatched instructions. Additionally, instructions within a line of storage are concurrently retired fromreorder buffer32 as well. Advantageously, storage allocation withinreorder buffer32 is simplified. A fixed amount of storage is allocated each time instructions are dispatched, regardless of the number of instructions. Still further, a fixed amount of storage is deallocated upon retirement of instructions. Allocation logic is thereby dependent only upon successful dispatch of one or more instructions, not upon the number of instructions concurrently dispatched.
• [0045]Microprocessor10 employs a plurality of symmetrical issue positions for executing instructions dispatched byinstruction alignment unit18. The issue positions are symmetrical in that each issue position is configured to execute the same subset of the instruction set employed bymicroprocessor10 as each other issue position. In one embodiment, each issue position is configured to execute the integer and branch instructions of the x86 microprocessor architecture. In one particular embodiment, each issue position is configured to execute the fast path instructions. Other embodiments may define other subsets for the symmetrical issue positions. Additionally, the issue positions are fixed in that, once an instruction is provided to an issue position, that instruction remains within that issue position until it is executed.
• In one specific implementation,[0046]reorder buffer32 employs a future file to simplify dependency checking. The future file includes a storage location for each register employed bymicroprocessor10. The storage location is updated upon dispatch of an instruction which updates the register, and is further updated upon receipt of the instruction result corresponding to the instruction provided that a subsequent instruction is not dispatched which updates the register. Upon dispatch, the reorder buffer tag identifying the instruction is stored into the future file. Upon receipt of the instruction result, that result is stored into the future file. Therefore, the future file contains information (either reorder buffer tag or instruction result) corresponding to the last instruction (in program order) to update the register. Advantageously, the reorder buffer tag or register value which is to be provided when the register is used as a source operand of an instruction may be read from the corresponding storage location within the future file. It is noted that embodiments ofreorder buffer32 which do not employ a future file are contemplated.
• In one embodiment of the future file, the storage location allocated to the register stores either the reorder buffer tag corresponding to the instruction which updates the register or the corresponding instruction result. In other words, the reorder buffer tag and register value overwrite each other within the storage location. In the x86 microprocessor architecture, an instruction may use a portion of a register for a source or destination operand. For example, the EAX register is 32 bits. However, the least significant 16 bits of the EAX register may be accessed as the AX register. Additionally, the most significant 8 bits of the AX register may be accessed as the AH register and the least significant eight bits of the AX register may be accessed as the AL register. Therefore, multiple instructions may be outstanding which update different portions of the register. For such an embodiment, the future file storage location is configured to store multiple tags or the corresponding data. When an instruction uses a portion of the register as a source operand, the reorder buffer tag of the last instruction which updates that portion of the register is provided. Alternatively, if the instruction has been executed and has produced a result, the result is provided for that portion of the register.[0047]
• [0048]Instruction cache16 is a high speed cache memory provided to store instructions. Instructions are fetched frominstruction cache16 and dispatched to decodeunits20. In one embodiment,instruction cache16 is configured to store up to 32 kilobytes of instructions in an 8 way set associative structure having 32 byte lines (a byte comprises 8 binary bits).Instruction cache16 may additionally employ a way prediction scheme in order to speed access times to the instruction cache. Instead of accessing tags identifying each line of instructions and comparing the tags to the fetch address to select a way,instruction cache16 predicts the way that is accessed. In this manner, the way is selected prior to accessing the instruction storage. The access time ofinstruction cache16 may be similar to a direct-mapped cache. A tag comparison is performed and, if the way prediction is incorrect, the correct instructions are fetched and the incorrect instructions are discarded. It is noted thatinstruction cache16 may be implemented as a fully associative, set associative, or direct mapped configuration.
• Instructions are fetched from main memory and stored into[0049]instruction cache16 by prefetch/predecode unit12. Instructions may be prefetched prior toinstruction cache16 recording a miss for the instructions in accordance with a prefetch scheme. A variety of prefetch schemes may be employed by prefetch/predecode unit12. As prefetch/predecode unit12 transfers instructions from main memory toinstruction cache16, prefetch/predecode unit12 generates three predecode bits for each byte of the instructions: a start bit, an end bit, and a functional bit. The predecode bits form tags indicative of the boundaries of each instruction. The predecode tags may also convey additional information such as whether a given instruction can be decoded directly bydecode units20 or whether the instruction is executed by invoking a microcode procedure controlled byMROM unit34, as will be described in greater detail below. Still further, prefetch/predecode unit12 may be configured to detect branch instructions and to store branch prediction information corresponding to the branch instructions intobranch prediction unit14.
• One encoding of the predecode tags for an embodiment of[0050]microprocessor10 employing the x86 instruction set will next be described. If a given byte is the first byte of an instruction, the start bit for that byte is set. If the byte is the last byte of an instruction, the end bit for that byte is set. Instructions which may be directly decoded bydecode units20 are referred to as “fast path” instructions. The remaining x86 instructions are referred to as MROM instructions, according to one embodiment. For fast path instructions, the functional bit is set for each prefix byte included in the instruction, and cleared for other bytes. Alternatively, for MROM instructions, the functional bit is cleared for each prefix byte and set for other bytes. The type of instruction may be determined by examining the functional bit corresponding to the end byte. If that functional bit is clear, the instruction is a fast path instruction. Conversely, if that functional bit is set, the instruction is an MROM instruction. The opcode of an instruction may thereby be located within an instruction which may be directly decoded bydecode units20 as the byte associated with the first clear functional bit in the instruction. For example, a fast path instruction including two prefix bytes, a Mod R/M byte, and an SIB byte would have start, end, and functional bits as follows:

  	Start bits	10000
  	End bits	00001
  	Functional bits	11000

• MROM instructions are instructions which are determined to be too complex for decode by[0051]decode units20. MROM instructions are executed by invokingMROM unit34. More specifically, when an MROM instruction is encountered,MROM unit34 parses and issues the instruction into a subset of defined fast path instructions to effectuate the desired operation.MROM unit34 dispatches the subset of fast path instructions to decodeunits20. A listing of exemplary x86 instructions categorized as fast path instructions will be provided further below.
• [0052]Microprocessor10 employs branch prediction in order to speculatively fetch instructions subsequent to conditional branch instructions.Branch prediction unit14 is included to perform branch prediction operations. In one embodiment, up to two branch target addresses are stored with respect to each cache line ininstruction cache16. Prefetch/predecode unit12 determines initial branch targets when a particular line is predecoded. Subsequent updates to the branch targets corresponding to a cache line may occur due to the execution of instructions within the cache line.Instruction cache16 provides an indication of the instruction address being fetched, so thatbranch prediction unit14 may determine which branch target addresses to select for forming a branch prediction.Decode units20 andfunctional units24 provide update information tobranch prediction unit14. Becausebranch prediction unit14 stores two targets per cache line, some branch instructions within the line may not be stored inbranch prediction unit14.Decode units20 detect branch instructions which were not predicted bybranch prediction unit14.Functional units24 execute the branch instructions and determine if the predicted branch direction is incorrect. The branch direction may be “taken”, in which subsequent instructions are fetched from the target address of the branch instruction. Conversely, the branch direction may be “not taken”, in which subsequent instructions are fetched from memory locations consecutive to the branch instruction. When a mispredicted branch instruction is detected, instructions subsequent to the mispredicted branch are discarded from the various units ofmicroprocessor10. A variety of suitable branch prediction algorithms may be employed bybranch prediction unit14.
• Instructions fetched from[0053]instruction cache16 are conveyed toinstruction alignment unit18. As instructions are fetched frominstruction cache16, the corresponding predecode data is scanned to provide information to instruction alignment unit18 (and to MROM unit34) regarding the instructions being fetched.Instruction alignment unit18 utilizes the scanning data to align an instruction to each ofdecode units20. In one embodiment,instruction alignment unit18 aligns instructions from three sets of eight instruction bytes to decodeunits20. Instructions are selected independently from each set of eight instruction bytes into preliminary issue positions. The preliminary issue positions are then merged to a set of aligned issue positions corresponding to decodeunits20, such that the aligned issue positions contain the three instructions which are prior to other instructions within the preliminary issue positions in program order.Decode unit20A receives an instruction which is prior to instructions concurrently received bydecode units20B and20C (in program order). Similarly, decode unit2GB receives an instruction which is prior to the instruction concurrently received bydecode unit20C in program order.
• [0054]Decode units20 are configured to decode instructions received frominstruction alignment unit18. Register operand information is detected and routed to registerfile30 and reorderbuffer32. Additionally, if the instructions require one or more memory operations to be performed, decodeunits20 dispatch the memory operations to load/store unit26. Each instruction is decoded into a set of control values forfunctional units24, and these control values are dispatched toreservation stations22 along with operand address information and displacement or immediate data which may be included with the instruction.
• [0055]Microprocessor10 supports out of order execution, and thus employsreorder buffer32 to keep track of the original program sequence for register read and write operations, to implement register renaming, to allow for speculative instruction execution and branch misprediction recovery, and to facilitate precise exceptions. A temporary storage location withinreorder buffer32 is reserved upon decode of an instruction that involves the update of a register to thereby store speculative register states. If a branch prediction is incorrect, the results of speculatively-executed instructions along the mispredicted path can be invalidated in the buffer before they are written to registerfile30. Similarly, if a particular instruction causes an exception, instructions subsequent to the particular instruction may be discarded. In this manner, exceptions are “precise” (i.e. instructions subsequent to the particular instruction causing the exception are not completed prior to the exception). It is noted that a particular instruction is speculatively executed if it is executed prior to instructions which precede the particular instruction in program order. Preceding instructions may be a branch instruction or an exception-causing instruction, in which case the speculative results may be discarded byreorder buffer32.
• The instruction control values and immediate or displacement data provided at the outputs of[0056]decode units20 are routed directly torespective reservation stations22. In one embodiment, eachreservation station22 is capable of holding instruction information (i.e., instruction control values as well as operand values, operand tags and/or immediate data) for up to three pending instructions awaiting issue to the corresponding functional unit. It is noted that for the embodiment of FIG. 1, eachreservation station22 is associated with a dedicatedfunctional unit24. Accordingly, three dedicated “issue positions” are formed byreservation stations22 andfunctional units24. In other words,issue position0 is formed byreservation station22A andfunctional unit24A. Instructions aligned and dispatched toreservation station22A are executed byfunctional unit24A. Similarly,issue position1 is formed byreservation station22B andfunctional unit24B; andissue position2 is formed byreservation station22C andfunctional unit24C. Generally speaking, an issue position refers to a block of circuitry configured to properly execute an instruction. An issue position receives an instruction and executes that instruction within the issue position.
• Upon decode of a particular instruction, if a required operand is a register location, register address information is routed to reorder[0057]buffer32 and registerfile30 simultaneously. Those of skill in the art will appreciate that the x86 register file includes eight 32 bit real registers (i.e., typically referred to as EAX, EBX, ECX, EDX, EBP, ESI, EDI and ESP). In embodiments ofmicroprocessor10 which employ the x86 microprocessor architecture, registerfile30 comprises storage locations for each of the 32 bit real registers. Additional storage locations may be included withinregister file30 for use byMROM unit34.Reorder buffer32 contains temporary storage locations for results which change the contents of these registers to thereby allow out of order execution. A temporary storage location ofreorder buffer32 is reserved for each instruction which, upon decode, is determined to modify the contents of one of the real registers. Therefore, at various points during execution of a particular program, reorderbuffer32 may have one or more locations which contain the speculatively executed contents of a given register. If following decode of a given instruction it is determined that reorderbuffer32 has a previous location or locations assigned to a register used as an operand in the given instruction, thereorder buffer32 forwards to the corresponding reservation station either: 1) the value in the most recently assigned location, or 2) a tag for the most recently assigned location if the value has not yet been produced by the functional unit that will eventually execute the previous instruction. Ifreorder buffer32 has a location reserved for a given register, the operand value (or reorder buffer tag) is provided fromreorder buffer32 rather than fromregister file30. If there is no location reserved for a required register inreorder buffer32, the value is taken directly fromregister file30. If the operand corresponds to a memory location, the operand value is provided to the reservation station through load/store unit26.
• In one particular embodiment, reorder[0058]buffer32 is configured to store and manipulate concurrently decoded instructions as a unit. This configuration will be referred to herein as “line-oriented”. By manipulating several instructions together, the hardware employed withinreorder buffer32 may be simplified. For example, a line-oriented reorder buffer included in the present embodiment allocates storage sufficient for instruction information pertaining to three instructions (one from each decode unit20) whenever one or more instructions are dispatched bydecode units20. By contrast, a variable amount of storage is allocated in conventional reorder buffers, dependent upon the number of instructions actually dispatched. A comparatively larger number of logic gates may be required to allocate the variable amount of storage. When each of the concurrently decoded instructions has executed, the instruction results are stored intoregister file30 simultaneously. The storage is then free for allocation to another set of concurrently decoded instructions. Additionally, the amount of control logic circuitry employed per instruction is reduced because the control logic is amortized over several concurrently decoded instructions. A reorder buffer tag identifying a particular instruction may be divided into two fields: a line tag and an offset tag. The line tag identifies the set of concurrently decoded instructions including the particular instruction, and the offset tag identifies which instruction within the set corresponds to the particular instruction. It is noted that storing instruction results intoregister file30 and freeing the corresponding storage is referred to as “retiring” the instructions. It is further noted that any reorder buffer configuration may be employed in various embodiments ofmicroprocessor10.
• As noted earlier,[0059]reservation stations22 store instructions until the instructions are executed by the correspondingfunctional unit24. An instruction is selected for execution if: (i) the operands of the instruction have been provided; and (ii) the operands have not yet been provided for instructions which are within thesame reservation station22A-22C and which are prior to the instruction in program order. It is noted that when an instruction is executed by one of thefunctional units24, the result of that instruction is passed directly to anyreservation stations22 that are waiting for that result at the same time the result is passed to update reorder buffer32 (this technique is commonly referred to as “result forwarding”). An instruction may be selected for execution and passed to afunctional unit24A-24C during the clock cycle that the associated result is forwarded.Reservation stations22 route the forwarded result to thefunctional unit24 in this case.
• In one embodiment, each of the[0060]functional units24 is configured to perform integer arithmetic operations of addition and subtraction, as well as shifts, rotates, logical operations, and branch operations. The operations are performed in response to the control values decoded for a particular instruction bydecode units20. Therefore, thefunctional units24 are symmetrical functional units. It is noted that floatingpoint unit36 is also be employed to accommodate floating point operations. Floatingpoint unit36 may be operated as a coprocessor, receiving instructions fromMROM unit34.FPU36 may then communicate withreorder buffer32 for completing instructions. Additionally,functional units24 may be configured to perform address generation for load and store memory operations performed by load/store unit26.
• Each of the[0061]functional units24 also provides information regarding the execution of conditional branch instructions to thebranch prediction unit14. If a branch prediction was incorrect,branch prediction unit14 flushes instructions subsequent to the mispredicted branch that have entered the instruction processing pipeline, and causes fetch of the required instructions frominstruction cache16 or main memory. It is noted that in such situations, results of instructions in the original program sequence which occur after the mispredicted branch instruction are discarded, including those which were speculatively executed and temporarily stored in load/store unit26 and reorderbuffer32.
• Results produced by[0062]functional units24 are sent to reorderbuffer32 if a register value is being updated, and to load/store unit26 if the contents of a memory location are changed. If the result is to be stored in a register, reorderbuffer32 stores the result in the location reserved for the value of the register when the instruction was decoded. A plurality ofresult buses38 are included for forwarding of results fromfunctional units24 and load/store unit26.Result buses38 convey the result generated, as well as the reorder buffer tag identifying the instruction being executed.
• Load/[0063]store unit26 provides an interface betweenfunctional units24 anddata cache28. In one embodiment, load/store unit26 is configured with a load/store buffer having eight storage locations for data and address information for pending loads or stores.Decode units20 arbitrate for access to the load/store unit26. When the buffer is full, a decode unit must wait until load/store unit26 has room for the pending load or store request information. Load/store unit26 also performs dependency checking for load memory operations against pending store memory operations to ensure that data coherency is maintained. A memory operation is a transfer of data betweenmicroprocessor10 and the main memory subsystem. Memory operations may be the result of an instruction which utilizes an operand stored in memory, or may be the result of a load/store instruction which causes the data transfer but no other operation. Additionally, load/store unit26 may include a special register storage for special registers such as the segment registers and other registers related to the address translation mechanism defined by the x86 microprocessor architecture.
• In one embodiment, load/[0064]store unit26 is configured to perform load memory operations speculatively. Store memory operations are performed in program order, but may be speculatively stored into the predicted way. If the predicted way is incorrect, the data prior to the store memory operation is subsequently restored to the predicted way and the store memory operation is performed to the correct way. In another embodiment, stores may be executed speculatively as well. Speculatively executed stores are placed into a store buffer, along with a copy of the cache line prior to the update. If the speculatively executed store is later discarded due to branch misprediction or exception, the cache line may be restored to the value stored in the buffer. It is noted that load/store unit26 may be configured to perform any amount of speculative execution, including no speculative execution.
• [0065]Data cache28 is a high speed cache memory provided to temporarily store data being transferred between load/store unit26 and the main memory subsystem. In one embodiment,data cache28 has a capacity of storing up to sixteen kilobytes of data in an eight way set associative structure. Similar toinstruction cache16,data cache28 may employ a way prediction mechanism. It is understood thatdata cache28 may be implemented in a variety of specific memory configurations, including a set associative configuration.
• In one particular embodiment of[0066]microprocessor10 employing the x86 microprocessor architecture,instruction cache16 anddata cache28 are linearly addressed. The linear address is formed from the offset specified by the instruction and the base address specified by the segment portion of the x86 address translation mechanism. Linear addresses may optionally be translated to physical addresses for accessing a main memory. The linear to physical translation is specified by the paging portion of the x86 address translation mechanism. It is noted that a linear addressed cache stores linear address tags. A set of physical tags (not shown) may be employed for mapping the linear addresses to physical addresses and for detecting translation aliases. Additionally, the physical tag block may perform linear to physical address translation.
• Turning now to FIG. 2, a block diagram of one embodiment of[0067]decode units20B and20C are shown. Eachdecode unit20 receives an instruction frominstruction alignment unit18. Additionally,MROM unit34 is coupled to eachdecode unit20 for dispatching fast path instructions corresponding to a particular MROM instruction.Decode unit20B comprisesearly decode unit40B,multiplexor42B, andopcode decode unit44B. Similarly, decodeunit20C includesearly decode unit40C,multiplexor42C, andopcode decode unit44C.
• Certain instructions in the x86 instruction set are both fairly complicated and frequently used. In one embodiment of[0068]microprocessor10, such instructions include more complex operations than the hardware included within a particularfunctional unit24A-24C is configured to perform. Such instructions are classified as a special type of MROM instruction referred to as a “double dispatch” instruction. These instructions are dispatched to a pair of opcode decode units44. It is noted that opcode decode units44 are coupled torespective reservation stations22. Each ofopcode decode units44A-44C forms an issue position with the correspondingreservation station22A-22C andfunctional unit24A-24C. Instructions are passed from an opcode decode unit44 to the correspondingreservation station22 and further to the correspondingfunctional unit24.
• [0069]Multiplexor42B is included for selecting between the instructions provided byMROM unit34 and byearly decode unit40B. During times in whichMROM unit34 is dispatching instructions,multiplexor42B selects instructions provided byMROM unit34. At other times,multiplexor42B selects instructions provided byearly decode unit40B. Similarly,multiplexor42C selects between instructions provided byMROM unit34,early decode unit40B, andearly decode unit40C. The instruction fromMROM unit34 is selected during times in whichMROM unit34 is dispatching instructions. During times in which early decodeunit40A detects a double dispatch instruction, the instruction fromearly decode unit40B is selected bymultiplexor42C. Otherwise, the instruction fromearly decode unit40C is selected. Selecting the instruction fromearly decode unit40B intoopcode decode unit44C allows a fast path instruction decoded bydecode unit20B to be dispatched concurrently with a double dispatch instruction decoded bydecode unit20A.
• According to one embodiment employing the x86 instruction set, early decode units[0070]40 perform the following operations:
• (i) merge the prefix bytes of the instruction into an encoded prefix byte;[0071]
• (ii) decode unconditional branch instructions (which may include the unconditional jump, the CALL, and the RETURN) which were not detected during branch prediction;[0072]
• (iii) decode source and destination flags;[0073]
• (iv) decode the source and destination operands which are register operands and generate operand size information; and[0074]
• (v) determine the displacement and/or immediate size so that displacement and immediate data may be routed to the opcode decode unit.[0075]
• Opcode decode units[0076]44 are configured to decode the opcode of the instruction, producing control values forfunctional unit24. Displacement and immediate data are routed with the control values toreservation stations22.
• Since early decode units[0077]40 detect operands, the outputs of multiplexors42 are routed to registerfile30 and reorderbuffer32. Operand values or tags may thereby be routed toreservation stations22. Additionally, memory operands are detected by early decode units40. Therefore, the outputs of multiplexors42 are routed to load/store unit26. Memory operations corresponding to instructions having memory operands are stored by load/store unit26.
• Turning next to FIG. 3, a block diagram of[0078]decode unit20A,reservation station22A,functional unit24A, registerfile30,reorder buffer32,FPU36,MROM34, and load/store unit26 is shown. Interconnection between the units is shown according to one embodiment ofmicroprocessor10. Other embodiments may employ other interconnection, and additional interconnection may be employed for other purposes. Interconnection betweendecode units20B-20C,reservation stations22B-22C,functional units24B-24C and the remaining elements of FIG. 3 may be similar.
• [0079]Decode unit20A receives an instruction frominstruction alignment unit18.Early decode unit40A detects the operands used by the instruction and conveys indications of the register operands to reorderbuffer32 and registerfile30 upon anoperands request bus50A. Register pointers are conveyed, and the source and/or destination nature of the operand is identified. For the fast path instructions described above, up to two source operands may be identified, one of which is the destination operand as well. Still further, flag operands are identified uponoperand request bus50A. In one embodiment, the flag operands are divided into three groups: the carry flag, the status and direction flags, and the remaining flags. For embodiments employing the x86 microprocessor architecture, the status and direction flags are the D, O, S, Z, P, and A flags. Immediate data is conveyed to reorderbuffer32 upon immediate bus51A.Reorder buffer32 relays the immediate data uponoperand data bus58A. Most x86 instructions specify either a second register operand or immediate data, but not both. Therefore, the portion ofoperand data bus58A used to convey the second register operand value may be used to convey the immediate data. For branch instructions, the program counter address, an offset, and the predicted target address may be conveyed uponoperand data bus58A.
• [0080]Decode unit20A additionally conveys certain information regarding the instruction to reorderbuffer32 upon aninstruction bus52A. Exemplary instruction information employed in one embodiment ofmicroprocessor10 is described in more detail further below. Additionally,early decode unit40A detects load/store memory operations specified by the instruction. An indication of the memory operations is conveyed to load/store unit26 via load/store interface54.
• In response to the operands conveyed upon[0081]operands request bus50A, registerfile30 conveys register operand values uponregister operands bus56 to reorderbuffer32. The register values conveyed comprise the values stored in register file30 (i.e. the values generated according to the instructions previously retired byreorder buffer32).If reorderbuffer32 is not storing information regarding an instruction which uses the register as a destination operand, the value provided byregister file30 is conveyed to thereservation station22A-22C which receives the instruction. For example, a register value corresponding to the instruction conveyed toreservation station22A may be conveyed uponoperand data bus58A.
• Alternatively, reorder[0082]buffer32 may be storing information regarding an instruction which updates the requested register. If the instruction has executed and has provided an instruction result, that result is conveyed in lieu of the register value provided byregister file30 uponoperand data bus58A. If the instruction has not yet executed, the reorder buffer tag locating the instruction withinreorder buffer32 is conveyed upon an operand tagsbus60A. One operand data value and one operand tag are provided for each source operand of the instruction uponoperand data bus58A andoperand tags bus60A, respectively. Additionally, validity indicators are asserted for each data and tag value byreorder buffer32, such thatreservation station22A may discern which is being provided for a particular operand (e.g. data or reorder buffer tag).
• In addition to providing operand values and tags, reorder[0083]buffer32 provides an instruction tag for the instruction being dispatched toreservation station22A upon aninstruction tag bus62A. The instruction tag identifies the storage location withinreorder buffer32 which stores information regarding the instruction. The instruction tag is conveyed uponresult bus38A (one ofresult buses38 shown in FIG. 1) when the instruction is executed, such that the corresponding instruction result may be stored withinreorder buffer32. In one embodiment,instruction tag bus62A conveys a line tag identifying the line of storage which stores the instruction information. The offset tag is a constant which is inherent in the issue position to which the instruction is conveyed. In other words,functional unit24A provides results which are always stored at a particular offset within the lines of storage withinreorder buffer32.
• In addition to storing the operand values and tags corresponding to an instruction,[0084]reservation station22A receives the decoded instruction provided byopcode decode unit44A. When each of the source operand values corresponding to the instruction have been provided byreorder buffer32 or have been captured fromresult buses38, the instruction may be selected for execution byfunctional unit24A. Upon selecting the instruction for execution,reservation station22A conveys the decoded instruction and corresponding operands tofunctional unit24A.
• [0085]Functional unit24A executes instructions received fromreservation station22A and conveys the instruction tag corresponding to the instruction uponresult bus38A in addition to the instruction result generated therein. In one embodiment, the instruction tag is forwarded as the instruction begins execution but reorderbuffer32 does not receive the corresponding instruction result until the clock cycle following instruction execution. The instruction tag may be forwarded in this manner because it is unchanged during instruction execution, whereas the instruction result must be generated byfunctional unit24A and then forwarded. It is noted thatresult bus38A is coupled to reservation stations22 (such asreservation station22A shown in FIG. 3) for providing forwarded results thereto. Still further,result bus38A is coupled to load/store unit26.Functional unit24A provides the logical address of a memory operation specified by the instruction being executed therein to load/store unit26 viaresult bus38A.
• [0086]Functional unit24A additionally forwards a result status upon a result status bus64A to reorderbuffer32. The result status indicates any exceptions associated with the instruction, such thatreorder buffer32 may take appropriate corrective actions. Corrective actions may include hardware supported correction, trapping to a microcode routine withinMROM unit34, or trapping to a software routine stored at a particular address identified for the instruction. Result status bus64A may additionally be used to indicate execution of a branch instruction which is mispredicted.
• [0087]Reorder buffer32 interfaces to load/store unit26 to allow completion of load/store memory operations. Load/store unit26 may be configured to speculatively execute load and store memory operations which hit indata cache28. Load memory operation results (along with a reorder buffer tag including both line tag and offset tag portions) are conveyed upon an LS resultsbus66 to reorderbuffer32. Additionally, the load results are forwarded toreservation stations22 in order to provide operands thereto. In one embodiment, up to two results may be provided uponLS results bus66.
• Load/[0088]store unit26 may be configured not to speculatively perform memory operations which missdata cache28.Reorder buffer32 indicates upon retirepointers bus68 which memory operations are otherwise in position to be retired but have not yet executed. Load/store unit26 then performs the indicated memory operations and returns results uponLS results bus66. Additionally, load/store unit26 asserts a corresponding signal upon a donebus70.Reorder buffer32 recognizes the asserted done signal as a completion of the memory operation indicated upon retirepointers bus68. Since load/store unit26 may execute up to two memory operations concurrently according to one embodiment, retirepointers bus68 may carry up to two reorder buffer tags. Accordingly, donebus70 includes two done signals corresponding to each of the reorder buffer tags.
• A cancel[0089]bus72 is included betweenreorder buffer32 and load/store unit26 as well. Cancelbus72 includes a signal for each reorder buffer tag conveyed upon retirepointers bus68. If the corresponding cancel signal is asserted, then reorderbuffer32 is indicating that the corresponding memory operation should be deleted from load/store unit26. Memory operations are deleted when they are subsequent to a mispredicted branch or an instruction which experienced an exception, for example.
• [0090]Reorder buffer32 interfaces withMROM unit34 andFPU36 viaMROM interface74 andFPU interface76, respectively.MROM interface74 is used (among other things) to implement branch misprediction recovery for branch instructions which originate inMROM unit34 as opposed to the original instruction stream. If a mispredicted branch is encountered and the branch instruction originated withinMROM unit34,reorder buffer32 informsMROM unit34 viaMROM interface74.MROM interface74 performs branch misprediction recovery for such mispredicted branch instructions.
• Since[0091]FPU36 operates as a coprocessor, several signals are used to synchronize completion of an instruction withinFPU36. These signals are included withinFPU interface76. Generally, a signal may be asserted toFPU36 indicating that a particular floating point instruction may be retired. When the floating point instruction is retired,FPU36 asserts a second signal. Additionally, upon detection of a floating point synchronization instruction, another set of signals are asserted to synchronize the completion of the instruction.
• Instructions are retired from[0092]reorder buffer32 in program order. Upon retirement, the corresponding register results are conveyed upon a retirebus78 to registerfile30. As noted above, the instructions within a line of storage are retired simultaneously. Since more than one instruction within the instructions may update the same register, reorderbuffer32 employs a set of bits within each line referred to as the last in line (LIL) bits. The LIL bits are set for each instruction which is the last instruction within the line to update a particular register. One bit is included for each portion of the register (i.e. EAX, AH, and AL, wherein AX is represented by both AH and AL being set). Effectively, these bits act as byte enables for updating the register. Therefore, an instruction which updates AH and another instruction which updates AL may retire simultaneously. For embodiments employing a microprocessor architecture which does not allow updates to only a portion of a register, one LIL bit is included for each instruction.
• Finally, reorder[0093]buffer32 employs astall line80 for stalling instruction dispatch. Instruction dispatch may be stalled for many reasons, including: reorder buffer, reservation station, or load/store buffer full conditions; a narrow to wide stall; instruction serialization; etc. Upon detection of a stall condition, reorderbuffer32 asserts a stall signal uponstall line80. Ifdecode unit20A receives an asserted stall signal during a clock cycle and decodeunit20A is attempting to dispatch an instruction,decode unit20A provides that same instruction during a subsequent clock cycle. In this manner, an instruction which cannot be dispatched during a particular clock cycle is continuously redispatched until the stalling condition terminates.
• Turning now to FIG. 4, a block diagram of one particular embodiment of[0094]reorder buffer32 is shown. Other particular embodiments are contemplated as well. As shown in FIG. 4, reorderbuffer32 includes adispatch control unit90, aninstruction storage92, aresult control unit94, aretirement control unit96, anexception control unit98, acomparator block100, and a special registers block102. Buses which are suffixed in FIG. 3 with an “A” are shown in FIG. 4 without the “A” to represent the bus fromdecode unit20A as well as similar buses fromdecode units20B-20C. For example,operand request bus50 includesoperand request bus50A as well as an operand request bus50B fromdecode unit20B and an operand request bus50C fromdecode unit20C.
• [0095]Dispatch control unit90 is coupled toexception control unit98,instruction storage92, andcomparator block100.Comparator block100 is further coupled toinstruction storage92, as isexception control unit98.Result control unit94,retirement control unit96, and special registers block102 are coupled toinstruction storage92 as well.
• [0096]Dispatch control unit90 receives instruction information and corresponding operand identifiers uponinstruction buses52 andoperand request buses50, respectively. Furthermore, corresponding immediate data (if any) is received upon immediate buses51. Upon receipt of at least one valid instruction fromdecode units20,dispatch control unit90 allocates a line of storage withininstruction storage92.Instruction storage92 includes multiple lines of storage, such aslines104A and104B shown in FIG. 4. The instruction information received uponinstruction bus52 is stored into the line of storage, as well as an indication of the destination operand of the instruction.Dispatch control unit90 provides the line tag identifying the allocated line of storage uponinstruction tag bus62 toreservation stations22.Reservation stations22 may thereby identify the line of storage104 which stores the instruction, and the offset tag is inherent in the issue position of the receivingreservation station22A-22C.
• [0097]Dispatch control unit90 further provides dependency checking for each source operand.Comparator block100 is provided for performing dependency checking. A comparator withincomparator block100 is assigned to each destination operand which may be stored withininstruction storage92 and to each source operand which may be requested uponoperand request buses50. The comparator compares the destination operand to the source operand to detect any dependencies with instructions outstanding withinreorder buffer32. Because x86 instructions allow a portion of a register to be updated and accessed, the comparators compare not only the register identifiers but the respective sizes of the updates. If a dependency is detected, the corresponding reorder buffer tag (i.e. both line tag and offset tag) is forwarded uponoperand tags bus60. Additionally, if an instruction result has been provided for the instruction upon which the dependency is detected, the result is provided uponoperand data bus58. If no dependency is detected, the register file value provided uponregister operands bus56 is provided uponoperand data bus58.
• In one embodiment,[0098]instruction storage92 stores a last-in-buffer indication for each instruction. The last-in-buffer indication indicates whether or not the instruction is the last (in program order) within the buffer to update the destination operand of that instruction. Comparators withincomparator block100 include the last-in-buffer indication in their comparisons, such that only the last instruction is detected as a dependency. Since only the correct dependency is identified by comparator block100 (as opposed to all instructions within the buffer which update the same destination), logic which determines the correct dependency from the comparator outputs may be simplified. Additionally, since one of the source operands is also the destination, resetting the last-in-buffer indication when a new instruction is dispatched requires little extra logic. When the comparator corresponding to a particular instruction withininstruction storage92 asserts its output signal and the source operand being compared is also the destination of the instruction being dispatched, the last-in-buffer indication of that particular instruction is reset. The last-in-buffer indication is set for each instruction dispatched.
• For embodiments employing the x86 instruction set, three types of dependencies may exist: an equal-sized dependency, a narrow-to-wide dependency, and a wide-to-narrow dependency. An equal-sized dependency exists if both the source operand and the destination operand being compared update the same portion of the same register. A narrow-to-wide dependency exists if the source operand accesses a larger portion of the register than the destination operand updates. Conversely, a wide-to-narrow dependency exists if the source operand accessed a smaller portion of the register than the destination operand updates. Equal-sized dependencies and wide-to-narrow dependencies may be handled by forwarding the destination operand's reorder buffer tag or result value. Narrow-to-wide dependencies are somewhat more problematic, since the instruction corresponding to the destination operand does not provide the entire value used by the source operand.[0099]Dispatch control unit90 may stall the instruction corresponding to the narrow-to-wide dependency for such embodiments via assertion of a stall signal uponstall line80. The stall signal may remain asserted until the destination operand is retired or discarded frominstruction storage92.
• Instruction results are provided by[0100]functional units24 uponresult buses38, while load/store unit26 provides load memory operation results uponLS results bus66.Result control unit94 examines the reorder buffer tags provided byfunctional units24 and load/store unit26 to determine which lines of storage and which instructions within the lines receive the results. As noted above,functional units24 provide a line tag only. The offset tag is a constant for each functional unit. However, load/store unit26 is not associated with a fixed, symmetrical issue position in the manner offunctional units24. Therefore, load/store unit26 provides both the line tag and the offset tag for each result.Result control unit94 directsinstruction storage92 to store each result in the appropriate line and offset.
• Additionally, result[0101]control unit94 receives an exception status for each instruction uponresult status bus64. If afunctional unit24 or load/store unit26 reports an exception while executing an instruction,result control unit94 stores the exception status intoinstruction storage92 at the line and offset storing the corresponding instruction.Result control unit94 may also signalexception control unit98 directly regarding certain exceptions (e.g. branch misprediction), such that recovery may begin. Alternatively,exception control unit98 may detect other exceptions as the corresponding instructions are retired frominstruction storage92.
• [0102]Retirement control unit96 is configured to retire instructions frominstruction storage92. Generally, the instructions within a line of storage104 are retired simultaneously. Additionally, instructions are retired in program order. Therefore,retirement control unit96 monitors the line of storage104 storing the instruction which is foremost in program order among the instructions within instruction storage92 (the “oldest line”). When each of the instructions within the oldest line have executed and provided results, the instructions are retired. Instruction results which updateregister file30 are conveyed upon retirebus98 along with the corresponding last-in-line bits. The line of storage is then deallocated, freeing storage space for a set of concurrently dispatched instructions.
• [0103]Retirement control unit96 further scans the instructions withininstruction storage92 to detect load/store memory operations which have not yet completed and which are no longer speculative. A load/store memory operation is no longer speculative if the instructions prior to the instruction corresponding to the load/store memory operation have completed without exception.Retirement control unit96 conveys the reorder buffer tag of the instruction corresponding to the non-speculative load/store memory operation upon retirepointers bus68 to load/store unit26. Load/store unit26 may subsequently select the memory operation for access todata cache28. Upon completion of the memory operation, load/store unit26 asserts a done signal upon donebus70.Retirement control unit96 may then mark the corresponding memory operation as completed withininstruction storage92. If the remaining instruction operations associated with the instruction corresponding to the completed memory operation have also been performed, the instruction is ready for retirement.
• [0104]Retirement control unit96 may further operate signals upon cancelbus72 in conjunction with retirepointers bus68. If an instruction corresponding to a load/store memory operation has been cancelled (due to exception conditions), the cancel signal is asserted when the reorder buffer tag of the instruction is conveyed upon retirepointers bus68. Load/store unit26 discards the identified memory operation and asserts the corresponding done signal. Alternatively,exception control unit98 may operate the cancel signals.
• Upon retirement of instructions which update special registers within special registers block[0105]102, the special registers are updated. In one embodiment, the special registers within special registers block102 include: the program counter register, which stores an address indicative of the last instruction to be retired; an MROM program counter register, which stores a ROM address indicative of the last retired instruction fromMROM unit34; a floating point program counter register, which stores an address indicative of the last floating point instruction to be retired; recovery registers for the program counter and ESP for use with branch and CALL/RETURN instructions whose targets experience a segment limit violation; the flags registers; a floating point opcode register storing the opcode of the last floating point instruction to be retired; and a debug register.
• [0106]Exception control unit98 handles recovery from exceptions experienced bymicroprocessor10. An exceptions controlbus106 is provided byexception control unit98 to indicate exceptions and corrective actions toreservation stations22 and load/store unit26. Any suitable set of corrective actions may be performed.
• In one embodiment, branch misprediction exception recovery begins upon detection of the branch misprediction, while exception recovery for other exceptions begins upon retirement of the corresponding instruction. Branch misprediction recovery may be performed in many ways. For example,[0107]exception control unit98 may provide the reorder buffer tag of the branch instruction upon exceptions controlbus106. Instructions subsequent to the branch instruction are discarded by comparing the corresponding reorder buffer tags to the branch instruction tag. For this method,reservation stations22 and load/store unit26 must be able to determine program order from the values of the reorder buffer tags. As another example,exception control unit98 may assert a branch misprediction signal upon exceptions controlbus106.Reservation stations22 and load/store unit26 may note the instructions which are stored therein upon receipt of the asserted signal. Subsequently,exception control unit98 may indicate that the mispredicted branch instruction is retired. Instructions remaining withinreservation stations22 and load/store unit26 upon receipt of the retirement indication may then be discarded if the instructions are noted as stored therein upon detection of the mispredicted branch. Other instructions which arrived subsequent to detection of the mispredicted branch are from the corrected path and therefore are retained. In yet another example, load/store memory operations subsequent to the mispredicted branch in program order may be cancelled via cancelbus72. Random data may be forwarded for the cancelled load memory operations, and other instructions which are subsequent to the mispredicted branch may be allowed to execute and forward results. The instructions are then discarded byreorder buffer32.
• In addition to causing instruction discard in other portions of[0108]microprocessor10,exception control unit98 directsdispatch control unit98 to “redispatch” the instructions withininstruction storage92 which are prior to the mispredicted branch in program order. Since instructions subsequent to the mispredicted branch instruction may be indicated to be last-in-buffer updates to one or more registers, this “redispatch” allows the dependency checking logic ofdispatch control unit90 to recover the state of the last-in-buffer indications for the instructions prior to the mispredicted branch. The “redispatch” is performed internal to reorder buffer32 (i.e. other portions ofmicroprocessor10 are unaffected). In one embodiment,dispatch control unit90B begins with the oldest line of instructions and redispatches each line of instructions up to and including the line of instructions including the mispredicted branch instruction (save the instructions within the line which are subsequent to the mispredicted branch instruction).
• In another embodiment, redispatch begins with the line of instructions including the mispredicted branch instruction and proceeds in inverse program order. If an update to a register is detected, the LIB bits are set appropriately. Additionally,[0109]dispatch control unit90 notes that the LIB bits for that register have been set during the recovery. Updates to that register (or portion thereof) are ignored in subsequent redispatches since the redispatch is proceeding in inverse program order. This embodiment has the advantage that lines of instructions prior to the mispredicted branch which are retired prior to the completion of mispredicted branch recovery are not redispatched. Branch misprediction recovery may thereby complete in fewer clock cycles than other branch misprediction recovery mechanisms.
• Turning now to FIG. 5, a block diagram depicting one implementation of[0110]instruction storage92 is shown. The implementation shown in FIG. 5 is a first-in, first-out (FIFO)buffer92A. Additionally, an embodiment of dispatch control unit90 (dispatch control unit90A) is shown.
• A FIFO buffer generally comprises multiple storage locations which operate as a queue. As the name implies, the first item placed in a FIFO buffer is the first item to be removed from the buffer. The “items” for[0111]FIFO buffer92A comprise lines of instructions. For example, the embodiment ofFIFO buffer92A illustrated in FIG. 5 stores up to three instructions per line. Therefore, each line of storage includes a first instruction (I0)field110, a second instruction (I1)field112, and a third instruction (I2)field114. Additionally, certain information which is shared by the instructions in the line is stored in a shared (SH)field116. A line of storage104 is allocated to one or more concurrently dispatched instructions bydispatch control unit90A. Although the line of storage104 shown in this implementation includes up to three instructions, other embodiments of FIFO buffers or instruction storages may include any number of instructions greater than one.
• [0112]FIFO buffer92A shifts the lines of instructions stored therein such that the oldest line of instructions is in the bottom storage location ofFIFO buffer92A (e.g. the location labeled zero in FIG. 5). The “bottom” of a FIFO buffer is the storage location which is defined to store the item which is next to be removed from the FIFO buffer. When the item at the bottom is removed, the remaining items are shifted within the FIFO buffer such that the item which was second to the bottom of the FIFO buffer becomes the item stored at the bottom. ForFIFO buffer92A, each time a line of instructions is retired,FIFO buffer92A is shifted such that the line of instructions which was next to the bottom ofFIFO buffer92A becomes the line of instructions stored at the bottom. In this manner, the storage location which is defined to be the bottom ofFIFO buffer92A is the only storage location accessed byretirement control unit76 in order to retire instructions.
• [0113]Dispatch control unit90A allocates a storage location withinFIFO buffer92A for each set of concurrently dispatched instructions received byreorder buffer32. WhenFIFO buffer92A is empty,dispatch control unit90A allocates location zero. If location zero is occupied and location one is empty, location one is allocated. Similarly, other locations withinFIFO buffer92A are allocated if all the locations between that location and the bottom ofFIFO buffer92A are occupied with instructions. The location numbers shown in FIG. 5 next toFIFO buffer92A are therefore physical line tags which identify one line of storage withinFIFO buffer92A from the other lines of storage withinFIFO buffer92A.
• Because instruction information and results are shifted between lines of storage[0114]104 withinFIFO buffer92A, physical line tags are unsuitable for use in identifying a particular instruction. The physical line tag changes as instructions are retired fromFIFO buffer92A. Therefore,dispatch control unit90A assigns a virtual line tag to a set of concurrently dispatched instructions. The virtual line tag is stored in the sharedfield116 of the line of storage allocated to the instructions. As the line of instructions is shifted between lines of storage104 withinFIFO buffer92A, the virtual line tag is moved along as well. Therefore, resultcontrol unit94 may search the virtual line tags stored withinFIFO buffer92A in order to locate the line of storage104 storing an instruction for which a result is being provided.
• [0115]Dispatch control unit90A includes astorage location118 which stores the virtual line tag to be allocated to the next set of concurrently dispatched instructions received byreorder buffer32. Whendispatch control unit90A allocates a line of storage to the set of concurrently dispatched instructions, the virtual line tag stored instorage location118 is incremented. If lines of instructions are discarded due to branch misprediction, the virtual line tag may be reset to the virtual line tag subsequent to the virtual line tag assigned to the mispredicted branch instruction. The virtual line tag is the tag conveyed toreservation stations22, load/store unit26, and any other portions ofmicroprocessor10 which receive reorder buffer tags.
• Turning next to FIG. 6, an illustration of the connection of[0116]results buses38 andLS result buses66 to an exemplary line ofstorage104A is shown.Result bus38A fromfunctional unit24A,result bus38B fromfunctional unit24B, and resultbus38C fromfunctional unit24C are shown. Becausemicroprocessor10 employs fixed issue positions and because an instruction field110-114 corresponds to a particular issue position, eachresult bus38 connects to a particular instruction field110-114 within each line of storage. In other words, results provided uponresult bus38A are stored intofirst instruction field110; results provided uponresult bus38B are stored intosecond instruction field112; and results provided uponresult bus38C are stored intothird instruction field114.
• FIG. 6 illustrates that[0117]functional units24 need only provide a line tag to reorderbuffer32 uponresult buses38. The offset within the line (i.e. the particular instruction within the line of instructions), is inherent in the bus upon which the result arrives.Result control unit96 uses the line tag to identify the line of storage to be updated, and the instruction field within the line is automatically located as the only instruction field to which theparticular result bus38A-38C may provide a value.
• It is noted that, by configuring[0118]microprocessor10 with multiple fixed, symmetrical issue positions,microprocessor10 may be more likely to dispatch larger numbers of instructions concurrently than microprocessors having asymmetrical issue positions and line-oriented reorder buffers. Since the symmetrical issue positions execute the same subset of instructions, any random group of instructions within the subset may be dispatched to and executed concurrently by the symmetrical issue positions. Conversely, asymmetrical issue positions are limited to certain groups of instructions within the subset of instructions executed by the asymmetrical issue positions as a whole. For example, if several instructions are eligible for concurrent dispatch, but only one of the asymmetrical issue positions is configured to execute the several instructions, then typically only one of the several instructions may be dispatched at a time. Even if the issue position is configured to receive multiple dispatched instructions concurrently, the issue position may only execute the instructions one at a time. Therefore, the fixed, symmetrical issue positions configured intomicroprocessor10 operate in conjunction with the lines of storage withinreorder buffer32 to provide high instruction dispatch and execution rates.
• Load/[0119]store unit26, on the other hand, does not correspond to a particular fixed issue position. Load/store unit26 therefore provides both a line tag and an offset tag uponLS result buses66.LS result buses66 are coupled to each field of the lines of storage, thereby allowing results provided by load/store unit26 to update any instruction field. The particular instruction field updated by a particular result is identified by the offset tag conveyed therewith.
• Turning to FIG. 7, a block diagram of a portion of the dependency checking logic employed by one embodiment of[0120]reorder buffer32 is shown.First instruction field110 from line ofstorage104A is shown, as well as acomparator120A and a hitlogic block122.Comparator120A receives the destination operand identifier frominstruction field110, as well as the last-in-buffer (LIB) indication. Additionally,comparator120A receives a source operand identifier from operand request bus50 (or frominstruction storage92, if branch misprediction recovery is being performed).Comparator120A includes anoutput line124A connected to hitlogic block122.Output line124A is asserted if the destination operand identifier and the source operand identifier compare equal and the LIB indication is set. If the operand identifiers do not compare equal or the LIB indication is not set,output line124A is deasserted.
• Hit[0121]logic block122 receivesoutput line124A as well as other output lines124 (such asoutput lines124B,124C, and124D shown in FIG. 7, among others). The output lines124 received by hitlogic block122 emanate fromcomparators120 which receive the same source operand identifier fromoperand request bus50. Since the LIB indicator is included incomparators120, only zero or one of output lines124 is asserted for a particular dependency check. Hitlogic122 may therefore select the reorder buffer tag corresponding to the one asserted output line124 for conveyance as the operand tag. No prioritization logic need be included withinhit logic122. For example, hitlogic122 may effectively comprise a multiplexor having reorder buffer tags as inputs and output lines124 as selection controls.
• Hit[0122]logic block122 may additionally be configured to reset the LIB indication for an instruction if the source operand for which hitlogic block122 provides dependency information is also the destination operand. For example, if hitline124A is asserted andcomparator120A receives a source/destination operand, hitlogic122 asserts areset LIB line126A toinstruction field110. Additional reset LIB lines126 may be conveyed to other instruction fields corresponding toother comparators120. It is noted that comparator output signals124 may comprise reset LIB lines126, since only the instruction for which the LIB indication is set is indicated as comparing equal.
• It is further noted that, for embodiments employing the x86 microprocessor architecture, operand size information must be taken into account as well. The type of dependency (e.g. equal-sized, wide-to-narrow, or narrow-to-wide) is determined as well for such embodiments, as described above.[0123]
• Turning now to FIG. 8, a[0124]list130 of exemplary information stored in an instruction field110-114 according to one specific implementation ofreorder buffer32 is shown. Additional, substitute, or alternative information may be stored by other embodiments. Information having a bit encoding suffixed thereto is multi-bit information. Otherwise, a single bit is used.
• The instruction result is stored in the instruction field, and a result valid bit indicates whether or not the instruction result has been provided. Similarly, any flag bits which are updated are stored the instruction field. The branch indication is set if the instruction is a branch. The LS_Sync bit is set if a load/store resync is needed. A load instruction may need resynchronization (i.e. refetch and reexecution of the instruction and subsequent instructions in program order) if the load instruction is performed out of order and a snoop hit is detected on the address accessed by the load instruction prior to retirement of the load instruction. Store instructions which update instruction code which is outstanding within[0125]microprocessor10 are also detected, causing a setting of the LS_Sync bit. Instructions following the store instruction for which the bit is set are refetched and reexecuted. The SBZ bit indicates, when set, that a shift by zero is performed for the corresponding instruction. Shift by zero is a defined exception for x86 instructions. Exception and breakpoint information corresponding to the instruction is stored as well.
• As mentioned above, last-in-line (LIL) and last-in-buffer (LIB) information is stored for each instruction. LIL and LIB information corresponds to the destination register, while FLIL and FLIB correspond to the flags register. Four LIB bits are used, one bit corresponding to each portion of the destination register which may be selected by an instruction. The LIB bit to be used in the dependency comparison may be selected according to the size of the source operand being compared. In this manner, an update to the AH register, for example, does not interfere with an access to the AL register. Four FLIB bits are used as well, except that the four FLIB bits correspond to four groups of flag bits. A first group includes the S, Z, P, and A bits; a second group is the O bit; a third group is the D bit; and a fourth group is the C bit. Similar to the FLIB bits, the FLIL bits correspond to each of four groups of flags. The groups are chosen based upon the manner in which the x86 instruction set updates the flags.[0126]
• The LIL bits are used as enables for updating[0127]register file30. Therefore, one LIL bit indicates that the most significant two bytes of the destination register are updated by the instruction corresponding to this instruction field; a second LIL bit indicates that byte1 (e.g. AH) is updated by the instruction; and a third LIL bit indicates that byte0 (e.g. AL) is updated by the instruction.
• The cancel bit, when set, indicates that the instruction has been cancelled. An instruction is cancelled if it is subsequent to a mispredicted branch. An instruction having the cancel bit set does not update[0128]register file30.
• The destination specifier is stored for each instruction, as well as a destination valid bit. The destination specifier may be invalid, for example, when the destination operand of the instruction is a memory location. WRFL[3:0] is used to indicate which flag groups are updated by the instruction. Similar to the LIL bits, Size[2:0] encodes the size of the destination operand. End_byte[3:0] stores the least significant four bits of the address at which the last byte of the instruction is stored. End_byte[3:0] may be used in conjunction with a program counter field described below to calculate an address for the program count register upon retirement of the instruction. The CRET bit is set if the instruction is a CALL or RETURN instruction. PC_Sel indicates which of two program counter values stored in shared[0129]field116 corresponds to the instruction. If PC_Sel is clear, the first program counter value is selected. Otherwise, the second program counter value is selected. Similarly, the Sel_eflg field indicates which of two flags registers should be updated by this instruction. MROM instructions have a flags register dedicated for their use in addition to the architecturally defined flags register.
• The INT_ENB bit, when set, indicates that the instruction may cause an interrupt. Instructions dispatched from[0130]MROM unit34 cannot cause an interrupt, while fast path instructions may. The store bit is set if the instruction performs a store memory operation. Similarly, the WSR bit is set if the instruction updates a special register. The Null bit is set if the instruction field is not storing a valid instruction.
• The Null bit may be set for instruction fields which did not receive an instruction upon allocation of the line of storage (i.e. less than the maximum number of concurrently dispatchable instructions was dispatched). Alternatively, an entry may be nullified if an exception is detected. The exit bit is set if the instruction is the last instruction of an MROM instruction sequence of if the instruction is a fast path instruction. Finally, the entry valid bit indicates that the instruction field is storing valid information. The entry valid bit is set if the Null bit is clear and the Cancel bit is clear.[0131]
• FIG. 9 is a[0132]list132 of exemplary information stored in sharedfield116 according to one specific implementation ofreorder buffer32. Additional, substitute, or alternative information may be stored by other embodiments. Information having a bit encoding suffixed thereto is multi-bit information. Otherwise, a single bit is used.
• The branch misprediction bit is set if a mispredicted branch is within the line of storage. Otherwise, the branch misprediction bit is clear. CSSEL stores the code segment selector for the line of instructions. The floating point bit is set if the line includes a floating point instruction, and the floating point instruction opcode is stored in FPOPC[10:0]. The FSYNC bit is set if a forced synchronization is performed for this line of storage. Forced synchronizations are performed upon execution of a taken branch instruction which was not detected by[0133]branch prediction unit14.Branch prediction unit14 is thereby updated with information identifying the taken branch instruction prior to retirement of the taken branch instruction.
• The shared field stores up to two program count values per line. PC1 stores the program counter address for the first instruction stored within the line. PC2 stores the address of a split line instruction or the target of a branch instruction. In this manner, instructions for up to two different cache lines may be stored within a single line of storage. In one particular embodiment, instructions from three different cache lines may be stored when the first instruction in the line is a split line instruction and the second instruction is a predicted taken branch instruction. The Last1 bit, Linetag1[4:0], and LineOffset[3:0] correspond to PC1. Similarly, the Last2 bit, Linetag2[4:0], and LineOffset[3:0] correspond to PC2. The last bit is set if the last instruction in the cache line indicated by the corresponding PC value is within the line of storage. The line tag identifies branch prediction information corresponding to a branch instruction within the line. The branch prediction information may remain stored in[0134]branch prediction unit14, and is updated by communicating the results of the branch instruction along with the line tag to branchprediction unit14. Branch mispredictions are communicated upon detection of the mispredictions, while correct predictions are updated upon retirement of the corresponding branch instruction. The line offset contains a value which, when added to the corresponding PC value, locates the beginning of the next instruction after the instructions included within the line of storage.
• The MROM bit is set if the line of storage contains one or more MROM instructions, and is clear otherwise. The NoMisp bit is set if the line cannot mispredict (i.e. no predicted branch instruction is in the line). The PCSHFT bit is set if the first instruction in the line of storage is a split line instruction (e.g. a portion of the instruction is in one instruction cache line the remainder is in another instruction cache line). If the first instruction is a split line instruction, PC1 corresponds to the cache line storing the remaining portion. PC2 may therefore be used for the target of a branch instruction. Finally, VLTAG[3:0] stores the virtual line tag assigned to the line of storage. VLTAGP1[3:0] stores the virtual line tag plus 1 (for use in resetting[0135]storage location118 shown in FIG. 5 upon detection of a mispredicted branch instruction).
• Turning now to FIG. 10, a block diagram of a portion of a second embodiment of[0136]reorder buffer32 is shown. Additionally, registerfile30 is shown in FIG. 10. For the embodiment shown in FIG. 10,reorder buffer32 includes afuture file140. Additionally,FIFO buffer92A,dispatch control unit90B, results controlunit94A, andexception control unit98A are included.
• [0137]Future file140 stores reorder buffer tags and/or instruction results for each register employed withinregister file30. In other words,future file140 includes a plurality of storage locations142 such asstorage locations142A,142B, and142C. One storage location142 is assigned to each register. The storage location142 for a particular register stores the reorder buffer tag of the instruction which is last (in program order) withinFIFO buffer92A to update the register. An instruction having the register as a source operand receives the reorder buffer tag by accessing the corresponding storage location142. When the corresponding instruction result is provided via execution of the instruction, the instruction result is stored into the storage location142. Subsequently, the instruction result is provided instead of the reorder buffer tag. For this embodiment, therefore, a combined operands/tags bus144 may be employed instead of separate operands and tags buses. Tag validity information may be used to indicate if a tag or data is conveyed for a given operand upon operands/tags bus144.
• Upon dispatch of an instruction,[0138]dispatch control unit90B interacts withFIFO buffer92A substantially as described above. Additionally,dispatch control unit90B accesses the storage location142 corresponding to each source operand. The corresponding reorder buffer tag or data is conveyed upon operands/tags bus144. Additionally, for each instruction which has a register destination operand, the reorder buffer tag assigned to the instruction is stored into the storage location142 assigned to that register. Advantageously, the large number of comparators used to compare source operands of dispatching instructions to destinations stored inFIFO buffer92A are eliminated.Dispatch control unit90B still performs dependency checking between concurrently dispatched instructions and forwards a reorder buffer tag upon operands/tags bus144 if a dependency is detected therein, but the number of comparator circuits is relatively small. For example, three comparator circuits are employed when the maximum number of concurrently dispatched instructions is three. Six comparators are used when the maximum number of concurrently dispatched instructions is four, etc. Additionally, the number of entries infuture file140 is determined by the number of registers implemented bymicroprocessor10. Therefore,FIFO buffer92A may be increased in size arbitrarily without substantively increasing the size of the dependency checking logic (i.e. future file140).
• [0139]Result control unit94A also interacts withFIFO buffer92A substantially as described above upon receipt of results uponresults buses38 and/orLS result buses66. In addition to updating the instruction result stored inFIFO buffer92A,result control unit94A examines the LIB bits for the instructions providing results. If the LIB bits are set, then resultcontrol unit94A updates the corresponding entry infuture file140 as well.Result control unit94A checks the status of the LIB bits in order to avoid overwriting a reorder buffer tag of an instruction subsequent to the instruction for which results are being provided when the subsequent instruction updates the same register as the instruction.
• As noted above for one embodiment, the reorder buffer tag is provided upon[0140]results buses38 andLS results buses66 during the clock cycle prior to the instruction result itself. During the clock cycle that the reorder buffer tag is provided,result control unit94A checks the LIB bits for the identified instruction. In this manner,result control unit94A determines whether to update bothfuture file140 andFIFO buffer92A or onlyFIFO buffer92A prior to arrival of the corresponding data.
• [0141]Future file140 maintains dependency information corresponding to updates by the last instructions in the predicted program order speculatively fetched and dispatched bymicroprocessor10. In the case of branch misprediction and exception, the values stored infuture file140 must be recovered so as not to reflect the instructions from the predicted instruction stream which are discarded.Exception control unit98A communicates withregister file30 upon initiation of exception or branch misprediction recovery.Register file30 transmits the contents of each register included therein upon anupdate bus146 tofuture file140.Future file140 stores the transmitted results into the corresponding storage locations142. For exceptions which are serviced when the instruction experiencing the exception is retired, the transmittal of register file values completes recovery offuture file140. However, additional steps are employed for branch misprediction recovery, which is initiated prior to retirement of the mispredicted branch instruction.
• For mispredicted branch instructions, subsequent to copying the contents of[0142]register file30 intofuture file140,dispatch control unit90B redispatches the instructions prior to the mispredicted branch instruction (as described above).Dispatch control unit90B recovers the LIB bits of the lines of storage which store instructions prior to the mispredicted branch instruction in program order, as described above. In addition, the destination tags (or the instruction results, if already provided) of the instructions are stored intofuture file140. In this manner, the state offuture file140 is recovered to the state consistent with execution of the mispredicted branch instruction and the prior instructions in program order.
• FIG. 11 is a[0143]flowchart148 depicting receipt of a result byresult control unit94A. Update ofFIFO buffer92A is illustrated, as well as the conditional update offuture file140 depending upon the state of the LIB bits.
• Turning next to FIG. 12, a diagram illustrating a[0144]storage location142A offuture file140 is shown according to one implementation offuture file140. Other implementations are contemplated. The implementation shown in FIG. 12 may be employed for embodiments ofmicroprocessor10 employing the x86 microprocessor architecture. In the implementation shown,storage location142A corresponds to the EAX register. Other storage locations142 may be configured similarly.
• Because the x86 microprocessor architecture allows for updates and accesses of portions of the EAX register, the value corresponding to the EAX register at any given clock cycle may be a combination of one or more reorder buffer tags as well as data. For the embodiment shown in FIG. 12,[0145]storage location142A comprises atag validity field150 as well as astorage field152. For the embodiment shown,tag validity field150 comprises 5 bits, although other embodiments may included different numbers of bits. Similarly,storage field152 comprises 32 bits in the embodiment shown although other embodiments may employ other numbers of bits.Storage field152 is divided into a first tag ordata portion154, a second tag ordata portion156, and a third tag ordata portion158.
• First tag or[0146]data portion154 stores a reorder buffer tag or data corresponding to the most significant two bytes of the EAX register. Therefore, a reorder buffer tag stored infirst portion154 corresponds to an instruction having the EAX register as a destination operand. Similarly, second tag ordata portion156 stores a reorder buffer tag or data corresponding to the more significant byte of the least significant two bytes of the EAX register. Therefore, a reorder buffer tag stored insecond portion156 corresponds to an instruction having the EAX, AX, or AH register as a target. Finally, third tag ordata portion158 stores a reorder buffer tag or data corresponding to the less significant byte of the least significant two bytes of the EAX register. Therefore, a reorder buffer tag stored inthird portion158 corresponds to an instruction having the EAX, AX, or AL register as a target.
• [0147]Arrows160,162,164, and166 indicate which portions ofstorage field152 are updated when an instruction is dispatched which has the EAX register or a portion thereof as a destination operand. An instruction updating the EAX register updates the entire register. Therefore, the reorder buffer tag of an instruction having EAX as a destination operand is stored into each offirst portion154,second portion154, and third portion156 (arrow160). Conversely, an instruction having the AX register as a destination operand updates the least two significant bytes of the EAX register. Therefore, the reorder buffer tag of an instruction having AX as a destination operand is stored intosecond portion156 and third portion158 (arrow162)First portion154 is thereby unmodified from the value stored therein prior to dispatch of the instruction having AX as a destination. Instructions which update the AH and AL registers updatesecond portion156 andthird portion158, respectively (arrows164 and166).
• [0148]Arrows168,170,172, and174 indicate the source for the reorder buffer tag used by an instruction having the EAX register (or a portion thereof) as a source operand.First portion154 is used to provide the reorder buffer tag if the EAX register is a source operand (arrow168).Second portion156 is used to provide the reorder buffer tag if the AX or AR register is a source operand (arrows170 and172). Finally,third portion158 is used to provide the reorder buffer tag if the AL register is a source operand (arrow174). The receivingreservation station22 selects the appropriate reorder buffer tag based upon tag validity information and operand size information.Future file140 provides the contents ofstorage location142A upon operands/tags bus144.
• [0149]Tag validity field150 is used to indicate if a particular portion ofstorage field152 is storing a tag or data, as well as to indicate narrow-to-wide dependencies. As shown in FIG. 12,tag validity field150 comprises five bits: a T32V bit, a T16V bit, a T8V bit, a 32V bit, and a 16V bit. The T32V bit is set whenfirst portion154 is storing a tag, and is clear whenfirst portion154 is storing data. Similarly, the T16V bit and the T8V bit indicate the contents ofsecond portion156 andthird portion158, respectively. The T32V, T16V, and T8V bits are set when a tag is stored into the respective portions. The bits are cleared when the corresponding data is provided, in accordance with the LIB bits withinFIFO buffer92A.
• For example, a first instruction may have the EAX register as a destination operand. Therefore, the reorder buffer tag of the first instruction is stored into first, second, and[0150]third portions154,156, and158. Accordingly, each of the T32V, T16V, and T8V bits are set. Additionally, the LIB bits of the first instruction are set withinFIFO buffer92A. A second instruction may subsequently be dispatched. The second instruction may have the AX register as a destination operand. Therefore, the reorder buffer tag of the second instruction is stored intosecond portion156 andthird portion158. The LIB bits corresponding tosecond portion156 andthird portion158 are set for the second instruction and cleared for the first instruction. When the instruction result is provided for the first instruction, the LIB bit corresponding tofirst portion154 is set. Therefore,first portion154 is updated and T32V bit is cleared. However,second portion156 andthird portion158 are not updated since the corresponding LIB bits of the first instruction are clear.
• The 32V bit and the 16V bit are used to indicate narrow-to-wide dependencies for, 32 bit operands (32V bit). and 16 bit operands (16V bit). If the 32V bit is clear, then a 32-bit access to the corresponding register experiences a narrow-to-wide dependency. Similarly, if the 16V bit is clear than a 16-bit access experiences a narrow-to-wide dependency. Instruction dispatch is stalled upon detection of a narrow-to-wide dependency. However, because the value of the register is assembled within[0151]future file140 as instruction results are stored therein, the narrow-to-wide dependency is resolved upon execution of the instruction which updates the narrower register. Previously, the narrow-to-wide dependency was resolved (i.e. the dispatch stall released) upon retirement of the instruction which updates the narrower register.
• In another embodiment, if a narrow-to-wide dependency is detected, the dependency information is forwarded when only one reorder buffer tag remains valid within the future file. The receiving reservation station may collect the remaining data upon detection of the reorder buffer tag upon[0152]results buses38. In still another embodiment, instruction dispatch is not stalled on a narrow-to-wide dependency. Instead,storage field152 andtag validity field150 are forwarded upon operands/tags bus144.Reservation stations22 detect each valid reorder buffer tag within the value provided and collect results fromresult bus38.
• The 32V bit is set whenever an instruction which updates the EAX register is dispatched. Upon dispatch of an instruction which updates the AX, AH, or AL registers, the 32V bit is cleared. Similarly, the 16V bit is set upon dispatch of an instruction which updates either the EAX or AX registers. The 16V bit is cleared upon dispatch of an instruction which updates the AH or AL registers.[0153]
• It is noted that the “program order” has been used above to describe the order of instructions within[0154]reorder buffer32, the order of instructions dispatched, etc. In embodiments ofmicroprocessor10 which employ speculative instruction fetching and execution, the program order of instructions is a predicted program order. The actual program order upon execution of the instructions may change. For example, branch misprediction or exception events may cause a change in the actual program order. Therefore, the term program order may be taken to mean “predicted program order” or “speculative program order” for such embodiments.
• Turning now to FIG. 13, a[0155]computer system200 includingmicroprocessor10 is shown.Computer system200 further includes a bus bridge202, amain memory204, and a plurality of input/output (I/O)devices206A-206N. Plurality of I/O devices206A-206N will be collectively referred to as I/O devices206.Microprocessor10, bus bridge202, andmain memory204 are coupled to asystem bus208. I/O devices206 are coupled to an I/O bus210 for communication with bus bridge202.
• Bus bridge[0156]202 is provided to assist in communications between I/O devices206 and devices coupled tosystem bus208. I/O devices206 typically require longer bus clock cycles thanmicroprocessor10 and other devices coupled tosystem bus208. Therefore, bus bridge202 provides a buffer betweensystem bus208 and input/output bus210. Additionally, bus bridge202 translates transactions from one bus protocol to another. In one embodiment, input/output bus210 is an Enhanced Industry Standard Architecture (EISA) bus and bus bridge202 translates from the system bus protocol to the EISA bus protocol. In another embodiment, input/output bus210 is a Peripheral Component Interconnect (PCI) bus and bus bridge202 translates from the system bus protocol to the PCI bus protocol. It is noted that many variations of system bus protocols exist.Microprocessor10 may employ any suitable system bus protocol.
• I/O devices[0157]206 provide an interface betweencomputer system200 and other devices external to the computer system. Exemplary I/O devices include a modem, a serial or parallel port, a sound card, etc. I/O devices206 may also be referred to as peripheral devices.Main memory204 stores data and instructions for use bymicroprocessor10. In one embodiment,main memory204 includes at least one Dynamic Random Access Memory (DRAM) and a DRAM memory controller.
• It is noted that although[0158]computer system200 as shown in FIG. 13 includes one bus bridge202, other embodiments ofcomputer system200 may include multiple bus bridges202 for translating to multiple dissimilar or similar I/O bus protocols. Still further, a cache memory for enhancing the performance ofcomputer system200 by storing instructions and data referenced bymicroprocessor10 in a faster memory storage may be included. The cache memory may be inserted betweenmicroprocessor10 andsystem bus208, or may reside onsystem bus208 in a “lookaside” configuration.
• Although the x86 microprocessor architecture is used in certain illustrative embodiments above as a specific example, the present invention is not limited to this architecture. Conversely, the present invention may be useful in embodiments of[0159]microprocessor10 employing any microprocessor architecture. Certain portions of the present invention are believed to be particularly useful in microprocessor architectures which allow update and access to portions of registers defined therein (as opposed to allowing update and access to only the entirety of each register). It is further noted that, as opposed to a FIFO buffer as described above, instruction storages similar toinstruction storage92 may employ a plurality of storage locations which are not shifted. Instead, read and write pointers are used to indicate the next storage location to be allocated to a set of concurrently decoded instructions and to indicate the bottom of the reorder buffer, respectively.
• It is still further noted that the present discussion may refer to the assertion of various signals. As used herein, a signal is “asserted” if it conveys a value indicative of a particular condition. Conversely, a signal is “deasserted” if it conveys a value indicative of a lack of a particular condition. A signal may be defined to be asserted when it conveys a logical zero value or, conversely, when it conveys a logical one value. Additionally, various values have been described as being discarded in the above discussion. A value may be discarded in a number of manners, but generally involves modifying the value such that it is ignored by logic circuitry which receives the value. For example, if the value comprises a bit, the logic state of the value may be inverted to discard the value. If the value is an n-bit value, one of the n-bit encodings may indicate that the value is invalid. Setting the value to the invalid encoding causes the value to be discarded. Additionally, an n-bit value may include a valid bit indicative, when set, that the n-bit value is valid. Resetting the valid bit may comprise discarding the value. Other methods of discarding a value may be used as well.[0160]
• Table 1 below indicates fast path, double dispatch, and MROM instructions for one embodiment of microprocessor[0161]10 employing the x86 instruction set:

  TABLE 1
  x86 Fast Path, Double Dispatch, and MROM Instructions

  	X86 Instruction	Instruction Category
  	AAA	MROM
  	AAD	MROM
  	AAM	MROM
  	AAS	MROM
  	ADC	fast path
  	ADD	fast path
  	AND	fast path
  	ARPL	MROM
  	BOUND	MROM
  	BSF	fast path
  	BSR	fast path
  	BSWAP	MROM
  	BT	fast path
  	BTC	fast path
  	BTR	fast path
  	BTS	fast path
  	CALL	fast path/double dispatch
  	CBW	fast path
  	CWDE	fast path
  	CLC	fast path
  	CLD	fast path
  	CLI	MROM
  	CLTS	MROM
  	CMC	fast path
  	CMP	fast path
  	CMPS	MROM
  	CMPSB	MROM
  	CMPSW	MROM
  	CMPSD	MROM
  	CMPXCHG	MROM
  	CMPXCHG8B	MROM
  	CPUID	MROM
  	CWD	MROM
  	CWQ	MROM
  	DDA	MROM
  	DAS	MROM
  	DEC	fast path
  	DIV	MROM
  	ENTER	MROM
  	HLT	MROM
  	IDIV	MROM
  	IMUL	double dispatch
  	IN	MROM
  	INC	fast path
  	INS	MROM
  	INSB	MROM
  	INSW	MROM
  	INSD	MROM
  	INT	MROM
  	INTO	MROM
  	INVD	MROM
  	INVLPG	MROM
  	IRET	MROM
  	IRETD	MROM
  	Jcc	fast path
  	JCXZ	double dispatch
  	JECXZ	double dispatch
  	JMP	fast path
  	LAHF	fast path
  	LAR	MROM
  	LDS	MROM
  	LES	MROM
  	LFS	MROM
  	LGS	MROM
  	LSS	MROM
  	LEA	fast path
  	LEAVE	double dispatch
  	LGDT	MROM
  	LIDT	MROM
  	LLDT	MROM
  	LMSW	MROM
  	LODS	MROM
  	LODSB	MROM
  	LODSW	MROM
  	LODSD	MROM
  	LOOP	double dispatch
  	LOOPcond	MROM
  	LSL	MROM
  	LTR	MROM
  	MOV	fast path
  	MOVCC	fast path
  	MOV.CR	MROM
  	MOV.DR	MROM
  	MOVS	MROM
  	MOVSB	MROM
  	MOVSW	MROM
  	MOVSD	MROM
  	MOVSX	fast path
  	MOVZX	fast path
  	MUL	double dispatch
  	NEG	fast path
  	NOP	fast path
  	NOT	fast path
  	OR	fast path
  	OUT	MROM
  	OUTS	MROM
  	OUTSB	MROM
  	OUTSW	MROM
  	OUTSD	MROM
  	POP	double dispatch
  	POPA	MROM
  	POPAD	MROM
  	POPF	MROM
  	POPFD	MROM
  	PUSH	fast path/double dispatch
  	PUSHA	MROM
  	PUSHAD	MROM
  	PUSHF	fast path
  	PUSHFD	fast path
  	RCL	MROM
  	RCR	MROM
  	ROL	fast path
  	ROR	fast path
  	RDMSR	MROM
  	REP	MROM
  	REPE	MROM
  	REPZ	MROM
  	REPNE	MROM
  	REPNZ	MROM
  	RET	double dispatch
  	RSM	MROM
  	SAHF	fast path
  	SAL	fast path
  	SAR	fast path
  	SHL	fast path
  	SHR	fast path
  	SBB	fast path
  	SCAS	double dispatch
  	SCASB	MROM
  	SCASW	MROM
  	SCASD	MROM
  	SETcc	fast path
  	SGDT	MROM
  	SIDT	MROM
  	SHLD	MROM
  	SHRD	MROM
  	SLDT	MROM
  	SMSW	MROM
  	STC	fast path
  	STD	fast path
  	STI	MROM
  	STOS	MROM
  	STOSB	MROM
  	STOSW	MROM
  	STOSD	MROM
  	STR	MROM
  	SUB	fast path
  	TEST	fast path
  	VERR	MROM
  	VERW	MROM
  	WBINVD	MROM
  	WRMSR	MROM
  	XADD	MROM
  	XCHG	MROM
  	XLAT	fast path
  	XLATB	fast path
  	XOR	fast path

• It is noted that a superscalar microprocessor in accordance with the foregoing may further employ the latching structures as disclosed within the co-pending, commonly assigned patent application entitled “Conditional Latching Mechanism and Pipelined Microprocessor Employing the Same”, Ser. No. 08/400,608 filed Mar. 8, 1995, by Pflum et al. The disclosure of this patent application is incorporated herein by reference in its entirety.[0162]
• It is further noted that aspects regarding array circuitry may be found in the co-pending, commonly assigned patent application entitled “High Performance Ram Array Circuit Employing Self-Time Clock Generator for Enabling Array Access”, Ser. No. 08/473,103 filed Jun. 7, 1995 by Tran. The disclosure of this patent application is incorporated herein by reference in its entirety.[0163]
• It is additionally noted that other aspects regarding superscalar microprocessors may be found in the following co-pending, commonly assigned patent applications: “Linearly Addressable Microprocessor Cache”, Ser. No. 08/146,381, filed Oct. 29, 1993 by Witt; “Superscalar Microprocessor Including a High Performance Instruction Alignment Unit”, Ser. No. 08/377,843, filed Jan. 25, 1995 by Witt, et al; “A Way Prediction Structure”, Ser. No. 08/522,181, filed Aug. 31, 1995 by Roberts, et al; “A Data Cache Capable of Performing Store Accesses in a Single Clock Cycle”, Ser. No. 08/521,627, filed Aug. 31, 1995 by Witt, et al; “A Parallel and Scalable Instruction Scanning Unit”, Ser. No. 08/475,400, filed Jun. 7, 1995 by Narayan; and “An Apparatus and Method for Aligning Variable-Byte Length Instructions to a Plurality of Issue Positions”, Ser. No. 08/582,473, filed Jan. 2, 1996 by Tran, et al. The disclosure of these patent applications are incorporated herein by reference in their entirety.[0164]
• In accordance with the above disclosure, a reorder buffer has been provided. The reorder buffer allocates and deallocates lines of storage, simplifying allocation and deallocation logic. Whenever instructions are dispatched, a fixed amount of storage is allocated and deallocated. The reorder buffer is shown in a microprocessor having fixed, symmetrical issue positions. Fixed, symmetrical issue positions are likely to generate large numbers of concurrently dispatched instructions, making efficient use of the line-oriented reorder buffer configuration. One embodiment of the reorder buffer employs a future file for simplified dependency checking and more efficient handling of narrow-to-wide dependencies.[0165]
• Numerous variations and modifications will become apparent to those skilled in the art once the above disclosure is fully appreciated. It is intended that the following claims be interpreted to embrace all such variations and modifications.[0166]

Claims (19)

What is claimed is:

1. A superscalar microprocessor comprising:

a plurality of fixed, symmetrical issue positions coupled to receive instructions, wherein an instruction received by one of said plurality of issue positions remains within said one of said plurality of issue positions until said instruction is executed by said one of said plurality of issue positions; and

a reorder buffer coupled to receive operand information regarding a plurality of concurrently dispatched instructions from said plurality of fixed, symmetrical issue positions, wherein said reorder buffer is configured to allocate storage for instruction results corresponding to said plurality of concurrently dispatched instructions.

2. The superscalar microprocessor as recited inclaim 1 wherein said reorder buffer is configured to allocate a fixed amount of storage upon receipt of said plurality of concurrently dispatched instructions, regardless of a number of said plurality of concurrently dispatched instructions.

3. The superscalar microprocessor as recited inclaim 2 wherein said fixed amount of storage comprises an amount of storage capable of storing instruction results corresponding to a maximum number of said plurality of concurrently dispatched instructions.

4. The superscalar microprocessor as recited inclaim 3 wherein said reorder buffer includes a buffer comprising multiple lines of storage, wherein each one of said multiple lines of storage comprises said fixed amount of storage.

5. The superscalar microprocessor as recited inclaim 4 wherein said reorder buffer is configured to retire a line of storage upon receipt of an instruction result for each of said plurality of concurrently dispatched instructions stored within said line of storage.

6. The superscalar microprocessor as recited inclaim 5 further comprising a register file coupled to said reorder buffer, wherein said reorder buffer retires a line of storage by storing the corresponding instruction results into said register file.

7. The superscalar microprocessor as recited inclaim 1 wherein said reorder buffer is configured to check dependencies of source operands indicated by said operand information against instruction results stored within said reorder buffer.

8. The superscalar microprocessor as recited inclaim 7 wherein said reorder buffer is configured to detect a particular instruction which updates a particular source operand.

9. The superscalar microprocessor as recited inclaim 8 wherein said particular instruction updates said particular source operand and said particular instruction is. flagged as the last instruction in program order within said reorder buffer to update said particular source operand.

10. The superscalar microprocessor as recited inclaim 1 wherein each one of said plurality of issue positions comprises a decode unit configured to decode an instruction.

11. The superscalar microprocessor as recited inclaim 10 wherein said decode unit comprises an early decode unit configured to detect said operand information corresponding to said instruction and to convey said operand information to said reorder buffer.

12. The superscalar microprocessor as recited inclaim 11 wherein said decode unit further comprises an opcode decode unit coupled to receive said instruction from said early decode unit wherein said opcode decode unit is configured to decode an opcode of said instruction.

13. The superscalar microprocessor as recited inclaim 10 wherein said each one of said plurality of issue positions further comprises a reservation station coupled to said opcode decode unit, wherein said reservation station is configured to store said instruction prior to instruction execution.

14. The superscalar microprocessor as recited inclaim 13 wherein said each one of said plurality of issue positions further comprises a functional unit coupled to said reservation station, wherein said functional unit is configured to execute said instruction.

15. The superscalar microprocessor as recited inclaim 14 wherein said functional unit is further configured to convey an instruction result corresponding to said instruction to said reorder buffer upon execution of said instruction.

16. A superscalar microprocessor comprising:

a first decode unit configured to decode a first instruction;

a second decode unit configured to decode a second instruction concurrently with said first decode unit decoding said first instruction;

a first reservation station coupled to receive said first instruction from said first decode unit, wherein said first reservation station is configured to store said first instruction until said first instruction is executed;

a second reservation station coupled to receive said second instruction from said second decode unit, wherein said second reservation station is configured to store said second instruction until said second instruction is executed; and

a reorder buffer coupled to said first decode unit and said second decode unit, wherein said reorder buffer receives an indication of said first instruction and said second instruction from said first decode unit and said second decode unit respectively, and wherein said reorder buffer is configured to allocate a line of storage to store a first instruction result corresponding to said first instruction and a second instruction result corresponding to said second instruction, and wherein said line of storage comprises a fixed amount of storage capable of storing instruction results corresponding to a maximum number of concurrently dispatchable instructions.

17. The superscalar microprocessor as recited inclaim 16 further comprising a first functional unit coupled to said first reservation station, wherein said first functional unit is configured to execute said first instruction and to provide said first instruction result to said reorder buffer.

18. The superscalar microprocessor as recited inclaim 17 wherein said reorder buffer is configured to associate said first instruction result with said first instruction due to receiving said first instruction result from said first functional unit.

19. The superscalar microprocessor as recited inclaim 18 wherein said first functional unit further provides a line tag identifying said line of storage within said reorder buffer.

Images