14
Quando si passano gli argomenti a una funzione, ho sempre pensato che passare argomenti uno per uno non sia diverso dal passarli racchiusi in un array o una struct o una tuple. Tuttavia, un semplice esperimento ha dimostrato che avevo torto.Passare i parametri uno ad uno o avvolgerli in un array, struct o tuple
Il seguente programma quando compiled with GCC:
int test(int a, int b, int c, int d) {
return a + b + c + d;
}
int test(std::array<int, 4> arr) {
return arr[0] + arr[1] + arr[2] + arr[3];
}
struct abcd {
int a; int b; int c; int d;
};
int test(abcd s) {
return s.a + s.b + s.c + s.d;
}
int test(std::tuple<int, int, int, int> tup) {
return std::get<0>(tup) + std::get<1>(tup) + std::get<2>(tup) + std::get<3>(tup);
}
... produce una varietà di uscite di montaggio:
impl_test(int, int, int, int):
lea eax, [rdi+rsi]
add eax, edx
add eax, ecx
ret
impl_test(std::array<int, 4ul>):
mov rax, rdi
sar rax, 32
add eax, edi
add eax, esi
sar rsi, 32
add eax, esi
ret
impl_test(abcd):
mov rax, rdi
sar rax, 32
add eax, edi
add eax, esi
sar rsi, 32
add eax, esi
ret
impl_test(std::tuple<int, int, int, int>):
mov eax, DWORD PTR [rdi+8]
add eax, DWORD PTR [rdi+12]
add eax, DWORD PTR [rdi+4]
add eax, DWORD PTR [rdi]
ret
main:
push rbp
push rbx
mov ecx, 4
mov edx, 3
movabs rbp, 8589934592
mov esi, 2
sub rsp, 24
mov edi, 1
movabs rbx, 17179869184
call int test<int, int, int, int>(int, int, int, int)
mov rdi, rbp
mov rsi, rbx
or rbx, 3
or rdi, 1
or rsi, 3
call int test<std::array<int, 4ul> >(std::array<int, 4ul>)
mov rdi, rbp
mov rsi, rbx
or rdi, 1
call int test<abcd>(abcd)
mov rdi, rsp
mov DWORD PTR [rsp], 4
mov DWORD PTR [rsp+4], 3
mov DWORD PTR [rsp+8], 2
mov DWORD PTR [rsp+12], 1
call int test<std::tuple<int, int, int, int> >(std::tuple<int, int, int, int>)
add rsp, 24
xor eax, eax
pop rbx
pop rbp
ret
Perché c'è una differenza?
I compilatori non possono generalmente fare quello che vogliono purché il risultato finale sia lo stesso? – AndyG
@AndyG Sì e no. Ci sono anche convenzioni di chiamata basate sia sul linguaggio che sulla piattaforma che determinano come vengono chiamate le cose. Senza tali elementi (come gli argomenti passati in registri da destra a sinistra) sarebbe impossibile collegare vari file di oggetti insieme da lingue di origine diverse e produrre codice affidabile. –
La struttura * viene * inoltrata come se i singoli membri fossero separati. Ma l'ottimizzatore (o la mancanza di) sta facendo qualcosa di strano con la conversione a 64 bit verso il basso a 32 bit. – Mysticial