Construido para arquitecturas de 32 y 64 bits

El sistema de compilación admite la creación de binarios para dos arquitecturas de CPU de destino, 32 bits y 64 bits, en la misma compilación. Esta compilación de dos objetivos se conoce como compilación multilib .

Para bibliotecas estáticas integradas y bibliotecas compartidas, el sistema de compilación establece reglas para crear archivos binarios para ambas arquitecturas. La configuración del producto ( PRODUCT_PACKAGES ), junto con el gráfico de dependencia, determina qué archivos binarios se crean e instalan en la imagen del sistema.

Para ejecutables y aplicaciones, el sistema de compilación solo crea la versión de 64 bits de forma predeterminada, pero puede anular esta configuración con una variable global BoardConfig.mk o una variable con alcance de módulo.

Precaución: Si una aplicación expone una API a otras aplicaciones que pueden ser de 32 o 64 bits, la aplicación debe tener la propiedad android:multiarch configurada en true dentro de su manifiesto para evitar posibles errores.

Identificar una segunda arquitectura de CPU y ABI

BoardConfig.mk incluye las siguientes variables para configurar la segunda arquitectura de CPU y la interfaz binaria de aplicación (ABI):

• TARGET_2ND_ARCH
• TARGET_2ND_ARCH_VARIANT
• TARGET_2ND_CPU_VARIANT
• TARGET_2ND_CPU_ABI
• TARGET_2ND_CPU_ABI2

Para ver un archivo MAKE de ejemplo que utiliza estas variables, consulte build/make/target/board/generic_arm64/BoardConfig.mk .

En una compilación multilib, los nombres de los módulos en PRODUCT_PACKAGES cubren los binarios de 32 y 64 bits, siempre que estén definidos por el sistema de compilación. Para las bibliotecas incluidas por dependencia, se instala una biblioteca de 32 o 64 bits solo si la requiere otra biblioteca o ejecutable de 32 o 64 bits.

Sin embargo, los nombres de los módulos en la línea de comando make cubren solo la versión de 64 bits. Por ejemplo, después de ejecutar lunch aosp_arm64-eng , make libc compila solo la libc de 64 bits. Para compilar la libc de 32 bits, debe ejecutar make libc_32 .

Definir la arquitectura del módulo en Android.mk

Puede utilizar la variable LOCAL_MULTILIB para configurar su compilación para 32 bits y 64 bits y anular la variable global TARGET_PREFER_32_BIT .

Para anular TARGET_PREFER_32_BIT , establezca LOCAL_MULTILIB en uno de los siguientes:

• both compilan tanto de 32 bits como de 64 bits.
• 32 compilaciones de solo 32 bits.
• 64 compila solo 64 bits.
• first compilaciones solo para la primera arquitectura (32 bits en dispositivos de 32 bits y 64 bits en dispositivos de 64 bits).

De forma predeterminada, LOCAL_MULTILIB no está configurado y el sistema de compilación decide qué arquitectura compilar en función de la clase del módulo y otras variables LOCAL_ * , como LOCAL_MODULE_TARGET_ARCH y LOCAL_32_BIT_ONLY .

Nota: En una compilación multilib, los condicionales como ifeq $(TARGET_ARCH) no funcionan.

Si desea crear su módulo para arquitecturas específicas, utilice las siguientes variables:

• LOCAL_MODULE_TARGET_ARCH : establece esta variable en una lista de arquitecturas, como arm x86 arm64 . Si la arquitectura que se está construyendo está en esa lista, el sistema de compilación incluye el módulo actual.

• LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH : esta variable es lo opuesto a LOCAL_MODULE_TARGET_ARCH . Si la arquitectura que se está construyendo not está en esa lista, el sistema de compilación incluye el módulo actual.

Existen variantes menores de estas dos variables:

• LOCAL_MODULE_TARGET_ARCH_WARN
• LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH_WARN

El sistema de compilación advierte si se omite el módulo actual debido a las arquitecturas enumeradas.

Para configurar indicadores de compilación para una arquitectura particular, use las variables LOCAL_ * específicas de la arquitectura donde * es un sufijo específico de la arquitectura, por ejemplo:

