Skip to content

This Repository is a collection of different ethical hacking tools and malware's for penetration testing and research purpose written in python, ruby, rust, c++, go and c.

3.2 KB
Raw Blame

In assembly language, loading and storing values into registers is fundamental for manipulating data. The process involves transferring data between memory and registers. Here, we'll focus on loading and storing a single register, which is essential for various operations.

Basic Concepts of Load/Store Instructions

  1. Load: This operation transfers data from memory into a register.
  2. Store: This operation transfers data from a register back to memory.

Assembly Code Examples

Let’s explore examples of loading and storing a single register in x86 assembly language.

Example 1: Loading a Value into a Register

section .data
    value   dd  42               ; Define a variable with a value (42)

section .text
    global _start

_start:
    ; Load the value from memory into the EAX register
    mov     eax, [value]        ; EAX = value (42)

    ; Now, EAX contains the value 42
    ; You can perform operations using EAX here

    ; Exit system call
    mov     eax, 60             ; exit system call number
    xor     edi, edi            ; exit code 0
    syscall

Explanation of the Load Example:

  • mov eax, [value]: This instruction loads the value stored at the memory location labeled value into the EAX register.
  • After this instruction executes, EAX contains 42.

Example 2: Storing a Value from a Register

section .data
    result  dd  0                ; Reserve space for the result

section .text
    global _start

_start:
    ; Load a value into EAX
    mov     eax, 25              ; Load 25 into EAX

    ; Store the value from EAX into memory
    mov     [result], eax        ; Store the value of EAX into result

    ; Now, memory location 'result' contains 25

    ; Exit system call
    mov     eax, 60              ; exit system call number
    xor     edi, edi             ; exit code 0
    syscall

Explanation of the Store Example:

  • mov [result], eax: This instruction takes the value in the EAX register and stores it into the memory location labeled result.
  • After this instruction executes, the memory at result contains 25.

Summary of Load/Store Operations:

  • Loading: Use mov with the destination register on the left and the source memory location on the right to load data into a register.
  • Storing: Use mov with the destination memory location on the left and the source register on the right to store data from a register back into memory.

General Register Loading and Storing

  1. Load a Value from Immediate:

    • You can also load an immediate value directly into a register:
      mov eax, 100               ; Load the immediate value 100 into EAX
      
  2. Store the Register Value into Another Memory Location:

    • You can store a register value into a different memory location:
      mov [another_location], eax ; Store EAX into another memory location
      

Additional Considerations:

  • Ensure that the memory address is correctly aligned and has been allocated before performing load/store operations to prevent segmentation faults.
  • In x86 assembly, it's common to use eax, ebx, ecx, edx, etc., as general-purpose registers for various arithmetic and logical operations.