Esegui la compilazione per architetture a 32 e 64 bit

Il sistema di compilazione supporta la creazione di file binari per due architetture CPU di destinazione, 32 bit e 64 bit, nella stessa build. Questa build a due target è nota come build multilib.

Per le librerie statiche e condivise integrate, il sistema di build configura regole per creare file binari per entrambe le architetture. La configurazione del prodotto (PRODUCT_PACKAGES), insieme al grafico delle dipendenze, determina quali binari vengono compilati e installati nell'immagine di sistema.

Per eseguibili e app, il sistema di compilazione crea solo la versione a 64 bit per impostazione predefinita, ma puoi ignorare questa impostazione con una variabile globale BoardConfig.mk o una variabile con ambito modulo.

Attenzione: se un'app espone un'API ad altre app che possono essere a 32 bit o a 64 bit, l'app deve avere la proprietà android:multiarch impostata su true nel manifest per evitare potenziali errori.

Identificare una seconda architettura CPU e ABI

BoardConfig.mk include le seguenti variabili per configurare la seconda architettura della CPU e l'interfaccia binaria dell'applicazione (ABI):

• TARGET_2ND_ARCH
• TARGET_2ND_ARCH_VARIANT
• TARGET_2ND_CPU_VARIANT
• TARGET_2ND_CPU_ABI
• TARGET_2ND_CPU_ABI2

Per un esempio di makefile che utilizza queste variabili, consulta build/make/target/board/generic_arm64/BoardConfig.mk.

In una build multilib, i nomi dei moduli in PRODUCT_PACKAGES coprono i binari a 32 bit e 64 bit, purché siano definiti dal sistema di build. Per le librerie incluse per dipendenza, una libreria a 32 o 64 bit viene installata solo se è richiesta da un'altra libreria o eseguibile a 32 o 64 bit.

Tuttavia, i nomi dei moduli nella riga di comando make coprono solo la versione a 64 bit. Ad esempio, dopo aver eseguito lunch aosp_arm64-eng, make libc compila solo la libc a 64 bit. Per creare la libreria libc a 32 bit, devi eseguire make libc_32.

Definisci l'architettura del modulo in Android.mk

Puoi utilizzare la variabile LOCAL_MULTILIB per configurare la build per 32 bit e 64 bit e sostituire la variabile globale TARGET_PREFER_32_BIT.

Per ignorare TARGET_PREFER_32_BIT, imposta LOCAL_MULTILIB su uno dei seguenti valori:

• both crea build a 32 bit e a 64 bit.
• Le build 32 sono solo a 32 bit.
• 64 crea solo build a 64 bit.
• first solo per la prima architettura (32 bit nei dispositivi a 32 bit e 64 bit nei dispositivi a 64 bit).

Per impostazione predefinita, LOCAL_MULTILIB non è impostato e il sistema di build decide quale architettura creare in base alla classe del modulo e ad altre variabili LOCAL_*, come LOCAL_MODULE_TARGET_ARCH e LOCAL_32_BIT_ONLY.

Nota: in una build multilib, le condizioni come ifeq $(TARGET_ARCH) non funzionano.

Se vuoi creare il modulo per architetture specifiche, utilizza le seguenti variabili:

• LOCAL_MODULE_TARGET_ARCH: imposta questa variabile su un elenco di architetture, ad esempio arm x86 arm64. Se l'architettura in fase di creazione è presente nell'elenco, il modulo corrente viene incluso dal sistema di compilazione.

• LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH - Questa variabile è l'opposto di LOCAL_MODULE_TARGET_ARCH. Se l'architettura in fase di creazione è not in questo elenco, il modulo corrente viene incluso dal sistema di compilazione.

Esistono piccole varianti di queste due variabili:

• LOCAL_MODULE_TARGET_ARCH_WARN
• LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH_WARN

Il sistema di compilazione avvisa se il modulo corrente viene ignorato a causa delle architetture elencate.

Per configurare i flag di build per una determinata architettura, utilizza le variabili LOCAL_* specifiche per l'architettura, dove * è un suffisso specifico per l'architettura, ad esempio:

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

Queste variabili vengono applicate solo se viene creato un binario per quell'architettura.

A volte è più facile impostare i flag in base al fatto che il binario venga creato per 32 o 64 bit. Utilizza la variabile LOCAL_* con un suffisso _32 o _64, ad esempio:

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

Nota: non tutte le variabili LOCAL_* supportano le varianti specifiche dell'architettura. Per un elenco aggiornato delle variabili LOCAL_*, consulta build/make/core/clear_vars.mk.

Imposta il percorso di installazione della libreria

Per una build non multilib, puoi utilizzare LOCAL_MODULE_PATH per installare una libreria in una posizione diversa da quella predefinita. Ad esempio, LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw.

Tuttavia, in una build multilib, utilizza invece LOCAL_MODULE_RELATIVE_PATH:

LOCAL_MODULE_RELATIVE_PATH := hw

Con questo formato, le librerie a 64 bit e a 32 bit vengono installate nella posizione corretta.

Se crei un eseguibile sia a 32 bit che a 64 bit, utilizza una delle seguenti variabili per distinguere il percorso di installazione:

• LOCAL_MODULE_STEM_32, LOCAL_MODULE_STEM_64: specifica il nome del file installato.
• LOCAL_MODULE_PATH_32, LOCAL_MODULE_PATH_64: specifica il percorso di installazione.

Ottenere la directory intermedia per i file di origine

In una build multilib, se generi file sorgente in $(local-intermediates-dir) (o $(intermediates-dir-for) con variabili esplicite), non funziona in modo affidabile. Questo perché le origini intermedie generate sono richieste sia dalle build a 32 bit sia da quelle a 64 bit, ma $(local-intermediates-dir) punta a una sola delle due directory intermedie.

Il sistema di compilazione fornisce una directory intermedia dedicata e compatibile con multilib per la generazione delle origini. Per recuperare il percorso della directory intermedia, utilizza la macro $(local-generated-sources-dir) o $(generated-sources-dir-for). L'utilizzo di queste macro è simile a $(local-intermediates-dir) e $(intermediates-dir-for).

Se un file di origine viene generato in questa directory dedicata e selezionato da LOCAL_GENERATED_SOURCES, viene creato sia per 32 bit che per 64 bit in una build multilib.

Indica l'architettura di sistema dei target binari precompilati

In una build multilib, non puoi utilizzare TARGET_ARCH o TARGET_ARCH in combinazione con TARGET_2ND_ARCH per indicare l'architettura di sistema dei target binari precompilati. Utilizza invece le variabili LOCAL_* LOCAL_MODULE_TARGET_ARCH o LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH.

Con queste variabili, il sistema di compilazione può scegliere il binario precompilato a 32 bit corrispondente anche se sta lavorando a una compilazione multilib a 64 bit.

Se vuoi utilizzare l'architettura scelta per calcolare il percorso di origine del binario precompilato, chiama $(get-prebuilt-src-arch).

Assicurati della generazione di file ODEX a 32 bit e 64 bit

Per i dispositivi a 64 bit, per impostazione predefinita Google genera file ODEX a 32 bit e a 64 bit per l'immagine di avvio e per tutte le librerie Java. Per gli APK, per impostazione predefinita Google genera ODEX solo per l'architettura a 64 bit principale. Se un'app viene avviata in processi a 32 bit e a 64 bit, utilizza LOCAL_MULTILIB := both per assicurarti che vengano generati file ODEX a 32 bit e a 64 bit. Se l'app ha librerie JNI a 32 bit o 64 bit, questo flag indica anche al sistema di build di includerle.