# Patent

## Title
Link stack repair of erroneous speculative update

## Abstract

Whenever a link address is written to the link stack, the prior value of the link stack entry is saved, and is restored to the link stack after a link stack push operation is speculatively executed following a mispredicted branch. This condition is detected by maintaining an incrementing tag register which is incremented by each link stack write instruction entering the pipeline, and a snapshot of the incrementing tag register, associated with each branch instruction. When a branch is evaluated and determined to have been mispredicted, the snapshot associated with it is compared to the incrementing tag register. A discrepancy indicates a link stack write instruction was speculatively issued into the pipeline after the mispredicted branch instruction, and pushed a link address onto the link stack, thus corrupting the link stack. The prior link address is restored to the link stack from the link stack restore buffer.

## Background
CLAIM OF PRIORITY UNDER 35 U.S.C. §120
The present Application for Patent is a continuation-in-part of patent application Ser. No. 11/867,727 entitled “LINK STACK REPAIR OF ERRONEOUS SPECULATIVE UPDATE” filed Oct. 05, 2007, pending, and assigned to the assignee hereof and hereby expressly incorporated by reference herein.


FIELD OF DISCLOSURE
The present invention relates generally to the field of processors and in particular to a system and method for repairing a link stack corrupted by speculative instruction execution.
BACKGROUND
Modern software is modular in nature, with specific functions being implemented in subroutines. To efficiently implement subroutine calls and returns, many modern processors employ circuits that implement (or emulate) a link stack. A link stack is a logical structure for storing link addresses that is visible only to the hardware and not directly accessible to the programmer. An instruction that calls (branches to) a subroutine, such as a branch and link instruction, “pushes” the address of the following instruction onto the link stack. Upon encountering a return-type instruction in the subroutine, the link stack is “popped” to yield the address of the instruction following the one that made the subroutine call. As subroutines call other subroutines, link addresses are successively pushed onto the link stack, and popped as the subroutines complete execution and return.
Most modern processors employ a pipelined architecture, where sequential instructions, each having multiple execution steps, are overlapped in execution. For maximum performance, the instructions should flow continuously through the pipeline. Any situation that causes instructions to stall in the pipeline detrimentally affects performance.
Virtually all real-world programs include conditional branch instructions, the actual branching behavior of which is not known until the instruction is evaluated deep in the pipeline. To avoid pipeline stalls that would result from waiting for actual evaluation of each branch instruction, many modern processors employ some form of branch prediction, whereby the branching behavior of conditional branch instructions is predicted early in the pipeline. Based on the predicted branch evaluation, the processor speculatively fetches and executes instructions from a predicted address—either the branch target address (if the branch is predicted taken) or the next sequential address after the branch instruction (if the branch is predicted not taken). When the actual branch behavior is determined, if the branch was mispredicted, the speculatively fetched instructions are flushed from the pipeline, and new instructions are fetched from the correct next address. Mispredicted branches adversely impact both performance and power consumption.
Another consequence of mispredicted branches may be corruption of the link stack. If speculatively executed instructions following a mispredicted branch include a subroutine return and subsequent call, a valid link address will be popped from the link stack and a new link address pushed onto the stack. Depending on the link stack hardware implementation, erroneously popping the link stack may not itself have adverse consequences, as popping the stack merely moves a read pointer; the data remain in the link stack buffer. Subsequently erroneously pushing a new value onto the link stack, however, may overwrite the previous value. When the branch misprediction is detected and the proper instruction stream is fetched and executed, a subroutine return will transfer control to the wrong location if the link stack corruption is not detected and repaired.
One way to avoid link stack corruption is to disallow link stack updates by speculative instructions. For example, link stack updates may be deferred until all conditional branches are resolved. This would effectively move link stack updates deep into the pipeline, as branch evaluation occurs in execute pipe stages deep in the pipeline. However, this would detrimentally affect performance for short subroutines by effectively denying them the use of the link stack functionality. Accordingly, to gain maximum performance from the link stack hardware, the link stack is preferably updated early in the pipeline, such as at a decode pipe stage.
One known approach to guarding against corruption of processor resources (such as register renaming buffers and the like) due to branch mispredictions is to maintain a parallel, “committed” copy of the resource. The committed copy is only updated when instructions that alter its state commit for execution. An instruction confirms its own execution when it is ascertained that no hazards exist that would preclude the instruction from completing execution. For example, an instruction that implements an arithmetic or logical operation may confirm execution when all of its operands are available (that is, they have been calculated by other instructions or have been successfully retrieved from memory). An instruction commits for execution when it, and all instructions ahead of it in the pipeline, are confirmed.
To avoid corruption due to branch mispredictions, the state of a working copy of a processor resource is altered on an ongoing basis during the routine execution of instructions; however, the state of a committed copy of the processor resource is only altered by instructions that have committed for execution. When a branch misprediction is detected, the committed copy of the processor resource is copied over to, and replaces the contents of the working copy. This technique places the working copy in a state it had prior to the speculative execution of any instruction.
It is possible to employ this approach to the link stack corruption problem. A working link stack would be updated by instructions in the pipeline implementing subroutine calls and returns. A committed link stack would only be updated by subroutine call and return instructions that have committed for execution. Upon discovering a branch misprediction, the committed copy of the link stack would simply be copied over to be working link stack. However, this approach is costly in terms of both silicon area and power consumption. Replicating the link stack requires duplicating the registers or other memory structures that implement it, along with the control logic necessary to manage the link stacks. The extra hardware occupies valuable integrated circuit area, increases wiring congestion, and complicates clock and power distribution. Continuously updating two complete link stacks consumes, nominally, twice the power of running only one link stack. Particularly in processors deployed in mobile electronic devices, minimizing power consumption is critical to preserve battery life and reduce heat dissipation.
SUMMARY
According to one or more embodiments disclosed and claimed herein, link stack corruption is detected and efficiently repaired. Whenever a link address is written to the link stack, the prior value of the link stack entry is saved in a link stack restore buffer. This value is restored to the link stack when an erroneous link stack push operation is detected. An erroneous link stack push operation is one that is speculatively executed following a mispredicted branch. This condition is detected by maintaining a tag register which is incremented by each link stack write instruction entering the pipeline. A snapshot of the value stored in the tag register is associated with each branch instruction as it enters the pipeline. When a branch is evaluated and determined to have been mispredicted, the snapshot associated with the mispredicted branch is compared to the tag register. A discrepancy indicates a link stack write instruction was speculatively issued into the pipeline after the mispredicted branch instruction, and pushed a link address onto the link stack. In this case, the prior link address is restored to the link stack from the link stack restore buffer.
An exemplary embodiment is directed to a method of detecting corruption in a link stack comprising a plurality of entries, each entry operative to store a link address, the method comprising: predicting branch evaluations of branch instructions; in response to the predictions, speculatively executing instructions in a pipeline; allowing link stack write instructions to speculatively write the link stack; maintaining an incrementing tag register which is incremented by each link stack write instruction entering the pipeline; maintaining a snapshot of the incrementing tag register, associated with each branch instruction in the pipeline; detecting that a branch instruction was mispredicted; upon detecting that the branch instruction was mispredicted, comparing the incrementing tag register to the snapshot; and determining that the link stack is corrupted if the incrementing tag register and the snapshot are not the same.
Another exemplary embodiment is directed to a processor comprising: an instruction execution pipeline; a link stack comprising a plurality of entries, each entry operative to store a link address; a branch predictor configured to predict branch evaluations of branch instructions in the pipeline, such that instructions are speculatively executed in the pipeline based on the predictions; a link stack write circuit configured to allow speculatively executed link stack write instructions to speculatively write to the link stack; an incrementing tag register, configured to be incremented with each link stack write instruction entering the pipeline; a snapshot of the incrementing tag register, associated with each branch instruction in the pipeline; branch evaluation logic to detect that a branch instruction was mispredicted; and a link stack monitor circuit configured to compare the incrementing tag register to the snapshot upon indication from the branch evaluation logic that a branch instruction was mispredicted, wherein the link stack monitor is configured to determine that the link stack is corrupted if the incrementing tag register and the snapshot are not the same.
Yet another exemplary embodiment is directed to a system for detecting corruption in a link stack comprising a plurality of entries, each entry operative to store a link address, the system comprising: means for predicting branch evaluations of branch instructions; in response to the predictions, means for speculatively executing instructions in a pipeline; means for allowing link stack write instructions to speculatively write the link stack; means for maintaining an incrementing tag register which is incremented by each link stack write instruction entering the pipeline; means for maintaining a snapshot of the incrementing tag register, associated with each branch instruction in the pipeline; means for detecting that a branch instruction was mispredicted; upon detecting that the branch instruction was mispredicted, means for comparing the incrementing tag register to the snapshot; and means for determining that the link stack is corrupted if the incrementing tag register and the snapshot are not the same.
Yet another exemplary embodiment is directed to a non-transitory computer-readable storage medium comprising code, which, when executed by a processor, causes the processor to perform operations for detecting corruption in a link stack comprising a plurality of entries, each entry operative to store a link address the non-transitory computer-readable storage medium comprising: code for predicting branch evaluations of branch instructions; in response to the predictions, code for speculatively executing instructions in a pipeline; code for allowing link stack write instructions to speculatively write the link stack; code for maintaining an incrementing tag register which is incremented by each link stack write instruction entering the pipeline; code for maintaining a snapshot of the incrementing tag register, associated with each branch instruction in the pipeline; code for detecting that a branch instruction was mispredicted; upon detecting that the branch instruction was mispredicted, code for comparing the incrementing tag register to the snapshot; and code for determining that the link stack is corrupted if the incrementing tag register and the snapshot are not the same.
Another exemplary embodiment is directed to a method of managing a link stack comprising a plurality of entries, each entry operative to store a link address, the method comprising: speculatively reading a first link address from a link stack entry of the link stack; saving the first link address in a link stack restore buffer in response to determining that a speculative write following the speculative read would overwrite the first link address at the link stack entry; and speculatively writing a second link address to the link stack entry after speculatively reading the first link address, wherein the first link address of the link stack entry is overwritten by the second link address.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a functional block diagram of a processor.
FIG. 2 is a functional block diagram of selected portions of the processor.
FIG. 3 is a code flow diagram.
FIG. 4 is a flow diagram of a method of link stack management.
FIG. 5 is an alternate embodiment for a method of link stack management.
FIG. 6 illustrates an exemplary wireless communication system 600 in which an embodiment of the disclosure may be advantageously employed.



