_camlRay__aux_106:
    sub esp, 24
L111:
    mov DWORD PTR 12[esp], eax
    mov DWORD PTR 8[esp], ecx
    mov eax, DWORD PTR [eax]
    mov DWORD PTR 4[esp], eax
    movzx   eax, BYTE PTR [ebx-4]
    test   eax, eax
    je  L109
    mov DWORD PTR 0[esp], ebx
    mov ebx, DWORD PTR [ebx]
    mov eax, DWORD PTR [ecx+12]
    call    _camlRay__ray_sphere_94
L112:
    fld REAL8 PTR [eax]
    fstp    REAL8 PTR 16[esp]
    mov eax, DWORD PTR 4[esp]
    fld REAL8 PTR [eax]
    fcomp   REAL8 PTR 16[esp]
    fnstsw  ax
    and ah, 69
    dec ah
    cmp ah, 64
    jae L110
    mov eax, DWORD PTR 12[esp]
    add    esp, 24
    ret

Просто откомпилируйте что-нибудь простое на окамле и си++ — увидите в чем разница

Автор: reductor
Дата: 04.12.05

let test2 n : int = n + (n * 2)

        .globl  camlTest__test2_57
        .type   camlTest__test2_57,@function
camlTest__test2_57:
.L100:
        lea     -2(%eax, %eax, 2), %eax
        ret

int test2(int n) {
   return (n + (n * 2));
}

        .globl test2
        .type   test2, @function
test2:
        movl    4(%esp), %eax
        leal    (%eax,%eax,2), %eax
        ret

void test(int a, ...) {
        int* x = &a;
        x++;
        cout << *x;
}

int main() {
        test(5, 6);
        return 0;
}

> Does the Caml integer/pointer bit trick make arithmetics slower (with
> respect to 'pure' 32 bit arithmetics) because of some mask/shift
> intermediate operations or is it just the same ?

In principle yes, because int values are represented as tagged
(31bits) ints (with the LSB set to 1). So conversion is a shift
followed by an addition (or viceversa).

R>let test2 n : int = n + (n * 2)
R>

R>        .globl  camlTest__test2_57
R>        .type   camlTest__test2_57,@function
R>camlTest__test2_57:
R>.L100:
R>        lea     -2(%eax, %eax, 2), %eax
R>        ret

R>int test2(int n) {
R>   return (n + (n * 2));
R>}

R>        .globl test2
R>        .type   test2, @function
R>test2:
R>        movl    4(%esp), %eax
R>        leal    (%eax,%eax,2), %eax
R>        ret

let test2 n : int = n - (n / 5)

_camlTest__test2_57:
L100:
    mov ebx, eax
    mov ecx, 5
    mov eax, ebx
    sar eax, 1
    cdq
    idiv    ecx
    sal eax, 1
    sub ebx, eax
    mov eax, ebx
    ret

int __fastcall test(int n) { return n - (n / 5); }

; Оптимизация по размеру
; Function compile flags: /Ogspy
?test@@YIHH@Z PROC                  ; test, COMDAT
; _n$ = ecx
    push    esi
    mov eax, ecx ;; * 
    push    5
    cdq
    pop esi
    idiv    esi
    pop esi
    sub ecx, eax
    mov eax, ecx ;; * 
    ret 0

; оптимизация по скорости - деление на константу заменено умножением
; Function compile flags: /Ogtpy
?test@@YIHH@Z PROC                  ; test
; _n$ = ecx
    mov eax, 1717986919             ; 66666667H
    imul    ecx
    sar edx, 1
    mov eax, edx
    shr eax, 31                 ; 0000001fH
    add edx, eax
    mov eax, ecx
    sub eax, edx
    ret 0

Просто откомпилируйте что-нибудь простое на окамле и си++ — увидите в чем разница

R>void test(int a, ...) {
R>        int* x = &a;
R>        x++;
R>        cout << *x;
R>}

R>int main() {
R>        test(5, 6);
R>        return 0;
R>}

R>Вы узнать хотите или что?