I'd like to hear why you ask as well, clementttttttttt. Could you describe the actual problem you are trying to solve?
My guess is that the real question is something along the lines, "how do I access a C-style format string (on the stack) from assembly", but that's just speculation.
We'd really need to know what the OP is trying to accomplish, rather than what they are asking about, to to have any chance of helping.
EDITFor the record: IIUC, string arguments are not stored on the stack, only pointers to the strings are (and even those might not be, depending on how the compiler optimizes the references and/or argument passing).
Constant strings (string literals and those string variables which were initialized with string literals when declared) are stored globally, usually in an
.rodata section (which the paging mechanism will usually enforce by marking the mapped pages as read-only, but that would be up to your virtual memory manager), even if they are only visible locally within a given function.
Mutable global strings which are declared as a sized
char array rather than initialized (which are fixed in size, but not in the data they contain) are in the global
.data section.
Local mutable strings - which, remember, are just
char arrays -
are stored on the stack, but the array elements, like the fields of other data structures, go 'up' as far as I can tell, so that the pointer arithmetic is consistent.
For strings whose storage space is dynamically allocated, the data would be on the heap, and has to be explicitly freed when you no longer are using it (otherwise it causes a memory leak).
In all of these cases, they grow 'up' through memory, not down, no matter how the stack grows, i.e.,
my_array[1] is always higher in memory than
my_array[0],
my_array[2] is higher still, etc.
Comments and corrections welcome.