Why does a C/C++ compiler need know the size of an array at compile time?

by

To understand why variably-sized arrays are more complicated to implement, you need to know a little about how automatic storage duration (“local”) variables are usually implemented.

Local variables tend to be stored on the runtime stack. The stack is basically a large array of memory, which is sequentially allocated to local variables and with a single index pointing to the current “high water mark”. This index is the stack pointer.

When a function is entered, the stack pointer is moved in one direction to allocate memory on the stack for local variables; when the function exits, the stack pointer is moved back in the other direction, to deallocate them.

This means that the actual location of local variables in memory is defined only with reference to the value of the stack pointer at function entry1. The code in a function must access local variables via an offset from the stack pointer. The exact offsets to be used depend upon the size of the local variables.

Now, when all the local variables have a size that is fixed at compile-time, these offsets from the stack pointer are also fixed – so they can be coded directly into the instructions that the compiler emits. For example, in this function:

void foo(void)
{
    int a;
    char b[10];
    int c;

a might be accessed as STACK_POINTER + 0, b might be accessed as STACK_POINTER + 4, and c might be accessed as STACK_POINTER + 14.

However, when you introduce a variably-sized array, these offsets can no longer be computed at compile-time; some of them will vary depending upon the size that the array has on this invocation of the function. This makes things significantly more complicated for compiler writers, because they must now write code that accesses STACK_POINTER + N – and since N itself varies, it must also be stored somewhere. Often this means doing two accesses – one to STACK_POINTER + <constant> to load N, then another to load or store the actual local variable of interest.

1. In fact, “the value of the stack pointer at function entry” is such a useful value to have around, that it has a name of its own – the frame pointer – and many CPUs provide a separate register dedicated to storing the frame pointer. In practice, it is usually the frame pointer from which the location of local variables is calculated, rather than the stack pointer itself.

More Related Contents:

  1. How to get the CPU cycle count in x86_64 from C++?
  2. What are the main purposes of using std::forward and which problems it solves?
  3. How to initialize private static members in C++?
  4. What are access specifiers? Should I inherit with private, protected or public?
  5. How do I print UTF-8 from c++ console application on Windows
  6. Compiling multithread code with g++
  7. In C/C++ what’s the simplest way to reverse the order of bits in a byte?
  8. What is shared_ptr’s aliasing constructor for?
  9. Effective C++ Item 23 Prefer non-member non-friend functions to member functions
  10. Bjarne Stroustrup says we must avoid linked lists
  11. How to choose between map and unordered_map?
  12. Converting from signed char to unsigned char and back again?
  13. The usage of anonymous enums
  14. Differentiate between function overloading and function overriding
  15. Is there a way to automatically avoiding stepping into certain functions in Visual Studio?
  16. does (w)ifstream support different encodings
  17. How to do serialization of Class having members of custom data types in C++? [closed]
  18. Does std::mt19937 require warmup?
  19. std::string length() and size() member functions
  20. What is value of EOF and ‘\0’ in C
  21. Is reinterpret_cast type punning actually undefined behavior?
  22. Read into std::string using scanf
  23. Header file included only once in entire program?
  24. Hooking DirectX EndScene from an injected DLL
  25. Understanding region of interest in openCV 2.4
  26. Template assignment operator overloading mystery
  27. Scope and return values in C++
  28. Duplicate const qualifier allowed in C but not in C++?
  29. Sorry, unimplemented: 64 bit mode not compiled in
  30. Find available network interfaces in C/C++? [closed]

Leave a Comment