为何GCC将数组清零的for循环转换为memset调用？

测试代码与优化输出 #

先看测试用的最简C代码：

unsigned char count[256][256];

int main()
{
    for (int i=0; i<256; ++i)
        for (int j=0; j<256; ++j)
            count[i][j] = 0;
}

-Os优化下的汇编输出 #

使用-Os（优先优化代码尺寸）时，编译器生成了rep stosd指令直接清零数组：

mov     edx, OFFSET FLAT:count
        xor     eax, eax
        mov     ecx, 16384
        mov     rdi, rdx
        rep stosd

这里rep stosd是x86架构的重复存储指令，通过16384次双字（4字节）操作，完成65536字节（256×256）数组的清零。

-O2优化下的汇编输出 #

使用-O2（优先优化性能）时，编译器则生成了memset函数调用：

mov     edx, 65536
        xor     esi, esi
        mov     edi, OFFSET FLAT:count
        call    memset

核心疑问：memset vs rep stosd，谁更快？ #

问题的核心在于：调用glibc的memset是否会比直接内联rep stosd更慢？还是说性能差异取决于memset针对不同架构的优化程度？

glibc的memset实现分析 #

你找到的glibc/string/memset.c是通用C版本（针对无特定汇编优化的架构），核心逻辑如下（已添加中文注释）：

/* Copyright (C) 1991-2024 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */
#include <string.h>
#include <memcopy.h>
#ifndef MEMSET
# define MEMSET memset
#endif
void *
inhibit_loop_to_libcall
MEMSET (void *dstpp, int c, size_t len)
{
  long int dstp = (long int) dstpp;
  if (len >= 8)
    {
      size_t xlen;
      op_t cccc;
      cccc = (unsigned char) c;
      cccc |= cccc << 8;
      cccc |= cccc << 16;
      if (OPSIZ > 4)
    /* 分两步移位避免32位长整型的编译警告 */
    cccc |= (cccc << 16) << 16;
      /* 将目标地址对齐到操作数宽度（OPSIZ）的边界 */
      while (dstp % OPSIZ != 0)
    {
      ((byte *) dstp)[0] = c;
      dstp += 1;
      len -= 1;
    }
      /* 每次迭代写入8个操作数宽度的数据，减少循环次数 */
      xlen = len / (OPSIZ * 8);
      while (xlen > 0)
    {
      ((op_t *) dstp)[0] = cccc;
      ((op_t *) dstp)[1] = cccc;
      ((op_t *) dstp)[2] = cccc;
      ((op_t *) dstp)[3] = cccc;
      ((op_t *) dstp)[4] = cccc;
      ((op_t *) dstp)[5] = cccc;
      ((op_t *) dstp)[6] = cccc;
      ((op_t *) dstp)[7] = cccc;
      dstp += 8 * OPSIZ;
      xlen -= 1;
    }
      len %= OPSIZ * 8;
      /* 每次迭代写入1个操作数宽度的数据 */
      xlen = len / OPSIZ;
      while (xlen > 0)
    {
      ((op_t *) dstp)[0] = cccc;
      dstp += OPSIZ;
      xlen -= 1;
    }
      len %= OPSIZ;
    }
  /* 处理剩余的不足操作数宽度的零散字节 */
  while (len > 0)
    {
      ((byte *) dstp)[0] = c;
      dstp += 1;
      len -= 1;
    }
  return dstpp;
}
libc_hidden_builtin_def (MEMSET)

这个实现的核心优化点：

• 先对齐目标地址，避免非对齐访问的性能损耗
• 对大块数据批量写入，减少循环迭代次数
• 仅在最后处理零散字节

而rep stosd是x86硬件级指令，现代CPU（如Intel Ice Lake、AMD Zen系列）已对其做了深度优化（Enhanced REP MOVSB/STOSB），吞吐量接近SIMD指令。

性能对比结论 #

1. 通用架构场景：如果使用上述纯C版本的memset，大块数据清零时rep stosd可能更快——它是硬件原生批量操作，没有C循环的开销。但实际中，glibc针对主流x86架构提供了汇编优化版memset，比如用SSE/AVX/AVX-512指令批量写入，这种情况下memset性能会超过rep stosd。
2. 编译器选择逻辑：-Os优先缩小代码体积，rep stosd的指令长度远短于函数调用，因此被选中；-O2优先追求性能，编译器认为调用高度优化的memset库函数，比直接生成rep stosd能获得更好的实际性能（尤其是现代CPU或有专属优化的架构上）。
3. 小块数据例外：极小块数据清零时，rep stosd可能比memset更快——省去了函数调用的栈帧开销，但你的测试是64KB的大块数据，函数调用的开销可以忽略。

内容的提问来源于stack exchange，提问作者qwr