почему компилятор vs c++ 2010 создает другой ассемблерный код для аналогичной функции

Итак, недавно я думал о strcpy и вернулся к K&R, где они показывают реализацию как

while (*dst++ = *src++) ;

Однако я по ошибке расшифровал это как:

while (*dst = *src)
{
    src++; //technically could be ++src on these lines
    dst++; 
}

В любом случае это заставило меня задуматься о том, действительно ли компилятор будет производить другой код для этих двух. Моя первоначальная мысль заключалась в том, что они должны быть почти идентичными, поскольку src и dst увеличиваются, но никогда не используются. Я думал, что компилятор будет знать, что не нужно пытаться сохранять их как «переменные» в созданном машинном коде.

Используя windows7 с сборкой VS 2010 C++ SP1 в 32-битном режиме выпуска (/O2), я получил код дизассемблирования для обоих вышеупомянутых воплощений. Чтобы сама функция не ссылалась на ввод напрямую и не была встроена, я создал dll с каждой из функций. Я опустил пролог и эпилог произведенного ASM.

    while (*dst++ = *src++)
6EBB1003 8B 55 08             mov         edx,dword ptr [src]     
6EBB1006 8B 45 0C             mov         eax,dword ptr [dst]     
6EBB1009 2B D0                sub         edx,eax                //prepare edx so that edx + eax always points to src     
6EBB100B EB 03                jmp         docopy+10h (6EBB1010h)  
6EBB100D 8D 49 00             lea         ecx,[ecx]              //looks like align padding, never hit this line
6EBB1010 8A 0C 02             mov         cl,byte ptr [edx+eax]  //ptr [edx+ eax] points to char in src  :loop begin
6EBB1013 88 08                mov         byte ptr [eax],cl      //copy char to dst
6EBB1015 40                   inc         eax                    //inc src ptr
6EBB1016 84 C9                test        cl,cl                  // check for 0 (null terminator)
6EBB1018 75 F6                jne         docopy+10h (6EBB1010h)  //if not goto :loop begin
        ;

Выше я аннотировал код, по сути один цикл, только 1 проверка на нуль и 1 копирование в память.

Теперь давайте посмотрим на мою ошибочную версию:

    while (*dst = *src)
6EBB1003 8B 55 08             mov         edx,dword ptr [src]  
6EBB1006 8A 0A                mov         cl,byte ptr [edx]  
6EBB1008 8B 45 0C             mov         eax,dword ptr [dst]  
6EBB100B 88 08                mov         byte ptr [eax],cl       //copy 0th char to dst
6EBB100D 84 C9                test        cl,cl                   //check for 0
6EBB100F 74 0D                je          docopy+1Eh (6EBB101Eh)  // return if we encounter null terminator
6EBB1011 2B D0                sub         edx,eax  
6EBB1013 8A 4C 02 01          mov         cl,byte ptr [edx+eax+1]  //get +1th char  :loop begin
    {
        src++;
        dst++;
6EBB1017 40                   inc         eax                   
6EBB1018 88 08                mov         byte ptr [eax],cl        //copy above char to dst
6EBB101A 84 C9                test        cl,cl                    //check for 0
6EBB101C 75 F5                jne         docopy+13h (6EBB1013h)   // if not goto :loop begin
    }

В моей версии я вижу, что сначала копируется 0-й символ в место назначения, затем проверяется значение null , а затем, наконец, входит в цикл, где снова проверяется значение null. Таким образом, цикл остается в основном таким же, но теперь он обрабатывает 0-й символ перед циклом. Это, конечно, будет неоптимально по сравнению с первым случаем.

Мне интересно, знает ли кто-нибудь, почему компилятор не может создать тот же (или почти такой же) код, что и в первом примере. Является ли это конкретной проблемой компилятора ms или, возможно, с настройками моего компилятора/компоновщика?

вот полный код, 2 файла (одна функция заменяет другую).

// in first dll project
__declspec(dllexport) void docopy(const char* src, char* dst)
{
    while (*dst++ = *src++);
}

__declspec(dllexport) void docopy(const char* src, char* dst)
{
    while (*dst = *src)
    {
        ++src;
        ++dst;
    }
}


//seprate main.cpp file calls docopy
void docopy(const char* src, char* dst);
char* source ="source";
char destination[100];
int main()
{

    docopy(source, destination);
}