Assembly

Trabalha com AND, OR, XOR, NOT, máscaras, deslocamentos e complemento de dois. Essas operações formam a base para manipular flags, campos de bits e valores compactados.

Apresenta CPU, memória, barramentos, registradores, cache e ciclo de busca, decodificação e execução. O aluno acompanha como uma instrução movimenta dados pelo computador.

Mostra a passagem dos primeiros computadores programáveis para mainframes, microprocessadores, arquiteturas CISC e RISC e sistemas de 64 bits. Também situa x86, ARM, RISC-V e a evolução das extensões vetoriais.

Explica instruções, opcodes, operandos, registradores e os limites definidos por uma arquitetura de conjunto de instruções. Compara linguagem de máquina, assembly, montador e linguagem de alto nível.

Prepara um ambiente acessível com editor, montador, linker, depurador e ferramentas de inspeção de binários. Apresenta NASM, GNU Assembler e LLVM, além das sintaxes Intel e AT&T.

Cria, monta, vincula e executa um pequeno programa x86-64 em Linux. O processo deixa visível cada arquivo gerado e a relação entre código-fonte, objeto e executável.

Usa registradores gerais, subregistradores e instruções de transferência como MOV, LEA, PUSH e POP. Exercícios mostram truncamento, extensão de sinal e extensão com zeros.

Trata de endereços, bytes, palavras, endianness, alinhamento e segmentos de memória. O aluno inspeciona valores na memória e identifica erros comuns de tamanho e acesso.

Constrói endereços com base, índice, escala e deslocamento na arquitetura x86-64. A prática inclui percorrer vetores, tabelas e estruturas sem perder o controle dos limites.

Executa soma, subtração, multiplicação, divisão e negação, acompanhando carry, overflow, zero e sinal. Também diferencia overflow de inteiros com sinal e sem sinal.

Aplica máscaras, rotações, contagem de bits, extração de campos e operações condicionais sobre bits. Os exercícios incluem permissões, formatos compactados e algoritmos bit a bit.

Lê a codificação de instruções x86-64, incluindo prefixos, opcode, ModR/M, SIB e imediatos. O aluno codifica instruções simples manualmente e confere o resultado com um disassembler.

Implementa comparações, saltos, laços, tabelas de salto e seleção sem desvios. Estruturas como if, while e switch são reconstruídas diretamente com instruções.

Representa vetores, strings, matrizes, enums, registros e estruturas alinhadas. A prática inclui cópia, busca, contagem e acesso a campos sem apoio de uma biblioteca de alto nível.

Explica crescimento da pilha, ponteiro de pilha, frames, alinhamento e armazenamento temporário. O aluno acompanha chamadas aninhadas e diagnostica corrupção da pilha.

Cobre passagem de argumentos, valores de retorno, registradores preservados, alinhamento e dados variádicos. Compara System V AMD64, Windows x64 e convenções comuns de 32 bits.

Constrói funções reutilizáveis, prólogos, epílogos, funções folha, recursão e tail calls. Cada rotina é validada quanto à preservação de registradores e equilíbrio da pilha.

Usa chamadas de sistema para saída, arquivos, memória e término de processos sem depender da biblioteca C. Também diferencia APIs do sistema operacional, bibliotecas e instruções privilegiadas.

Examina seções, símbolos, tabelas de strings e informações de depuração em arquivos objeto e executáveis. O foco principal é ELF, com referências aos formatos PE e Mach-O.

Mostra como símbolos são resolvidos, endereços são realocados e bibliotecas estáticas ou compartilhadas entram no programa. Inclui código independente de posição, PLT, GOT, carregamento dinâmico e ASLR.

Organiza constantes, rótulos, seções, inclusão de arquivos, macros e montagem condicional. O aluno cria pequenas abstrações sem esconder os efeitos reais das instruções.

Representa valores IEEE 754 e realiza cálculos escalares com x87 e SSE. Casos práticos tratam de arredondamento, NaN, infinito, precisão e conversões entre inteiros e ponto flutuante.

Processa vários dados por instrução com SSE, AVX e AVX2. O aluno vetoriza operações sobre vetores, lida com alinhamento e mede quando o SIMD realmente melhora o desempenho.

Trabalha com máscaras, predicação e vetores largos ou escaláveis em AVX-512, Arm SVE e RISC-V Vector. Também aborda custos de portabilidade, frequência, largura vetorial e detecção de recursos da CPU.

