Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f9d1eee9 authored by Yo Chiang's avatar Yo Chiang Committed by Gerrit Code Review
Browse files

Merge changes I47d523e4,Ib2f4b548 

* changes:
  Make required modules support :32 and :64 suffix
  Refactor *-select-bitness-of-required-modules
parents 173149f1 60da88da

core/main.mk

+83 −96
Original line number Diff line number Diff line
@@ -551,6 +551,13 @@ ifneq ($(PRODUCT_ENFORCE_RRO_TARGETS),) 
$(call generate_all_enforce_rro_packages)

endif



# -------------------------------------------------------------------

# Sort ALL_MODULES to remove duplicate entries.

# -------------------------------------------------------------------

ALL_MODULES := $(sort $(ALL_MODULES))

# Cannot set to readonly because Makefile extends ALL_MODULES

# .KATI_READONLY := ALL_MODULES



# -------------------------------------------------------------------

# Fix up CUSTOM_MODULES to refer to installed files rather than

# just bare module names.  Leave unknown modules alone in case
@@ -618,65 +625,85 @@ $(sort $(foreach m,$(1),\ 
    $(m))))

endef



# If a module is for a cross host os, the required modules must be for

# that OS too.

# If a module is built for 32-bit, the required modules must be 32-bit too;

# Otherwise if the module is an executable or shared library,

#   the required modules must be 64-bit;

#   otherwise we require both 64-bit and 32-bit variant, if one exists.

define target-select-bitness-of-required-modules

$(foreach m,$(ALL_MODULES),\

  $(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_TARGET))\

  $(if $(r),\

    $(if $(ALL_MODULES.$(m).FOR_2ND_ARCH),\

      $(eval r_r := $(call get-32-bit-modules-if-we-can,$(r))),\

      $(if $(filter EXECUTABLES SHARED_LIBRARIES NATIVE_TESTS,$(ALL_MODULES.$(m).CLASS)),\

        $(eval r_r := $(r)),\

        $(eval r_r := $(r) $(call get-32-bit-modules,$(r)))\

       )\

     )\

     $(eval ALL_MODULES.$(m).REQUIRED_FROM_TARGET := $(strip $(r_r)))\

  )\

)

endef

$(call target-select-bitness-of-required-modules)



define host-select-bitness-of-required-modules

$(foreach m,$(ALL_MODULES),\

  $(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_HOST))\

  $(if $(r),\

    $(if $(ALL_MODULES.$(m).FOR_2ND_ARCH),\

      $(eval r_r := $(call get-host-32-bit-modules-if-we-can,$(r))),\

      $(if $(filter EXECUTABLES SHARED_LIBRARIES NATIVE_TESTS,$(ALL_MODULES.$(m).CLASS)),\

        $(eval r_r := $(r)),\

        $(eval r_r := $(r) $(call get-host-32-bit-modules,$(r)))\

       )\

     )\

     $(eval ALL_MODULES.$(m).REQUIRED_FROM_HOST := $(strip $(r_r)))\

  )\

# Resolves module bitness for PRODUCT_PACKAGES and PRODUCT_HOST_PACKAGES.

# The returned list of module names can be used to access

# ALL_MODULES.<module>.<*> variables.

# Name resolution for PRODUCT_PACKAGES / PRODUCT_HOST_PACKAGES:

#   foo:32 resolves to foo_32;

#   foo:64 resolves to foo;

#   foo resolves to both foo and foo_32 (if foo_32 is defined).

#

# Name resolution for HOST_CROSS modules:

#   foo:32 resolves to foo;

#   foo:64 resolves to foo_64;

#   foo resolves to both foo and foo_64 (if foo_64 is defined).

#

# $(1): TARGET, HOST or HOST_CROSS

# $(2): A list of simple module names with :32 and :64 suffix

define resolve-bitness-for-modules

