p96705831
/
platform_build
forked from openkylin/platform_build
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Split ALL_MODULES.*.REQUIRED and friends between target/host 

So that we actually respect different LOCAL_REQUIRED_MODULES for the
host and device versions instead of unioning them. That got particularly
problematic when LOCAL_SHARED_LIBRARIES is implicitly added to
LOCAL_REQUIRED_MODULES. We also used to walk through device-only modules
when filling out the list of required modules, which triggered even more
extra installations.

This also changes the requirements for PRODUCT_HOST_PACKAGES so that it
no longer accepts target-only phony modules (since we can now
differentiate them). They were all removed in previous patches.

Test: treehugger; diff resulting builds
Test: diff list of product_target_FILES and product_host_FILES
Change-Id: I2ed8950320d31f5693323ad8cef6ec5b6780b7d4
This commit is contained in:
Dan Willemsen 2019-04-02 14:43:32 -07:00
parent d72873dc41
commit 8e96a794ac
4 changed files with 133 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
core/base_rules.mk
View File

@ -760,6 +760,18 @@ endif # LOCAL_PRESUBMIT_DISABLED
## Register with ALL_MODULES
###########################################################
ifeq ($(filter $(my_register_name),$(ALL_MODULES)),)
# These keys are no longer used, they've been replaced by keys that specify
# target/host/host_cross (REQUIRED_FROM_TARGET / REQUIRED_FROM_HOST) and similar.
#
# Marking them obsolete to ensure that anyone using these internal variables looks for
# alternates.
$(KATI_obsolete_var ALL_MODULES.$(my_register_name).REQUIRED)
$(KATI_obsolete_var ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED)
$(KATI_obsolete_var ALL_MODULES.$(my_register_name).HOST_REQUIRED)
$(KATI_obsolete_var ALL_MODULES.$(my_register_name).TARGET_REQUIRED)
endif
ALL_MODULES += $(my_register_name)
# Don't use += on subvars, or else they'll end up being
@ -820,17 +832,42 @@ ifneq ($(LOCAL_USE_VNDK),)
endif
endif
ALL_MODULES.$(my_register_name).REQUIRED := \
$(strip $(ALL_MODULES.$(my_register_name).REQUIRED) $(my_required_modules))
ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED := \
$(strip $(ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED)\
$(my_required_modules))
ALL_MODULES.$(my_register_name).TARGET_REQUIRED := \
$(strip $(ALL_MODULES.$(my_register_name).TARGET_REQUIRED)\
$(LOCAL_TARGET_REQUIRED_MODULES))
ALL_MODULES.$(my_register_name).HOST_REQUIRED := \
$(strip $(ALL_MODULES.$(my_register_name).HOST_REQUIRED)\
$(LOCAL_HOST_REQUIRED_MODULES))
ifdef LOCAL_IS_HOST_MODULE
ifneq ($(my_host_cross),true)
ALL_MODULES.$(my_register_name).REQUIRED_FROM_HOST := \
$(strip $(ALL_MODULES.$(my_register_name).REQUIRED_FROM_HOST) $(my_required_modules))
ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED_FROM_HOST := \
$(strip $(ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED_FROM_HOST)\
$(my_required_modules))
ALL_MODULES.$(my_register_name).TARGET_REQUIRED_FROM_HOST := \
$(strip $(ALL_MODULES.$(my_register_name).TARGET_REQUIRED_FROM_HOST)\
$(LOCAL_TARGET_REQUIRED_MODULES))
else
ALL_MODULES.$(my_register_name).REQUIRED_FROM_HOST_CROSS := \
$(strip $(ALL_MODULES.$(my_register_name).REQUIRED_FROM_HOST_CROSS) $(my_required_modules))
ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED_FROM_HOST_CROSS := \
$(strip $(ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED_FROM_HOST_CROSS)\
$(my_required_modules))
ifdef LOCAL_TARGET_REQUIRED_MODULES
$(call pretty-error,LOCAL_TARGET_REQUIRED_MODULES may not be used from host_cross modules)
endif
endif
ifdef LOCAL_HOST_REQUIRED_MODULES
$(call pretty-error,LOCAL_HOST_REQUIRED_MODULES may not be used from host modules. Use LOCAL_REQUIRED_MODULES instead)
endif
else
ALL_MODULES.$(my_register_name).REQUIRED_FROM_TARGET := \
$(strip $(ALL_MODULES.$(my_register_name).REQUIRED_FROM_TARGET) $(my_required_modules))
ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED_FROM_TARGET := \
$(strip $(ALL_MODULES.$(my_register_name).EXPLICITLY_REQUIRED_FROM_TARGET)\
$(my_required_modules))
ALL_MODULES.$(my_register_name).HOST_REQUIRED_FROM_TARGET := \
$(strip $(ALL_MODULES.$(my_register_name).HOST_REQUIRED_FROM_TARGET)\
$(LOCAL_HOST_REQUIRED_MODULES))
ifdef LOCAL_TARGET_REQUIRED_MODULES
$(call pretty-error,LOCAL_TARGET_REQUIRED_MODULES may not be used from target modules. Use LOCAL_REQUIRED_MODULES instead)
endif
endif
ALL_MODULES.$(my_register_name).EVENT_LOG_TAGS := \
$(ALL_MODULES.$(my_register_name).EVENT_LOG_TAGS) $(event_log_tags)
ALL_MODULES.$(my_register_name).MAKEFILE := \

