float - long c++

Entendiendo la conversión de doble a int64_t

Question

Así que tengo dos funciones, una solo int64_t de double a int64_t , la otra llama std::round :

std::int64_t my_cast(double d)
{
auto t = static_cast<std::int64_t>(d);
return t;
}
std::int64_t my_round(double d)
{
auto t = std::round(d);
return t;
}

Funcionan correctamente: cast(3.64) = 3 y round(3.64) = 4 . Pero, cuando miro la asamblea, parecen estar haciendo lo mismo. Así que me pregunto cómo obtienen resultados diferentes?

$ g++ -std=c++1y -c -O3 ./round.cpp -o ./round.o
$ objdump -dS ./round.o
./round.o: file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <_Z7my_castd>:
0: f2 48 0f 2c c0 cvttsd2si %xmm0,%rax
5: c3 retq
6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
d: 00 00 00
0000000000000010 <_Z8my_roundd>:
10: 48 83 ec 08 sub $0x8,%rsp
14: e8 00 00 00 00 callq 19 <_Z7my_castd+0x19> <========!!!
19: 48 83 c4 08 add $0x8,%rsp
1d: f2 48 0f 2c c0 cvttsd2si %xmm0,%rax
22: c3 retq
Disassembly of section .text.startup:
0000000000000030 <_GLOBAL__sub_I__Z7my_castd>:
30: 48 83 ec 08 sub $0x8,%rsp
34: bf 00 00 00 00 mov $0x0,%edi
39: e8 00 00 00 00 callq 3e <_GLOBAL__sub_I__Z7my_castd+0xe>
3e: ba 00 00 00 00 mov $0x0,%edx
43: be 00 00 00 00 mov $0x0,%esi
48: bf 00 00 00 00 mov $0x0,%edi
4d: 48 83 c4 08 add $0x8,%rsp
51: e9 00 00 00 00 jmpq 56 <_Z8my_roundd+0x46>

No estoy seguro de cuál es el propósito de ese callq en la línea 14 , pero, aun así, my_cast y my_round parecen estar simplemente haciendo un cvttsd2si que, creo, es conversión con truncamiento.

Sin embargo, las dos funciones, como mencioné anteriormente, producen valores diferentes (correctos) en la misma entrada (por ejemplo, 3.64 )

¿Que esta pasando?

Answer 1

Al volcar un archivo de objeto con objdump -d , es muy importante agregar la opción -r , que ordena a la utilidad que también vuelque las reubicaciones:

$ objdump -dr round.o
...
0000000000000010 <_Z8my_roundd>:
10: 48 83 ec 28 sub $0x28,%rsp
14: e8 00 00 00 00 callq 19 <_Z8my_roundd+0x9>
15: R_X86_64_PC32 _ZSt5roundd
19: 48 83 c4 28 add $0x28,%rsp
1d: f2 48 0f 2c c0 cvttsd2si %xmm0,%rax

Ahora, note la nueva línea que apareció. Esa es una instrucción de reubicación incorporada en el archivo objeto. Le indica al enlazador que agregue una distancia entre _Z8my_roundd+0x9 y _ZSt5roundd al valor encontrado en el desplazamiento 15.

El e8 en el desplazamiento 14 es el código de operación para la llamada relativa. Los siguientes 4 bytes deben contener el desplazamiento relativo a la IP a la función que se está llamando (la IP en el momento de la ejecución que apunta a la siguiente instrucción). Debido a que el compilador no puede conocer esa distancia, la deja llena de ceros e inserta una reubicación para que el enlazador pueda llenarla más tarde.

Al desmontar sin la opción -r , las reubicaciones se ignoran, y eso crea la ilusión de que la función _Z8my_roundd realiza una llamada en el centro de sí misma.

Answer 2

Con g ++ puede tener una vista de nivel superior de lo que está sucediendo con el conmutador -fdump-tree-optimized :

$ g++ -std=c++1y -c -O3 -fdump-tree-optimized ./round.cpp

Eso produce un archivo round.cpp.165t.optimized :

;; Function int64_t my_cast(double) (_Z7my_castd, funcdef_no=224, decl_uid=4743$
int64_t my_cast(double) (double d)
{
long int t;
<bb 2>:
t_2 = (long int) d_1(D);
return t_2;
}
;; Function int64_t my_round(double) (_Z8my_roundd, funcdef_no=225, decl_uid=47$
int64_t my_round(double) (double d)
{
double t;
int64_t _3;
<bb 2>:
t_2 = round (d_1(D));
_3 = (int64_t) t_2;
return _3;
}

Aquí las diferencias son bastante claras (y la llamada a la función de round es evidente).

Answer 3

El resultado del ensamblaje es más útil ( g++ ... -S && cat round.s ):

...
_Z7my_castd:
.LFB225:
.cfi_startproc
cvttsd2siq %xmm0, %rax
ret
.cfi_endproc
...
_Z8my_roundd:
.LFB226:
.cfi_startproc
subq $8, %rsp
.cfi_def_cfa_offset 16
call round <<< This is what callq 19 means
addq $8, %rsp
.cfi_def_cfa_offset 8
cvttsd2siq %xmm0, %rax
ret
.cfi_endproc

Como puede ver, my_round llama a std::round y luego ejecuta la instrucción cvttsd2siq . Esto se debe a que std::round(double) devuelve el double , por lo que su resultado aún debe convertirse a int64_t . Y eso es lo que hace cvttsd2siq en tus dos funciones.