Commit e08d6de4 authored by Masahiro Yamada's avatar Masahiro Yamada
Browse files

kbuild: remove kbuild cache 



The kbuild cache was introduced to remember the result of shell
commands, some of which are expensive to compute, such as
$(call cc-option,...).

However, this turned out not so clever as I had first expected.
Actually, it is problematic.  For example, "$(CC) -print-file-name"
is cached.  If the compiler is updated, the stale search path causes
build error, which is difficult to figure out.  Another problem
scenario is cache files could be touched while install targets are
running under the root permission.  We can patch them if desired,
but the build infrastructure is getting uglier and uglier.

Now, we are going to move compiler flag tests to the configuration
phase.  If this is completed, the result of compiler tests will be
naturally cached in the .config file.  We will not have performance
issues of incremental building since this testing only happens at
Kconfig time.

To start this work with a cleaner code base, remove the kbuild
cache first.

Revert the following commits:
Commit 9a234a2e ("kbuild: create directory for make cache only when necessary")
Commit e17c400a ("kbuild: shrink .cache.mk when it exceeds 1000 lines")
Commit 4e562071 ("kbuild: Cache a few more calls to the compiler")
Commit 3298b690 ("kbuild: Add a cache for generated variables")

Signed-off-by: default avatarMasahiro Yamada <yamada.masahiro@socionext.com>
Reviewed-by: default avatarKees Cook <keescook@chromium.org>
parent 694c49a7

Makefile

+2 −3
Original line number Diff line number Diff line
@@ -504,7 +504,7 @@ KBUILD_CFLAGS += $(call cc-option,-fno-PIE) 
KBUILD_AFLAGS	+= $(call cc-option,-fno-PIE)



# check for 'asm goto'

ifeq ($(call shell-cached,$(CONFIG_SHELL) $(srctree)/scripts/gcc-goto.sh $(CC) $(KBUILD_CFLAGS)), y)

ifeq ($(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-goto.sh $(CC) $(KBUILD_CFLAGS)), y)

  CC_HAVE_ASM_GOTO := 1

  KBUILD_CFLAGS += -DCC_HAVE_ASM_GOTO

  KBUILD_AFLAGS += -DCC_HAVE_ASM_GOTO
@@ -807,7 +807,7 @@ KBUILD_CFLAGS += $(call cc-option,-fdata-sections,) 
endif



# arch Makefile may override CC so keep this after arch Makefile is included

NOSTDINC_FLAGS += -nostdinc -isystem $(call shell-cached,$(CC) -print-file-name=include)

NOSTDINC_FLAGS += -nostdinc -isystem $(shell $(CC) -print-file-name=include)

CHECKFLAGS     += $(NOSTDINC_FLAGS)



# warn about C99 declaration after statement
@@ -1625,7 +1625,6 @@ clean: $(clean-dirs) 
		-o -name '*.asn1.[ch]' \

		-o -name '*.symtypes' -o -name 'modules.order' \

		-o -name modules.builtin -o -name '.tmp_*.o.*' \

		-o -name .cache.mk \

		-o -name '*.c.[012]*.*' \

		-o -name '*.ll' \

		-o -name '*.gcno' \) -type f -print | xargs rm -f

scripts/Kbuild.include

+14 −87
Original line number Diff line number Diff line
@@ -8,8 +8,6 @@ squote := ' 
empty   :=

space   := $(empty) $(empty)

space_escape := _-_SPACE_-_

right_paren := )

left_paren := (

pound := \#



###
@@ -82,71 +80,6 @@ cc-cross-prefix = \ 
			echo $(c);                                    \

		fi)))



# Tools for caching Makefile variables that are "expensive" to compute.

#

# Here we want to help deal with variables that take a long time to compute

# by making it easy to store these variables in a cache.

#

# The canonical example here is testing for compiler flags.  On a simple system

# each call to the compiler takes 10 ms, but on a system with a compiler that's

# called through various wrappers it can take upwards of 100 ms.  If we have

# 100 calls to the compiler this can take 1 second (on a simple system) or 10

