Call stack starts at bottom or top

A "local" stack, as that comment uses it, means stack implicitly declared as a local variable. I would differentiate it from the call stack by calling it an "explicit" stack.

Iterating on an explicit stack can be faster than recursion in languages that don't support recursion related optimizations such as tail recursion. Or a language may have limited stack depth.

Here is a good explanation with an example by Eric Lippert.

In addition to what Dirk said, an important use of stack frames is to save previous values of registers so that they can be restored after a function call. So, even on processors where registers are used for passing parameters, returning a value, and saving the return address, the values of those registers are saved on the stack before a function call so that they can be restored after the call. This allows one function to call another without overwriting its own parameters or forgetting its own return address.

So, calling a function B from function A on a typical "generic" system might involve the following steps:

• function A:
  • push space for the return value
  • push parameters
  • push the return address
• jump to the function B
• function B:
  • push the address of the previous stack frame
  • push values of registers that this function uses (so they can be restored)
  • push space for local variables
  • do the necessary computation
  • restore the registers
  • restore the previous stack frame
  • store the function result
  • jump to the return address
• function A:
  • pop the parameters
  • pop the return value

This is by no means the only way function calls can work (and I may have a step or two out of order), but it should give you an idea of how the stack is used to let the processor handle nested function calls.