referring now to the drawings , and initially to fig1 there is illustrated an exemplary embodiment of the present invention . this embodiment illustrates the present invention as applied to , for example , an instruction pipeline for processing intel architecture ( i . e ., x86 ) instructions ( e . g ., ia - 32 ). as a person of ordinary skill in the art will understand , however , the present invention may be applied to instruction pipelines of other processor architectures , such as , for example , risc and cisc architectures , or any processor architecture that includes the use of an instruction pipeline . as illustrated in fig1 in the exemplary embodiment of the present invention , the instruction pipeline 100 includes seven major stages or units , although each of the pipeline stages or units may actually be comprised of a number sub - stages . as illustrated , the instruction pipeline 100 includes an instruction fetch unit ( ifu ) 110 , an instruction decode unit ( id ) 120 , a decoded cache unit ( dc ) 130 , a micro - code sequencer ( ms ) 135 , an allocation unit ( alloc ) 140 , an execution unit ( ex ) 150 , and a write - back unit ( wb ) 160 . it will be understood , however , that the number of pipeline units in the pipeline 100 ( and , the function of each unit , for that matter ) may be different than that described in connection with the exemplary embodiment , depending on , for example , the microprocessor architecture . furthermore , the term “ unit ” used throughout the present description may include ( but is not limited to ), for example , a stage , a discrete component ( implemented in hardware , firmware , and / or software ), a portion of a discrete component , an electrical circuit or portion thereof , etc . the instruction fetch unit 110 fetches , for example , program macro - code instructions from memory 111 ( e . g ., main memory , cache memory , or any other storage or memory device ) and pushes the fetched instructions into the pipeline 100 to the next downstream pipeline unit . although in this exemplary embodiment , macro - code instructions are intel architecture instructions , other instruction types such as , for example , risc or cisc instructions , or any other type of instruction may instead by fetched , depending on the specific architecture implemented . during operation , the instruction fetch unit 110 fetches instructions from memory 111 in order to provide the pipeline 100 with a stream of instructions . if a fetched instruction is a branch instruction , the instruction fetch unit 110 must determine whether to next fetch the instruction at the next sequential address , or the instruction at the branch target address . accordingly , the instruction fetch unit 110 uses branch prediction circuitry ( btb ) 113 , to predict whether or not a branch instruction will be taken or not taken . if the branch is predicted as “ taken ,” the instruction fetch unit 110 fetches the instruction at the branch target address . if the branch is predicted as “ not taken ,” the instruction fetch unit 110 fetches the next sequential instruction . in any event , the instruction fetch unit 110 pushes the fetched macro - code instruction to the next downstream pipeline unit . ( the depth of the pipeline between the units within the pipeline 100 may depend on factors such as , for example , the particular design and architecture being used , the speed of units within the pipeline , etc .) the instruction decode unit 120 receives the macro - code instruction from the instruction fetch unit 110 in , for example , first - in , first - out ( fifo ) order . the instruction decode unit 120 then decodes the macro - code instructions into , for example , fixed - length risc instructions called micro - ops or uops . each macro - code instruction may decode to one or a number of micro - ops . each of these micro - ops is assigned an identifier , e . g ., a sequence number , by the allocation unit 140 , and each is temporarily stored in an instruction pool 141 . of course , as will be understood by a person of ordinary skill in the art , in some microprocessor architectures , instructions do not require decoding . in a pipeline in such a system , therefore , an instruction decoder ( i . e ., instruction decode unit 120 ), for example , would not be needed . in the exemplary embodiment , if the instruction decode unit 120 receives a macro - code instruction from the instruction fetch unit 110 that is complex , for example , a macro - code instruction that decodes to more than four micro - ops , the instruction decode unit 120 provides only the first four micro - ops . the micro - code sequencer 135 then provides the remaining micro - ops . ( also , as illustrated in fig1 micro - ops provided to the instruction pool 141 by the instruction decode unit 130 pass through the micro - code sequencer 135 .) the micro - code sequencer 135 of the exemplary embodiment transforms all complex macro - code instructions into a corresponding set of micro - ops ( the corresponding micro - ops are retrieved , for example , from a rom 135 a illustrated in fig3 ). in certain cases , if the decoded macro - code instruction includes a micro - branch instruction ( a micro - op that is of branch type , i . e ., a branch within the micro - code flow ), the micro - code sequencer 135 predicts branch direction , i . e ., whether the branch will be taken or not taken . in the exemplary embodiment , the micro - code sequencer 135 may make “ static ” branch predictions . in particular , the micro - code sequencer 135 may always predict , for example , that an unconditional micro - branch will be taken , an conditional backward micro - branch will be taken , and a conditional forward micro - branch will not be taken . ( other prediction schemes may , of course , be employed .) the micro - code sequencer 135 then transmits to the allocation unit 140 only those micro - ops along the predicted path . in the exemplary embodiment of the present invention , the instruction pipeline 100 includes an additional source of program instructions . in particular , the decoded cache unit 130 stores instruction sequences in the form of micro - ops ( i . e ., instruction traces ) in high speed cache memory in order to later provide these instructions to the allocation unit 140 for execution by the execution unit 150 . the structure and operation of a decoded cache unit , such as , for example , a trace cache unit , is described in further detail in u . s . pat . no . 5 , 381 , 533 to peleg et al . the decoded cache unit 130 controls whether the source for instructions entering the instruction pool 141 is the instruction fetch unit 110 ( via the instruction decode unit 120 ) or the decoded cache unit 130 . in particular , the decoded cache unit 130 snoops the instruction path 136 between the micro - code sequencer 135 and the allocation unit 140 . if the decoded cache unit 130 recognizes that a particular instruction detected along the snooped the instruction path 132 corresponds to a “ trace head ” ( i . e ., the first instruction in an instruction trace ) are stored at the decoded cache unit 130 ( i . e ., a decoded cache hit ), the decoded cache unit 130 signals the instruction fetch unit 110 to discontinue fetching instructions . instead , the decoded cache unit 130 provides the appropriate instructions to the allocation unit 140 from its cache memory . when decoded the cache unit 130 detects that further necessary instructions are not in cache ( i . e ., a decoded cache miss ), the decoded cache unit 130 instructs the instruction fetch unit 110 to recommence fetching instructions at an address provided by the decoded cache unit 130 . the decoded cache unit 130 then discontinues providing instructions to the allocation unit 140 . in the exemplary embodiment of the present invention , the execution unit 150 obtains instructions from the instruction pool 141 . the execution unit 150 executes the micro - ops in the instruction pool 141 in any order possible as data and execution units required for each micro - op becomes available . accordingly , the execution unit 150 is an out - of - order ( ooo ) portion of the pipeline . in other microprocessor architectures , the pipeline 100 could include , for example , an execution unit that processes instructions in - order , or in some predetermined order . finally , the write back unit 160 “ retires ” each executed micro - op . that is , the write back unit 160 commits the result of each micro - op execution to the processor &# 39 ; s “ architectural state ” including , for example , the software - visible registers , flags , etc ., in the order of original program flow . thus , the write back unit 160 is an in - order rear end of the pipeline . of course , in a microprocessor architecture in which instructions are executed in an in - order sequence , the instructions may not need to be “ retired ,” thus , the pipeline 100 may not include a write back unit . furthermore , even if the instructions are executed out - of order , it may be possible that the some ( if not all ) of the instructions be retired out - of order . in accordance with the present invention , certain information ( i . e ., recovery state information ) regarding each micro - op processed in the instruction pipeline 100 is stored in a table . this information may be later used by machine micro - code , for example , during event recovery or during micro - branch misprediction recovery . in accordance with the exemplary embodiment of the present invention , an information table ( it ) 142 stores information for some or all of the micro - ops processed . fig2 illustrates the format of an exemplary it 142 . referring now to fig2 each entry 210 in the it 142 includes i ) a sequence number field 215 ; ii ) an nlip field 220 ; iii ) a blip field 225 ; iv ) a branch prediction field 230 ; v ) an ipdelta field 235 ; vi ) a uip field 240 ; and vii ) an msissue field 245 . each entry 210 corresponds to , for example , one micro - op , and is described in further detail below . as described above , the allocation unit 140 assigns a sequence number to each micro - op . after each micro - op is assigned a sequence number , the it 142 stores in the sequence number field 215 the sequence number assigned to the current micro - op . since the sequence number uniquely identifies each micro - op , the sequence number field 215 may be used for indexing the it 142 . in an alternative embodiment , the sequence number is not stored in the it 142 , and is simply used as an index into the table . other indexing schemes may of course be employed . in the nlip field 220 , the address of the next linear macro - code instruction ( nlip ) ( i . e ., the address of the macro - code instruction following the macro - code instruction associated with the current micro - op in an instruction sequence ) is stored . if the macro - code instruction associated with the current micro - op is a branch instruction , the branch target address ( blip ) is stored in the blip field 225 . otherwise this field is marked as invalid by filling it in with , for example , “ don &# 39 ; t cares ” ( e . g ., all zeroes , all ones , a preselected pattern of zeroes or ones , etc . ), setting a flag , etc . ( alternatively , the field may simply be ignored ). in the exemplary embodiment , a branch “ target ” address is the address of an instruction to be executed if the branch is taken . for example , if the instruction is a branch to an instruction foo , the address of foo is the branch target address . additionally , if the macro - code instruction associated with the current micro - op is a branch instruction , an n - bit branch prediction indicator may be stored in the branch prediction field 230 . for example , the branch indicator may indicate using a single bit whether the branch was predicted by upstream prediction circuitry as taken or not taken (“ 1 ” or “ 0 ”, respectively ). the length of the macro - code instruction associated with the current micro - op is stored in the ipdelta field 235 . thus , the address of the macro - code instruction associated with the current micro - op may be determined by subtracting this length from the value stored in the nlip field 220 , i . e ., current macro - code instruction address = nlip − ipdelta . in an alternative embodiment , a current linear address pointer ( clip ) may be stored instead of the nlip . in that case , the next linear address ( i . e ., the nlip ) may be calculated by adding the ipdelta to the clip . in the exemplary embodiment of the present invention , the msissue field 245 is an n - bit field indicating which unit issued the micro - op . for example , if the micro - op originated from the micro - code sequencer 135 , a bit may be turned on ( i . e ., “ 1 ”). otherwise , the bit may turned off ( i . e ., “ 0 ”), indicating that the micro - op originated either from the instruction decode unit 120 or the decoded cache unit 130 . if the bit in the msissue field 245 is turned on , a pointer to the current micro - op is stored in the uip field 240 . an exemplary use of each of the above - mentioned fields is described below . fig3 illustrates in detail portions of the instruction pipeline 100 pertinent to the maintenance and us e of the it 142 . as illustrated , in accordance with the exemplary embodiment of the present invention , a recirculation register 310 is provided . the recirculation register 310 is coupled to the path 136 ( between the micro - code sequencer 135 and the allocation unit 140 ). the recirculation register 310 is also coupled to the it 142 through a multiplexer 315 . the allocation unit 140 is coupled to the it 142 through the multiplexer 315 . in operation , information that is common to all of the micro - ops associated with a particular macro - code instruction is stored in the recirculation register 310 . in particular , for each decoded macro - code instruction , the micro - code sequencer 135 provides the nlip , ipdelta , blip , branch prediction bit , and the msissue along path 136 . this information is stored by the recirculation register 310 , for example , under control of the micro - code sequencer 135 . then , for each of the micro - ops associated with the macro - code instruction , the allocation unit 140 provides to the multiplexer 315 any information unique to that particular micro - op such as , for example , uip and sequence number . the micro - code sequencer 135 then controls the multiplexer 315 in such a manner as to provide the information from the recirculation register 310 , and the information from the allocation unit 140 to the it 142 . accordingly , in operation , the recirculation register 310 may be loaded , for example , only one time for each macro - code instruction processed . if a macro - code instruction decodes to several micro - ops , the micro - op specific information ( e . g ., sequence number and uip ) is provided to the multiplexor 315 as the allocation unit 140 assigns each sequence number . thus , one entry is stored in it 142 for each micro - op of a macro - code instruction . moreover , each entry associated with a particular macro - code instruction has , for example , the same information stored in the nlip field , the blip field , the branch prediction bit field , the ipdelta field and the msissue . only the information in the sequence number field and the uip field are different . as a person of ordinary skill will understand from the above description , the use of a recirculation register for assisting in the storage of data common to more than one micro - op saves valuable resources . without the recirculation , if it was determined to be desirable to store the repeated information in a table for each of a number of micro - ops , a unit , such as , for example , a micro - code sequencer , may be required to copy the repeated information into the table for each of the micro - ops , rather than to simply trigger the storage into the table from the recirculation register . accordingly , use of the recirculation register of the exemplary embodiment is more efficient . in an alternative embodiment , a number of instructions may instead map to the same entry in the table , for example , if the data is the same for each of the instructions . this may , however , add to the complexity of indexing the table and retrieving the information when needed . as will be understood by a person of ordinary skill , the it 142 of the exemplary embodiment of the present invention centralizes the storage of information that may be necessary during event recovery and micro - branch misprediction recovery . in prior known systems , many of the pieces of information stored in the it 142 of the exemplary embodiment were previously required to be transmitted between pipeline units along data paths during recovery . for example , in intel &# 39 ; s pentium ® pro microprocessor , the bit stored information only for branch misprediction recovery , and only nlip information . accordingly , information needed for event recovery was transmitted along data paths during recovery . the it 142 in accordance with the present invention conserves valuable resources by reducing the number of data paths required in an instruction pipeline . moreover , certain of the information stored in the it 142 was previously derived “ on - the - fly ” by one or more pipeline units during recovery . with the it 142 , the information is always available and conveniently stored in the it 142 . as illustrated in fig3 in accordance with the exemplary embodiment , the recirculation register 310 is loaded with information from the it 142 during both event recovery and micro - branch recovery ( via data path 340 ) as is described in further detail below . the pipeline 100 may also include additional registers for use during event recovery and branch misprediction recovery . for example , in the exemplary embodiment , two additional registers are included in the pipeline 100 , an event register 320 and a micro - branch register 330 . ( of course , the use of more or less registers is also possible .) each of these registers is coupled to the it 142 and to the micro - code sequencer 135 . the event register 320 and the micro - branch register 330 are loaded with information from the it 142 during event recovery and micro - branch misprediction recovery , respectively . the flowchart of fig4 shows an exemplary process performed in connection with the it 142 during event recovery . when the processor events , the write back unit 160 detects the event and provides the sequence number of the “ current ” micro - op ( i . e ., the micro - op that was next to be retired ) to the it 142 ( step 405 ). of course , in other embodiments , it is possible that the sequence number of a micro - op other than the current one be provided . the it 142 then loads the event register 320 ( step 410 ) and the recirculation register 310 ( step 415 ) with information pertinent to the instruction upon which the processor evented . in particular , in the exemplary embodiment , upon the occurrence of an event , the it 142 reads the entry associated with the micro - op upon which the processor evented . the appropriate entry is selected by comparing the sequence number of the micro - op that evented to the sequence numbers in the sequence number field . the selected entry is then loaded into the event register 320 ( step 410 ). the recirculation register 310 is also loaded with information from selected fields of that selected it entry ( step 415 ). for example , the nlip , blip , branch prediction bit , ipdelta and msissue are loaded into the recirculation register 310 in this embodiment . in the exemplary embodiment , the event register 320 and the recirculation register 310 are loaded simultaneously as illustrated in fig4 . however , the registers may be loaded at different times . next , the micro - code sequencer 135 provides the appropriate event recovery micro - code to the allocation unit 140 for execution ( step 420 ). in particular , the micro - code sequencer 135 provides to the allocation unit 140 particular micro - ops associated with event recovery . for example , the particular micro - ops provided may relate to a particular event recovery code depending on the implementation and the particular event that occurred . the allocation unit 140 assigns each micro - op a sequence number , and transmits each sequence number and uip to the multiplexer 315 . for each micro - op , the micro - code sequencer 135 controls the multiplexer 315 in such a manner as to store the information from the recirculation register 310 and the information provided by the allocation unit 140 ( sequence number and uip ) in individual entries in the it 142 . this stored information may be needed if the processor events on one of the event recovery micro - ops . after the event recovery micro - code is executed , the micro - code sequencer 135 reads the information stored in the event register 320 and determines which macro - code instruction should be executed once the machine recovers ( step 425 ). in particular , if the event is a fault condition ( e . g ., a hardware problem is detected ), and msissue =“ 0 ” ( i . e ., the instruction which evented did not originate from the micro - code sequencer 135 ) the micro - code may determine , for example , that the current macro - instruction should be re - executed . the micro - code then calculates the address of the current instruction from information stored in the event register 320 , e . g ., nlip − ipdelta . this address is then transmitted to the instruction fetch unit 110 , and the pipeline may be flushed and restarted . alternatively ( or in addition ), the address may be transmitted to a pipeline unit other than the instruction fetch unit 110 if , for example , the instruction as the address is stored elsewhere in the instruction pipeline or external to the pipeline . for example , if the instruction is stored in a cache unit within the pipeline , the instruction may be transmitted to the cache for retrieval of the instruction . if the event is a trap condition ( e . g ., an automatic procedure call initiated by some condition , such as , for example , an overflow condition ), and msissue =“ 0 ,” the micro - code may determine , for example , that the current instruction has completed and that the next instruction should be executed . in particular , if the macro - instruction upon which the machine evented is a branch instruction ( the blip field has a well defined value ), and the branch instruction was predicted as taken ( as indicated by the branch prediction bit ), the micro - code transmits blip ( i . e ., the branch target address ) to the instruction fetch unit 110 , for example . if the macro - instruction is not a branch instruction or the macro - instruction is not a branch instruction predicted as taken , nlip is transmitted to the instruction fetch unit 110 . if , however , msissue = 1 , i . e ., the instruction originated from the micro - code sequencer 135 , the micro - code utilizes the uip to restart . in particular , the micro - code sequencer 135 retrieves micro - ops from , for example , rom 35 a illustrated in fig3 starting from , for example , the micro - op pointed to by the uip . in any case , once the micro - code makes the determination as to which instruction should be executed next , the micro - code sequencer 135 utilizes the information in the event register 320 to determine the appropriate instruction address . the instruction address is then provided to the instruction fetch unit 110 ( and / or the decoded cache unit 130 ) so that the instruction fetch unit 110 ( or the decoded cache unit 130 ) can fetch the macro - code instruction . turning now to the flowchart of fig5 the process performed in connection with the it 142 during micro - branch misprediction recovery is illustrated . as described above , for certain micro - branch instructions , the micro - code sequencer 135 makes branch direction predictions . the micro - code sequencer 135 then provides the allocation unit 140 with micro - ops along only the predicted instruction path . accordingly , it is possible that the micro - code sequencer 135 mispredicted a micro - branch instruction . when the execution unit 150 detects a micro - branch misprediction ( step 505 ), the execution unit 150 provides the sequence number of the mispredicted branch instruction to the it 142 ( step 505 ). using the sequence number as an index , the it 142 then loads the micro - branch register 330 ( step 510 ) and the recirculation register 310 ( step 520 ) with information pertinent to mispredicted micro - branch instruction from the appropriate entry . information from the selected entry 210 , such as , for example , the nlip and ipdelta , is then loaded into the micro - branch register 330 ( step 510 ). additionally ( either simultaneously or at a different time ), the recirculation register 310 is loaded with information from selected fields of the it 142 entry ( step 515 ). for example , the nlip , blip , branch prediction bit , ipdelta and msissue are loaded into the recirculation register 310 in this embodiment . next , the micro - code sequencer 135 provides the appropriate micro - branch misprediction micro - code to the allocation unit 140 for execution ( step 520 ). in particular , the micro - code sequencer 135 provides to the allocation unit 140 particular micro - ops associated with micro - branch misprediction recovery . the allocation unit 140 assigns each micro - op a sequence number , and transmits each sequence number and uip to the multiplexer 315 . for each micro - op , the micro - code sequencer 135 controls the multiplexor 315 in such a manner as to store the information from the recirculation register 310 and the information provided by the allocation unit 140 ( sequence number and uip ) in individual entries in the it 142 . this stored information may be needed if the processor events on one of the micro - code micro - ops . finally , after the branch misprediction recovery micro - code is executed , the micro - code sequencer 135 reads the micro - branch register 330 and determines which macro - code instruction should be executed once the machine recovers based on , for example , the information stored in the micro - branch register 330 ( step 525 ).