# seconds (on a complicated system).

#

# The "cache" will be in Makefile syntax and can be directly included.

# Any time we try to reference a variable that's not in the cache we'll

# calculate it and store it in the cache for next time.



# Include values from last time

make-cache := $(if $(KBUILD_EXTMOD),$(KBUILD_EXTMOD)/,$(if $(obj),$(obj)/)).cache.mk

$(make-cache): ;

-include $(make-cache)



cached-data := $(filter __cached_%, $(.VARIABLES))



# If cache exceeds 1000 lines, shrink it down to 500.

ifneq ($(word 1000,$(cached-data)),)

$(shell tail -n 500 $(make-cache) > $(make-cache).tmp; \

	mv $(make-cache).tmp $(make-cache))

endif



create-cache-dir := $(if $(KBUILD_SRC),$(if $(cache-data),,1))



# Usage: $(call __sanitize-opt,Hello=Hola$(comma)Goodbye Adios)

#

# Convert all '$', ')', '(', '\', '=', ' ', ',', ':' to '_'

__sanitize-opt = $(subst $$,_,$(subst $(right_paren),_,$(subst $(left_paren),_,$(subst \,_,$(subst =,_,$(subst $(space),_,$(subst $(comma),_,$(subst :,_,$(1)))))))))



# Usage:   $(call shell-cached,shell_command)

# Example: $(call shell-cached,md5sum /usr/bin/gcc)

#

# If we've already seen a call to this exact shell command (even in a

# previous invocation of make!) we'll return the value.  If not, we'll

# compute it and store the result for future runs.

#

# This is a bit of voodoo, but basic explanation is that if the variable

# was undefined then we'll evaluate the shell command and store the result

# into the variable.  We'll then store that value in the cache and finally

# output the value.

#

# NOTE: The $$(2) here isn't actually a parameter to __run-and-store.  We

# happen to know that the caller will have their shell command in $(2) so the

# result of "call"ing this will produce a reference to that $(2).  The reason

# for this strangeness is to avoid an extra level of eval (and escaping) of

# $(2).

define __run-and-store

ifeq ($(origin $(1)),undefined)

  $$(eval $(1) := $$(shell $$(2)))

ifeq ($(create-cache-dir),1)

  $$(shell mkdir -p $(dir $(make-cache)))

  $$(eval create-cache-dir :=)

endif

  $$(shell echo '$(1) := $$($(1))' >> $(make-cache))

endif

endef

__shell-cached = $(eval $(call __run-and-store,$(1)))$($(1))

shell-cached = $(call __shell-cached,__cached_$(call __sanitize-opt,$(1)),$(1))



# output directory for tests below

TMPOUT := $(if $(KBUILD_EXTMOD),$(firstword $(KBUILD_EXTMOD))/)
@@ -154,36 +87,30 @@ TMPOUT := $(if $(KBUILD_EXTMOD),$(firstword $(KBUILD_EXTMOD))/) 
# Usage: option = $(call try-run, $(CC)...-o "$$TMP",option-ok,otherwise)

# Exit code chooses option. "$$TMP" serves as a temporary file and is

# automatically cleaned up.

__try-run = set -e;			\

try-run = $(shell set -e;		\

	TMP="$(TMPOUT).$$$$.tmp";	\

	TMPO="$(TMPOUT).$$$$.o";	\

	if ($(1)) >/dev/null 2>&1;	\

	then echo "$(2)";		\

	else echo "$(3)";		\

	fi;				\

	rm -f "$$TMP" "$$TMPO"



try-run = $(shell $(__try-run))



# try-run-cached

# This works like try-run, but the result is cached.

try-run-cached = $(call shell-cached,$(__try-run))

	rm -f "$$TMP" "$$TMPO")



# as-option

# Usage: cflags-y += $(call as-option,-Wa$(comma)-isa=foo,)