Usa breakpoints, execução passo a passo, inspeção de registradores, memória, pilha e core dumps. GDB, LLDB, objdump e ferramentas equivalentes ajudam a localizar falhas reais.

Cria testes determinísticos para rotinas, compara resultados com implementações de referência e verifica casos-limite. Sanitizadores, análise dinâmica e fuzzing são usados por meio de componentes integrados em C ou C++.

Liga rotinas Assembly a programas C e C++, exporta símbolos e respeita tipos, alinhamento e convenções de chamada. O aluno constrói uma biblioteca pequena com interface documentada.

Lê a saída de compiladores para reconhecer laços, funções, objetos, exceções e otimizações. Ferramentas de compilação interativa ajudam a relacionar código-fonte, opções do compilador e instruções produzidas.

Mede tempo, ciclos, instruções, cache misses, previsões de desvio e outras métricas com contadores de hardware. O capítulo ensina a criar benchmarks confiáveis e evitar conclusões baseadas em ruído.

Melhora caminhos críticos considerando dependências, latência, throughput, cache, desvios e execução fora de ordem. As versões otimizadas são comparadas com uma referência correta e com código produzido pelo compilador.

Explica threads, condições de corrida, operações atômicas, barreiras e ordenação de memória. O aluno implementa primitivas simples e compara os modelos de memória de x86, ARM e RISC-V.

Mostra traps, faults, interrupções, sinais, níveis de privilégio e transições entre usuário e kernel. Pequenos exemplos acompanham uma exceção desde a instrução causadora até seu tratador.

Distingue modo real, protegido, compatibilidade e modo longo, além de paginação e tabelas de descritores. Um exercício de inicialização acompanha a CPU x86 do reset até a execução de código de 64 bits.

Explica estouros de buffer, uso após liberação, corrupção de retorno, ROP e shellcode em ambientes isolados. O objetivo é reconhecer como erros de memória se tornam desvios de controle e como investigá-los com segurança.

Aplica NX, ASLR, stack canaries, PIE, RELRO, CFI e separação de privilégios. Também cobre mecanismos recentes como Intel CET, Arm Pointer Authentication e Memory Tagging Extension.

Parte de um executável sem código-fonte para identificar funções, dados, convenções de chamada e fluxo de controle. Análise estática e dinâmica são combinadas para reconstruir o comportamento de um programa.

Trabalha com os registradores, instruções, endereçamento e ABI da arquitetura AArch64. O aluno porta uma rotina x86-64 e compara predicação, chamadas, memória e modelo de instruções.

Usa o conjunto de instruções modular e extensível do RISC-V, incluindo extensões de inteiros, multiplicação, atomics e ponto flutuante. Emuladores permitem montar, executar e depurar programas sem hardware dedicado.

Programa sem sistema operacional, configura memória, pilha, vetores de interrupção, temporizadores e periféricos mapeados em memória. O projeto pode rodar em um microcontrolador acessível ou em um emulador.

Mostra os trechos de Assembly necessários em bootloaders, troca de contexto, entrada de chamadas de sistema, tratadores de interrupção e drivers. O aluno integra uma rotina curta a um kernel didático.

Cria programas verificados para observabilidade, redes e segurança dentro do kernel. O capítulo cobre a máquina virtual eBPF, registradores, verifier, mapas, helpers e compilação a partir de C.

Trata WebAssembly como alvo portátil de baixo nível, com pilha, memória linear, funções, módulos e validação. O aluno inspeciona o formato textual e binário e integra um módulo a uma aplicação.

Explica geração de instruções em tempo de execução, permissões de memória, cache de instruções, relocação e segurança W^X. Um pequeno compilador JIT traduz uma expressão ou bytecode simples para código nativo.

Apresenta o modelo de execução massivamente paralelo das GPUs e representações como PTX e SPIR-V. O aluno inspeciona um kernel compilado e relaciona threads, registradores, memória e divergência às instruções geradas.

Conduz um trabalho completo desde a definição da rotina e escolha da arquitetura até implementação, testes, depuração, benchmark, otimização e integração. A entrega inclui código-fonte, build reproduzível, documentação da ABI e evidências de correção e desempenho.

Mapeia caminhos em sistemas embarcados, compiladores, kernels, segurança, engenharia reversa e otimização. Indica projetos de portfólio, formas de contribuir com software livre, certificações quando úteis e fontes para acompanhar novas arquiteturas, ABIs e ferramentas.