¿Qué es un zig compilation target triple?

En Zig, la compilación se realiza sobre un target triple, una cadena que describe la arquitectura, el sistema operativo y el vendor de destino. Este identificador es fundamental porque le dice al compilador qué código de máquina generar, cómo manejar la llamada al sistema y qué biblioteca estándar usar.

Componentes de un target triple

• Arch – La arquitectura del procesador (p.ej. x86_64, aarch64, armv7).
• Vendor – El fabricante de la plataforma, a veces omitido en Zig (por convención se suele usar unknown).
• OS – El sistema operativo objetivo (p.ej. linux, windows, macos, freestanding).
• ABI – (opcional) La Application Binary Interface, que determina la convención de llamada y el layout de la pila.

Un triple típico en Zig se ve así:

x86_64-unknown-linux-gnu

Donde:

• x86_64 → arquitectura de 64 bits de Intel/AMD.
• unknown → vendor genérico.
• linux → sistema operativo Linux.
• gnu → ABI estándar de GNU.

Cómo se especifica el target en Zig

El target triple se puede indicar de tres maneras principales:

1. Por línea de comandos con la opción -target.
2. En un build.zig usando el objeto Build.
3. Como argumento dentro de la propia fuente con @import("std").build.target (menos común).

Ejemplo 1: Compilación desde la línea de comandos

Supongamos que tenemos un archivo hello.zig con el siguiente contenido:

// hello.zig
// Importamos el módulo estándar de Zig.
const std = @import("std");

// Definimos la función principal del programa.
pub fn main() !void {
    // Imprimimos un mensaje en la consola.
    std.debug.print("¡Hola, mundo!\n", .{});
}

Para compilarlo para una máquina x86_64 con Linux, usaríamos:

zig build-exe -target x86_64-unknown-linux-gnu hello.zig

Explicación línea por línea de la compilación:

• zig – Invoca el ejecutable del compilador Zig.
• build-exe – Indica que queremos compilar un ejecutable.
• -target x86_64-unknown-linux-gnu – Especifica el triple de destino.
• hello.zig – Archivo fuente que se compila.

El resultado es un binario hello que puede ejecutarse en cualquier máquina con arquitectura x86_64 y sistema operativo Linux.

Ejemplo 2: Configuración desde build.zig

Cuando el proyecto crece, se suele usar un archivo build.zig para gestionar dependencias y configuraciones. Aquí vemos cómo definir el target triple allí.

// build.zig
const std = @import("std");

pub fn build(b: *std.build.Builder) void {
    // Creamos una nueva proyecto con nombre "hello".
    const exe = b.addExecutable("hello", "src/main.zig");

    // Especificamos el triple de destino.
    exe.setTarget(std.Target{
        .arch = .x86_64, // Arquitectura de 64 bits.
        .os = .linux,    // Sistema operativo Linux.
        .abi = .gnu,     // ABI estándar de GNU.
    });

    // Añadimos la configuración de lanzamiento (ReleaseFast, por ejemplo).
    exe.setBuildMode(.ReleaseFast);

    // Definimos el punto de entrada y el directorio de salida.
    exe.install();
}

En este fragmento, cada línea se comenta para que los novatos comprendan qué hace:

• const std = @import("std"); – Importa el módulo estándar de Zig, que contiene las utilidades de construcción.
• pub fn build(b: *std.build.Builder) void { ... } – Función de entrada que el comando zig build invoca para preparar la construcción.
• const exe = b.addExecutable("hello", "src/main.zig"); – Crea una regla de construcción para el ejecutable hello usando el archivo fuente src/main.zig.
• exe.setTarget(...); – Define explícitamente el triple de destino con los campos correspondientes.
• exe.setBuildMode(.ReleaseFast); – Configura el modo de compilación (optimización, depuración, etc.).
• exe.install
  

  Share via:

  • Facebook
  • X (Twitter)
  • LinkedIn
  • More