Segmentação de Memória!

Segmento .Data

Local em que as variáveis globais inicializadas ficam.

Exemplo:

            .data
                    Hello_ZEROED: .asciz "Hello World!!" 
                    Hello_NO_ZEROED .ascii "Hello World!!"
                    Inteiro: .int 10
                    SHORT: .short 2 
                    FLOAT: .float 3.14px
                    DOUBLE: .double. 2.341253234

                                

Segmento .BSS
(Block Started by Symbol)

Local em que as variáveis não inicializadas ficam.

Exemplo:

                .bss
                    some_static_global_var:
                        .lcomm 32

                    some_global_var:
                        .comm 32

                                            

Segmento .Text

Local em que as instruções do programa Ficam.

Segmento Pilha (stack)

Local em que as variáveis locais da função atual ficam alocadas

Layout

.Data

Variáveis globais Inicializadas

.BSS

Variáveis globais não inicializadas

.text

As instruções de execução propriamente ditas

Stack Frame

Variáveis locais da função em execução

Registradores

O que são?

Registradores Importantes

• RBP - Base Pointer
• RSP - Stack Pointer
• RIP - Instruction Pointer

Divisão Interna dos Registradores

Exemplo de utilizaçao da stack:

        int  
        main (void) {      |     push    %rbp
            int a = 1;     |     mov     %rsp, %rbp
            int b = 2;     |     sub     0x10, %rsp 
            int c = 3;     |
            int d = 4;     |     mov     $0x01, -0x04(%rbp)
                           |     mov     $0x02, -0x08(%rbp)
                           |     mov     $0x03, -0x0c(%rbp)
            return 0;      |     mov     $0x04, -0x10(%rbp)
        }                  |     
                           |     mov     $0x00, %rax
                           |     
                           |     mov     %rbp, %rsp
                           |     pop     %rbp
                           |     ret 
                            

Detalhes

                            

#prologo
push    %rbp               # salvando a base da pilha, na pulha.
mov     %rsp, %rbp         # Setando a nova base da pulha para o topo da antiga

sub     $0x10, %rsp        # alocando 4 inteiros (4*4 = 16 = 0x10)

mov     $0x1, -0x4(%rbp)   # atribuindo valores às variáveis
mov     $0x2, -0x8(%rbp)   #   "                   "
mov     $0x3, -0xc(%rbp)   #   "                   "
mov     $0x4, -0x10($rbp)  #   "                   "
        
mov     $0x0, %rax         # zerando rax (retorno da função)

# epilogo
mov     %rbp, %rsp         # setando a topo da pilha igual a base
pop     %rbp               # restaurando base da natiga pilha que havia sido salva
ret                        # saltando para o endereço de retorno
                            
                        

Operações da stack

push src

Coloca algo no topo¹ da pilha e, portanto, incrementa o topo¹

pop dest

Coloca o que esta no topo no lugar indicado pelo operand (dest) e, portanto, decrementa o topo

Call Instruction

 
                    .
                    .
                    mov     $FMT_STR, %rdi   # considerando STR_FMT = "%s\n"
                    mov     $MSG, %rsi       # considerando MSG = "Hello World!!"
                    call    fpritnf

                        

                    call addr 
                    
                    # /* Na realidade executa: */

                    push %rip
                    jmp  address
                

Funções - Convenção de chamada

Ordem de parametros

1. rdi
2. rsi
3. rdx
4. rcx
5. r8
6. r9
7. use a stack

Retorno da função

Retorno das funções são passados através do rax

Exemplo de chamada de função

                                
                                /*int soma (int a, int b, int c);*/

                                xor     %rax, %rax

                                mov     -0x04(%rbp), %rdi       #a
                                mov     -0x08(%rbp), %rsi       #b
                                mov     -0x0c(%rbp), %rcx       #c
                                call    soma
                                mov     %rax, %rcx              #retorno da soma no rax