Direct vs Indirect Branching

(mostly by Bard, with double-checks on prompted output)

Direct Branch:

• Target address specified directly in the instruction. This can be done as an absolute address, a relative offset from the current instruction address, or an index into a branch table.
• Faster to execute: The target address is readily available, requiring only a single memory fetch in most cases.
• Examples: Conditional jump instructions like if-then-else statements, function calls.

Indirect Branch:

• Target address stored indirectly in a register or memory location. The instruction itself only specifies the location of the address, not the address itself.
• Slower to execute: Two memory fetches are typically required – one for the instruction and another for the target address stored indirectly.
• Offers more flexibility: Allows for dynamic branching based on runtime values or data structures like switch statements and jump tables.

Jump Table

1. Structure: The jump table itself is an array of memory addresses. Each address points to a specific block of code within the program.
2. Lookup: During runtime, based on some condition or input, the program calculates an index or identifier. This index is then used to access the corresponding address stored in the jump table.
3. Branching: Finally, the program jumps to the code section located at the retrieved address. This effectively allows the program to dynamically execute different sections of code based on the chosen index or identifier.

Benefits of using jump tables:

• Speed: Compared to traditional if-else statements or large (and/or nested) switch statements, jump tables can be significantly faster for handling many branching scenarios. This is because the address lookup is often a single memory access, while comparing multiple conditions in if-else or switch statements can take more instructions.
• Flexibility: Jump tables offer flexibility in dynamically choosing target code sections based on runtime values or data structures. This is useful for implementing state machines, handling different event types, or switching algorithms based on input parameters.
• Code size: Using a jump table can sometimes reduce the overall code size compared to complex branching logic with many conditions. This is because the table itself can store the jump addresses efficiently, while the branching logic can be simplified to just looking up the corresponding address.

Common applications of jump tables:

• Switch statements: Many compilers optimize large switch statements with dense values into jump tables for improved performance.
• State machines: Jump tables are often used to implement state machines where the next state and its associated actions are determined based on the current state and input.
• Virtual function tables: In object-oriented programming, virtual function tables utilize jump tables to efficiently dispatch calls to the correct concrete method based on the actual object type at runtime.

Overall, jump tables are a powerful technique for optimizing branching logic in programs, offering improved speed, flexibility, and sometimes code size reduction. Understanding how they work can help you write more efficient and dynamic code.

==> Class Inheritance in C++ is usually implemented using jump tables. 

Branch prediction techniques aim to guess the target address of a branch instruction before it's actually executed, improving overall program performance. While direct branches are easier to predict due to their readily available target address, indirect branches pose a greater challenge but offer significant benefits in certain situations.

==> most simpler MCUs would simply provide no support for indirect branching predictions and simply stall its pipeline till resolution of the branching.