Câmbio de moedas

Nos conceitos anteriores, foi mencionado que a diretiva global torna uma função ou variável definida em um arquivo fonte visível para outros arquivos. Da mesma forma, a diretiva extern informa ao montador que uma função ou variável usada no arquivo fonte atual está definida em outro.

Essas duas diretivas são a principal forma de o código assembly interagir com outros arquivos fonte para alcançar a modularização.

Para os propósitos dessas diretivas, é indiferente se o código externo é definido ou usado em assembly ou em uma linguagem de alto nível. Assim, por exemplo, até uma função definida em uma linguagem de alto nível pode ser usada em código x86-64 se for declarada extern.

Da mesma forma, a convenção de chamada é compartilhada por todas essas funções, definidas em assembly ou em linguagens de alto nível, e até mesmo com o Sistema Operacional (SO).

No entanto, como em assembly os dados são apenas uma sequência de bytes, é importante entender como a linguagem de alto nível envolvida gerencia a memória.

Tipos em C

A linguagem C é uma escolha comum quando uma linguagem de alto nível precisa interagir com código assembly. Ela facilita a tarefa de interagir com o SO, oferecendo abstrações de alto nível para muitas tarefas importantes, como imprimir na tela, ler do teclado ou alocar memória dinâmica.

Nesta trilha, os testes são escritos em C, então é importante apresentar uma visão geral da linguagem.

Tipos primitivos

Existem muitos tipos primitivos em C, e o tamanho deles, em bytes, pode variar. Alguns deles estão resumidos na tabela a seguir, com o tamanho típico em um sistema x86-64:

Cada um desses tipos integrais pode ser com sinal (o padrão) ou sem sinal. Caso sejam sem sinal, isso precisa ser especificado, por exemplo: unsigned int.

Existem aliases para os tipos integrais, definidos para dar controle preciso sobre o tamanho deles:

Esses aliases podem receber o prefixo u para indicar um tipo sem sinal, por exemplo: uint64_t.

Outros aliases que vale a pena mencionar:

Um _Bool, ou seu alias bool, é especial porque, embora ocupe 1 byte inteiro, só pode assumir um de dois valores: true (1) e false (0).

Os valores desses tipos primitivos são passados para funções, e retornados por elas, de acordo com as regras usuais para inteiros e valores de ponto flutuante.

Enums

Um enum é um tipo que pode assumir um entre vários elementos indicados explicitamente:

enum example {
    example_1,
    example_2,
    example_3,
    example_4
};

Em C, enums são convertidos implicitamente para um tipo inteiro, que normalmente é um int, ou seja, um inteiro de 4 bytes.

Por padrão, o primeiro elemento possível de um enum é convertido para 0, e todos os elementos seguintes são convertidos para o próximo inteiro. Então, no enum example definido acima, example_1 teria o valor 0, example_2 teria o valor 1, e assim por diante.

É possível indicar o valor de qualquer elemento de um enum e, a partir daí, por padrão, o próximo elemento teria o próximo inteiro como valor:

enum example_2 {
    example_1 = 4,
    example_2 = 8,
    example_3
}; // example_3 is equal to 9

Endereços de memória

Em C, um endereço de memória é referenciado por um ponteiro para um tipo e denotado com o operador *. Assim, por exemplo, int64_t * se refere a um local de memória para um ou mais int64_t.

Os endereços são tratados como inteiros de 8 bytes, como de costume.

Arrays

Arrays são passados para funções, e retornados por elas, como ponteiros para o primeiro elemento.

int64_t example_arr[] = {1, 2, 3}; // this is an array of 3 signed 8-byte integers
fn(example_arr); // this is a function that passes a pointer (int64_t *) to the beginning of the array as an argument

Cada elemento de um array tem o tamanho do tipo de elemento do array. O example_arr definido acima, por exemplo, tem 3 elementos de 8 bytes cada, o que dá 24 bytes no total.

Como os arrays não armazenam seu comprimento, normalmente é necessário um valor separado para indicar o número de elementos, a menos que um valor sentinela marque o fim.

Strings

Strings em C são um array de char, que é um tipo de 1 byte. A maioria das strings é composta de caracteres ASCII e termina com NUL, então elas acabam quando um byte com o valor 0 é encontrado. Isso significa que o comprimento de uma string geralmente não precisa ser passado como um argumento separado.