GoSudaGeneración de código ensamblador AMD64 para la sentencia condicional (if) de Go y análisis de las instrucciones de salto
Sentencias If en el lenguaje Go
Primero, la razón por la que elegimos Go es que, entre los lenguajes modernos, es el que tiene el ensamblador más "bonito" y, comparado incluso con lenguajes clásicos, su eficiencia sintáctica resulta abrumadora en ocasiones.
Ahora que en la lección anterior entendimos el funcionamiento de un programa sencillo en Go, comparemos Go y Assembly línea por línea.
Código fuente
Ante todo, al igual que ocurre en Go, incluso los compiladores modernos, incluido GCC, optimizan automáticamente las ramas que no tienen ningún sentido. Los compiladores de C como GCC y Clang también realizan optimizaciones muy agresivas con -O2, el estándar de la industria, por lo que la época en la que el programador difícilmente podía confiar plenamente en el compilador quedó definitivamente atrás, ya que se consolidó a finales del siglo XX.
Por tanto, solo tiene sentido, al menos, si se proporciona una condición que el compilador no pueda predecir ni reemplazar fácilmente por otra sentencia.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Si esto se sustituye por algo predecible y que permite eliminar la rama, como x = 10,
10 // el compilador optimiza el código y elimina la rama.
11 // Por tanto, para observar esto directamente en ensamblador, en C se usa -O0 u otra opción similar,
12 // o bien se hace que el compilador utilice un valor externo impredecible,
13 // como esta sección trata sobre programación moderna, no se usa el método de desactivar
14 // la optimización binaria de Go.
15 if len(os.Args) < 2 {
16 return
17 }
18 x, _ := strconv.Atoi(os.Args[1])
19
20 if x < 10 {
21 println("X is smaller than 10")
22 } else {
23 println("X is larger or same as 10")
24 }
25}
En este caso, como el compilador no puede predecir la entrada, la sentencia de rama se traduce tal cual a código máquina.
Ensamblador
1TEXT main.main(SB) /home/yjlee/introduction-to-golang/learn-golang/if-and-switch/golang-if/main.go
2 main.go:8 0x47a840 493b6610 CMPQ SP, 0x10(R14)
3 main.go:8 0x47a844 7670 JBE 0x47a8b6
4 main.go:8 0x47a846 55 PUSHQ BP
5 main.go:8 0x47a847 4889e5 MOVQ SP, BP
6 main.go:8 0x47a84a 4883ec10 SUBQ $0x10, SP
7 main.go:15 0x47a84e 48833d12fb0a0002 CMPQ os.Args+8(SB), $0x2
8 main.go:15 0x47a856 7c58 JL 0x47a8b0
9 main.go:15 0x47a858 488b0d01fb0a00 MOVQ os.Args(SB), CX
10 main.go:18 0x47a85f 488b4110 MOVQ 0x10(CX), AX
11 main.go:18 0x47a863 488b5918 MOVQ 0x18(CX), BX
12 main.go:18 0x47a867 e834e8ffff CALL strconv.Atoi(SB)
13 main.go:20 0x47a86c 4883f80a CMPQ AX, $0xa
14 main.go:20 0x47a870 7d1d JGE 0x47a88f
15 main.go:21 0x47a872 e809befbff CALL runtime.printlock(SB)
16 main.go:21 0x47a877 488d0519f50100 LEAQ 0x1f519(IP), AX
17 main.go:21 0x47a87e bb15000000 MOVL $0x15, BX
18 main.go:21 0x47a883 e878c6fbff CALL runtime.printstring(SB)
19 main.go:21 0x47a888 e853befbff CALL runtime.printunlock(SB)
20 main.go:21 0x47a88d eb1b JMP 0x47a8aa
21 main.go:23 0x47a88f e8ecbdfbff CALL runtime.printlock(SB)
22 main.go:23 0x47a894 488d05c8040200 LEAQ 0x204c8(IP), AX
23 main.go:23 0x47a89b bb1a000000 MOVL $0x1a, BX
24 main.go:23 0x47a8a0 e85bc6fbff CALL runtime.printstring(SB)
25 main.go:23 0x47a8a5 e836befbff CALL runtime.printunlock(SB)
26 main.go:25 0x47a8aa 4883c410 ADDQ $0x10, SP
27 main.go:25 0x47a8ae 5d POPQ BP
28 main.go:25 0x47a8af c3 RET
29 main.go:16 0x47a8b0 4883c410 ADDQ $0x10, SP
30 main.go:16 0x47a8b4 5d POPQ BP
31 main.go:16 0x47a8b5 c3 RET
32 main.go:8 0x47a8b6 e845f0feff CALL runtime.morestack_noctxt.abi0(SB)
33 main.go:8 0x47a8bb eb83 JMP main.main(SB)
Si se usa go tool, este indica amablemente qué sentencia corresponde a cada instrucción de ensamblador.
Como lo que aprenderemos en esta ocasión son las comparaciones y las ramas if, basta con fijarnos en algunas líneas.
Instrucciones CMPQ y JL
La instrucción CMPQ es una instrucción para comparar tipos de datos de 4 bytes (4 palabras), y su etimología es CoMPareQuadword, abreviada como CMPQ.
En la dirección de memoria 0x47a84e aparece la sentencia CMPQ os.Args+8(SB), $0x2.
En este caso, se compara el número de argumentos recibidos por el programa con el valor hexadecimal 0x2 (es decir, simplemente 2).
Después, mediante JL se realiza el salto tras la comparación, para verificar si el número de argumentos es menor que 2 (es decir, si solo está el propio programa como argumento). Es decir, esto es la abreviatura de Jump, Less than', o sea, JL.
Si en la operación de comparación anterior el número de argumentos era menor que 2, se salta a la dirección 0x47a8b0, donde se encuentra JGE.
Sin embargo, como en esta sentencia se utiliza el registro AX, es necesario conocer la identidad del valor almacenado en el registro.
Instrucción MOVQ
A continuación, hay que entender cómo se almacena la dirección inicial de los datos utilizando el registro 'CX', y cómo se pretende extraer los datos reales después de leer la dirección.
Si observamos el rango 0x47858-0x47863, esta operación se realiza por etapas.
Primero, se inserta la dirección inicial del arreglo de argumentos en el registro CX mediante la instrucción MOVQ os.Args(SB), CX. En este punto es necesario comprender el tipo string de Go.
El string de Go es una estructura, y esta estructura está compuesta por 16 bytes, formados por dos datos de 8 bytes.
| struct | 8 bytes | 8 bytes |
|---|---|---|
| string | dirección de memoria | longitud de string |
Visualmente, se representa como arriba: los primeros 8 bytes almacenan la dirección de inicio del string, y los 8 bytes siguientes almacenan la longitud del string.
Por tanto, la dirección del string se guarda en el registro AX y la longitud del string en el registro BX.
CALL
En la entrada anterior, al observar las funciones del grupo runtime, también aparecía la instrucción CALL.
Esta instrucción aparece delante de las funciones que se usan en Go, y significa llamar a una función, es decir, literalmente CALL. Después, mediante la llamada a función CALL se convierte el string en un entero, pero dónde se almacena el entero no se muestra, al estar abstraído dentro de la función.
Instrucciones CMPQ y JGE
Volviendo a la dirección anterior 0x47a86c, la instrucción está comparando la dirección del string con el número 0xa (en decimal, 10)!
Esto significa que, como el programa ya no utiliza ese argumento, se sobrescribió la posición del string para crear el lugar de la variable entera x.
Esta es la esencia de las optimizaciones agresivas que se realizan en lenguajes como Go.
Después aparece la instrucción JGE, que es la abreviatura de Jump, Greater or Equals. Por tanto, esta sentencia pregunta si el valor es mayor o igual al término de comparación.
Por tanto, no es exactamente la sentencia x < 10, sino x < 10 con ¡la dirección de la comparación invertida!
Esto se debe a que, en código máquina, saltar de antemano cuando la condición no se cumple es más intuitivo y ahorra una instrucción que realizar una comparación cuando la condición se cumple y luego verificar de nuevo si no se cumple.
Esta optimización es muy clásica, por lo que, a diferencia del ejemplo de strconv.Atoi visto antes, es un patrón que aparece con frecuencia incluso en compiladores con un nivel de optimización bastante bajo, así que conviene conocerlo.
Por tanto, aplicando este principio se puede obtener código fuente distinto que coincide al 100% a nivel de ensamblador.
Ejemplo de código espejo
Mediante el siguiente script, el script de bash genera dos fuentes que son espejo al 100%, y luego permite verificar que, al considerar solo main y excluir los metadatos que varían en cada momento, se obtiene exactamente el mismo ensamblador.
1#!/usr/bin/env bash
2
3# 1. Inicialización completa de archivos y directorios residuales previos
4echo "[1/6] Cleaning up old artifacts..."
5rm -rf test_dir main_orig main_asm orig.asm asm.asm orig_pure.asm asm_pure.asm
6mkdir -p test_dir
7
8# 2. Escritura del código fuente de la versión original (main.go)
9echo "[2/6] Generating main.go..."
10cat << 'EOF' > main.go
11package main
12
13import (
14 "os"
15 "strconv"
16)
17
18func main() {
19 if len(os.Args) < 2 {
20 return
21 }
22 x, _ := strconv.Atoi(os.Args[1])
23
24 s1 := "X is smaller than 10"
25 s2 := "X is larger or same as 10"
26
27 if x < 10 {
28 println(s1)
29 } else {
30 println(s2)
31 }
32}
33EOF
34
35# 3. Escritura del código fuente de la versión espejo (main_from_asm.go)
36# Sincronización perfectamente simétrica de la estructura de operadores para que el compilador use la misma plantilla de optimización (JGE)
37echo "[3/6] Generating main_from_asm.go..."
38cat << 'EOF' > main_from_asm.go
39package main
40
41import (
42 "os"
43 "strconv"
44)
45
46func main() {
47 if len(os.Args) < 2 {
48 return
49 }
50 x, _ := strconv.Atoi(os.Args[1])
51
52 s1 := "X is smaller than 10"
53 s2 := "X is larger or same as 10"
54
55 // 10를 기준으로 삼아 x < 10 구조를 유지하면 컴파일러는
56 // main.go와 정확히 동일한 JGE 매커니즘 및 블록 배치를 채택합니다.
57 switch {
58 case x < 10:
59 println(s1)
60 default:
61 println(s2)
62 }
63}
64EOF
65
66# 4. Compilación de cada uno en el mismo entorno de ruta de directorio y nombre de archivo
67echo "[4/6] Compiling both sources inside 'test_dir'..."
68cp main.go test_dir/main.go
69cd test_dir && go build -o ../main_orig main.go && cd ..
70rm test_dir/main.go
71
72cp main_from_asm.go test_dir/main.go
73cd test_dir && go build -o ../main_asm main.go && cd ..
74
75# 5. Extracción de la función ensamblador pura main.main mediante go tool objdump
76echo "[5/6] Extracting main.main assembly sections..."
77go tool objdump -s "main\.main" main_orig > orig.asm
78go tool objdump -s "main\.main" main_asm > asm.asm
79
80# Se eliminan las direcciones virtuales, los desplazamientos y el texto de los bytes de código máquina,
81# y se filtran solo los campos del conjunto puro de instrucciones que ejecutará la CPU (Opcode & Operands)
82awk '{print $4, $5, $6, $7}' orig.asm > orig_pure.asm
83awk '{print $4, $5, $6, $7}' asm.asm > asm_pure.asm
84
85# 6. Verificación mediante diff de la estructura de instrucciones de ambos códigos máquina
86echo "[6/6] Verifying assembly structural integrity via diff..."
87echo "------------------------------------------------------------"
88if diff orig_pure.asm asm_pure.asm > /dev/null; then
89 echo "===> [성공] 두 바이너리의 main.main 기계어 로직이 100% 일치합니다! <==="
90 echo "컴파일러의 최적화 파이프라인 가이드라인을 완벽하게 동기화하여 동일한 어셈블리를 얻었습니다."
91else
92 echo "===> [실패] 어셈블리 명령어 구조에 차이점이 발견되었습니다. <==="
93 diff -u orig_pure.asm asm_pure.asm
94fi
95echo "------------------------------------------------------------"
Al ejecutar el código en la práctica, se obtiene la siguiente información.
1[1/6] Cleaning up old artifacts...
2[2/6] Generating main.go...
3[3/6] Generating main_from_asm.go...
4[4/6] Compiling both sources inside 'test_dir'...
5[5/6] Extracting main.main assembly sections...
6[6/6] Verifying assembly structural integrity via diff...
7------------------------------------------------------------
8===> [성공] 두 바이너리의 main.main 기계어 로직이 100% 일치합니다! <===
9컴파일러의 최적화 파이프라인 가이드라인을 완벽하게 동기화하여 동일한 어셈블리를 얻었습니다.
10------------------------------------------------------------
Conclusión
Los lenguajes de programación ofrecen muchas abstracciones, pero hemos visto que tras la abstracción se esconden optimizaciones muy interesantes y agresivas. Además, aprovechando esto a la inversa, también pudimos crear código espejo con fuentes distintas pero ensamblador idéntico. Si te interesa el bajo nivel y te encuentras con software propietario escrito en Go, quizá no sea imposible desensamblarlo y analizarlo para recuperar el código fuente.
Próxima lección
En la próxima sesión veremos la sentencia If y la sentencia select-case, que también resulta muy interesante.