as-option = $(call try-run-cached,\

as-option = $(call try-run,\

	$(CC) $(KBUILD_CFLAGS) $(1) -c -x assembler /dev/null -o "$$TMP",$(1),$(2))



# as-instr

# Usage: cflags-y += $(call as-instr,instr,option1,option2)



as-instr = $(call try-run-cached,\

as-instr = $(call try-run,\

	printf "%b\n" "$(1)" | $(CC) $(KBUILD_AFLAGS) -c -x assembler -o "$$TMP" -,$(2),$(3))



# __cc-option

# Usage: MY_CFLAGS += $(call __cc-option,$(CC),$(MY_CFLAGS),-march=winchip-c6,-march=i586)

__cc-option = $(call try-run-cached,\

__cc-option = $(call try-run,\

	$(1) -Werror $(2) $(3) -c -x c /dev/null -o "$$TMP",$(3),$(4))



# Do not attempt to build with gcc plugins during cc-option tests.
@@ -203,23 +130,23 @@ hostcc-option = $(call __cc-option, $(HOSTCC),\ 


# cc-option-yn

# Usage: flag := $(call cc-option-yn,-march=winchip-c6)

cc-option-yn = $(call try-run-cached,\

cc-option-yn = $(call try-run,\

	$(CC) -Werror $(KBUILD_CPPFLAGS) $(CC_OPTION_CFLAGS) $(1) -c -x c /dev/null -o "$$TMP",y,n)



# cc-disable-warning

# Usage: cflags-y += $(call cc-disable-warning,unused-but-set-variable)

cc-disable-warning = $(call try-run-cached,\

cc-disable-warning = $(call try-run,\

	$(CC) -Werror $(KBUILD_CPPFLAGS) $(CC_OPTION_CFLAGS) -W$(strip $(1)) -c -x c /dev/null -o "$$TMP",-Wno-$(strip $(1)))



# cc-name

# Expands to either gcc or clang

cc-name = $(call shell-cached,$(CC) -v 2>&1 | grep -q "clang version" && echo clang || echo gcc)

cc-name = $(shell $(CC) -v 2>&1 | grep -q "clang version" && echo clang || echo gcc)



# cc-version

cc-version = $(call shell-cached,$(CONFIG_SHELL) $(srctree)/scripts/gcc-version.sh $(CC))

cc-version = $(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-version.sh $(CC))



# cc-fullversion

cc-fullversion = $(call shell-cached,$(CONFIG_SHELL) \

cc-fullversion = $(shell $(CONFIG_SHELL) \

	$(srctree)/scripts/gcc-version.sh -p $(CC))



# cc-ifversion
@@ -232,21 +159,21 @@ cc-if-fullversion = $(shell [ $(cc-fullversion) $(1) $(2) ] && echo $(3) || echo 


# cc-ldoption

# Usage: ldflags += $(call cc-ldoption, -Wl$(comma)--hash-style=both)

cc-ldoption = $(call try-run-cached,\

cc-ldoption = $(call try-run,\

	$(CC) $(1) $(KBUILD_CPPFLAGS) $(CC_OPTION_CFLAGS) -nostdlib -x c /dev/null -o "$$TMP",$(1),$(2))



# ld-option

# Usage: LDFLAGS += $(call ld-option, -X)

ld-option = $(call try-run-cached, $(LD) $(LDFLAGS) $(1) -v,$(1),$(2))

ld-option = $(call try-run, $(LD) $(LDFLAGS) $(1) -v,$(1),$(2))



# ar-option

# Usage: KBUILD_ARFLAGS := $(call ar-option,D)

# Important: no spaces around options

ar-option = $(call try-run-cached, $(AR) rc$(1) "$$TMP",$(1),$(2))

ar-option = $(call try-run, $(AR) rc$(1) "$$TMP",$(1),$(2))



# ld-version

# Note this is mainly for HJ Lu's 3 number binutil versions

ld-version = $(call shell-cached,$(LD) --version | $(srctree)/scripts/ld-version.sh)

ld-version = $(shell $(LD) --version | $(srctree)/scripts/ld-version.sh)



# ld-ifversion

# Usage:  $(call ld-ifversion, -ge, 22252, y)

CRA Git | Maintained and supported by SUSTech CRA and CCSE