“String”总是分配在堆上吗？

Question

In this Rust documentation , it is written that:

String is allocated on the heap.

However, when I look at the memory mapping, I see that it is allocated in the stack...

Let's consider the basic Rust source file below:

// rustc -o string_vs_str -C opt-level=0 -C debuginfo=2 main.rs

fn main() {
    let my_string: String = String::from("abc");
    let my_str: &str = "def";
    println!("{}{}", my_string, my_str);
    let my_string_str: &str = my_string.as_str();
    println!("my_string_str: {}", my_string_str);
}

Let's executed RUST-GDB on the executable, upon the following commands:

# rust-gdb --batch --command=test.gdb --args ./string_vs_str

set width 0
set height 0
set verbose off

### Set 2 breakpoints
b main.rs:6
b main.rs:8

### Start the process
r

### Display the memory mapping into the file "map.txt"
set logging redirect on
set logging file map.txt
set logging overwrite on
set logging enabled on
info proc map
set logging enabled off

### Get information about "my_string"
echo == my_string ==\n
print my_string
ptype my_string
print &my_string
print my_string.vec
c

### Get information about "my_str"
echo == my_str ==\n
print my_str
ptype my_str
print &my_str
print my_str.length
print my_str.data_ptr

The result is given below:

Breakpoint 1, main::main () at main.rs:6
6       println!("{}{}", my_string, my_str);
== my_string ==
$1 = "abc"
type = struct alloc::string::String {
  vec: alloc::vec::Vec<u8, alloc::alloc::Global>,
}
$2 = (*mut alloc::string::String) 0x7fffffffd960
$3 = Vec(size=3) = {97, 98, 99}
abcdef

Breakpoint 2, main::main () at main.rs:8
8       println!("my_string_str: {}", my_string_str);
== my_str ==
$4 = "def"
type = struct &str {
  data_ptr: *mut u8,
  length: usize,
}
$5 = (*mut &str) 0x7fffffffd978
$6 = 3
$7 = (*mut u8) 0x55555559304f

And the content of the (logged) file " map.txt " is:

process 11932
Mapped address spaces:

          Start Addr           End Addr       Size     Offset  Perms  objfile
      ...
      0x5555555a5000     0x5555555c6000    0x21000        0x0  rw-p   [heap]
      0x7ffff7d5c000     0x7ffff7d5f000     0x3000        0x0  rw-p   
      ...
      0x7ffffffde000     0x7ffffffff000    0x21000        0x0  rw-p   [stack]
  0xffffffffff600000 0xffffffffff601000     0x1000        0x0  --xp   [vsyscall]

Please note: I have removed some lines that I consider as not important.

Unless I am mistaken:

• the head starts at 0x5555555a5000 and ends at 0x5555555c6000 .
• the stack starts at 0x7ffffffde000 and ends at 0x7ffffffff000 .
• the variable my_string is allocated at 0x7fffffffd960 .
• the variable my_str is allocated at 0x7fffffffd978 .

OK. Thus, unless I am mistaken, both my_string and my_str are allocated in the stack:

VAR my_string

my_string at 0x7fffffffd960 :

$ value="7fffffffd960"  # address of my_string
$ start="7ffffffde000"  # start of the stack
$ stop="7ffffffff000"   # end of the stack
$ echo "obase=16;ibase=16;${value^^} > ${start^^}" | bc
1
$ echo "obase=16;ibase=16;${value^^} < ${stop^^}" | bc
1

Thus: 0x7ffffffde000 < &my_string < 0x7ffffffff000 => my_string is allocated in the stack.

VAR my_str

my_str.data_ptr at 0x7fffffffd978 :

$ value="7fffffffd978"  # address of my_str.data_ptr
$ start="7ffffffde000"  # start of the stack
$ stop="7ffffffff000"   # end of the stack
$ echo "obase=16;ibase=16;${value^^} > ${start^^}" | bc
1
$ echo "obase=16;ibase=16;${value^^} < ${stop^^}" | bc
1

Thus: 0x7ffffffde000 < &my_str.data_ptr < 0x7ffffffff000 => my_str.data_ptr is allocated in the stack.

my_str.length at 0x55555559304f :

$ value="55555559304f"  # adress of my_str.length
$ start="5555555a5000"  # start of the heap
$ stop="5555555c6000"   # end of the heap
$ echo "obase=16;ibase=16;${value^^} > ${start^^}" | bc
0
$ echo "obase=16;ibase=16;${value^^} < ${stop^^}" | bc
1

Thus: &my_str.length is not allocated in the stack nor it is in the heap.

Conclusion:

The structure that defines " str " is allocated in the stack.

The vector that defines the content of a "String" is also allocated in the stack.

What's wrong with this experiment?

Answer 1

The String and &str variables themselves are allocated on the stack (the length, data pointer and capacity for String ). But the data they point at is allocated on the heap for String , and at .rodata for your &str .

To see that, print my_string.vec.buf.ptr.pointer.pointer (yep, that's long) and my_str.data_ptr . You will see that the first points at the heap and the second is mapped to the executable. These are the data pointers.