Where does const string store? in stack or .data?

Question

I have written a simple c code which shows below. In this code snippet I want to verify where the const string abcd stores. I first guess that it should be stored in .data section for read-only. After a test in Debian, however, things is different from what I initial guessed. By checking the assembly code which generated by gcc, I find it is placed in the stack frame of function p. But when I try it later in OSX, the string is stored in .data section again. Now I am confused by this. Is there any standard for the storing of const string?

#include<stdio.h>
char *p()
{
    char p[] = "abcd";
    return p;
}

int main()
{
    char *pp = p();
    printf("%s\n",pp);
    return 0;
}

UPDATE: rici's answer awaken me. In OSX, the initial literal is stored in .data and then moved into function's stack frame later. Thus, it becomes a local variable for this function. However, gcc in Debian handle this situation is different from OSX. In Debian, gcc directly stored literal in stack instead of moving it from .data. I'm sorry for my carelessness.

It is up to the implementation to decide where to store literals — David Heffernan, Sep 18 '14 at 16:25
You are returning a pointer to a local array which is undefined behavior anyway. — 5gon12eder, Sep 18 '14 at 16:26
And FWIW, I don't believe you when you state that the literal is stored in the stack frame. — David Heffernan, Sep 18 '14 at 16:37
Trust me, it is exactly stored in the stack frame in Debian. I found `movl $1684234849, -16(%rbp)` in the stack frame of function p. As you can see, `$1684234849` means `abcd`, and it is then moved into `-16(%rbp)`, in turn, the address of `-16(%rbp)` is returned as function's return value. — Douglas Su, Sep 18 '14 at 16:49
it's in .data if it has default value, in .bss if not in ELF. — Jason Hu, Sep 18 '14 at 17:00
This has been asked a million times, probably hyde's link is a duplicate — Marco A., Sep 18 '14 at 18:10

score 1 · Answer 1 · answered Sep 18 '14 at 17:02

1

in your case, it's located in stack. and returning the pointer to main will cause undefined behavior. but, if you have static char p[] = "abcd"; or char *p = "abcd"; they(the data) are located in .data.

answered Sep 18 '14 at 17:02

Jason Hu

6,239
1
20
41

`p` should be a pointer to const as you may not change that string literal. – edmz Sep 18 '14 at 18:12
@black .rodata is loaded with .data so i presume .rodata is kinda sub-segment of .data, at least in ELF. correct me if i am wrong. – Jason Hu Sep 18 '14 at 18:34

rici · Accepted Answer · 2014-09-18T17:48:25.217

There is a huge difference between:

const char s[] = "abcd";

and

const char* t = "abcd";

The first of these declares s to be an array object initialized from the string "abcd". s will have an address distinct from that of any other object in the program. The character string itself might be a compile-time artifact; the initialization is a copy so the character string does not need to be present at runtime if the compiler can find some other way of performing the initialization (such as a store immediate operation).

The second declaration declares t to be a pointer to a string constant. The string constant now must be present at runtime, because expressions like t+1, which are pointers inside the string, are valid. The language standard does not guarantee that every occurrence of string literals in the program is unique, nor does it guarantee that all occurrence are merged (although good compilers will try to do the second.) It does, however, guarantee that they have static lifetime.

Consequently, this is undefined behaviour, because the lifetime of the array s ends when the function returns:

const char *gimme_a_string() {
  const char s[] = "abcd";
  return s;
}

However, this is fine:

const char *gimme_a_string() {
  const char *s = "abcd";
  return s;
}

Also:

const char s[] = "abcd";
const char t[] = "abcd";
printf("%d\n", s == t);

is guaranteed to print 0, while

const char* s = "abcd";
const char* t = "abcd";
printf("%d\n", s == t);

might print either 0 or 1, depending on the implementation. (As written, it will almost certainly print 1. However, if the two declarations are in separate compilation units and lto is not enable, it is likely to print 0.)

Since the array form is initialized with a copy the non-const version is fine:

char s[] = "abcd";
s[3] = 'C';

But the char pointer version must be a const to avoid undefined behaviour.

// Will produce a warning on most compilers with compile option -Wall or equivalent
char* s = "abcd";
// *** UNDEFINED BEHAVIOUR *** Can cause random program breakage
s[3] = 'C';

Technically, the non-const declaration of s is legal (which is why the compiler only warns) because it is the attempt to modify the constant which is UB. But you should always heed compiler warnings; it is better to think of the declaration / initialization as wrong, because it is.

Where does const string store? in stack or .data?

2 Answers2