kbuild: change working directory to external module directory with M=

- Your directory from which spatch is called is processed next

- The directory provided with the ``--dir`` option is processed last, if used

Since coccicheck runs through make, it naturally runs from the kernel

proper dir; as such the second rule above would be implied for picking up a

.cocciconfig when using ``make coccicheck``.

``make coccicheck`` also supports using M= targets. If you do not supply

any M= target, it is assumed you want to target the entire kernel.

The kernel coccicheck script has::

    if [ "$KBUILD_EXTMOD" = "" ] ; then

        OPTIONS="--dir $srctree $COCCIINCLUDE"

    else

        OPTIONS="--dir $KBUILD_EXTMOD $COCCIINCLUDE"

    fi

KBUILD_EXTMOD is set when an explicit target with M= is used. For both cases

the spatch ``--dir`` argument is used, as such third rule applies when whether

M= is used or not, and when M= is used the target directory can have its own

.cocciconfig file. When M= is not passed as an argument to coccicheck the

target directory is the same as the directory from where spatch was called.

    OPTIONS="--dir $srcroot $COCCIINCLUDE"

Here, $srcroot refers to the source directory of the target: it points to the

external module's source directory when M= used, and otherwise, to the kernel

source directory. The third rule ensures the spatch reads the .cocciconfig from

the target directory, allowing external modules to have their own .cocciconfig

file.

If not using the kernel's coccicheck target, keep the above precedence

order logic of .cocciconfig reading. If using the kernel's coccicheck target,

  to prerequisites are referenced with $(src) (because they are not

  generated files).

$(srcroot)

  $(srcroot) refers to the root of the source you are building, which can be

  either the kernel source or the external modules source, depending on whether

  KBUILD_EXTMOD is set. This can be either a relative or an absolute path, but

  if KBUILD_ABS_SRCTREE=1 is set, it is always an absolute path.

$(srctree)

  $(srctree) refers to the root of the kernel source tree. When building the

  kernel, this is the same as $(srcroot).

$(objtree)

  $(objtree) refers to the root of the kernel object tree. It is ``.`` when

  building the kernel, but it is different when building external modules.

$(kecho)

  echoing information to user in a rule is often a good practice

  but when execution ``make -s`` one does not expect to see any output

  KBUILD_OUTPUT := $(O)

endif

ifdef KBUILD_EXTMOD

    ifdef KBUILD_OUTPUT

        objtree := $(realpath $(KBUILD_OUTPUT))

        $(if $(objtree),,$(error specified kernel directory "$(KBUILD_OUTPUT)" does not exist))

    else

        objtree := $(CURDIR)

    endif

    output := $(KBUILD_EXTMOD)

    # KBUILD_EXTMOD might be a relative path. Remember its absolute path before

    # Make changes the working directory.

    srcroot := $(realpath $(KBUILD_EXTMOD))

    $(if $(srcroot),,$(error specified external module directory "$(KBUILD_EXTMOD)" does not exist))

else

    objtree := .

    output := $(KBUILD_OUTPUT)

endif

export objtree srcroot

# Do we want to change the working directory?

ifneq ($(output),)

# We process the rest of the Makefile if this is the final invocation of make

ifeq ($(abs_srctree),$(CURDIR))

        # building in the source tree

        srctree := .

ifndef KBUILD_EXTMOD

srcroot := $(abs_srctree)

endif

ifeq ($(srcroot),$(CURDIR))

building_out_of_srctree :=

else

        ifeq ($(abs_srctree)/,$(dir $(CURDIR)))

                # building in a subdirectory of the source tree

                srctree := ..

        else

                srctree := $(abs_srctree)

        endif

	building_out_of_srctree := 1

export building_out_of_srctree := 1

endif

ifneq ($(KBUILD_ABS_SRCTREE),)

srctree := $(abs_srctree)

ifdef KBUILD_ABS_SRCTREE

    # Do nothing. Use the absolute path.

else ifeq ($(srcroot),$(CURDIR))

    # Building in the source.

    srcroot := .

else ifeq ($(srcroot)/,$(dir $(CURDIR)))

    # Building in a subdirectory of the source.

    srcroot := ..

endif

objtree		:= .

