Re: Segments

On 17/01/2025 04:52, Keith Thompson wrote:

antispam@fricas.org (Waldek Hebisch) writes:
[...]

Well, AFAICS VLA-s may get allocated on function entry.

[...]
 That would rarely be possible for objects with automatic storage
duration (local variables).  For example:
      void func(void) {
         do_this();
         do_that();
         int vla[rand() % 10 + 1];
     }
 Memory for `vla` can't be allocated until its size is known,
and it can't be known until the definition is reached.  For most
automatically allocated objects, the lifetime begins when execution
reaches the `{` of the enclosing block; the lifetime of `vla`
begins at its definition.
 Or did you have something else in mind?

I'm guessing he was thinking of something like :
void func(int n) {
if (n < 1000) {
int vla[n];
do_stuff(vla);
} else {
int * p = malloc(n * sizeof(int));
do_stuff(p);
free(p);
}
}
Although the lifetime of vla[n] is limited to the block that is in that one branch, the compiler could certainly handle the allocation with a single stack-pointer change at the entry to the function.  It is common for optimised code to try to have just one stack frame allocation at code entry, and a deallocation at exit, rather than re-arranging the stack within blocks of code.  But it is not common to do so when the sizes are not known at compile time and the VLA (or alloca) is not on all paths - precisely because the programmer might be doing such checks.

 (Should this part of the discussion migrate to comp.lang.c, or is it
still sufficiently relevant to computer architecture?)
 

Some of the "arch" folks here have compared to other languages, which is nice.  But if regulars here think the thread branch has become too bogged down in details of C, we can stop.