将字符串文字分配给char数组，字符串文字如何复制到堆栈中？

Question

I understand when you do char array[] = "string", the string literal "string" gets copied from the data segment to the stack. Is the string literal copied over character by character? Or the compiler gets the start and end address of the string literal and copies the entire string to the stack at one time?

thanks

Answer 1

The compiler does anything it “wants” to do, as long as the observed result is the same. Sometimes there is no copy at all.

The C standard does not specify how the copy is done, so the C implementation is free to achieve the result by any means. The only requirement the C standard imposes is that the observable results (such as text written to standard output) must be as defined.

When engineers are designing a C implementation to be high quality, they will spend some time considering the best ways to copy a string in such a situation, and they will seek to design a compiler that chooses the best way in each situation. A short string might be built in place by using “move immediate value” instructions. A long string might be copied by a call to memcpy . An intermediate string might be copied by an inlined call to memcpy , effectively a few instructions that move several bytes each.

When engineers are designing a cheap C implementation, something that just gets the job done so that code can be ported to machine but does not need to be fast, they will do whatever is easiest for them.

Sometimes a compiler will not copy the string at all: If the compiler can tell that you do not need a copy, there is no reason to make a copy. For example, if the compiler sees that you merely pass the string to printf and do not modify it at all, then the compiler get the same result without making a copy by passing the original to printf .

Answer 2

I'm not sure what you mean by your distinction between "character by character" and "entire string" copying methods. A string is typically not a machine-level entity, which means that there's no possibility of it being copied as "entire string". How do you expect this to happen?

String will always be copied "character by character", at least conceptually. Now, when it comes to copying extended memory regions, the copying process can be optimized by the compiler through performing word-by-word (instead of byte-by-byte) copying whenever possible. A similar optimization might be implemented at the processor micro-architecture level.

But anyway, in general case the copying is implemented as an iterative process, not as some atomic operation on the "entire string".

On top of that, a smart compiler might realize that in some cases the copying is not necessary at all. For example, if your code does not modify the array object and does not rely on its address identity, the compiler might simply decide to use the original string literal directly, without doing any copying at all (ie basically quietly replace your char array[] = "string" with const char *array = "string" )

Answer 3

There's no reason to think there's a copy at all.

Take the following code for example.

int main() {
  char c[] = "hi";
}

For me this produces (unoptimized) assembly:

main:
    pushq   %rbp
    movq    %rsp, %rbp
    movw    $26984, -16(%rbp)
    movb    $0, -14(%rbp)
    movl    $0, %eax
    popq    %rbp
    ret

The array's memory is initialized by setting it to the value 26984. This value happens to be represented by two bytes 0x68 and 0x69, which are the ascii values of 'h' and 'i'. There is no data segment representation of the string at all, and the array is not initialized by copying anything into it character-by-character, or by any other clever method of copying.

Of course this is only one compiler's implementation (g++ 4.8) and other compilers can do whatever they want so long as the conform to the language specification.

Answer 4

This depends on the compiler and target architecture.

There could be very simple target architectures, like microcontrollers, which don't have instructions to support copying blocks of memory. There probably exist very simple compilers designed for teaching, which generate byte-by-byte copying even on architectures which support more effective methods.

However, you can assume that production-level compilers would do the reasonable thing and produce the fastest code possible for most popular architectures in this case, and you don't really need to worry about it.

Still, the best way to check would be to read the assembly the compiler generates.

Take this test code (stack_array_init.c):

#include <stdio.h>

int
main()
{
    char a[]="Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed\n"
             "do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n";

    printf("%s", a);

    return 0;
}

And compile it into assembly with gcc with optimization for size (to have less to read), like this:

gcc -Os -S stack_array_init.c

Here is the output for x86-64:

        .file   "stack_array_init.c"
        .section        .rodata.str1.1,"aMS",@progbits,1
.LC1:
        .string "%s"
.LC0:
        .string "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed\ndo eiusmod tempor incididunt ut labore et dolore magna aliqua.\n"
        .section        .text.startup,"ax",@progbits
        .globl  main
        .type   main, @function
main:
.LFB0:
        .cfi_startproc
        subq    $136, %rsp
        .cfi_def_cfa_offset 144
        movl    $.LC0, %esi
        movl    $126, %ecx
        leaq    2(%rsp), %rdi
        xorl    %eax, %eax
        rep movsb
        leaq    2(%rsp), %rsi
        movl    $.LC1, %edi
        call    printf
        xorl    %eax, %eax
        addq    $136, %rsp
        .cfi_def_cfa_offset 8
        ret
        .cfi_endproc
.LFE0:
        .size   main, .-main
        .ident  "GCC: (Debian 4.7.2-5) 4.7.2"
        .section        .note.GNU-stack,"",@progbits

Here, "rep movsb" is the instruction which copies the string to the stack.

Here is an excerpt from an ARMv4 assembly (which might be easier to read):

main:
    @ Function supports interworking.
    @ args = 0, pretend = 0, frame = 128
    @ frame_needed = 0, uses_anonymous_args = 0
    str lr, [sp, #-4]!
    sub sp, sp, #132
    mov r2, #126
    ldr r1, .L2
    mov r0, sp
    bl  memcpy
    mov r1, sp
    ldr r0, .L2+4
    bl  printf
    mov r0, #0
    add sp, sp, #132
    ldr lr, [sp], #4
    bx  lr
.L3:
    .align  2
.L2:
    .word   .LC0
    .word   .LC1
    .size   main, .-main
    .section    .rodata.str1.4,"aMS",%progbits,1
    .align  2
.LC1:
    .ascii  "%s\000"
    .space  1
.LC0:
    .ascii  "Lorem ipsum dolor sit amet, consectetur adipisicing"
    .ascii  " elit, sed\012do eiusmod tempor incididunt ut labor"
    .ascii  "e et dolore magna aliqua.\012\000"
    .ident  "GCC: (Debian 4.6.3-14) 4.6.3"
    .section    .note.GNU-stack,"",%progbits

To my understanding of ARM assembly, this looks like the code is calling memcpy to copy the string into the stack array. Although this doesn't show the assembly for memcpy, I would expect it to use one of the fastest methods available.