ZJIT: Format the term-definition table

* Using extra whitespace should not harm rendering it on github.com or docs.ruby-lang.org, but will
  make it easier for those in a text editor to read it.

1 files changed, 23 insertions, 23 deletions

diff --git a/doc/zjit.md b/doc/zjit.md
index 86a27d7119..b7a3e1827c 100644
--- a/doc/zjit.md
+++ b/doc/zjit.md
@@ -179,26 +179,26 @@ This glossary contains terms that are helpful for understanding ZJIT.
 
 Please note that some terms may appear in CRuby internals too but with different meanings.
 
-| Term | Definition |
-| ---  | -----------|
-| HIR | High-level Intermediate Representation. High-level (Ruby semantics) graph representation in static single-assignment (SSA) form |
-| LIR | Low-level Intermediate Representation. Low-level IR used in the backend for assembly generation |
-| SSA | Static Single Assignment. A form where each variable is assigned exactly once |
-| `opnd` | Operand. An operand to an IR instruction (can be register, memory, immediate, etc.) |
-| `dst` | Destination. The output operand of an instruction where the result is stored |
-| VReg | Virtual Register. A virtual register that gets lowered to physical register or memory |
-| `insn_id` | Instruction ID. An index of an instruction in a function |
-| `block_id` | The index of a basic block, which effectively acts like a pointer |
-| `branch` | Control flow edge between basic blocks in the compiled code |
-| `cb` | Code Block. Memory region for generated machine code |
-| `entry` | The starting address of compiled code for an ISEQ |
-| Patch Point | Location in generated code that can be modified later in case assumptions get invalidated |
-| Frame State | Captured state of the Ruby stack frame at a specific point for deoptimization |
-| Guard | A run-time check that ensures assumptions are still valid |
-| `invariant` | An assumption that JIT code relies on, requiring invalidation if broken |
-| Deopt | Deoptimization. Process of falling back from JIT code to interpreter |
-| Side Exit | Exit from JIT code back to interpreter |
-| Type Lattice | Hierarchy of types used for type inference and optimization |
-| Constant Folding | Optimization that evaluates constant expressions at compile time |
-| RSP | x86-64 stack pointer register used for native stack operations |
-| Register Spilling | Process of moving register values to memory when running out of physical registers |
+| Term              | Definition                                                                                                                      |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| HIR               | High-level Intermediate Representation. High-level (Ruby semantics) graph representation in static single-assignment (SSA) form |
+| LIR               | Low-level Intermediate Representation. Low-level IR used in the backend for assembly generation                                 |
+| SSA               | Static Single Assignment. A form where each variable is assigned exactly once                                                   |
+| `opnd`            | Operand. An operand to an IR instruction (can be register, memory, immediate, etc.)                                             |
+| `dst`             | Destination. The output operand of an instruction where the result is stored                                                    |
+| VReg              | Virtual Register. A virtual register that gets lowered to physical register or memory                                           |
+| `insn_id`         | Instruction ID. An index of an instruction in a function                                                                        |
+| `block_id`        | The index of a basic block, which effectively acts like a pointer                                                               |
+| `branch`          | Control flow edge between basic blocks in the compiled code                                                                     |
+| `cb`              | Code Block. Memory region for generated machine code                                                                            |
+| `entry`           | The starting address of compiled code for an ISEQ                                                                               |
+| Patch Point       | Location in generated code that can be modified later in case assumptions get invalidated                                       |
+| Frame State       | Captured state of the Ruby stack frame at a specific point for deoptimization                                                   |
+| Guard             | A run-time check that ensures assumptions are still valid                                                                       |
+| `invariant`       | An assumption that JIT code relies on, requiring invalidation if broken                                                         |
+| Deopt             | Deoptimization. Process of falling back from JIT code to interpreter                                                            |
+| Side Exit         | Exit from JIT code back to interpreter                                                                                          |
+| Type Lattice      | Hierarchy of types used for type inference and optimization                                                                     |
+| Constant Folding  | Optimization that evaluates constant expressions at compile time                                                                |
+| RSP               | x86-64 stack pointer register used for native stack operations                                                                  |
+| Register Spilling | Process of moving register values to memory when running out of physical registers                                              |