What are these specific purpose registers?

Question

I’m following a book about Computer Architecture and I’m on the register side, but it doesn’t contain any practical examples of how

Registers of Specific Purpose.

Among them are:

PC (Program Control) -> Has the address and search the next instruction to be searched

GO (Instruction Register) Save the Instruction and pass to the UCD

SEA (Memory Adress Register) Works when the data is in memory and not in the recorder

MBR (Memory Buffer Register, alias this has something to do with the buffer that we see in programming?) Response of Memory is recorded in MBR

How these above recorders work when we are coding?

The general purpose recorders are what we keep variables so the clear example already comes close to my mind, but the general purpose approach is quite different...

var x = 10 //Seria isso?

Answer 1

I would start reading How a computer understands binary code?.

PC - is the registrar used to determine which address it should run next. Every executed instruction makes it move to the next instruction. In RISC processors it is easy because all instructions are the same size and the increment is easy, in CISC processors you need to find the size in an internal table and increment that. It only points to regions of memory that have code and not data. It can be manipulated by a code when there is some branch in your code, either by a if, whileougoto` simple, ie, your code can manipulate it.

GO - generally more internal use has the instruction to be executed, is a kind of cache and is usually only present in RISC processors that performs an instruction in several cycles and needs a greater control of what is occurring.

SEA - It is also usually internal and indicates where a data is to be transferred to or from the processor. It is usually necessary for data transport operations. It is usually used when accessing or assigning values to a variable, as shown in the question.

MBR - also used to be internal and used as a kind of cache to store the data that will be transferred, this is useful because the processor may be running another instruction while this transfer takes place.

Only the PC is useful for those who are programming, and even if using Assembly.

Variables are design standards for access to addresses that can be RAM or a register (contrary to what the other answer says). It is extremely common for an Assembly programmer to use registers as their variables and the minimally good compilers put as many local variables and parameters as they can into registers.

Answer 2

Dude, each of these recorders has a purpose in memory management, in the description of each one it already says what they are, to see in practice you can find illustrative images on the internet, to work directly with them, you need to know how each type of architecture(ex:MIPS,x86) works.

With Assembly language or one that has privileged access to memory, you will be able to manipulate these registers.

Example of a code in Assembly, using data loggers and processing:

section .text

       global _start     ;must be declared for linker (gcc)

    _start:          ;tell linker entry point
       mov  edx,len  ;message length
       mov  ecx,msg  ;message to write
       mov  ebx,1    ;file descriptor (stdout)
       mov  eax,4    ;system call number (sys_write)
       int  0x80     ;call kernel

       mov  edx,9    ;message length
       mov  ecx,s2   ;message to write
       mov  ebx,1    ;file descriptor (stdout)
       mov  eax,4    ;system call number (sys_write)
       int  0x80     ;call kernel

       mov  eax,1    ;system call number (sys_exit)
       int  0x80     ;call kernel

    section .data
    msg db 'Displaying 9 stars',0xa ;a message
    len equ $ - msg  ;length of message
    s2 times 9 db '*'

eax, edx, ecx, etc.; are registers.