• LOCAL_SRC_FILES_arm, LOCAL_SRC_FILES_x86,
• LOCAL_CFLAGS_arm, LOCAL_CFLAGS_arm64,
• LOCAL_LDFLAGS_arm, LOCAL_LDFLAGS_arm64,

Estas variables se aplican sólo si se está creando un binario para esa arquitectura.

A veces es más fácil configurar indicadores en función de si el binario se está compilando para 32 o 64 bits. Utilice la variable LOCAL_ * con un sufijo _32 o _64 , por ejemplo:

• LOCAL_SRC_FILES_32, LOCAL_SRC_FILES_64,
• LOCAL_CFLAGS_32, LOCAL_CFLAGS_64,
• LOCAL_LDFLAGS_32, LOCAL_LDFLAGS_64,

Nota: No todas las variables LOCAL_ * admiten las variantes específicas de la arquitectura. Para obtener una lista actualizada de variables LOCAL_ * , consulte build/make/core/clear_vars.mk .

Establecer la ruta de instalación de la biblioteca

Para una compilación que no sea multilib, puede usar LOCAL_MODULE_PATH para instalar una biblioteca en una ubicación distinta a la predeterminada. Por ejemplo, LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw .

Sin embargo, en una compilación multilib, use LOCAL_MODULE_RELATIVE_PATH en su lugar:

LOCAL_MODULE_RELATIVE_PATH := hw

Con este formato, las bibliotecas de 64 y 32 bits se instalan en la ubicación correcta.

Si crea un ejecutable de 32 y 64 bits, utilice una de las siguientes variables para distinguir la ruta de instalación:

• LOCAL_MODULE_STEM_32, LOCAL_MODULE_STEM_64 : especifica el nombre del archivo instalado.
• LOCAL_MODULE_PATH_32, LOCAL_MODULE_PATH_64 : especifica la ruta de instalación.

Obtener directorio intermedio para archivos fuente

En una compilación multilib, si genera archivos fuente en $(local-intermediates-dir) (o $(intermediates-dir-for) con variables explícitas), no funciona de manera confiable. Esto se debe a que las fuentes intermedias generadas son requeridas por las compilaciones de 32 y 64 bits, pero $(local-intermediates-dir) apunta solo a uno de los dos directorios intermedios.

El sistema de compilación proporciona un directorio intermedio dedicado y compatible con múltiples bibliotecas para generar fuentes. Para recuperar la ruta del directorio intermedio, utilice la macro $(local-generated-sources-dir) o $(generated-sources-dir-for) . Los usos de estas macros son similares a $(local-intermediates-dir) y $(intermediates-dir-for) .

Si se genera un archivo fuente en este directorio dedicado y LOCAL_GENERATED_SOURCES lo recoge, está creado para 32 y 64 bits en una compilación multilib.

Indicar la arquitectura del sistema de objetivos binarios prediseñados.

En una compilación multilib, no puede usar TARGET_ARCH o TARGET_ARCH combinado con TARGET_2ND_ARCH para indicar la arquitectura del sistema de los objetivos binarios precompilados. En su lugar, utilice las variables LOCAL_ * LOCAL_MODULE_TARGET_ARCH o LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH .

Con estas variables, el sistema de compilación puede elegir el binario precompilado de 32 bits correspondiente incluso si está trabajando en una compilación multilib de 64 bits.

Si desea utilizar la arquitectura elegida para calcular la ruta de origen del binario prediseñado, llame a $(get-prebuilt-src-arch) .

Garantizar la generación de archivos ODEX de 32 y 64 bits

Para dispositivos de 64 bits, de forma predeterminada, Google genera archivos ODEX de 32 y 64 bits para la imagen de arranque y cualquier biblioteca de Java. Para los APK, de forma predeterminada, Google genera ODEX solo para la arquitectura principal de 64 bits. Si se inicia una aplicación en procesos de 32 y 64 bits, use LOCAL_MULTILIB := both para asegurarse de que se generen archivos ODEX de 32 y 64 bits. Si la aplicación tiene bibliotecas JNI de 32 o 64 bits, ese indicador también le indica al sistema de compilación que las incluya.