DETAILED DESCRIPTION
FIG. 1 depicts a functional block diagram of a processor 10 including circuits to efficiently repair corruption of a link stack due to branch mispredictions. The processor 10 executes instructions in an instruction execution pipeline 12 according to control logic 11. The pipeline 12 may be a superscalar design, with multiple parallel execution pipelines 14, 16. The pipeline 12 includes various registers or latches 18, organized in pipe stages, as well as logical and computational circuits such as arithmetic logic units (ALU) (not shown). A general purpose register (GPR) file 20 provides registers comprising the top of the memory hierarchy. Other processor resources supporting the pipeline 12 are a link stack 22, link stack restoration buffer (LSRB) 23, branch prediction circuit 24, and branch information queue (BIQ) 25, the operation of which are further explicated herein.
The pipeline 12 fetches instructions from an instruction cache (I-Cache or I$) 26, with memory addressing and permissions managed by an instruction-side translation lookaside buffer (ITLB) 28. Data is accessed from a data cache (D-Cache or D$) 30, with memory addressing and permissions managed by a main translation lookaside buffer (TLB) 32. In various embodiments, the ITLB 28 may comprise a copy of part of the TLB 32. Alternatively, the ITLB 28 and TLB 32 may be integrated. In some embodiments, a dedicated data-side TLB, or DTLB (not shown), may be completely separate from the ITLB 28. Similarly, in various embodiments of the processor 10, the I-cache 26 and D-cache 30 may be unified.
Misses in the I-cache 26 and/or the D-cache 30 cause an access to main (off-chip) memory 34, under the control of a memory interface 36 (other caches, not shown, may be interposed between the processor 10 and main memory 34). The processor 10 may include an Input/Output (I/O) interface 38, controlling access to various peripheral devices 40, 42. Those of skill in the art will recognize that numerous variations of the processor 10 are possible. For example, the processor 10 may include a second-level (L2) cache for either or both the I and D caches 26, 30. In addition, one or more of the functional blocks depicted in the processor 10 may be omitted from a particular embodiment.
FIG. 2 is a functional block diagram depicting operation of the link stack restore buffer 23 to repair corruption of the link stack 22 resulting from mispredicted branches. Low-level details, such as control circuits and signals, are omitted from FIG. 2 for clarity. In the embodiment depicted, the link stack 22 is implemented as a circular buffer, in this case comprising 8 registers, by incrementing and decrementing read and write pointers, as well known in the art. This implementation is not limiting, and embodiments of the present invention may advantageously be applied to a link stack 22 implemented using any hardware structure known in the art or yet to be invented.
A link stack restore buffer 23 maintains a copy of the last link address overwritten by a link stack push operation. That is, as a branch and link instruction writes a link address to the link stack 22, the prior address stored in the corresponding link stack entry is automatically saved to the link stack restore buffer 23. Additionally, in the embodiment depicted, the link stack index is stored, so that the link address may be restored, if necessary, to the location in the link stack 22 at which it was overwritten. In the embodiment depicted, the link stack restore buffer 23 comprises a single register. However, the present invention is not limited to this embodiment. In other embodiments, particularly in processors having very deep pipelines, the link stack restore buffer 23 may comprise multiple entries, and maybe organized as a stack, buffer, or other logical structure as required or desired.
Link addresses are written to the link stack 22 as subroutine call (e.g., branch and link) instructions are executed in the pipeline 12. Link addresses are preferably written early in the pipeline 12, such as at a decode pipe stage, as in the embodiment depicted in FIG. 2. This allows short subroutines to take advantage of the link stack 22 hardware. However, in other embodiments, the link stack 22 may be written at any pipe stage, as required or desired for a particular pipeline 12. If the instruction stream including the link stack write instruction is speculatively fetched in response to a branch prediction, it is possible that the link stack write operation may override a valid link address. Accordingly, the prior link address is saved to the link stack restore buffer 23 when the new value is written to the link stack 22. When the branch misprediction is detected, if the link stack write is determined to have been erroneous, the prior value stored in the link stack restore buffer 23 may be restored to the link stack 22 entry at which it was overwritten.
FIG. 3 depicts a hypothetical sequence of instructions that demonstrates how the link stack 22 may be corrupted in response to a mispredicted branch. A main program sequence (on the right) executes two load (LD) instructions, an ADD, and a store (ST), then a branch and link instruction calling subroutine A (BL SUB A). This is a proper code sequence, as represented by solid-line arrows depicting program flow. The BL SUB A instruction pushes the address of the following LD instruction onto the link stack, and branches to subroutine A, where LD, ADD, and compare (CMP) instructions are executed.
When the pipeline 12 fetches the instructions for subroutine A, the branch if equal (BEQ) instruction is detected, and a predicted branch direction and next address are formulated in a branch prediction circuit 51. In this example, the branch is erroneously predicted taken, with a branch target of index 1. Instructions are fetched beginning at index 1 and speculatively executed, as indicated by dashed-line arrows depicting program flow. The execution stream thus branches to the LD instruction at index 1, skipping over the first branch to link return instruction BX LR (which is the first exit point from subroutine A).
The LD, subtract (SUB), and ST instructions are speculatively executed, and the BX LR instruction branches to the link address at the top of the link stack 22, popping the link stack 22 by moving the read pointer. In the link stack embodiment depicted in FIG. 2, popping the link stack 22 does not corrupt any entry. That is, upon detecting the mispredicted branch, the link stack 22 read pointer may simply be reset to its prior position.
Speculative program execution continues along the main program flow, executing LD, SUB, and ST instructions. A call to subroutine B is then speculatively executed, branching to the LD instruction in subroutine B and pushing the address of the following main program ADD instruction onto the link stack 22. The link stack 22 push operation overwrites the prior value of the link stack entry, which contains the address of the earlier main program LD instruction. According to embodiments of the present invention, when the address of the ADD instruction is pushed onto the link stack 22, the address of the LD instruction is saved in the link stack restore buffer 23. Speculative execution continues at subroutine B, executing two LD instructions and an ADD.
At this point, the earlier, mispredicted branch instruction has progressed through the pipeline 12 and is evaluated in an execution pipe stage. The branch misprediction is detected, and the pipeline 12 is flushed of all instructions following the mispredicted branch instruction (the BEQ to index 1 in Subroutine A). The erroneous push operation to the link stack 22 is also detected (as described in greater detail herein), and the address of the main program LD instruction is written from the link stack restore buffer 23 to the proper entry in the link stack 22 (that is, the link stack index saved, along with the link address, in the link stack restore buffer 23), overwriting the erroneous address of the main program ADD instruction. The link stack 22 read and write pointers are also reset, and instructions following the mispredicted branch instruction are fetched and executed (i.e., beginning with the LD following the BEQ to index 1). After the LD and ORR instructions are executed, the branch to link return instruction branches to the LD instruction in the main program (not the ADD, to which the corrupted link stack 22 would have directed it), and proper instruction execution continues.
Referring back to FIG. 2, erroneous, speculative writes to the link stack 22 are detected by comparing, for each predicted branch instruction, a count of the total number of uncommitted link stack write instructions in the pipeline 12 with a count of the number of uncommitted link stack write instructions ahead of the branch instruction in the pipeline 12. A discrepancy in these two counts indicates a link stack write instruction—that pushed a link address onto the link stack 22—behind the relevant branch instruction. If that branch instruction is determined to have been mispredicted, the push operation is known to have been both speculative and erroneous, and may be repaired by restoring the link address saved in the link stack repair buffer 23.
When an instruction that writes to the link stack 22, such as a branch and link construction, is decoded in the pipeline 12, the link address is written to the link stack 22, and an up/down counter 50 is incremented. In the embodiment depicted in FIG. 2, this occurs at the decode pipe stage, although the present invention is not limited to this implementation. When each instruction that writes to the link stack 22 commits for execution in the pipeline 12, the up/down counter 50 is decremented. The value of the up/down counter 50 thus indicates the number of uncommitted link stack write instructions that are “in-flight” in the pipeline 12, regardless of the order of instructions in the pipeline 12.
Many processors that support branch prediction and speculative instruction execution include a branch information queue (BIQ) 25. The BIQ 25 stores information about in-flight branch instructions, such as the branch prediction, predicted branch target address, and the like. Each entry in the BIQ 25 is associated with a unique uncommitted (i.e., in-flight) branch instruction. According to one or more embodiments of the present invention, a count field is defined in each BIQ 25 entry, and accordingly is associated with each uncommitted branch instruction. When a branch instruction leaves an early pipe stage such as the decode pipe stage, the current value of the up/down counter 50 is copied into the count field of the BIQ entry associated with that branch instruction. This value represents the number of uncommitted link stack write instructions in the pipeline 12, and hence ahead of the branch instruction. The BIQ count field value is decremented every time an instruction that writes to the link stack 22 commits for execution in the pipeline 12. The BIQ count field value thus represents the number of uncommitted link stack write instructions ahead of the associated branch instruction in the pipeline 12.
The BIQ count field is initialized with the value of the up/down counter 50. Both the BIQ count field and the up/down counter 50 are decremented by link stack write instructions committing. The up/down counter 50 is incremented by newly decoded link stack write instructions; the BIQ count field is never incremented. Accordingly, the two count values will track each other only if no new link stack write instructions enter the pipeline 12 after the relevant branch instruction. Conversely, a discrepancy in the two count values indicates that at least one new link stack write instruction entered the pipeline 12 after the relevant branch instruction.
When a branch instruction evaluates in the pipeline 12 and is determined to have been mispredicted, all instructions following the mispredicted branch instruction are flushed from the pipeline 12, as known in the art. Additionally, the BIQ count field associated with the mispredicted branch instruction is compared to the value of the up/down counter 50 at comparator 52. If the two counts are the same, the number of uncommitted link stack write instructions ahead of the mispredicted branch instruction equals the total number of uncommitted link stack write instructions in the pipeline 12, which means that there are no uncommitted (speculatively executed) link stack write instructions behind the mispredicted branch. Accordingly, no link stack 22 repair is required.
However, if the BIQ count field differs from the value of the up/down counter 50, at least one link stack write instruction was decoded after the BIQ entry was created for the mispredicted branch instruction, which means the link stack 22 was written by an instruction speculatively executed in response to a branch misprediction, and may need to be repaired by restoring the contents of the link stack repair buffer 23 to the link stack 22. This is indicated functionally by the output of the compare circuit 52 multiplexing the input to the link stack 22 between the link stack repair buffer 23 and the pipeline 12. Those of skill in the art will recognize that actual implementations will differ. The up/down counter 50, the plurality of BIQ count fields, the comparator 52, and other implementation logic (not shown) comprise a link stack monitor circuit.
In the embodiment depicted in FIG. 2, the link stack repair buffer 23 comprises a single entry. In this case, the comparator 52 may implement a simple bit-wise XOR function, with a reduction AND. In other embodiments, where two or more link addresses may be saved in the link stack repair buffer 23, a numerical comparison between the up/down counter 50 value and the BIQ count field will indicate the number of link stack write operations that followed the mispredicted branch, and which will be repaired. Note that the XOR/AND function may fail to detect a corrupted link stack 22 in the event that 2n link stack write instructions followed the mispredicted branch instruction, where n is the width of the BIQ count field (causing the count field to “wrap”). For n>=2, this is unlikely unless the pipeline 12 is extremely deep.
Referring now to FIG. 5, another embodiment for detecting erroneous, speculative writes to the link stack 22 is illustrated. In comparison to FIG. 2, up/down counter 50 is replaced by incrementing tag register 60; and BIQ 25 comprising count fields is replaced by BIQ 65 comprising snapshot fields. Correspondingly, comparator 62 replaces comparator 52 for comparing the BIQ snapshot field to the value of the incrementing tag register 60. The operational features of this embodiment illustrated in FIG. 5 will now be described.
Incrementing tag register 60 may be deployed in the DCD stage. For each branch instruction in flight, whose information is stored in BIQ 65, a snapshot of incrementing tag register 60 may be included in the snapshot field. As depicted in FIG. 5, each of the eight entries in BIQ 65 includes a snapshot field. As previously described, link stack restore buffer 23 maintains a copy of the last link address overwritten by a link stack push operation. In this embodiment, when a link stack write instruction, such as a branch and link instruction, writes a link address to link stack 22, the prior address stored in the corresponding link stack entry is automatically saved to link stack restore buffer 23, and simultaneously, incrementing tag register 60 is incremented. In other words, each time a link stack write instruction enters the pipeline (or as in the depicted embodiment, leaves the DCD stage) incrementing tag register 60 is incremented. When an in-flight branch instruction enters BIQ 65, a snapshot of the value stored in incrementing tag register 60 is copied to the snapshot field associated with the branch instruction in BIQ 65.
When the branch instruction evaluates in the pipeline 12 and is determined to have been mispredicted, all instructions following the mispredicted branch instruction are flushed from the pipeline 12. Additionally, the BIQ snapshot field associated with the mispredicted branch instruction is compared to the value of incrementing tag register 60, at comparator 62. If the comparison reveals that the two values are the same, there are no uncommitted (speculatively executed) link stack write instructions behind the mispredicted branch. Accordingly, no link stack 22 repair is required.
However, if the snapshot field differs from the value of incrementing tag register 60, it is determined that at least one link stack write instruction was decoded after the snapshot of the tag was taken for the mispredicted branch instruction. Accordingly, link stack 22 was written by an instruction speculatively executed down the mispredicted branch path. This may require link stack 22 to be repaired by restoring the contents of the link stack repair buffer 23 to the link stack 22. The repair of link stack 22 is indicated functionally by the output of the compare circuit 62 multiplexing the input to the link stack 22 between the link stack repair buffer 23 and the pipeline 12. Those of skill in the art will recognize that actual implementations will differ. In this embodiment, incrementing tag register 60, the plurality of BIQ snapshot fields, the comparator 62, and other implementation logic (not shown) comprise a link stack monitor circuit. It will be seen that unlike up/down counter 52, incrementing tag register 62 does not need to be reset when a branch is corrected after a misprediction. Moreover, incrementing tag register 62 may be implemented with a small number of bits, such as, 2 or 3 bits, such that if the value stored therein overflows based on the incrementing, a simple wraparound may be allowed, without requiring logic to decrement the value.
While in the above embodiment the comparison between the snapshot field and the incrementing tag register 60 may reveal that at least one link stack write instruction was decoded after the snapshot of the tag was taken for the mispredicted branch instruction, in other embodiments, where two or more link addresses may be saved in the link stack repair buffer 23, a numerical comparison between the incrementing tag register 60 value and the BIQ snapshot field may indicate the number of link stack write operations that followed the mispredicted branch, and which will be repaired. As previously described, for processors having very deep pipelines, the link stack restore buffer 23 may comprise multiple entries, and maybe organized as a stack, buffer, or other logical structure as required or desired.
In at least the embodiment of the link stack 22 depicted in FIG. 2 or FIG. 5—that is, implemented as a circular buffer—a speculative link stack write instruction (push) will not corrupt a link stack 22 entry, unless a speculative link stack read instruction (pop) precedes it. Accordingly, in one embodiment the stored value from the link stack repair buffer 23 is restored to the link stack 22 only if it is detected that a speculative link stack pop operation preceded the erroneous, speculative link stack push. In another embodiment, the stored value from the link stack repair buffer 23 is restored to the link stack 22 only if both speculative link stack pop and push operations are detected, but without regard to their relative order of execution. In one embodiment, such as the one depicted in FIG. 2, the speculative link stack pop detection may be implemented similarly to that described herein for detecting a speculative link stack push operation—that is, maintaining a pipeline-wide speculative link stack read instruction up/down counter, and a speculative link stack read instruction count associated with each branch instruction, and comparing the two values if a branch is determined to have been mispredicted. In another embodiment, such as the one depicted in FIG. 5, the speculative link stack pop detection may be implemented similarly to that described herein for detecting a speculative link stack push operation—that is, maintaining a pipeline-wide speculative link stack read instruction incrementing tag register, and a speculative link stack read instruction snapshot of the incrementing tag register, associated with each branch instruction, and comparing the two values if a branch is determined to have been mispredicted.
FIG. 4 depicts a flow diagram of a method 60 of managing a link stack. The evaluation of a branch instruction is predicted (block 62). Based on the branch prediction, instructions are speculatively fetched from the next sequential address or a predicted branch target address, and executed (block 64). Any time an instruction (including a speculatively executed instruction) writes the link stack 22 (block 66), the prior value of the overwritten link stack entry is saved in a link stack restore buffer 23 (block 68). When the branch instruction is evaluated in an execute pipe stage, if the branch prediction was correct (block 70), pipeline operation continues normally. If the branch was mispredicted (block 70), the speculative instructions are flushed from the pipeline and proper instructions are fetched from either the address following the branch instruction or the calculated branch target address (block 72).
Whether a speculative instruction—that is, an instruction following the branch instruction—wrote the link stack 22 is ascertained (block 74). In one embodiment, this comprises maintaining an ongoing count of all uncommitted link stack write instructions in the pipeline, and a count of all uncommitted link stack write instructions ahead of each branch instruction, and comparing the count associated with the mispredicted branch instruction to the total count. In another embodiment, this comprises maintaining an incrementing tag register which increments each time a link stack write instruction leaves the decode stage, saving a snapshot of the incrementing register in the BIQ, and comparing the value of the snapshot associated with the mispredicted branch instruction to the value stored in the incrementing tag register. If no instruction following the mispredicted branch instruction wrote link stack 22 the snapshot and the incrementing tag register values will be equal and pipeline operation continues normally. If a speculative instruction wrote the link stack 22, the snapshot and the incrementing tag register values will not be equal and the prior link stack entry value may be restored from the link stack restore buffer 23 at the stored link stack index, and pipeline operation continues normally.
Accordingly, returning to FIG. 4, If no instruction following the mispredicted branch instruction wrote the link stack 22 (block 74), pipeline operation continues normally. If a speculative instruction wrote the link stack 22, the prior link stack entry value may be restored from the link stack restore buffer 23 (block 76), at the stored link stack index, and pipeline operation continues normally. In some embodiments, the link stack 22 restore only occurs if a speculative read instruction also popped the link stack 22.
In one embodiment, the single-entry link stack repair buffer 23 comprises 32 bits for the link address and a mode bit (e.g., an ARM/Thumb mode bit), and a 3-bit index (for an 8-entry link stack 22). Each BIQ count field may comprise only 2 or 3 bits, depending on the depth of the pipeline 12. Accordingly, the hardware impact of this approach is minimal. Simulation of the single-entry link stack repair buffer 23 yielded greater than 20% increase in link stack accuracy over no link stack repair mechanism. Simulation of deeper link stack repair buffers yielded negligible additional accuracy increase. Of course, these results depend on numerous factors, including the pipeline depth, code characteristics, and the like. In general, those of skill in the art will be able to choose a link stack repair buffer depth that balances performance and power savings with design complexity and silicon area for any particular processor implementation, given the teachings of this disclosure. Even with multiple link stack repair buffer entries (and the concomitant complexity of the counter comparisons), embodiments of the present invention provide a far more efficient solution to corrupted link stack repair than a separate, “committed” link stack. Furthermore, link stack 22 operations occur early in the pipeline 12, providing link stack optimization for even short subroutines.
As used herein, a “link stack write instruction” is any instruction, such as a branch and link instruction, that pushes a link address onto the link stack, even if the instruction implements other functionality (such as program flow redirection). As used herein, a “counter” may comprise a hardware counter operative to increment and/or decrement a stored value, or may comprise a bit field in a buffer whose value is incremented and/or decremented by reading the value, performing the operation, and writing a new value to the bit field.
Although the present invention has been described herein with respect to particular features, aspects and embodiments thereof, it will be apparent that numerous variations, modifications, and other embodiments are possible within the broad scope of the present invention, and accordingly, all variations, modifications and embodiments are to be regarded as being within the scope of the invention. The present embodiments are therefore to be construed in all aspects as illustrative and not restrictive and all changes coming within the meaning and equivalency range of the appended claims are intended to be embraced therein.
FIG. 6 illustrates an exemplary wireless communication system 600 in which an embodiment of the disclosure may be advantageously employed. For purposes of illustration, FIG. 6 shows three remote units 620, 630, and 650 and two base stations 640. In FIG. 6, remote unit 620 is shown as a mobile telephone, remote unit 630 is shown as a portable computer, and remote unit 650 is shown as a fixed location remote unit in a wireless local loop system. For example, the remote units may be mobile phones, hand-held personal communication systems (PCS) units, portable data units such as personal data assistants, GPS enabled devices, navigation devices, settop boxes, music players, video players, entertainment units, fixed location data units such as meter reading equipment, or any other device that stores or retrieves data or computer instructions, or any combination thereof. Although FIG. 6 illustrates remote units according to the teachings of the disclosure, the disclosure is not limited to these exemplary illustrated units. Embodiments of the disclosure may be suitably employed in any device which includes active integrated circuitry including memory and on-chip circuitry for test and characterization.
The foregoing disclosed devices and methods are typically designed and are configured into GDSII and GERBER computer files, stored on a computer readable media. These files are in turn provided to fabrication handlers who fabricate devices based on these files. The resulting products are semiconductor wafers that are then cut into semiconductor die and packaged into a semiconductor chip. The chips are then employed in devices described above.

