Skip to content

CS 315-01 Lecture/Lab — Meeting Summary (Fall 2025)

  • Date: September 10, 2025
  • Time: 05:00 PM Pacific (US and Canada)
  • Zoom ID: 886 4953 2573

Quick Recap

The session focused on assembly language programming with emphasis on: - Function calls and returns - Return address (RA) handling - Stack management and conventions - Caller-saved vs. callee-saved registers - Defensive coding practices and debugging

Next Steps

No next steps were generated due to insufficient transcript.

Detailed Summary

1) Function Calls and Control Flow

  • The instructor introduced complex functions and the mechanics of function calls.
  • Key control registers:
  • RA (Return Address): updated to the address of the instruction following the call.
  • PC (Program Counter): updated to the target function’s entry point.
  • A function call updates both the RA and the PC to transfer control correctly.

2) Call and Return Mechanics

  • Call/return instructions manipulate the PC and rely on RA to return to the caller.
  • When a function calls another function, the original RA is overwritten.
  • To prevent incorrect returns, the callee (or caller, depending on convention) must save RA—typically on the stack—before making another call, and restore it before returning.

3) Stack Concepts in Assembly

  • The stack is used to store temporary data and track return addresses.
  • Stack space is managed via the stack pointer register (SP).
  • Allocation/deallocation:
  • Allocate stack space in multiples of 16 bytes.
  • Ensure the amount deallocated matches the amount allocated to avoid corruption.

4) Register Saving Rules and Conventions

  • Register roles commonly referenced:
  • X0: constant zero
  • X1: RA (return address)
  • X2: SP (stack pointer)
  • Calling convention distinctions:
  • Caller-saved: A0–A7, T0–T6, RA — the caller must preserve these if needed after a call.
  • Callee-saved: S0–S11, SP — the callee must preserve and restore these.
  • The session previewed storing/restoring values on the stack using memory instructions covered earlier.

5) Stack Memory and Pointer Management

  • On 64-bit systems, pointers are 8 bytes (double words).
  • Example practice:
  • Allocate 16 bytes when storing a double word to respect alignment.
  • Save and restore callee-saved registers (e.g., S0) as needed.
  • Always deallocate stack space on function exit to restore SP correctly.

6) Caller-Saved Registers and Defensive Conventions

  • Even in simple cases, follow conventions strictly to avoid subtle bugs.
  • While it may be possible to reload RA after a call, restoring it at function end is generally cleaner and avoids overhead.
  • A “Hello, World” assembly example illustrated the benefits of assuming worst-case scenarios when making library calls and preserving state.

7) Function Call Stack Management and Debugging

  • Proper RA preservation prevents infinite loops and incorrect returns.
  • A gdb walkthrough demonstrated:
  • Allocating stack space
  • Saving RA
  • Making a call
  • Restoring RA
  • Returning correctly
  • Emphasis was placed on debugging call/return paths and verifying stack adjustments.

8) Assembly Programming Basics

  • The instructor demonstrated building functions at the lowest software level:
  • Example: a function adding four numbers using three calls to a simpler add function.
  • Key practices:
  • Preserve caller-saved registers when needed.
  • Manage stack space for temporary values.
  • Maintain correct operation ordering to preserve results.
  • Upcoming topics include a code review and recursion.

9) Code Review and Stack Management

  • A structured review approach:
  • Identify function arguments and which caller-state registers need preservation.
  • Decide what to place on the stack to maintain correctness.
  • Example strategies:
  • Compute a maximum value in a loop vs. write a helper function max(a, b).
  • Use a ternary-like pattern to set up conditional moves or branches in assembly.

10) Converting to Call-Based Assembly

  • Introducing calls increases complexity due to caller-saved registers and stack preservation.
  • Recommended workflow:
  • First write correct logic without preservation concerns.
  • Then add stack management and register saves/restores.
  • Follow alignment rules (e.g., allocate in multiples of 16 bytes).
  • Students were encouraged to seek help; both June and the instructor are available.

11) Compiler Analysis and Integration

  • Compilers handle significant complexity in register allocation and calling conventions.
  • Integration guidance:
  • Start by incorporating assembly from lab exercises.
  • Add required components (e.g., a Max function).
  • Register usage should follow provided instructions; resetting registers is context-dependent.
  • The instructor noted recent repository updates and invited questions.

12) Register Allocation Mindset

  • Think through register allocation as if writing from scratch:
  • SP is used to compute where to store data; SP itself is not stored in memory.
  • Preserve SP by correctly accounting for all allocations and deallocations.
  • Administrative note: There were issues accessing Zoom recordings via SSO; this was acknowledged.

Key Takeaways

  • Always preserve RA when making nested or external calls.
  • Adhere to caller-saved and callee-saved conventions rigorously.
  • Allocate stack space in 16-byte multiples and precisely match deallocations.
  • Use gdb or similar tools to step through call/return flows and verify stack behavior.
  • Implement logic first, then add preservation to reduce complexity.