# In-Class Design Exercise 3: SSA-IR Design

Design an in-memory representation (data structure) for an SSA-based IR. Think about the following aspects:

- Instructions:
  - How many result types? If one: how to handle operations with multiple result (e.g., add-with-overflow)?
  - How many operands? Can instructions have a variable number of operands?
  - How to handle constant operands?
  - How to refer to operands, esp. if instructions have multiple results?
  - How to store the instruction and operands in memory? (Hint: reduce the amount of necessary memory allocations for the common case.)
  - Think about representing other (constant) properties, e.g. load/store alignment, vector element index (e.g., for extraction), comparison predicates, .
- Basic Blocks:
  - How to store enclosed instructions?
  - How to represent phi nodes -- instructions or block arguments?
  - How to manage control flow -- store successors/predecessors? Think about efficient construction and modification.
- Memory Management: how?
- Operations on the IR: (these should be executed efficiently)
  - Replacing an instruction result with a different value or a constant
  - Inserting an instruction or phi node/block argument
  - Removing an instruction or phi node/block argument
  - Changing the operand of an instruction
  - Finding predecessors and successors of a basic block


## Variant A: Fast Compilation

The IR has a limited set of operations and types. Optimize the IR design for compilation speed, thereby focusing on efficient construction, iteration, and memory footprint.


## Variant B: Optimization

The IR has a large set of possibly complex operations and complex types, including structures and fixed-size arrays. Optimize the IR for performing analyses and transformations and support the following operations efficiently:

- Comparison of types for equality
- Moving instructions between blocks
- Iterating over all users of an instruction result