编译器在添加字符时停止优化未使用的字符串

Question

我很好奇为什么下面的代码：

#include <string>
int main()
{
    std::string a = "ABCDEFGHIJKLMNO";
}

当使用-O3编译时，生成以下代码：

main:                                   # @main
    xor     eax, eax
    ret

#include <string>
int main()
{
    std::string a = "ABCDEFGHIJKLMNOP"; // <-- !!! One Extra P 
}

main:                                   # @main
        push    rbx
        sub     rsp, 48
        lea     rbx, [rsp + 32]
        mov     qword ptr [rsp + 16], rbx
        mov     qword ptr [rsp + 8], 16
        lea     rdi, [rsp + 16]
        lea     rsi, [rsp + 8]
        xor     edx, edx
        call    std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_create(unsigned long&, unsigned long)
        mov     qword ptr [rsp + 16], rax
        mov     rcx, qword ptr [rsp + 8]
        mov     qword ptr [rsp + 32], rcx
        movups  xmm0, xmmword ptr [rip + .L.str]
        movups  xmmword ptr [rax], xmm0
        mov     qword ptr [rsp + 24], rcx
        mov     rax, qword ptr [rsp + 16]
        mov     byte ptr [rax + rcx], 0
        mov     rdi, qword ptr [rsp + 16]
        cmp     rdi, rbx
        je      .LBB0_3
        call    operator delete(void*)
.LBB0_3:
        xor     eax, eax
        add     rsp, 48
        pop     rbx
        ret
        mov     rdi, rax
        call    _Unwind_Resume
.L.str:
        .asciz  "ABCDEFGHIJKLMNOP"

当使用相同的-o3编译时。我不明白为什么它不能识别A仍未使用，而不管字符串长了一个字节。

这个问题与GCC9.1和CLANG8.0（在线:https://gcc.godbolt.org/z/p1z8ns)相关，因为在我看来，其他编译器要么完全删除未使用的变量(ellcc)，要么为其生成代码，而不管字符串的长度如何。

Answer 1

这是由于小字符串优化。当字符串数据小于或等于16个字符（包括空结束符）时，它将存储在std::string对象本身的本地缓冲区中。否则，它在堆上分配内存并将数据存储在那里。

第一个字符串“abcdefghijklmno”加上空结束符的大小正好是16。添加“p”使其超出缓冲区，因此在内部调用new，不可避免地导致系统调用。如果有可能确保没有副作用，编译器可以优化一些内容。一个系统调用可能使它不可能做到这一点-通过约束，改变构建中的对象的本地缓冲区允许这样的副作用分析。

在libstdc++++9.1版中跟踪本地缓冲区可以显示bits/basic_string.h:

template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
   // ...

  enum { _S_local_capacity = 15 / sizeof(_CharT) };

  union
    {
      _CharT           _M_local_buf[_S_local_capacity + 1];
      size_type        _M_allocated_capacity;
    };
   // ...
 };

void _M_construct(_InIterator __beg, _InIterator __end, ...)
{
  size_type __len = 0;
  size_type __capacity = size_type(_S_local_capacity);

  while (__beg != __end && __len < __capacity)
  {
    _M_data()[__len++] = *__beg;
    ++__beg;
  }

  while (__beg != __end)
  {
    if (__len == __capacity)
      {
        // Allocate more space.
        __capacity = __len + 1;
        pointer __another = _M_create(__capacity, __len);
        this->_S_copy(__another, _M_data(), __len);
        _M_dispose();
        _M_data(__another);
        _M_capacity(__capacity);
      }
    _M_data()[__len++] = *__beg;
    ++__beg;
  }

顺便说一句，小字符串优化本身就是一个相当重要的话题。为了了解调整单个部分如何在大范围内产生影响，我推荐这个讲座。它还提到了gcc(libstdc++)附带的std::string实现是如何工作的，并在过去进行了更改，以匹配标准的新版本。