int c(int *d, int *e) {int r;d[0] += 1;r = e[0];d[1] += 1;return r;
}

00000000 <c>:0:   4603        mov r3, r02:   c805        ldmia   r0, {r0, r2}4:   3001        adds    r0, #16:   3201        adds    r2, #18:   6018        str r0, [r3, #0]a:   6808        ldr r0, [r1, #0]c:   605a        str r2, [r3, #4]e:   4770        bx  lr

int c(int *d, int *e) {int r;d[0] += 1;r = e[0];asm volatile("" ::: "memory");d[1] += 1;return r;
}

00000000 <c>:0:   6802        ldr r2, [r0, #0]2:   4603        mov r3, r04:   3201        adds    r2, #16:   6002        str r2, [r0, #0]8:   6808        ldr r0, [r1, #0]a:   685a        ldr r2, [r3, #4]c:   3201        adds    r2, #1e:   605a        str r2, [r3, #4]10:   4770        bx  lr12:   bf00        nop

This sequence is a compiler memory access scheduling barrier, as noted in the article referenced by Udo. This one is GCC specific - other compilers have other ways of describing them, some of them with more explicit (and less esoteric) statements.

__asm__ is a gcc extension of permitting assembly language statements to be entered nested within your C code - used here for its property of being able to specify side effects that prevent the compiler from performing certain types of optimisations (which in this case might end up generating incorrect code).

__volatile__ is required to ensure that the asm statement itself is not reordered with any other volatile accesses any (a guarantee in the C language).

memory is an instruction to GCC that (sort of) says that the inline asm sequence has side effects on global memory, and hence not just effects on local variables need to be taken into account.