Crea per architetture a 32 bit e 64 bit, Crea per architetture a 32 bit e 64 bit

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, come arm 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 di LOCAL_MODULE_TARGET_ARCH . Se l'architettura in fase di creazione not è 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.