Compiler Design

  1. Runtime Environment
    1. Storage Organization
      1. Memory Layout
        1. Code Segment
          1. Static Data Segment
            1. Stack Segment
              1. Heap Segment
              2. Address Space Management
                1. Virtual Memory Considerations
                2. Activation Records
                  1. Activation Record Structure
                    1. Local Variables
                      1. Parameters
                        1. Return Address
                          1. Saved Registers
                          2. Activation Record Allocation
                            1. Variable Access Methods
                            2. Parameter Passing
                              1. Call-by-Value
                                1. Call-by-Reference
                                  1. Call-by-Name
                                    1. Call-by-Need
                                      1. Parameter Passing Implementation
                                      2. Procedure Call Implementation
                                        1. Calling Sequences
                                          1. Return Sequences
                                            1. Register Saving and Restoring
                                              1. Stack Frame Management
                                              2. Non-Local Variable Access
                                                1. Display Tables
                                                  1. Lambda Lifting
                                                    1. Closure Implementation
                                                    2. Dynamic Memory Management
                                                      1. Heap Organization
                                                        1. Memory Allocation Algorithms
                                                          1. First Fit
                                                            1. Best Fit
                                                              1. Worst Fit
                                                                1. Buddy System
                                                                2. Fragmentation Issues
                                                                  1. Garbage Collection
                                                                    1. Reference Counting
                                                                      1. Mark and Sweep
                                                                        1. Copying Collection
                                                                          1. Generational Collection
                                                                            1. Incremental Collection
                                                                              1. Concurrent Collection
                                                                            2. Exception Handling
                                                                              1. Exception Propagation
                                                                                1. Stack Unwinding
                                                                                  1. Exception Tables
                                                                                    1. Try-Catch Implementation

                                                                                  Previous

                                                                                  9. Code Generation

                                                                                  Go to top

                                                                                  Next

                                                                                  11. Advanced Compilation Topics