2
core/definitions.mk
View File

@ -3333,7 +3333,7 @@ $(foreach source,$(ENFORCE_RRO_SOURCES), \
$(eval enforce_rro_source_overlays := $(subst :, ,$(word 5,$(_o)))) \
$(eval enforce_rro_partition := $(word 6,$(_o))) \
$(eval include $(BUILD_SYSTEM)/generate_enforce_rro.mk) \
$(eval ALL_MODULES.$$(enforce_rro_source_module).REQUIRED += $$(LOCAL_PACKAGE_NAME)) \
$(eval ALL_MODULES.$$(enforce_rro_source_module).REQUIRED_FROM_TARGET += $$(LOCAL_PACKAGE_NAME)) \
)
endef

108
core/main.mk
View File

@ -595,12 +595,10 @@ endef
# 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 select-bitness-of-required-modules
define target-select-bitness-of-required-modules
$(foreach m,$(ALL_MODULES),\
$(eval r := $(ALL_MODULES.$(m).REQUIRED))\
$(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_TARGET))\
$(if $(r),\
$(if $(ALL_MODULES.$(m).FOR_HOST_CROSS),\
$(eval r := $(addprefix host_cross_,$(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)),\
@ -608,11 +606,47 @@ $(foreach m,$(ALL_MODULES),\
$(eval r_r := $(r) $(call get-32-bit-modules,$(r)))\
)\
)\
$(eval ALL_MODULES.$(m).REQUIRED := $(strip $(r_r)))\
$(eval ALL_MODULES.$(m).REQUIRED_FROM_TARGET := $(strip $(r_r)))\
)\
)
endef
$(call select-bitness-of-required-modules)
$(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)))\
)\
)
endef
$(call host-select-bitness-of-required-modules)
define host-cross-select-bitness-of-required-modules
$(foreach m,$(ALL_MODULES),\
$(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_HOST_CROSS))\
$(if $(r),\
$(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)))\
)\
)
endef
$(call host-cross-select-bitness-of-required-modules)
r_r :=
define add-required-deps
@ -628,30 +662,42 @@ $(1): $(2)
endef
# Sets up dependencies such that whenever a host module is installed,
# any other host modules listed in $(ALL_MODULES.$(m).REQUIRED) will also be installed
# any other host modules listed in $(ALL_MODULES.$(m).REQUIRED_FROM_HOST) will also be installed
define add-all-host-to-host-required-modules-deps
$(foreach m,$(ALL_MODULES), \
$(eval r := $(ALL_MODULES.$(m).REQUIRED)) \
$(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_HOST)) \
$(if $(r), \
$(eval r := $(call module-installed-files,$(r))) \
$(eval h_m := $(filter $(HOST_OUT)/%, $(ALL_MODULES.$(m).INSTALLED))) \
$(eval hc_m := $(filter $(HOST_CROSS_OUT)/%, $(ALL_MODULES.$(m).INSTALLED))) \
$(eval h_r := $(filter $(HOST_OUT)/%, $(r))) \
$(eval hc_r := $(filter $(HOST_CROSS_OUT)/%, $(r))) \
$(eval h_m := $(filter-out $(h_r), $(h_m))) \
$(eval hc_m := $(filter-out $(hc_r), $(hc_m))) \
$(if $(h_m), $(eval $(call add-required-deps, $(h_m),$(h_r)))) \
$(if $(hc_m), $(eval $(call add-required-deps, $(hc_m),$(hc_r)))) \
) \
)
endef
$(call add-all-host-to-host-required-modules-deps)
# Sets up dependencies such that whenever a host cross module is installed,
# any other host cross modules listed in $(ALL_MODULES.$(m).REQUIRED_FROM_HOST_CROSS) will also be installed
define add-all-host-cross-to-host-cross-required-modules-deps
$(foreach m,$(ALL_MODULES), \
$(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_HOST_CROSS)) \
$(if $(r), \
$(eval r := $(call module-installed-files,$(r))) \
$(eval hc_m := $(filter $(HOST_CROSS_OUT)/%, $(ALL_MODULES.$(m).INSTALLED))) \
$(eval hc_r := $(filter $(HOST_CROSS_OUT)/%, $(r))) \
$(eval hc_m := $(filter-out $(hc_r), $(hc_m))) \
$(if $(hc_m), $(eval $(call add-required-deps, $(hc_m),$(hc_r)))) \
) \
)
endef
$(call add-all-host-cross-to-host-cross-required-modules-deps)
# Sets up dependencies such that whenever a target module is installed,
# any other target modules listed in $(ALL_MODULES.$(m).REQUIRED) will also be installed
# any other target modules listed in $(ALL_MODULES.$(m).REQUIRED_FROM_TARGET) will also be installed
define add-all-target-to-target-required-modules-deps
$(foreach m,$(ALL_MODULES), \
$(eval r := $(ALL_MODULES.$(m).REQUIRED)) \
$(eval r := $(ALL_MODULES.$(m).REQUIRED_FROM_TARGET)) \
$(if $(r), \
$(eval r := $(call module-installed-files,$(r))) \
$(eval t_m := $(filter $(TARGET_OUT_ROOT)/%, $(ALL_MODULES.$(m).INSTALLED))) \
@ -664,10 +710,10 @@ endef
$(call add-all-target-to-target-required-modules-deps)
# Sets up dependencies such that whenever a host module is installed,
# any target modules listed in $(ALL_MODULES.$(m).TARGET_REQUIRED) will also be installed
# any target modules listed in $(ALL_MODULES.$(m).TARGET_REQUIRED_FROM_HOST) will also be installed
define add-all-host-to-target-required-modules-deps
$(foreach m,$(ALL_MODULES), \
$(eval req_mods := $(ALL_MODULES.$(m).TARGET_REQUIRED))\
$(eval req_mods := $(ALL_MODULES.$(m).TARGET_REQUIRED_FROM_HOST))\
$(if $(req_mods), \
$(eval req_files := )\
$(foreach req_mod,$(req_mods), \
@ -690,10 +736,10 @@ endef
$(call add-all-host-to-target-required-modules-deps)
# Sets up dependencies such that whenever a target module is installed,
# any host modules listed in $(ALL_MODULES.$(m).HOST_REQUIRED) will also be installed
# any host modules listed in $(ALL_MODULES.$(m).HOST_REQUIRED_FROM_TARGET) will also be installed
define add-all-target-to-host-required-modules-deps
$(foreach m,$(ALL_MODULES), \
$(eval req_mods := $(ALL_MODULES.$(m).HOST_REQUIRED))\
$(eval req_mods := $(ALL_MODULES.$(m).HOST_REQUIRED_FROM_TARGET))\
$(if $(req_mods), \
$(eval req_files := )\
$(foreach req_mod,$(req_mods), \
@ -723,7 +769,7 @@ h_r :=
hc_r :=
# Establish the dependencies on the shared libraries.
# It also adds the shared library module names to ALL_MODULES.$(m).REQUIRED,
# It also adds the shared library module names to ALL_MODULES.$(m).REQUIRED_FROM_(TARGET|HOST|HOST_CROSS),
# so they can be expanded to product_MODULES later.
# $(1): TARGET_ or HOST_ or HOST_CROSS_.
# $(2): non-empty for 2nd arch.
@ -743,7 +789,7 @@ $(foreach m,$($(if $(2),$($(1)2ND_ARCH_VAR_PREFIX))$(1)DEPENDENCIES_ON_SHARED_LI
$(eval ALL_MODULES.$(mod).HOST_SHARED_LIBRARIES := $$(ALL_MODULES.$(mod).HOST_SHARED_LIBRARIES) $(deps))\
$(eval $(call add-required-host-so-deps,$(word 2,$(p)),$(r))),\
$(eval $(call add-required-deps,$(word 2,$(p)),$(r))))\
$(eval ALL_MODULES.$(mod).REQUIRED += $(deps)))
$(eval ALL_MODULES.$(mod).REQUIRED_FROM_$(patsubst %_,%,$(1)) += $(deps)))
endef
# Recursively resolve host shared library dependency for a given module.
@ -1025,7 +1071,7 @@ endef
# $(3): The list of overridden modules.
# Returns empty string (maybe with some whitespaces).
define expand-required-modules
$(eval _erm_req := $(foreach m,$(2),$(ALL_MODULES.$(m).REQUIRED))) \
$(eval _erm_req := $(foreach m,$(2),$(ALL_MODULES.$(m).REQUIRED_FROM_TARGET))) \
$(eval _erm_new_modules := $(sort $(filter-out $($(1)),$(_erm_req)))) \
$(eval _erm_new_overrides := $(call module-overrides,$(_erm_new_modules))) \
$(eval _erm_all_overrides := $(3) $(_erm_new_overrides)) \
@ -1038,12 +1084,17 @@ endef
# Same as expand-required-modules above, but does not handle module overrides, as
# we don't intend to support them on the host.
# $(1): The variable name that holds the initial module name list.
# the variable will be modified to hold the expanded results.
# $(2): The initial module name list.
# $(3): HOST or HOST_CROSS depending on whether we're expanding host or host cross modules
# Returns empty string (maybe with some whitespaces).
define expand-required-host-modules
$(eval _erm_req := $(foreach m,$(2),$(ALL_MODULES.$(m).REQUIRED))) \
$(eval _erm_req := $(foreach m,$(2),$(ALL_MODULES.$(m).REQUIRED_FROM_$(3)))) \
$(eval _erm_new_modules := $(sort $(filter-out $($(1)),$(_erm_req)))) \
$(eval $(1) += $(_erm_new_modules)) \
$(if $(_erm_new_modules),\
$(call expand-required-host-modules,$(1),$(_erm_new_modules)))
$(call expand-required-host-modules,$(1),$(_erm_new_modules),$(3)))
endef
# Transforms paths relative to PRODUCT_OUT to absolute paths.
@ -1124,8 +1175,13 @@ define host-installed-files
$(eval ### For the rest we add both) \
$(eval _hif_modules += $(call get-host-32-bit-modules, $(_hif_modules_rest))) \
$(eval _hif_modules += $(_hif_modules_rest)) \
$(call expand-required-host-modules,_hif_modules,$(_hif_modules)) \
$(filter $(HOST_OUT_ROOT)/%,$(call module-installed-files, $(_hif_modules)))
$(eval ### Split host vs host cross modules) \
$(eval _hcif_modules := $(filter host_cross_%,$(_hif_modules))) \
$(eval _hif_modules := $(filter-out host_cross_%,$(_hif_modules))) \
$(call expand-required-host-modules,_hif_modules,$(_hif_modules),HOST) \
$(call expand-required-host-modules,_hcif_modules,$(_hcif_modules),HOST_CROSS) \
$(filter $(HOST_OUT)/%,$(call module-installed-files, $(_hif_modules))) \
$(filter $(HOST_CROSS_OUT)/%,$(call module-installed-files, $(_hcif_modules)))
endef
# Fails the build if the given list is non-empty, and prints it entries (stripping PRODUCT_OUT).
@ -1164,7 +1220,7 @@ ifdef FULL_BUILD
ifneq ($(HOST_OS),darwin)
_modules := $(PRODUCT_HOST_PACKAGES)
_nonexistant_modules := $(foreach m,$(_modules),\
$(if $(filter FAKE,$(ALL_MODULES.$(m).CLASS))$(filter $(HOST_OUT_ROOT)/%,$(ALL_MODULES.$(m).INSTALLED)),,$(m)))
$(if $(ALL_MODULES.$(m).REQUIRED_FROM_HOST)$(filter $(HOST_OUT_ROOT)/%,$(ALL_MODULES.$(m).INSTALLED)),,$(m)))
$(call maybe-print-list-and-error,$(_nonexistant_modules),\
$(INTERNAL_PRODUCT) includes non-existant modules in PRODUCT_HOST_PACKAGES)
endif

4
core/tasks/tools/package-modules.mk
View File

@ -21,8 +21,8 @@ my_pickup_files :=
my_modules_and_deps := $(my_modules)
$(foreach m,$(my_modules),\
$(eval _explicitly_required := \
$(strip $(ALL_MODULES.$(m).EXPLICITLY_REQUIRED)\
$(ALL_MODULES.$(m)$(TARGET_2ND_ARCH_MODULE_SUFFIX).EXPLICITLY_REQUIRED)))\
$(strip $(ALL_MODULES.$(m).EXPLICITLY_REQUIRED_FROM_TARGET)\
$(ALL_MODULES.$(m)$(TARGET_2ND_ARCH_MODULE_SUFFIX).EXPLICITLY_REQUIRED_FROM_TARGET)))\
$(eval my_modules_and_deps += $(_explicitly_required))\
)