Low-Level Programming

Part I BASIC ASSEMBLY Chapter 1 Basic Architecture Von Neumann architecture Extensions of von Neumann architecture Registers and locality General-purpose registers Other useful registers Special registers Protection rings Hardware stack Chapter 2 Basics of Assembly Programming Where will we program? Example: Hello, world File interaction in *nix Code structure Instructions Example: register output Local labels Relative addressing Jumps Procedure calling sequences Endianness Strings Pointers Constant calculations Complex addressing IO libraries Chapter 3 Legacy Real mode Protected mode Minimal Intel 64 segmentation Is it RISC or CISC? Chapter 4 Memory What is caching in the large sense? Virtual memory Why do we need abstraction over memory? Address spaces Example: Access to nonexistent memory Performance Implementation Page tables Memory mapping Chapter 4 Compilation Cycle Preprocessing Translation Linkage Object files Relocatable object files Executable object files Loading Dynamic libraries Chapter 5 Interrupts and System Calls Interrupts System calls Model Specific Registers syscall and sysret Chapter 6 Model of Computations Finite automatons Definition Implementation Practical importance Forth machine Architecture Examples Dictionary Word structure Forth compilation Jumps Forth compiler Static dictionary, interpretation Dynamic dictionary, compilation< Bootstrap Part II C LANGUAGE Chapter 7 Main Concepts What distinguishes C? Program structure Abstract machine Number types Common pitfalls Examples Statements and expressions lvalue and rvalue Preprocessor Data types Overview Type conversion Integer promotion Arrays Functional types Pointers strings const Type aliases Common code practice static array sum Prime numbers Structures, unions, and enumerations Data types in programming Typing Strict static typing Nonstrict static typing Strict dynamic typing Nonstrict dynamic typing Polymorphism Polymorphism types Polymorphism in C Functions and procedures Chapter 8 Code Structure Declaration vs definition Functions and procedures Structures Recursive data types Incomplete types Calling external code Code from other source files Standard library What's the connection between headers and libraries? Preprocessor usage Basics Include guard Advanced techniques Side effects Chapter 9 Memory Pointers Why do we need pointers? Address arithmetic void* NULL Function pointers Pointers vs arrays Pointers syntax pitfalls Programs outputting their arguments Memory model Memory kinds dynamic array sum String literals Linked lists Static keyword Higher-order functions on lists Data streams Chapter 10 Syntax, Semantics, and Pragmatics Syntax Grammars Semantics Undefined behavior vs unspecified behavior Sequence points Pragmatics Alignment Platform-independent data types Chapter 11 Good Code Practices Types Variables Functions Modules Hiding implementation Directory structure Immutability vs performance Image rotation BMP format Architecture Memory allocator Part III C AND ASSEMBLY Chapter 12 Translation Details Calling conventions Stack frames Argument passins Stack behavior Red zone Variable argument list vprintf volatile setjmp volatile and setjmp Optimized and non-optimized Classical vulnerabilities Stack overflow return-to-libc shellcode Protection mechanisms Stack guard Address space layout randomization DEP Chapter 13 Performance SSE and AVX Assignment: fast sepia filter Optimizations Is C fast? How to write performant code Omitting stack frames Tail recursion Common subexpressions Constant propagation Return value optimization Cycle unwinding Architecture-specific optimizations Caching Appendix A Debugging with gdb Appendix B Building with make Appendix C System Calls Table