kbuild: update modules.order only when contained modules are updated

		     $(patsubst %/,%,$(filter %/, $(core-) \

			$(drivers-) $(libs-))))

subdir-modorder := $(addsuffix modules.order,$(filter %/, \

			$(core-y) $(core-m) $(libs-y) $(libs-m) \

			$(drivers-y) $(drivers-m)))

build-dirs	:= $(vmlinux-dirs)

clean-dirs	:= $(vmlinux-alldirs)

# The actual objects are generated when descending,

# make sure no implicit rule kicks in

$(sort $(vmlinux-deps)): descend ;

$(sort $(vmlinux-deps) $(subdir-modorder)): descend ;

filechk_kernel.release = \

	echo "$(KERNELVERSION)$$($(CONFIG_SHELL) $(srctree)/scripts/setlocalversion $(srctree))"

modules_check: modules.order

	$(Q)$(CONFIG_SHELL) $(srctree)/scripts/modules-check.sh $<

modules.order: descend

	$(Q)$(AWK) '!x[$$0]++' $(addsuffix /$@, $(build-dirs)) > $@

cmd_modules_order = $(AWK) '!x[$$0]++' $(real-prereqs) > $@

modules.order: $(subdir-modorder) FORCE

	$(call if_changed,modules_order)

targets += modules.order

# Target to prepare building external modules

PHONY += modules_prepare

# subdir-builtin and subdir-modorder may contain duplications. Use $(sort ...)

subdir-builtin := $(sort $(filter %/built-in.a, $(real-obj-y)))

subdir-modorder := $(sort $(filter %/modules.order, $(modorder)))

subdir-modorder := $(sort $(filter %/modules.order, $(obj-m)))

targets-for-builtin := $(extra-y)

targets-for-builtin += $(obj)/built-in.a

endif

targets-for-modules := $(obj-m)

targets-for-modules += $(patsubst %.o, %.mod, $(obj-m))

targets-for-modules := $(patsubst %.o, %.mod, $(filter %.o, $(obj-m)))

ifdef need-modorder

targets-for-modules += $(obj)/modules.order

$(obj)/%.o: $(src)/%.S $(objtool_dep) FORCE

	$(call if_changed_rule,as_o_S)

targets += $(filter-out $(subdir-builtin), $(real-obj-y)) $(real-obj-m) $(lib-y)

targets += $(always-y) $(MAKECMDGOALS)

targets += $(filter-out $(subdir-builtin), $(real-obj-y))

targets += $(filter-out $(subdir-modorder), $(real-obj-m))

targets += $(lib-y) $(always-y) $(MAKECMDGOALS)

# Linker scripts preprocessor (.lds.S -> .lds)

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

#

# Create commands to either record .ko file or cat modules.order from

# a subdirectory

$(obj)/modules.order: $(subdir-modorder) FORCE

	$(Q){ $(foreach m, $(modorder), \

	$(if $(filter $^, $m), cat $m, echo $m);) :; } \

# Add $(obj-m) as the prerequisite to avoid updating the timestamp of

# modules.order unless contained modules are updated.

cmd_modules_order = { $(foreach m, $(real-prereqs), \

	$(if $(filter %/modules.order, $m), cat $m, echo $(patsubst %.o,%.ko,$m));) :; } \

	| $(AWK) '!x[$$0]++' - > $@

$(obj)/modules.order: $(obj-m) FORCE

	$(call if_changed,modules_order)

#

# Rule to compile a set of .o files into one .a file (with symbol table)

#

# Filter out objects already built-in

lib-y := $(filter-out $(obj-y), $(sort $(lib-y) $(lib-m)))

# Determine modorder.

# Unfortunately, we don't have information about ordering between -y

# and -m subdirs.  Just put -y's first.

ifdef need-modorder

modorder	:= $(patsubst %/,%/modules.order, $(filter %/, $(obj-y)) $(obj-m:.o=.ko))

endif

# Subdirectories we need to descend into

subdir-ym := $(sort $(subdir-y) $(subdir-m) \

			$(patsubst %/,%, $(filter %/, $(obj-y) $(obj-m))))

# Handle objects in subdirs

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

# o if we encounter foo/ in $(obj-y), replace it by foo/built-in.a

# o if we encounter foo/ in $(obj-m), remove it from $(obj-m)

# Handle objects in subdirs:

# - If we encounter foo/ in $(obj-y), replace it by foo/built-in.a and

#   foo/modules.order

# - If we encounter foo/ in $(obj-m), replace it by foo/modules.order

#

# Generate modules.order to determine modorder. Unfortunately, we don't have

# information about ordering between -y and -m subdirs. Just put -y's first.

ifdef need-modorder

obj-m := $(patsubst %/,%/modules.order, $(filter %/, $(obj-y)) $(obj-m))

else

obj-m := $(filter-out %/, $(obj-m))

endif

ifdef need-builtin

obj-y		:= $(patsubst %/, %/built-in.a, $(obj-y))

else

obj-y		:= $(filter-out %/, $(obj-y))

endif

obj-m		:= $(filter-out %/, $(obj-m))

# If $(foo-objs), $(foo-y), $(foo-m), or $(foo-) exists, foo.o is a composite object

multi-used-y := $(sort $(foreach m,$(obj-y), $(if $(strip $($(m:.o=-objs)) $($(m:.o=-y)) $($(m:.o=-))), $(m))))

extra-y		:= $(addprefix $(obj)/,$(extra-y))

always-y	:= $(addprefix $(obj)/,$(always-y))

targets		:= $(addprefix $(obj)/,$(targets))

modorder	:= $(addprefix $(obj)/,$(modorder))

obj-m		:= $(addprefix $(obj)/,$(obj-m))

lib-y		:= $(addprefix $(obj)/,$(lib-y))

real-obj-y	:= $(addprefix $(obj)/,$(real-obj-y))