export srctree := $(if $(KBUILD_EXTMOD),$(abs_srctree),$(srcroot))

VPATH		:=

ifeq ($(KBUILD_EXTMOD),)

ifdef building_out_of_srctree

VPATH		:= $(srctree)

endif

export VPATH := $(srcroot)

else

VPATH :=

endif

export building_out_of_srctree srctree objtree VPATH

# To make sure we do not include .config for any of the *config targets

# catch them early, and hand them over to scripts/kconfig/Makefile

# It is allowed to specify more targets when calling make, including

LINUXINCLUDE    := \

		-I$(srctree)/arch/$(SRCARCH)/include \

		-I$(objtree)/arch/$(SRCARCH)/include/generated \

		$(if $(building_out_of_srctree),-I$(srctree)/include) \

		-I$(srctree)/include \

		-I$(objtree)/include \

		$(USERINCLUDE)

# in addition to whatever we do anyway.

# Just "make" or "make all" shall build modules as well

ifneq ($(filter all modules nsdeps %compile_commands.json clang-%,$(MAKECMDGOALS)),)

ifneq ($(filter all modules nsdeps compile_commands.json clang-%,$(MAKECMDGOALS)),)

  KBUILD_MODULES := 1

endif

PHONY += prepare0

export extmod_prefix = $(if $(KBUILD_EXTMOD),$(KBUILD_EXTMOD)/)

export extmod_prefix =

export MODORDER := $(extmod_prefix)modules.order

export MODULES_NSDEPS := $(extmod_prefix)modules.nsdeps

KBUILD_BUILTIN :=

KBUILD_MODULES := 1

build-dir := $(KBUILD_EXTMOD)

compile_commands.json: $(extmod_prefix)compile_commands.json

PHONY += compile_commands.json

build-dir := .

clean-dirs := $(KBUILD_EXTMOD)

clean: private rm-files := $(KBUILD_EXTMOD)/Module.symvers $(KBUILD_EXTMOD)/modules.nsdeps \

	$(KBUILD_EXTMOD)/compile_commands.json

clean-dirs := .

clean: private rm-files := Module.symvers modules.nsdeps compile_commands.json

PHONY += prepare

# now expand this into a simple variable to reduce the cost of shell evaluations

clean: $(clean-dirs)

	$(call cmd,rmfiles)

	@find $(or $(KBUILD_EXTMOD), .) $(RCS_FIND_IGNORE) \

	@find . $(RCS_FIND_IGNORE) \

		\( -name '*.[aios]' -o -name '*.rsi' -o -name '*.ko' -o -name '.*.cmd' \

		-o -name '*.ko.*' \

		-o -name '*.dtb' -o -name '*.dtbo' \

PHONY += rust-analyzer

rust-analyzer:

	+$(Q)$(CONFIG_SHELL) $(srctree)/scripts/rust_is_available.sh

ifdef KBUILD_EXTMOD

# FIXME: external modules must not descend into a sub-directory of the kernel

	$(Q)$(MAKE) $(build)=$(objtree)/rust src=$(srctree)/rust $@

else

	$(Q)$(MAKE) $(build)=rust $@

endif

# Script to generate missing namespace dependencies

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

	$(Q)$(srctree)/scripts/generate_rust_analyzer.py \

		--cfgs='core=$(core-cfgs)' --cfgs='alloc=$(alloc-cfgs)' \

		$(realpath $(srctree)) $(realpath $(objtree)) \

		$(rustc_sysroot) $(RUST_LIB_SRC) $(KBUILD_EXTMOD) > \

		$(if $(KBUILD_EXTMOD),$(extmod_prefix),$(objtree))/rust-project.json

		$(rustc_sysroot) $(RUST_LIB_SRC) $(if $(KBUILD_EXTMOD),$(srcroot)) \

		> rust-project.json

redirect-intrinsics = \

	__addsf3 __eqsf2 __extendsfdf2 __gesf2 __lesf2 __ltsf2 __mulsf3 __nesf2 __truncdfsf2 __unordsf2 \

# Building

# ==========================================================================

src := $(if $(VPATH),$(VPATH)/)$(obj)

src := $(srcroot)/$(obj)

PHONY := $(obj)/

$(obj)/: