Is memory in same section always allocated contiguously?

Question

char a_1[512];
int some_variable;
char a_2[512];
main()
{
        ...
}

Here in the above program, I have declared some variables, all in bss section of the code. Considering that I have kept in mind the alignment issues, can I be sure that the memory allocated for those 3 variables will always be contiguous?

@AnttiHaapala Can you please give an example or a scenario where they wouldn't be? — Raman, Dec 21 '17 at 06:38
the scenario you provided. The C standard doesn't specify anything about contiguousness, and therefore compilers can do as they please. — Antti Haapala -- Слава Україні, Dec 21 '17 at 06:39
Assumptions in C mean that you're just shooting yourself in the foot. — Antti Haapala -- Слава Україні, Dec 21 '17 at 06:41
@AnttiHaapala what about using the same compiler? would that be guaranteed? — CIsForCookies, Dec 21 '17 at 06:44
The motivation (of hunting a bug) should go into the question. You probably need watchpoints! — Basile Starynkevitch, Dec 21 '17 at 06:58

Basile Starynkevitch · Accepted Answer · 2017-12-21T07:01:28.690

Considering that I have kept in mind the alignment issues, can I be sure that the memory allocated for those 3 variables will always be contiguous?

Certainly not. Read the C11 standard n1570, and you won't find any guarantee about that.

Different compilers are likely to order variables differently, in particular when they are optimizing. Some variables might even stay in a register, and not even have any memory location. In practice some compilers are following the order of the source, others are using some different order.

And you practically could customize (perhaps with some pain) your GCC or your Clang compiler to change that order. And this does happen in practice. For example, recent versions of the GCC kernel might be configured with some GCC plugin which could reorder variables. With GCC or Clang you might also add some variable attribute to alter that order.

BTW, if you need some specific order, you could pack the fields in some struct e.g. code:

struct {
  char a_1[512];
  int some_variable;
  char a_2[512];
} my_struct;

#define a_1 my_struct.a_1
#define some_variable my_struct.some_variable
#define a_2 my_struct.a_2

BTW, some old versions of GCC had an optional optimization pass which reordered (in some cases) fields in struct-s (but recent GCC removed that optimization pass).

In a comment (which should go into your question) you mention hunting some bug. Consider using the gdb debugger and its watchpoints (and/or valgrind). Don't forget to enable all warnings and debug info when compiling (so gcc -Wall -Wextra -g with GCC). Maybe you want also instrumentation options like -fsanitize=address etc...

Beware of undefined behavior.

Yeah thanks, I suggested valgrind already to my collegue who is doing it. — Raman, Dec 21 '17 at 06:59
This is answer is correct, but I have to note that this should only be a quick fix. Any code that depends on order of variables (even struct members) should most likely be rewritten completely. — user694733, Dec 21 '17 at 07:16

Is memory in same section always allocated contiguously?

1 Answers1