## Claims

1. A method of detecting corruption in a link stack comprising a plurality of entries, each entry operative to store a link address, the method comprising:
predicting branch evaluations of branch instructions;
in response to the predictions, speculatively executing instructions in a pipeline;
allowing link stack write instructions to speculatively write the link stack;
maintaining an incrementing tag register which is incremented by each link stack write instruction entering the pipeline;
maintaining a snapshot of the incrementing tag register, associated with each branch instruction in the pipeline;
detecting that a branch instruction was mispredicted;
upon detecting that the branch instruction was mispredicted, comparing the incrementing tag register to the snapshot associated with the branch instruction; and
determining that the link stack is corrupted if the incrementing tag register and the snapshot are not the same.

2. The method of claim 1, further comprising:
saving a prior value of a link stack entry in a link stack restore buffer in response to determining that a speculative link stack write instruction will overwrite the link stack entry; and
upon determination that the link stack is corrupted, restoring the saved prior value from the link stack restore buffer to the link stack.

3. The method of claim 2, wherein the link stack restore buffer is separate from the link stack.

4. The method of claim 2, further comprising storing a link stack index of the link stack entry in the link stack restore buffer.

5. The method of claim 2, wherein the link stack restore buffer comprises a plurality of entries.

6. The method of claim 5, further comprising, determining a numerical difference between the values of the incrementing tag register and the snapshot to determine a number of link stack entries overwritten by speculative link stack write instructions.

