Resumen

En este post te mostraré cómo compilar código de Go a un ejecutable de 32 bits desde una computadora con procesador de 64 bits.

Para ello usaré Windows, pero igualmente aplica para Linux, solo debes saber cómo cambiar las variables de entorno.

Requisitos

Asumo que tienes una instalación de Go funcionando y que lo has agregado a la PATH. Si no:

• Cómo instalar Go en Windows
• Cómo instalar Go en Ubuntu

Descargar Go de 32 bits

Aunque ya hayas instalado Go de 64 bits y todo esté funcionando bien, debes descargar Go para 32 bits.

Ve a la página de descargas: https://golang.org/dl/ y selecciona Go para 32 bits, en formato zip. Yo elegí para Windows, si estás en otro SO elige lo que te convenga.

Ahora se va a descargar el zip. Debes extraerlo en un lugar distinto a donde tienes instalado el otro.

En mi caso, el contenido del zip está en:

D:\Go32\go

Como se ve en la captura:

Recuerda bien esa ruta.

Compilar para 64 bits

Cuando compiles para 64 bits, haz tu proceso normal. Por ejemplo:

go build

Y ya

Compilar para 32 bits

Al compilar para 32 bits, debes modificar la PATH y la GOROOT. En resumen es lo siguiente en la terminal:

SET PATH=D:\Go32\go\bin;%PATH% && SET GOROOT=D:\Go32\go\

Cambiando obviamente tus rutas. En mi caso descargué todo en D:\Go32\go y por eso lo pongo así. Sigue leyendo para más detalles.

Detalles

La variable PATH es de Windows, y la GOROOT es la que indica la raíz de Go. Como el compilador de Go para 64 bits ya está en la PATH, debemos sobrescribirlo antes de compilar.

Pero bueno, vamos poco a poco. Para modificar la PATH temporalmente ejecutamos:

set PATH=D:\Go32\go\bin;%PATH%

En este caso D:\Go32\go\bin es la ubicación de Go de 32 bits. Al final agrego también %PATH% para que se concatene y respete los otros directorios existentes en la misma.

Compilar para 64 bits de nuevo

Si después de compilar para 32 quieres compilar para 64, simplemente cierra la terminal y vuelve a abrirla. Ya que los cambios que hicimos anteriormente solo viven mientras la terminal vive.

En caso de que no quieras cerrar la terminal, cambia la PATH y la GOROOT a la instalación de 64 bits; no recomiendo mucho esto último.

Demostración

Para que veas que esto funciona, crea el siguiente archivo llamado arquitectura.go:

package main

import "fmt"

/*
Recuerda establecer a 32 bits con:

SET PATH=D:\Go32\go\bin;%PATH% && SET GOROOT=D:\Go32\go\

(Obviamente cambiando las rutas)
*/
// Código tomado de https://grokbase.com/t/gg/golang-nuts/14c1mpnz2e/go-nuts-is-code-running-on-32-bit-or-64-bit-platform
const es64Bits = uint64(^uint(0)) == ^uint64(0)

func main() {
 fmt.Println("¿Es de 64 bits?", es64Bits)
}

Eso nos dirá si es de 32 o de 64 gracias a un código que tomé prestado de la página que aparece en el comentario.

Todo lo que explico se queda resumido en la siguiente captura:

Primero compilo normalmente para 64 bits en arquitectura_64.exe. El programa imprime true.

Después cambio la PATH y compilo de nuevo ahora a uno llamado arquitectura_32.exe. El programa imprime false.

También puedes comprobarlo usando una PC de 32 bits, al intentar ejecutar el de 64 bits dirá que no es posible 😉

Otra forma de comprobar que es para 32 bits (y no sé por qué) es mirando el peso de los archivos. Los de 32 bits pesan menos:

No es un método confiable, pero es una forma rápida de comprobarlo.

Conclusión

La compilación para otras arquitecturas es una de las cosas que hacen que me guste Go.

De esta forma podemos compilar para 32 bits desde una máquina de 64 bits.

Si te preguntas, no, no es posible compilar para 64 bits desde una máquina de 32 bits.

Recuerda: puedes leer más sobre Go en mi blog.