OP의 수정 사항과 동기화되도록 업데이트되었습니다.

코드를 수정하여 GCC가 첫 번째 사례를 최적화하는 방법을 확인했습니다.

왜 그렇게 다른지 이해하기 전에 먼저 GCC가 어떻게 최적화하는지 이해해야합니다 fast_trunc_one().

믿거 나 말거나 다음과 같이 fast_trunc_one()최적화하고 있습니다.

int fast_trunc_one(int i) {
    int mantissa, exponent;

    mantissa = (i & 0x07fffff) | 0x800000;
    exponent = 150 - ((i >> 23) & 0xff);

    if (exponent < 0) {
        return (mantissa << -exponent);             /* diff */
    } else {
        return (mantissa >> exponent);              /* diff */
    }
}

이것은 원래 fast_trunc_one()레지스터 이름과 모든 것과 정확히 동일한 어셈블리를 생성합니다 .

xor에 대한 어셈블리 가 없습니다 fast_trunc_one(). 그게 나를 위해 줬어.

어떻게 요?

1 단계: sign = -sign

먼저 sign변수를 살펴 보겠습니다 . 이후로 sign = i & 0x80000000;가능한 값은 두 가지뿐입니다 sign.

• sign = 0
• sign = 0x80000000

이제 두 경우 모두 sign == -sign. 따라서 원래 코드를 다음과 같이 변경하면

int fast_trunc_one(int i) {
    int mantissa, exponent, sign, r;

    mantissa = (i & 0x07fffff) | 0x800000;
    exponent = 150 - ((i >> 23) & 0xff);
    sign = i & 0x80000000;

    if (exponent < 0) {
        r = mantissa << -exponent;
    } else {
        r = mantissa >> exponent;
    }

    return (r ^ sign) + sign;
}

원본과 정확히 동일한 어셈블리를 생성합니다 fast_trunc_one(). 어셈블리를 아끼지 않겠지 만 등록 이름과 모두 동일합니다.

2 단계 : 수학 축소 :x + (y ^ x) = y

sign0또는 두 값 중 하나만 사용할 수 있습니다 0x80000000.

• 때 x = 0, 다음 x + (y ^ x) = y다음 사소한 보유.
• 추가 및 조정 기준 0x80000000은 동일합니다. 부호 비트를 뒤집습니다. 따라서 x + (y ^ x) = y때도 보유 x = 0x80000000합니다.

따라서로 x + (y ^ x)줄어 듭니다 y. 코드는 다음과 같이 단순화됩니다.

int fast_trunc_one(int i) {
    int mantissa, exponent, sign, r;

    mantissa = (i & 0x07fffff) | 0x800000;
    exponent = 150 - ((i >> 23) & 0xff);
    sign = i & 0x80000000;

    if (exponent < 0) {
        r = (mantissa << -exponent);
    } else {
        r = (mantissa >> exponent);
    }

    return r;
}

다시, 이것은 정확히 동일한 어셈블리 (레지스터 이름과 모두)로 컴파일됩니다.

위의 버전은 마침내 다음과 같이 줄어 듭니다.

int fast_trunc_one(int i) {
    int mantissa, exponent;

    mantissa = (i & 0x07fffff) | 0x800000;
    exponent = 150 - ((i >> 23) & 0xff);

    if (exponent < 0) {
        return (mantissa << -exponent);             /* diff */
    } else {
        return (mantissa >> exponent);              /* diff */
    }
}

GCC가 어셈블리에서 생성하는 것과 거의 똑같습니다.

그렇다면 컴파일러가 왜 fast_trunc_two()같은 것을 최적화하지 않습니까?

핵심 부분 fast_trunc_one()은 x + (y ^ x) = y최적화입니다. 에서 표현 분기에 분할되고있다.fast_trunc_two()x + (y ^ x)

나는이 최적화를하지 않기 위해 GCC를 혼동하기에 충분하다고 생각합니다. ( ^ -sign지점 밖으로 들어 올려 r + sign마지막에 병합해야 합니다.)

예를 들어, 다음과 같은 어셈블리를 생성합니다 fast_trunc_one().

int fast_trunc_two(int i) {
    int mantissa, exponent, sign, r;

    mantissa = (i & 0x07fffff) | 0x800000;
    exponent = 150 - ((i >> 23) & 0xff);
    sign = i & 0x80000000;

    if (exponent < 0) {
        r = ((mantissa << -exponent) ^ -sign) + sign;             /* diff */
    } else {
        r = ((mantissa >> exponent) ^ -sign) + sign;              /* diff */
    }

    return r;                                     /* diff */
}

답변

if (exponent < 0) {
  r = mantissa << -exponent;                       /* diff */
} else {
  r = mantissa >> exponent;                        /* diff */
}
return (r ^ -sign) + sign;                           /* diff */

if (exponent < 0) {
  return((mantissa << -exponent)^-sign)+sign;
} else {
  return((mantissa << -exponent)^-sign)+sign;
}

for(ra=0;ra<20;ra++) dummy(ra);

_fast_trunc_two:                        ## @fast_trunc_one
        movl    %edi, %edx
        andl    $-2147483648, %edx      ## imm = 0xFFFFFFFF80000000
        movl    %edi, %esi
        andl    $8388607, %esi          ## imm = 0x7FFFFF
        orl     $8388608, %esi          ## imm = 0x800000
        shrl    $23, %edi
        movzbl  %dil, %eax
        movl    $150, %ecx
        subl    %eax, %ecx
        js      LBB0_1
        shrl    %cl, %esi
        jmp     LBB0_3
LBB0_1:                                 ## %if.then
        negl    %ecx
        shll    %cl, %esi
LBB0_3:                                 ## %if.end
        movl    %edx, %eax
        negl    %eax
        xorl    %esi, %eax
        addl    %edx, %eax
        ret

fast_trunc_one:
        movl      %edi, %ecx
        shrl      $23, %ecx
        movl      %edi, %eax
        movzbl    %cl, %edx
        andl      $8388607, %eax
        negl      %edx
        orl       $8388608, %eax
        addl      $150, %edx
        movl      %eax, %esi
        movl      %edx, %ecx
        andl      $-2147483648, %edi
        negl      %ecx
        movl      %edi, %r8d
        shll      %cl, %esi
        negl      %r8d
        movl      %edx, %ecx
        shrl      %cl, %eax
        testl     %edx, %edx
        cmovl     %esi, %eax
        xorl      %r8d, %eax
        addl      %edi, %eax
        ret                         

fast_trunc_one:
    movl %edi,%r9d
    sarl $23,%r9d
    movzbl %r9b,%r9d
    addl $-150,%r9d
    movl %edi,%eax
    movl %r9d,%r8d
    andl $8388607,%eax
    negl %r8d
    orl $8388608,%eax
    testl %r8d,%r8d
    jl .LBB2_fast_trunc_one
    movl %r8d,%ecx
    movl %eax,%edx
    sarl %cl,%edx
.Lt_0_1538:
    andl $-2147483648,%edi
    movl %edi,%eax
    negl %eax
    xorl %edx,%eax
    addl %edi,%eax
    ret
    .p2align 5,,31
.LBB2_fast_trunc_one:
    movl %r9d,%ecx
    movl %eax,%edx
    shll %cl,%edx
    jmp .Lt_0_1538