7. The method of claim 1, comprising:
incrementing the value of the incrementing tag register upon decoding a link stack write instruction.

8. The method of claim 1, wherein maintaining the snapshot of the incrementing tag register comprises:
copying the value of the incrementing tag register to a snapshot field associated with a branch instruction upon decoding the branch instruction.

9. The method of claim 8, wherein the snapshot field is a field in a branch instruction queue entry associated with the branch instruction.

10. A processor comprising:
an instruction execution pipeline;
a link stack comprising a plurality of entries, each entry operative to store a link address;
a branch predictor configured to predict branch evaluations of branch instructions in the pipeline, such that instructions are speculatively executed in the pipeline based on the predictions;
a link stack write circuit configured to allow speculatively executed link stack write instructions to speculatively write to the link stack;
an incrementing tag register, configured to be incremented by each link stack write instruction entering the pipeline;
a snapshot of the incrementing tag register, associated with each branch instruction in the pipeline;
branch evaluation logic to detect that a branch instruction was mispredicted; and
a link stack monitor circuit configured to compare the incrementing tag register to the snapshot associated with the branch instruction upon indication from the branch evaluation logic that the branch instruction was mispredicted, wherein the link stack monitor is configured to determine that the link stack is corrupted if the incrementing tag register and the snapshot associated with the branch instruction are not the same.

