Can I push/pop data to the GCC C return stack?

Question

In GCC C, is there a way to push/pop data to the C return stack?

I'm not talking about implementing my own stack (I know how to do that); I mean using the existing C return stack to explicitly push/pop parameters (within the same level of braces, of course).

For example, something like:

extern int bar;

void foo(void) {
  PUSH(bar);

  bar = 12;
  doSomething(); // that depends on the value of bar

  bar = POP();   // restore original value of bar
}

If there were any easy way to do this, I think it would be a cleaner alternative to using a local variable like "oldBar" explicitly.

Answer 1

if you use a temporary variable, it's basically the same thing. The temporary variable is allocated on the stack or optimized to a register.

e.g.

extern int bar;

void foo(void) {
  int tmp = bar
  bar = 12;
  doSomething(); // that depends on the value of bar
  bar = tmp;   // restore original value of bar
}

Apparently C doesn't actually require a stack structure to be used for calls, so this functionality wouldn't make sense. This is claimed in the memory layout section of this article https://www.seebs.net/c/c_tcn4e.html

Quite simply, not every compiler even has a "stack". Some systems don't really have any such feature. Every compiler for C has some kind of mechanism for handling function calls, but that doesn't mean it's a stack. More significantly, it is quite common for function parameters or local variables not to be stored on any "stack", but to be stored in CPU registers. That distinction can matter a lot, and should have been covered, rather than hand-waved away.

Technically, you could also use alloca() (located in alloca.h) to do this, but the only way to deallocate that memory is for the function call to return. It also doesn't really do what you're suggesting. alloca isn't part of the C standard either

Answer 2

If you are writing in pure C, you can use variadic argument function. It is, of course, not a full solution, as stack is cleared after a function call and argument is pushed only when you call a function. But if you need to use it as you described, it might work:

extern int bar;
void doSomething(...);
void foo(void) {
  doSomething(&bar);
  //you do not need here to pop to restore the bar value, as you push a copy of value
}

If you want to do some other actions after push (which I can't even imagine), you can use a wrapper function.

extern int bar;
void doSomething();
void doSomethingWrapper(...) {
   //here arguments that are passed in ... are pushed
   doSomething();
   //and here they are poped
}
void foo(void) {
  //....
  doSomethingWrapper(&bar);
  //....
}

If you just want to manipulate stack in a cunning way the only solution is to use inline assembly. Or you can call function void push(...) to push whatever you want and use longjmp() in body of push() to avoid popping arguments when control flow leaves the function.

Answer 3

OK, this does what I wanted:

#define PUSHINT(var) int old__##var = var
#define POPINT(var) var = old__##var

extern int bar;

void foo(void) {
  PUSHINT(bar);

  bar = 12;
  doSomething(); // that depends on the value of bar

  POPINT(bar);   // restore original value of bar
}

It would be better if I could guarantee that the "old__" prefix was unique each time, but I don't know how to do that (it's unlikely to be a problem tho).

Also it doesn't truly do a PUSH/POP (altho it does store on the return stack, at least on my hardware). You can't push one value and pop a different one.

But I didn't want to do that in the first place.

I may rename the macros to SAVE() and RESTORE()...

(Thanks to the hint from @BobbySacamano's answer.)