education-2022/selected/compilers.md

196 lines
12 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Compilers: How To Make a Programming Language
Other compiler-related topics out of scope:
- What are programs anyway (Forth, LISP)
- Computation: Turing machines, lambda calculus
- Compiler optimization
- GC (motivated by LISP)
aesthetics:
- stay motivated; stick close to a c-like, imperative, procedural model because that's what people are used to
motivation / goals / what questions are we trying to answer:
- I want to be able to make a toy procedural language.
- like C, Algol, JS, Lua, etc.
- possible user motivations:
- I want to make a game scripting language
- I want to make a DSL for my job (and I want syntax highlighting!)
- I want to do simple static analysis of my projects
ok what do we want to cover
- classical compiler structure (lexer -> parser -> codegen)
|Star| Title | Page |
|----|---------------------------------------|------|
| | Phases of a Compiler | https://www.geeksforgeeks.org/phases-of-a-compiler/ |
|* | Compiler Architecture | https://cs.lmu.edu/~ray/notes/compilerarchitecture/ |
| | Compiler Design | https://www.tutorialspoint.com/compiler_design/compiler_design_phases_of_compiler.htm |
| | Structure of a Compiler | https://www.csd.uwo.ca/~mmorenom/CS447/Lectures/Introduction.html/node10.html |
| | The Structure of a Compiler | https://www.brainkart.com/article/The-Structure-of-a-Compiler_8121/ |
| | Wikipedia: Compiler | https://en.wikipedia.org/wiki/Compiler |
| | The Structure of a Compiler (slides) | https://pages.cs.wisc.edu/~fischer/cs536.s08/lectures/Lecture04.4up.pdf |
| | Wikipedia: Code Generation | https://en.wikipedia.org/wiki/Code_generation_(compiler) |
| | Intro to Code Generation | https://cs.lmu.edu/~ray/notes/codegen/ |
| | Code Generation | https://www.tutorialspoint.com/compiler_design/compiler_design_code_generation.htm |
|*? | Phases of a Compiler | https://www.guru99.com/compiler-design-phases-of-compiler.html |
|*? | Writing a C Compiler (Pt. 1) | https://norasandler.com/2017/11/29/Write-a-Compiler.html |
| | V: Phases of a Compiler | https://www.youtube.com/watch?v=jE7f3sGLGVk |
|* | V: Different Phases of Comp | https://www.youtube.com/watch?v=TApMNhQPaCM |
|* | V: Parser and Lexer (Pt. 1) | https://www.youtube.com/watch?v=eF9qWbuQLuw |
- semantic analysis / type checking
|Star| Title | Page |
|----|-------------------------------|------|
| | Wikipedia | https://en.wikipedia.org/wiki/Compiler#Front_end |
| | Compiler Design - SA | https://www.tutorialspoint.com/compiler_design/compiler_design_semantic_analysis.htm |
|* | What is Semantic Analysis? | https://home.adelphi.edu/~siegfried/cs372/372l8.pdf |
|*? | SA in Compiler Design | https://iq.opengenus.org/semantic-analysis-in-compiler-design/ |
|*? | Implementation of SA | https://pgrandinetti.github.io/compilers/page/implementation-semantic-analysis/ |
|*? | What is SA in a Compiler? | https://pgrandinetti.github.io/compilers/page/what-is-semantic-analysis-in-compilers/ |
| | SA (Slides) | https://www.computing.dcu.ie/~davids/courses/CA4003/CA4003_Semantic_Analysis_2p.pdf |
| | V: The Semantic Analysis! | https://www.youtube.com/watch?v=j172YWmBk5A |
| | V: Intro to Semantic Analysis | https://www.youtube.com/watch?v=cC8YRnDGMwI |
| | V: Compiler Design SA | https://www.youtube.com/watch?v=57U6pQRnSJA |
| | V: Semantic Analysis: Intro | https://www.youtube.com/watch?v=7pHmBEkeIdQ |
|Star| Title | Page |
|----|----------------------------------|------|
| | Type Checking in Compiler Design | https://www.geeksforgeeks.org/type-checking-in-compiler-design/ |
| | Type Checking (Slides) | https://www.slideshare.net/dipongkersen81/type-checkingcompilier-design |
| | What is Static Type Checking? | https://www.tutorialspoint.com/what-is-static-type-checking |
| | What is Dynamic Type Checking? | https://www.tutorialspoint.com/what-is-dynamic-type-checking |
| | Type Systems | https://www.csd.uwo.ca/~mmorenom/CS447/Lectures/TypeChecking.html/node1.html |
| | V: Type Checking | https://www.youtube.com/watch?v=-TQVAKby6oI |
- modern compiler structures (IR / SSA, optimization)
|Star| Title | Page |
|----|--------------------------------------------|------|
| | Modern Compiler Design (Book) | https://www.cs.usfca.edu/~galles/compilerdesign/cimplementation.pdf |
| | Modern Compiler Design (Different Book) |http://160592857366.free.fr/joe/ebooks/ShareData/Modern%20Compiler%20Design%202e.pdf|
| | Wikipedia (IR) | https://en.wikipedia.org/wiki/Intermediate_representation |
|* | Intermediate Representations | https://cs.lmu.edu/~ray/notes/ir/ |
| | Intermediate Representations in Comp Design| https://iq.opengenus.org/intermediate-representations-in-compiler-design/ |
|*? | Intermediate Representation (Slides) | https://www.cs.princeton.edu/courses/archive/spring03/cs320/notes/IR-trans1.pdf |
| | Single Static Assignment (Slides) | https://www.cs.cmu.edu/~fp/courses/15411-f08/lectures/09-ssa.pdf |
| | Wikipedia (SSA) | https://en.wikipedia.org/wiki/Static_single_assignment_form |
| | Understanding SSA Forms | https://blog.yossarian.net/2020/10/23/Understanding-static-single-assignment-forms |
|* | V: Anders Hejlsberg on Modern Comp. Construction | https://www.youtube.com/watch?v=wSdV1M7n4gQ |
- interpreters vs. JITs vs. AOTs vs. "transpilers"
|Star| Title | Page |
|----|--------------------------------------------|------|
| | Wikipedia (Compiler) | https://en.wikipedia.org/wiki/Compiler |
| | Wikipedia (Interpreter) | https://en.wikipedia.org/wiki/Interpreter_(computing) |
| | Interpreters vs. Compilers | https://www.programiz.com/article/difference-compiler-interpreter |
|*? | Compiler vs. Interpreter, What's the Difference? | https://www.guru99.com/difference-compiler-vs-interpreter.html |
| | Wikipedia (Transpiler [Source-to-source compiler]) | https://en.wikipedia.org/wiki/Source-to-source_compiler
| | Compiling vs. Transpiling (Stack Overflow) | https://stackoverflow.com/questions/44931479/compiling-vs-transpiling |
| | What does a JIT do? (Stack Overflow) | https://stackoverflow.com/questions/95635/w hat-does-a-just-in-time-jit-compiler-do |
| | JIT Compilation Explained | https://www.freecodecamp.org/news/just-in-time-compilation-explained/ |
| | Wikpedia (JIT Compilation) | https://en.wikipedia.org/wiki/Just-in-time_compilation |
- executables and linkers
|Star| Title | Page |
|----|--------------------------------------------|------|
| | Wikipedia (Linker) | https://en.wikipedia.org/wiki/Linker_(computing) |
| | Intro to compiler, linker, and libraries (C++) | https://www.learncpp.com/cpp-tutorial/introduction-to-the-compiler-linker-and-libraries/ |
| | Differences Between Compilers and Linkers (Stack Overflow) | https://stackoverflow.com/questions/3831312/what-are-the-differences-between-a-compiler-and-a-linker |
|* | Beginner's Guide to Linkers | https://www.lurklurk.org/linkers/linkers.html |
|* | V: Compiling, Assembling, and Linking | https://www.youtube.com/watch?v=N2y6csonII4 |
| | V: How the Linker Combines Object Files | https://www.youtube.com/watch?v=oXk87NRTL1Y |
| | V: Assembler, Linker, and Loader (C) | https://www.youtube.com/watch?v=cJDRShqtTbk |
| | What is an executable file? | https://www.computerhope.com/jargon/e/execfile.htm |
| | Wikipedia (Executable) | https://en.wikipedia.org/wiki/Executable |
|* | V: What are Executables? | https://www.youtube.com/watch?v=WnqOhgI_8wA |
|* | V: What is an EXE file? | https://www.youtube.com/watch?v=r5ldP1P1Rzc |
- regular expressions?
- regular languages / grammars / language structure / automata
- terminology?
the c compilation process
- translation units
- preprocessing -> (the whole compilation process) -> object files -> linking
- c compilation model is not in favor any more, don't like compiling all these files separately
- ABIs and FFI
- should maybe be in separate article
experts / consultants:
- Bill
- NeGate
## The actual progression
- Simple expression interpreter (parse and evaluate)
- Classical compiler construction (lex -> parse -> output), semantic analysis / type checking
- motivation: complex structures! recursion! etc.
- many of these resources exist and cover different aspects of the process in different ways
- Grammars and language structure
- Types of output (interpreter vs. AOT vs. JIT, etc.)
- We can probably find resources on specific ones of these
- Modern phases (IR / SSA)
- Mention WASM?
- The terrors of the real world
- Executables, linkers, and debug info
- Also debug info
- The C ABI and FFI
- Debug info
- Codegen
- Specifically: machine code generation, of reasonable quality
- Note: not necessary for all "compilers"
- Topics: register allocation, instruction selection, instruction scheduling
- Some examples of optimization passes
- There are not a lot of resources for this. Place a public TODO here?
- Appendix:
- Grammar basics (BNF, EBNF)
- Need not go into exhaustive detail on categories of grammars
- C is not the only language
- Brief summaries and examples of different language approaches:
- LISP
- Forth
- Languages in the ML family
- This could be a whole topic maybe
## Link dump
### Books
- Engineering a Compiler:
[Well liked]
http://www.r-5.org/files/books/computers/compilers/writing/Keith_Cooper_Linda_Torczon-Engineering_a_Compiler-EN.pdf
- Compiler Design in C:
[May have a full implementation inside]
https://holub.com/goodies/compiler/compilerDesignInC.pdf
- Dragon Book:
[Potentially outdated -- mixed reviews]
http://ce.sharif.edu/courses/94-95/1/ce414-2/resources/root/Text%20Books/Compiler%20Design/Alfred%20V.%20Aho,%20Monica%20S.%20Lam,%20Ravi%20Sethi,%20Jeffrey%20D.%20Ullman-Compilers%20-%20Principles,%20Techniques,%20and%20Tools-Pearson_Addison%20Wesley%20(2006).pdf
### Webpages
- lua grammar: http://lua-users.org/wiki/LuaGrammar
- pascal railroad diagrams: https://www.cs.utexas.edu/users/novak/grammar.html
- tons of links: https://github.com/aalhour/awesome-compilers
- expression parsing examples:
- pratt parsing and recursive descent: https://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/
- dunno, not recursive descent: https://www.cs.rochester.edu/u/nelson/courses/csc_173/grammars/parsing.html
- gary bernhardt's compiler from scratch: https://www.destroyallsoftware.com/screencasts/catalog/a-compiler-from-scratch
- lambda calculus interpreter: https://justine.lol/lambda/
- chibicc (full, readable C compiler): https://github.com/rui314/chibicc
- A Compiler Writing Journey (has many pages/topics): https://github.com/DoctorWkt/acwj
#### From NeGate
- Near-Optimal Instruction Selection on DAGs: https://llvm.org/pubs/2008-CGO-DagISel.pdf
- The Design and Implementation of Gnu Compiler Generation Framework: https://www.cse.iitb.ac.in/~uday/courses/cs715-10/cs715-gcc-intro-handout.pdf
- Lecture Notes on Static Single Assignment Form: https://www.cs.cmu.edu/~rjsimmon/15411-f15/lec/10-ssa.pdf
- Simple and Efficient Construction of Static Single Assignment Form: https://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf
- LLVM Greedy Register Allocator Improving Region Split Decisions: https://llvm.org/devmtg/2018-04/slides/Yatsina-LLVM%20Greedy%20Register%20Allocator.pdf
- NULLSTONE Optimization Categories: ttp://www.nullstone.com/htmls/category.htm
## Articles that we need to write
- Codegen (needs more details)
- Debug info