Il sistema di build supporta la creazione di file binari per due architetture CPU di destinazione, a 32 bit e 64 bit, nella stessa build. Questa build a due destinazioni è nota come build multilib .
Per le librerie statiche integrate e le librerie condivise, il sistema di compilazione imposta regole per creare file binari per entrambe le architetture. La configurazione del prodotto ( PRODUCT_PACKAGES
), insieme al grafico delle dipendenze, determina quali file binari vengono compilati e installati nell'immagine di sistema.
Per gli eseguibili e le app, il sistema di compilazione crea solo la versione a 64 bit per impostazione predefinita, ma puoi sovrascrivere questa impostazione con una variabile BoardConfig.mk
globale o una variabile con ambito modulo.
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 makefile di esempio che utilizza queste variabili, vedere build/make/target/board/generic_arm64/BoardConfig.mk
.
In una build multilib, i nomi dei moduli in PRODUCT_PACKAGES
coprono sia i file binari a 32 bit che quelli a 64 bit, purché siano definiti dal sistema di build. Per le librerie incluse dalla dipendenza, una libreria a 32 bit o 64 bit viene installata solo se è richiesta da un'altra libreria o eseguibile a 32 bit o 64 bit.
Tuttavia, i nomi dei moduli sulla 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 libc a 32 bit, è necessario eseguire make libc_32
.
Definire l'architettura del modulo in Android.mk
Puoi utilizzare la variabile LOCAL_MULTILIB
per configurare la build per 32 bit e 64 bit e sovrascrivere la variabile globale TARGET_PREFER_32_BIT
.
Per sovrascrivere TARGET_PREFER_32_BIT
, imposta LOCAL_MULTILIB
su uno dei seguenti:
-
both
costruiscono sia 32 bit che 64 bit. -
32
costruisce solo 32 bit. -
64
crea solo 64 bit. -
first
viene creato 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 compilazione decide quale architettura costruire in base alla classe del modulo e ad altre variabili LOCAL_ *
, come LOCAL_MODULE_TARGET_ARCH
e LOCAL_32_BIT_ONLY
.
Se vuoi creare il tuo modulo per architetture specifiche, utilizza le seguenti variabili:
LOCAL_MODULE_TARGET_ARCH
- Imposta questa variabile su un elenco di architetture, comearm x86 arm64
. Se l'architettura in fase di creazione è presente in quell'elenco, il modulo corrente è incluso nel sistema di compilazione.LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH
- Questa variabile è l'opposto diLOCAL_MODULE_TARGET_ARCH
. Se l'architettura in fase di creazionenot
è presente nell'elenco, il modulo corrente viene incluso dal sistema di creazione.
Esistono varianti minori 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 saltato a causa delle architetture elencate.
Per impostare i flag di build per una particolare architettura, utilizzare le variabili LOCAL_ *
specifiche dell'architettura dove *
è un suffisso specifico dell'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 file binario per quell'architettura.
A volte è più semplice impostare i flag in base al fatto che il file binario sia stato 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,
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, utilizzare invece LOCAL_MODULE_RELATIVE_PATH
:
LOCAL_MODULE_RELATIVE_PATH := hw
Con questo formato, sia la libreria a 64 bit che quella 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.
Ottieni 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 generate intermedie sono richieste sia dalla build a 32 bit che da quella a 64 bit, ma $(local-intermediates-dir)
punta solo a una delle due directory intermedie.
Il sistema di compilazione fornisce una directory intermedia dedicata, multilib-friendly per la generazione di sorgenti. Per recuperare il percorso della directory intermedia, utilizzare la macro $(local-generated-sources-dir)
o $(generated-sources-dir-for)
. Gli usi di queste macro sono simili a $(local-intermediates-dir)
e $(intermediates-dir-for)
.
Se un file sorgente viene generato in questa directory dedicata e raccolto da LOCAL_GENERATED_SOURCES
, viene creato sia per 32 bit che per 64 bit in una build multilib.
Indicare l'architettura del sistema di target binari predefiniti
In una build multilib, non è possibile utilizzare TARGET_ARCH
, o TARGET_ARCH
combinato con TARGET_2ND_ARCH
, per indicare l'architettura di sistema delle destinazioni binarie precostruite. Utilizzare invece le variabili LOCAL_ *
LOCAL_MODULE_TARGET_ARCH
o LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH
.
Con queste variabili, il sistema di compilazione può scegliere il corrispondente binario precompilato a 32 bit anche se funziona su una build multilib a 64 bit.
Se desideri utilizzare l'architettura scelta per calcolare il percorso di origine per il binario predefinito, chiama $(get-prebuilt-src-arch)
.
Garantisci la generazione di file ODEX a 32 e 64 bit
Per i dispositivi a 64 bit, per impostazione predefinita Google genera file ODEX sia a 32 bit che a 64 bit per l'immagine di avvio ed eventuali librerie Java. Per gli APK, per impostazione predefinita Google genera ODEX solo per l'architettura primaria a 64 bit. Se un'app viene avviata sia in processi a 32 bit che a 64 bit, utilizzare LOCAL_MULTILIB := both
per assicurarsi che vengano generati sia file ODEX a 32 bit che a 64 bit. Se l'app dispone di librerie JNI a 32 o 64 bit, il flag indica anche al sistema di compilazione di includerle.