数据如何进入通用寄存器和其他寄存器，以便 CPU 可以使用它来计算值？

Question

I know that registers serve as storage units for the CPU to access data from in order to execute an instruction. The assembly language for these instructions look something like ADD R2, R1, R3 essentially asking us to add contents in R1 and R3 and place it in R2. My question is, how does data get into the registers R1 and R3 so that the CPU can use those values to compute and store the result in R2? And if all registers get full, is data evicted to main memory from the registers using an LRU method similar to how data from caches are evicted?

Answer 1

Values get both into and out of registers using machine code instructions; machine code instructions can:

• Enter constants from the program into registers or memory
  • These are usually called load immediate or move
• Enter user input like keystrokes into registers or memory
  • some processors have input instructions, others load from memory mapped I/O
• Load data from memory, where long-lived variables & data structures are located
• Send register values to memory
  • to update data structures and other long-lived variables
• Send data to an output device (like a console)
• Compute new values given existing values

And if all registers get full

It depends somewhat on what you mean by full. In one sense, the registers always hold values, there's no notion in the CPU of free / busy registers _{(modulo some deep concepts on floating point and vector registers)} . Similar is true for your hard drive. It has exactly N gigabytes of storage, as far as the hardware is concerned, this number never grows or shrinks.

And if all registers get full, is data evicted to main memory from the registers using an LRU method similar to how data from caches are evicted?

Yes, but virtually 100% under program control: the program knows what logical variables from our algorithms are in what CPU registers (and others in what memory locations), so there is a notion of an algorithm translated to assembly having either sufficient registers (leaving some unused) and also of wanting more registers than are available. When that happens (desiring more than available), compiler writers and assembly programmers simply turn to memory for the overflow, writing machine code instructions to transfer data back & forth as needed. Unimportant things can live in memory and suffer slower access times, allowing the CPU registers to be used as desired.

(In the hard drive analogy, all the bits are always there but not always in meaningful use.)

To be clear, the hardware has many LRU algorithms, but these generally surround cache architectures, including L1, L2, and TLB.

Answer 2

General Purpose Registers are very similar in concept to variables in a programming language

R1 = 3
R3 = 5
R2 = R1 + R3

How you get those values into the registers is specific to the architecture and the value. Some instruction sets have variable length instructions and can support any possible value

mov r1,0x12345678

Others can load half a register

lui r1,0x12340000 

Not proper syntax for a real processor, but the ISA would allow for control over the top half then you would follow it with an

ori r1,0x5678

And the end result is r1 = 0x12345678

Another solution is to load from a nearby location

ldr r1,hello
...
hello: .word 0x12345678

This would use pc-relative addressing, the assembler would do the math for you when it generates the instruction, but for example the actual instruction would be something like load from memory at the address of pc+16 into the register r1.

Registers are discrete and there is a fixed number of them, they are not cached or a fifo or anything like that.

From a programmer or compiler perspective, you can run out of them if you only have say 8 registers, and you are managing more than 8 data items, variables, addresses, etc. AND you are using an architecture that requires you to use registers for everything, then you would typically use the stack to temporarily store variables.

r1 = 0x12345678  (variable hello)
r2 = 0x55443366  (variable world)
...
I need another variable as the programmer I decide that I can live with out hello for a while
push {r1}
r1 = r2+r3     (variable foo)
str r1,[r4]    (the computed value was generated to store in memory)
foo is no longer neaded, but I need hello back
pop {r1}

Compilers that take a higher level language and generate a lower level language, often assembly language or machine code, will track variables through a function and select which registers to use when. A particular register may through the course of the execution of a function may hold several variables or addresses or other data...obviously only one thing at a time. The same thing we would do as humans by hand, but according to an algorithm.