编译器优化会中断代码

Question

在过去的几个小时里，我一直在尝试追踪程序中的错误，该错误仅在以发布模式运行时发生。我已经解决了所有 4 级编译器警告，并且任何地方都没有未初始化的变量（在这种情况下，这通常是我的第一个嫌疑人）。

这是一个很难解释的问题，因为我甚至不知道到底发生了什么，所以请耐心等待。

经过大量调试，我将错误的原因缩小到以下函数中的某个位置：

void CModelSubMesh::Update()
{
    ModelSubMesh::Update();
    auto bHasAlphas = (GetAlphaCount() > 0) ? true : false;
    auto bAnimated = (!m_vertexWeights.empty() || !m_weightBoneIDs.empty()) ? true : false;
    if(bHasAlphas == false && bAnimated == false)
        m_glMeshData = std::make_unique<GLMeshData>(m_vertices,m_normals,m_uvs,m_triangles);
    else
    {
        m_glmesh = GLMesh();
        auto bufVertex = OpenGL::GenerateBuffer();
        auto bufUV = OpenGL::GenerateBuffer();
        auto bufNormal = OpenGL::GenerateBuffer();
        auto bufIndices = OpenGL::GenerateBuffer();
        auto bufAlphas = 0;
        if(bHasAlphas == true)
            bufAlphas = OpenGL::GenerateBuffer();
        auto vao = OpenGL::GenerateVertexArray();
        m_glmesh.SetVertexArrayObject(vao);
        m_glmesh.SetVertexBuffer(bufVertex);
        m_glmesh.SetUVBuffer(bufUV);
        m_glmesh.SetNormalBuffer(bufNormal);
        if(bHasAlphas == true)
            m_glmesh.SetAlphaBuffer(bufAlphas);
        m_glmesh.SetIndexBuffer(bufIndices);
        m_glmesh.SetVertexCount(CUInt32(m_vertices.size()));
        auto numTriangles = CUInt32(m_triangles.size()); // CUInt32 is equivalent to static_cast<unsigned int>
        m_glmesh.SetTriangleCount(numTriangles);
        // PLACEHOLDER LINE
        OpenGL::BindVertexArray(vao);
        OpenGL::BindBuffer(bufVertex,GL_ARRAY_BUFFER);
        OpenGL::BindBufferData(CInt32(m_vertices.size()) *sizeof(glm::vec3),&m_vertices[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);
        OpenGL::EnableVertexAttribArray(SHADER_VERTEX_BUFFER_LOCATION);
        OpenGL::SetVertexAttribData(
            SHADER_VERTEX_BUFFER_LOCATION,
            3,
            GL_FLOAT,
            GL_FALSE,
            (void*)0
        );
        OpenGL::BindBuffer(bufUV,GL_ARRAY_BUFFER);
        OpenGL::BindBufferData(CInt32(m_uvs.size()) *sizeof(glm::vec2),&m_uvs[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);
        OpenGL::EnableVertexAttribArray(SHADER_UV_BUFFER_LOCATION);
        OpenGL::SetVertexAttribData(
            SHADER_UV_BUFFER_LOCATION,
            2,
            GL_FLOAT,
            GL_FALSE,
            (void*)0
        );
        OpenGL::BindBuffer(bufNormal,GL_ARRAY_BUFFER);
        OpenGL::BindBufferData(CInt32(m_normals.size()) *sizeof(glm::vec3),&m_normals[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);
        OpenGL::EnableVertexAttribArray(SHADER_NORMAL_BUFFER_LOCATION);
        OpenGL::SetVertexAttribData(
            SHADER_NORMAL_BUFFER_LOCATION,
            3,
            GL_FLOAT,
            GL_FALSE,
            (void*)0
        );
        if(!m_vertexWeights.empty())
        {
            m_bufVertWeights.bufWeights = OpenGL::GenerateBuffer();
            OpenGL::BindBuffer(m_bufVertWeights.bufWeights,GL_ARRAY_BUFFER);
            OpenGL::BindBufferData(CInt32(m_vertexWeights.size()) *sizeof(float),&m_vertexWeights[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);
            OpenGL::EnableVertexAttribArray(SHADER_BONE_WEIGHT_LOCATION);
            OpenGL::BindBuffer(m_bufVertWeights.bufWeights,GL_ARRAY_BUFFER);
            OpenGL::SetVertexAttribData(
                SHADER_BONE_WEIGHT_LOCATION,
                4,
                GL_FLOAT,
                GL_FALSE,
                (void*)0
            );
        }
        if(!m_weightBoneIDs.empty())
        {
            m_bufVertWeights.bufBoneIDs = OpenGL::GenerateBuffer();
            OpenGL::BindBuffer(m_bufVertWeights.bufBoneIDs,GL_ARRAY_BUFFER);
            OpenGL::BindBufferData(CInt32(m_weightBoneIDs.size()) *sizeof(int),&m_weightBoneIDs[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);
            OpenGL::EnableVertexAttribArray(SHADER_BONE_WEIGHT_ID_LOCATION);
            OpenGL::BindBuffer(m_bufVertWeights.bufBoneIDs,GL_ARRAY_BUFFER);
            glVertexAttribIPointer(
                SHADER_BONE_WEIGHT_ID_LOCATION,
                4,
                GL_INT,
                0,
                (void*)0
            );
        }
        if(bHasAlphas == true)
        {
            OpenGL::BindBuffer(bufAlphas,GL_ARRAY_BUFFER);
            OpenGL::BindBufferData(CInt32(m_alphas.size()) *sizeof(glm::vec2),&m_alphas[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);
            OpenGL::EnableVertexAttribArray(SHADER_USER_BUFFER1_LOCATION);
            OpenGL::SetVertexAttribData(
                SHADER_USER_BUFFER1_LOCATION,
                2,
                GL_FLOAT,
                GL_FALSE,
                (void*)0
            );
        }
        OpenGL::BindBuffer(bufIndices,GL_ELEMENT_ARRAY_BUFFER);
        OpenGL::BindBufferData(numTriangles *sizeof(unsigned int),&m_triangles[0],GL_STATIC_DRAW,GL_ELEMENT_ARRAY_BUFFER);
        OpenGL::BindVertexArray(0);
        OpenGL::BindBuffer(0,GL_ARRAY_BUFFER);
        OpenGL::BindBuffer(0,GL_ELEMENT_ARRAY_BUFFER);
    }
    ComputeTangentBasis(m_vertices,m_uvs,m_normals,m_triangles);
}

我的程序是一个图形应用程序，这段代码生成稍后渲染所需的对象缓冲区。该错误基本上会导致在满足某些条件时错误地渲染特定网格的顶点。该错误是一致的，并且每次都发生在同一个网格上。

可悲的是，我无法进一步缩小代码范围，因为这会使错误消失，并且解释每行的作用需要相当长的时间，并且在这里不太相关。我几乎可以肯定这是编译器优化的问题，因此在这种情况下，实际的错误更像是一种副作用。

使用上面的代码，错误将发生，但仅在处于发布模式时发生。有趣的部分是我标记为"占位符行"的行。

如果我将代码更改为以下 3 种变体之一，该错误将消失：

#1：

void CModelSubMesh::Update()
{
    [...]
    // PLACEHOLDER LINE
    std::cout<<numTriangles<<std::endl;
    [...]
}

#2：

#pragma optimize( "", off )
void CModelSubMesh::Update()
{
    [...] // No changes to the code
}
#pragma optimize( "", on ) 

#3：

static void test()
{
    auto *f = new float; // Do something to make sure the compiler doesn't optimize this function away; Doesn't matter what
    delete f;
}
void CModelSubMesh::Update()
{
    [...]
    // PLACEHOLDER LINE
    test()
    [...]
}

特别是变体 #2 表示正在优化一些不应该优化的东西。

我不希望任何人神奇地知道问题的根源是什么，因为这需要更深入的代码知识。但是，也许对编译器优化过程有更好了解的人可以给我一些提示，这里会发生什么？

由于几乎对代码的任何更改都会消除错误，我只是不确定我能做些什么来真正找到它的原因。

Answer 1

大多数情况下，当我遇到在调试中有效但在发布中不起作用的东西时，它是一个未初始化的变量。大多数编译器初始化变量以在调试版本中0x00，但是当优化打开时，您将失去这些变量。

这可以解释为什么修改程序会改变行为：通过调整应用程序的内存映射，您最终会得到一些随机的不同未初始化内存块，以某种方式掩盖了问题。

如果您保持良好的内存管理卫生，您可能会使用 valgrind 等工具快速发现问题。从长远来看，您可能希望考虑利用自动检测内存滥用的内存管理框架（请参阅Ogre MemoryTracker，TCMalloc，Clang Memory Sanitizer）。