Usé ambos compiladores en diferentes proyectos.

¿Cómo son diferentes en términos de procesamiento de código y generaciones de salida? Por ejemplo ambosgcc yclang tiene-O2 Opciones de optimización. ¿Funcionan de la misma manera (alto nivel) en términos de optimización del código? Hice una pequeña prueba, por ejemplo, si tengo el siguiente código:

int foo(int num) {
    if(num % 2 == 1)
        return num * num;
    else
        return num * num +1;  
}

Los siguientes son los ensamblados de salida con clang y gcc con -O2:

----gcc 5.3.0-----                              ----clang 3.8.0----
foo(int):                                       foo(int):
        movl    %edi, %edx                              movl    %edi, %eax
        shrl    $31, %edx                               shrl    $31, %eax
        leal    (%rdi,%rdx), %eax                       addl    %edi, %eax
        andl    $1, %eax                                andl    $-2, %eax
        subl    %edx, %eax                              movl    %edi, %ecx
        cmpl    $1, %eax                                subl    %eax, %ecx
        je      .L5                                     imull   %edi, %edi
        imull   %edi, %edi                              cmpl    $1, %ecx
        leal    1(%rdi), %eax                           setne   %al
        ret                                             movzbl  %al, %eax
.L5:                                                    addl    %edi, %eax
        movl    %edi, %eax                              retq
        imull   %edi, %eax
        ret

Como se puede ver, la salida tiene diferentes instrucciones. Entonces, mi pregunta es si uno de ellos tiene ventaja sobre otro en diferentes proyectos.