$(strip \

  $(eval modules_32 := $(patsubst %:32,%,$(filter %:32,$(2)))) \

  $(eval modules_64 := $(patsubst %:64,%,$(filter %:64,$(2)))) \

  $(eval modules_both := $(filter-out %:32 %:64,$(2))) \

  $(eval ### For host cross modules, the primary arch is windows x86 and secondary is x86_64) \

  $(if $(filter HOST_CROSS,$(1)), \

    $(eval modules_1st_arch := $(modules_32)) \

    $(eval modules_2nd_arch := $(modules_64)), \

    $(eval modules_1st_arch := $(modules_64)) \

    $(eval modules_2nd_arch := $(modules_32))) \

  $(eval ### Note for 32-bit product, 32 and 64 will be added as their original module names.) \

  $(eval modules := $(modules_1st_arch)) \

  $(if $($(1)_2ND_ARCH), \

    $(eval modules += $(call get-modules-for-2nd-arch,$(1),$(modules_2nd_arch))), \

    $(eval modules += $(modules_2nd_arch))) \

  $(eval ### For the rest we add both) \

  $(eval modules += $(modules_both)) \

  $(if $($(1)_2ND_ARCH), \

    $(eval modules += $(call get-modules-for-2nd-arch,$(1),$(modules_both)))) \

  $(modules) \

)

endef

$(call host-select-bitness-of-required-modules)



define host-cross-select-bitness-of-required-modules

# TODO(b/7456955): error if a required module doesn't exist.

# Resolve the required module names in ALL_MODULES.*.REQUIRED_FROM_TARGET,

# ALL_MODULES.*.REQUIRED_FROM_HOST and ALL_MODULES.*.REQUIRED_FROM_HOST_CROSS

# to 32-bit or 64-bit variant.

# If a module is for cross host OS, the required modules are also for that OS.

# Required modules explicitly suffixed with :32 or :64 resolve to that bitness.

# Otherwise if the requiring module is native and the required module is shared

# library or native test, then the required module resolves to the same bitness.

# Otherwise the required module resolves to both variants, if they exist.

# $(1): TARGET, HOST or HOST_CROSS

define select-bitness-of-required-modules

$(foreach m,$(ALL_MODULES), \

  $(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_HOST_CROSS))\

  $(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_$(1))) \

  $(if $(r), \

    $(if $(filter HOST_CROSS,$(1)), \

      $(if $(ALL_MODULES.$(m).FOR_HOST_CROSS),,$(error Only expected REQUIRED_FROM_HOST_CROSS on FOR_HOST_CROSS modules - $(m))) \

    $(eval r := $(addprefix host_cross_,$(r)))\

    $(if $(ALL_MODULES.$(m).FOR_2ND_ARCH),\

      $(eval r_r := $(call get-host-32-bit-modules-if-we-can,$(r))),\

      $(if $(filter EXECUTABLES SHARED_LIBRARIES NATIVE_TESTS,$(ALL_MODULES.$(m).CLASS)),\

        $(eval r_r := $(r)),\

        $(eval r_r := $(r) $(call get-host-32-bit-modules,$(r)))\

       )\

     )\

     $(eval ALL_MODULES.$(m).REQUIRED_FROM_HOST_CROSS := $(strip $(r_r)))\

      $(eval r := $(addprefix host_cross_,$(r)))) \

    $(eval module_is_native := \

      $(filter EXECUTABLES SHARED_LIBRARIES NATIVE_TESTS,$(ALL_MODULES.$(m).CLASS))) \

    $(eval r_r := $(foreach r_i,$(r), \

      $(if $(filter %:32 %:64,$(r_i)), \

        $(eval r_m := $(call resolve-bitness-for-modules,$(1),$(r_i))), \

        $(eval r_m := \

          $(eval r_i_2nd := $(call get-modules-for-2nd-arch,$(1),$(r_i))) \

          $(eval required_is_shared_library_or_native_test := \

            $(filter SHARED_LIBRARIES NATIVE_TESTS, \

              $(ALL_MODULES.$(r_i).CLASS) $(ALL_MODULES.$(r_i_2nd).CLASS))) \

          $(if $(and $(module_is_native),$(required_is_shared_library_or_native_test)), \

            $(if $(ALL_MODULES.$(m).FOR_2ND_ARCH),$(r_i_2nd),$(r_i)), \

            $(r_i) $(r_i_2nd)))) \

      $(eval ### TODO(b/7456955): error if r_m is empty / does not exist) \

      $(r_m))) \

    $(eval ALL_MODULES.$(m).REQUIRED_FROM_$(1) := $(sort $(r_r))) \

  ) \

)

endef

$(call host-cross-select-bitness-of-required-modules)

r_r :=



$(call select-bitness-of-required-modules,TARGET)

$(call select-bitness-of-required-modules,HOST)

$(call select-bitness-of-required-modules,HOST_CROSS)



define add-required-deps

$(1): | $(2)
@@ -1126,45 +1153,6 @@ define auto-included-modules 


endef



# Resolves module bitness for PRODUCT_PACKAGES and PRODUCT_HOST_PACKAGES.

# The returned list of module names can be used to access

# ALL_MODULES.<module>.<*> variables.

# Name resolution for PRODUCT_PACKAGES / PRODUCT_HOST_PACKAGES:

#   foo:32 resolves to foo_32;

#   foo:64 resolves to foo;

#   foo resolves to both foo and foo_32 (if foo_32 is defined).

#

# Name resolution for HOST_CROSS modules:

#   foo:32 resolves to foo;

#   foo:64 resolves to foo_64;

#   foo resolves to both foo and foo_64 (if foo_64 is defined).

#

# $(1): TARGET, HOST or HOST_CROSS

# $(2): A list of simple module names with :32 and :64 suffix

define resolve-bitness-for-modules

$(strip \

  $(eval modules_32 := $(patsubst %:32,%,$(filter %:32,$(2)))) \

  $(eval modules_64 := $(patsubst %:64,%,$(filter %:64,$(2)))) \

  $(eval modules_both := $(filter-out %:32 %:64,$(2))) \

  $(eval ### For host cross modules, the primary arch is windows x86 and secondary is x86_64) \

  $(if $(filter HOST_CROSS,$(1)), \

    $(eval modules_1st_arch := $(modules_32)) \

    $(eval modules_2nd_arch := $(modules_64)), \

    $(eval modules_1st_arch := $(modules_64)) \

    $(eval modules_2nd_arch := $(modules_32))) \

  $(eval ### Note for 32-bit product, 32 and 64 will be added as their original module names.) \

  $(eval modules := $(modules_1st_arch)) \

  $(if $($(1)_2ND_ARCH), \

    $(eval modules += $(call get-modules-for-2nd-arch,$(1),$(modules_2nd_arch))), \

    $(eval modules += $(modules_2nd_arch))) \

  $(eval ### For the rest we add both) \

  $(eval modules += $(modules_both)) \

  $(if $($(1)_2ND_ARCH), \

    $(eval modules += $(call get-modules-for-2nd-arch,$(1),$(modules_both)))) \

  $(modules) \

)

endef



# Lists most of the files a particular product installs, including:

# - PRODUCT_PACKAGES, and their LOCAL_REQUIRED_MODULES

# - PRODUCT_COPY_FILES
@@ -1177,8 +1165,7 @@ endef 
#   foo resolves to both foo and foo_32 (if foo_32 is defined).

#

# Name resolution for LOCAL_REQUIRED_MODULES:

#   If a module is built for 2nd arch, its required module resolves to

#   32-bit variant, if it exits. See the select-bitness-of-required-modules definition.

#   See the select-bitness-of-required-modules definition.

# $(1): product makefile

define product-installed-files

  $(eval _pif_modules := \