Conçu pour les architectures 32 bits et 64 bits,Construit pour les architectures 32 bits et 64 bits

Le système de build prend en charge la création de binaires pour deux architectures de processeur cibles, 32 bits et 64 bits, dans la même version. Cette version à deux cibles est connue sous le nom de version multilib .

Pour les bibliothèques statiques intégrées et les bibliothèques partagées, le système de build définit des règles pour créer des binaires pour les deux architectures. La configuration du produit ( PRODUCT_PACKAGES ), ainsi que le graphique de dépendances, déterminent quels binaires sont créés et installés sur l'image système.

Pour les exécutables et les applications, le système de build crée uniquement la version 64 bits par défaut, mais vous pouvez remplacer ce paramètre par une variable globale BoardConfig.mk ou une variable à l'échelle du module.

Identifier une deuxième architecture CPU et ABI

BoardConfig.mk inclut les variables suivantes pour configurer la deuxième architecture du processeur et l'interface binaire d'application (ABI) :

  • TARGET_2ND_ARCH
  • TARGET_2ND_ARCH_VARIANT
  • TARGET_2ND_CPU_VARIANT
  • TARGET_2ND_CPU_ABI
  • TARGET_2ND_CPU_ABI2

Pour un exemple de makefile qui utilise ces variables, voir build/make/target/board/generic_arm64/BoardConfig.mk .

Dans une version multilib, les noms de module dans PRODUCT_PACKAGES couvrent à la fois les binaires 32 bits et 64 bits, à condition qu'ils soient définis par le système de build. Pour les bibliothèques incluses par dépendance, une bibliothèque 32 bits ou 64 bits est installée uniquement si elle est requise par une autre bibliothèque ou un autre exécutable 32 bits ou 64 bits.

Cependant, les noms de modules sur la ligne de commande make ne couvrent que la version 64 bits. Par exemple, après avoir exécuté lunch aosp_arm64-eng , make libc construit uniquement la libc 64 bits. Pour construire la libc 32 bits, vous devez exécuter make libc_32 .

Définir l'architecture du module dans Android.mk

Vous pouvez utiliser la variable LOCAL_MULTILIB pour configurer votre build pour 32 bits et 64 bits et remplacer la variable globale TARGET_PREFER_32_BIT .

Pour remplacer TARGET_PREFER_32_BIT , définissez LOCAL_MULTILIB sur l'un des éléments suivants :

  • both construisent à la fois 32 bits et 64 bits.
  • 32 ne construit que 32 bits.
  • 64 ne construit que 64 bits.
  • construit first uniquement pour la première architecture (32 bits dans les appareils 32 bits et 64 bits dans les appareils 64 bits).

Par défaut, LOCAL_MULTILIB n'est pas défini et le système de construction décide quelle architecture construire en fonction de la classe de module et d'autres variables LOCAL_ * , telles que LOCAL_MODULE_TARGET_ARCH et LOCAL_32_BIT_ONLY .

Si vous souhaitez construire votre module pour des architectures spécifiques, utilisez les variables suivantes :

  • LOCAL_MODULE_TARGET_ARCH - Définissez cette variable sur une liste d'architectures, telles que arm x86 arm64 . Si l'architecture en cours de construction figure dans cette liste, le module actuel est inclus par le système de construction.

  • LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH - Cette variable est l'opposé de LOCAL_MODULE_TARGET_ARCH . Si l'architecture en cours de construction ne figure not dans cette liste, le module actuel est inclus par le système de construction.

Il existe des variantes mineures de ces deux variables :

  • LOCAL_MODULE_TARGET_ARCH_WARN
  • LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH_WARN

Le système de build avertit si le module actuel est ignoré en raison des architectures répertoriées.

Pour configurer des indicateurs de build pour une architecture particulière, utilisez les variables LOCAL_ * spécifiques à l'architecture où * est un suffixe spécifique à l'architecture, par exemple :

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

Ces variables ne sont appliquées que si un binaire est construit pour cette architecture.

Parfois, il est plus facile de configurer des indicateurs selon que le binaire est construit pour 32 bits ou 64 bits. Utilisez la variable LOCAL_ * avec un suffixe _32 ou _64 , par exemple :

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

Définir le chemin d'installation de la bibliothèque

Pour une version non multilib, vous pouvez utiliser LOCAL_MODULE_PATH pour installer une bibliothèque à un emplacement autre que l'emplacement par défaut. Par exemple, LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw .

Cependant, dans une version multilib, utilisez plutôt LOCAL_MODULE_RELATIVE_PATH :

LOCAL_MODULE_RELATIVE_PATH := hw

Avec ce format, les bibliothèques 64 bits et 32 ​​bits sont installées au bon emplacement.

Si vous créez un exécutable en 32 bits et 64 bits, utilisez l'une des variables suivantes pour distinguer le chemin d'installation :

  • LOCAL_MODULE_STEM_32, LOCAL_MODULE_STEM_64 - Spécifie le nom du fichier installé.
  • LOCAL_MODULE_PATH_32, LOCAL_MODULE_PATH_64 - Spécifie le chemin d'installation.

Obtenir le répertoire intermédiaire pour les fichiers sources

Dans une version multilib, si vous générez des fichiers source dans $(local-intermediates-dir) (ou $(intermediates-dir-for) avec des variables explicites), cela ne fonctionne pas de manière fiable. En effet, les sources générées intermédiaires sont requises à la fois par les versions 32 bits et 64 bits, mais $(local-intermediates-dir) pointe vers un seul des deux répertoires intermédiaires.

Le système de construction fournit un répertoire intermédiaire dédié, compatible avec plusieurs bibliothèques, pour générer des sources. Pour récupérer le chemin du répertoire intermédiaire, utilisez la macro $(local-generated-sources-dir) ou $(generated-sources-dir-for) . Les utilisations de ces macros sont similaires à $(local-intermediates-dir) et $(intermediates-dir-for) .

Si un fichier source est généré dans ce répertoire dédié et récupéré par LOCAL_GENERATED_SOURCES , il est construit pour 32 bits et 64 bits dans une version multilib.

Indiquer l'architecture système des cibles binaires prédéfinies

Dans une version multilib, vous ne pouvez pas utiliser TARGET_ARCH , ou TARGET_ARCH combiné avec TARGET_2ND_ARCH , pour indiquer l'architecture système des cibles binaires prédéfinies. Utilisez plutôt les variables LOCAL_ * LOCAL_MODULE_TARGET_ARCH ou LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH .

Avec ces variables, le système de build peut choisir le binaire prédéfini 32 bits correspondant même s'il travaille sur une version multilib 64 bits.

Si vous souhaitez utiliser l'architecture choisie pour calculer le chemin source du binaire prédéfini, appelez $(get-prebuilt-src-arch) .

Assurer la génération de fichiers ODEX 32 bits et 64 bits

Pour les appareils 64 bits, Google génère par défaut des fichiers ODEX 32 bits et 64 bits pour l'image de démarrage et toutes les bibliothèques Java. Pour les APK, Google génère par défaut ODEX uniquement pour l'architecture principale 64 bits. Si une application est lancée dans des processus 32 bits et 64 bits, utilisez LOCAL_MULTILIB := both pour vous assurer que les fichiers ODEX 32 bits et 64 bits sont générés. Si l'application possède des bibliothèques JNI 32 bits ou 64 bits, cet indicateur indique également au système de build de les inclure.