11. The processor of claim 10, further comprising:
a link stack restore buffer configured to save a prior value of a link stack entry in response to determining that a speculative link stack write instruction will overwrite the link stack entry; and
logic to restore the saved prior value from the link stack restore buffer to the link stack based on the determination by the link stack monitor circuit that the link stack is corrupted.

12. The processor of claim 11, wherein the link stack restore buffer is separate from the link stack.

13. The processor of claim 11, wherein the link stack restore buffer further comprises a link stack index of the link stack entry.

14. The processor of claim 11, wherein the link stack restore buffer comprises a plurality of entries.

15. The processor of claim 14, further comprising, logic configured to calculate a numerical difference between the values of the incrementing tag register and the snapshot, such that a number of link stack entries overwritten by speculative link stack write instructions is determined based on the numerical difference.

16. The processor of claim 10, wherein: the value of the incrementing tag register is incremented upon decoding a link stack write instruction.

17. The processor of claim 10, wherein the snapshot of the incrementing tag register is stored in a snapshot field associated with a branch instruction upon decoding the branch instruction.

18. The processor of claim 17, wherein the snapshot field is part of a branch instruction queue entry associated with the branch instruction.

19. The processor of claim 10, integrated in at least one semiconductor die.

20. The processor of claim 10, integrated into a device selected from the group consisting of a set top box, music player, video player, entertainment unit, navigation device, communications device, personal digital assistant (PDA), fixed location data unit, and a computer.

