Câmbio de moedas

Em conceitos anteriores, foi mencionado que a diretiva global torna uma função ou variável definida num ficheiro de código-fonte visível a outros ficheiros. De forma semelhante, a diretiva extern informa o assembler de que uma função ou variável usada no ficheiro de código-fonte atual está definida noutro.

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

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

Do mesmo modo, a convenção de chamada é partilhada por todas essas funções, definidas em assembly ou em linguagens de alto nível, e até com o sistema operativo (SO).

No entanto, como em assembly os dados são apenas uma sequência de bytes, é importante perceber como a linguagem de alto nível com que estamos a interagir gere a memória.

Tipos em C

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

Neste track, os testes estão escritos em C, pelo que é importante dar uma visão geral da linguagem.

Tipos primitivos

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

Cada um desses tipos inteiros pode ser com sinal (o predefinido) ou sem sinal. Quando são sem sinal, isso tem de ser indicado, por exemplo: unsigned int.

Existem aliases para os tipos inteiros, definidos para permitir um controlo preciso do seu tamanho:

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

Outros aliases que vale a pena conhecer são:

Um _Bool, ou o seu alias bool, tem a particularidade de, apesar de ocupar 1 byte inteiro, só poder assumir um de dois valores: true (1) e false (0).

Os valores desses tipos primitivos são passados às funções e devolvidos por elas de acordo com as regras habituais para inteiros e valores de vírgula flutuante.

Enums

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

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

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

Por predefinição, o primeiro elemento possível de um enum é convertido em 0 e todos os elementos seguintes são convertidos no inteiro seguinte. Assim, no enum example definido acima, example_1 teria o valor 0, example_2 teria o valor 1, e assim sucessivamente.

É possível indicar o valor de qualquer elemento de um enum e, por predefinição, o elemento seguinte passa a ter como valor o inteiro seguinte:

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 representado com o operador *. Assim, por exemplo, int64_t * refere-se a uma localização de memória para um ou mais int64_t.

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

Arrays

Os arrays são passados às funções e devolvidos por elas como ponteiros para o seu 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 guardam o seu comprimento, normalmente é preciso um valor separado para indicar o número de elementos, a menos que um valor sentinela marque o fim.

Strings

Em C, as strings são um array de char, que é um tipo de 1 byte. A maioria das strings é composta por carateres ASCII e termina com NUL, ou seja, termina quando se encontra um byte com o valor 0. Isto significa que o comprimento de uma string normalmente não precisa de ser passado como um argumento separado.