int i, j;

int main()
{
    return ++i + ++j;
}

Выдержка из получающегося ассемблерника для Itanium с моими комментариями

main:
{.mii
    add    r11=@gprel(j#),gp // загрузим смещения переменных i и j
    add    r10=@gprel(i#),gp
    nop.i   0 ;; // так обозначается та самая пресловутаю "точка следования" в asm :)
}
{.mmi
    ld4    r9=[r11]   // загрузим значения переменных
    ld4    r8=[r10]
    nop.i   0 ;;       // "точка следования"
}
{.mii
    add    r3=1,r9    // к каждому прибавим по 1 
    add    r2=1,r8 ;; // "точка следования", ждем завершения предыдущих операций
    add    r8=r2,r3   // складываем
}
{.mmi
    st4    [r11]=r3   // сохраняем новые значения переменных
    st4    [r10]=r2
    nop.i   0 ;;
}
{.mib
    nop.m   0                
    nop.i   0                
    br.ret.sptk.many b0 ;; // возвращаемся, в r8 - результат
}

А>>>>    f(i++) + f(i++);
А>>

B>1.9/17
B>When calling a function (whether or not the function is inline), 
B>there is a sequence point after the evaluation of all function arguments (if any) 
B>which takes place before execution of any expressions or statements in 
B>the function body...

    f(i++)

А>>    i = (++i, 0);
А>>

    i = (++i, 0)  ;
  ^         ^    ^
  1         2    3

    i = A;

А>#include <iostream>

А>int f(int i) { return i;}

А>void main()
А>{
А>    int i = 0;
А>    std::cout << f(i) << " " << f(i++) << " " << f(++i) << " " << f(i++) << std::endl;
А>}

    f(i++) + f(i++);

А>>    f(i++) + f(i++);

#include <iostream>

int f(int i) { return i;}

void main()
{
    int i = 0;
    std::cout << f(i) << " " << f(i++) << " " << f(++i) << " " << f(i++) << std::endl;
}

А>>    f(i++) + f(i++);
А>>

    i = (++i, 0);

А>>>    f(i++) + f(i++);
А>

1.9/17
When calling a function (whether or not the function is inline), 
there is a sequence point after the evaluation of all function arguments (if any) 
which takes place before execution of any expressions or statements in 
the function body...

А>#include <iostream>

А>int f(int i) { return i;}

А>void main()
А>{
А>    int i = 0;
А>    std::cout << f(i) << " " << f(i++) << " " << f(++i) << " " << f(i++) << std::endl;
А>}

А>

int predinc(int& i) { return ++i; }
int postinc(int& i) { return i++; }

....
А>    std::cout << f(i) << " " << f(postinc(i)) << " " << f(predinc(i)) << " " << f(postinc(i)) << std::endl;
....

f(++i) + f(++i)

> Это странное утверждение. Обощая можно получить, что компилятор вообще не должен генерировать работающую прогроамму

If a program contains no violations of the rules in this International Standard, a conforming implementation shall, within its resource limits, accept and correctly execute3) that program.

All side effects (1.9) of the left expression, except for the destruction of temporaries (12.2), are performed before the evaluation of the right expression.

Except where noted, the order of evaluation of operands of individual operators and subexpressions of individual expressions, and the order in which side effects take place, is unspecified.

D>Это странное утверждение. Обощая можно получить, что компилятор вообще не должен генерировать работающую прогроамму Хотелось бы чего-то более конкретного.

int fun(int *i,int *j) { return ++(*i) + ++(*j); }

D>>>Это странное утверждение. Обощая можно получить, что компилятор вообще не должен генерировать работающую прогроамму Хотелось бы чего-то более конкретного.

Ш>>int fun(int *i,int *j) { return ++(*i) + ++(*j); }
Ш>>

int i_res=++(*i); 
int j_res=++(*j);

return i_res+j_res; // Всё что мы сделали -- разбили выражение на два подвыражения.

Ш>>>int fun(int *i,int *j) { return ++(*i) + ++(*j); }
Ш>>>

Ш>int i_res=++(*i); 
Ш>int j_res=++(*j);

Ш>return i_res+j_res; // Всё что мы сделали -- разбили выражение на два подвыражения.
Ш>

i = [SP+offset i]
j = [SP+offset j]

R1 <- i     R2 <- j
R3 <- [R1]    
R3++        
i <- R3
R4 <- [R2]
R4++
j <- R4
R0 <- R3 + R4 // возвращаем значение в R0

Ш>int fun(int *i,int *j) { return ++(*i) + ++(*j); }
Ш>

fun:
{   .mmi
    alloc    r10=ar.pfs,2,0,0,0
    ld4    r9=[r32]
    nop.i    0 ;;
}
{   .mmi
    add    r8=1,r9 ;;
    st4    [r32]=r8 // записываем
    nop.i    0
}
{   .mmi
    ld4    r3=[r33] ;; // и читаем в одной группе
    add    r2=1,r3
    nop.i    0 ;;
}
{   .mib
    st4    [r33]=r2
    add    r8=r8,r2
    br.ret.sptk.many    b0 ;;
}