21. A system for detecting corruption in a link stack comprising a plurality of entries, each entry operative to store a link address, the system comprising:
means for predicting branch evaluations of branch instructions;
in response to the predictions, means for speculatively executing instructions in a pipeline;
means for allowing link stack write instructions to speculatively write the link stack;
means for maintaining an incrementing tag register which is incremented by each link stack write instruction entering the pipeline;
means for maintaining a snapshot of the incrementing tag register, associated with each branch instruction in the pipeline;
means for detecting that a branch instruction was mispredicted;
upon detecting that the branch instruction was mispredicted, means for comparing the incrementing tag register to the snapshot associated with the branch instruction; and
means for determining that the link stack is corrupted if the incrementing tag register and the snapshot are not the same.

22. The system of claim 21, further comprising:
means for saving a prior value of a link stack entry in a link stack restore buffer in response to determining that a speculative link stack write instruction will overwrite the link stack entry; and
upon determination that the link stack is corrupted, means for restoring the saved prior value from the link stack restore buffer to the link stack.

23. The system of claim 22, further comprising means for storing a link stack index of the link stack entry in the link stack restore buffer.

24. The system of claim 21, comprising:
means for incrementing the value of the incrementing tag register upon decoding a link stack write instruction.

25. The system of claim 21, wherein means for maintaining the snapshot of the incrementing tag register comprises:
means for copying the value of the incrementing tag register to a snapshot field associated with a branch instruction upon decoding the branch instruction.

26. A non-transitory computer-readable storage medium comprising code, which, when executed by a processor, causes the processor to perform operations for detecting corruption in a link stack comprising a plurality of entries, each entry operative to store a link address the non-transitory computer-readable storage medium comprising:
code for predicting branch evaluations of branch instructions;
in response to the predictions, code for speculatively executing instructions in a pipeline;
code for allowing link stack write instructions to speculatively write the link stack;
code for maintaining an incrementing tag register which is incremented by each link stack write instruction entering the pipeline;
code for maintaining a snapshot of the incrementing tag register, associated with each branch instruction in the pipeline;
code for detecting that a branch instruction was mispredicted;
upon detecting that the branch instruction was mispredicted, code for comparing the incrementing tag register to the snapshot associated with the branch instruction; and
code for determining that the link stack is corrupted if the incrementing tag register and the snapshot are not the same.

27. The non-transitory computer-readable storage medium of claim 26, further comprising:
code for saving a prior value of a link stack entry in a link stack restore buffer in response to determining that a speculative link stack write instruction will overwrite the link stack entry; and
upon determination that the link stack is corrupted, code for restoring the saved prior value from the link stack restore buffer to the link stack.