Rev 1618 | Rev 1683 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed
# Copyright (c) 2007 Fabio Checconi <fabio@gandalf.sssup.it>## This is a non-recursive makefile that supports a Kbuild-like syntax# for input/output specification.# Handle the V=0|1 option. We use both a long and a short form. In# the short one we use the $(Q) variable prepended to shell commands# (e.g., $(Q)mkdir) that in quiet mode expands to @, and in verbose# mode expands to nothing. In the long one we have a couple of strings# per command, one named quiet_cmd, the other cmd, and we always echo# $(QS)cmd, so if $(QS) expands to quiet_ the first string is printed.# The first string is the quiet version of the command, the second one# holds the whole command.ifneq ($(V),1)Q:=@QS:=quiet_endif# Handle the make -s flag: produce no output at all...ifneq ($(findstring s,$(MAKEFLAGS)),)Q:=@QS:=nothing_endif# The variables used to generate the rules to build targets. Use# CROSS_COMPILE to specify the prefix to be used for the toolchain.ar:= $(CROSS_COMPILE)$(AR)as:= $(CROSS_COMPILE)$(CC)cc:= $(CROSS_COMPILE)$(CC)ld:= $(CROSS_COMPILE)$(LD)rm:= $(if $(RM),$(RM),rm)install:= $(if $(INSTALL),$(INSTALL),install)# As in the rules we cannot use the variables we use in the makefile,# because we reassign them for every directory we visit, we just try# to recover the information from the targets being built. Another# way could have been to expand the variables when generating the# rules, but it would have made rule generation unreadable.in-local:= $$(subst $$(srctree)/,,$$<)out-local:= $$(subst install-,,$$(subst $$(objtree)/,,$$@))in-objs:= $$(filter %.o,$$^)in-objs-local:= $$(filter %.o,$$(subst $$(objtree)/,,$$^))# The rule patterns, in quiet and in verbose form. The verbose form is# used also for the actual command.quiet_ar_cmd := ' AR\\t$(out-local) $(in-objs-local)'ar_cmd := $(ar) cr $$@ $(in-objs)quiet_cc_cmd := ' CC\\t$(in-local)'cc_cmd := $(cc) $$(cflags-$$(<:.c=.o)) $$(cppflags-$$(<:.c=.o)) \-c $$< -o $$@quiet_as_cmd := ' AS\\t$(in-local)'as_cmd := $(as) $$(aflags-$$(<:.s=.o)) -c $$< -o $$@quiet_dep_cmd := ' DEP\\t$(in-local)'dep_cmd := $(cc) $$(cflags-$$(<:.c=.o)) $$(cppflags-$$(<:.c=.o)) \-M -MT \"$$(subst $$(srctree),$$(objtree),$$(<:.c=.o))\$$@" $$< > $$@ 2>/dev/nullquiet_ld-r_cmd := ' LD\\t$(out-local) $(in-objs-local)'ld-r_cmd := $(ld) $$(ldflags-$$(dir $$@)) -r $(in-objs) -o $$@quiet_rm_cmd := ' RM\\t$$(subst clean-,,$$(subst distclean-,,$(out-local)))'rm_cmd := -$(rm) $$(subst clean-,,$$(subst distclean-,,$$@))quiet_install_cmd := ' INSTALL $(out-local)'install_cmd := -$(install) $$(subst install-,,$$@) $$(installdir)# Generate the requested rule for the requested directory. First echo# the command according to the requested verbosity (suppress all the# output if $(QS)$(1)_cmd is not defined, i.e., in the silent make case,)# and then emit the actual command.define cmd$(if $($(QS)$(1)_cmd),@echo -e '$($(QS)$(1)_cmd)')@$($(1)_cmd)endef# Remove duplicate slashes, ../'s, trailing slashes and so on from paths.define clean-path$(dir $(abspath $(1)))$(notdir $(abspath $(1)))endef# Adjust the paths for all the prerequisites of a target. Given a list# of objects, with relative or absolute path, figure out the right paths# in the build directory. Leave the output in $(target-objs).define all-prerequisites-templtarget-obj-list:=$(1)# Filter absolute paths.target-objs:=$$(filter $(srctree)/%,$$(target-obj-list))target-obj-list:=$$(filter-out $$(target-objs),$$(target-obj-list))# Add all the other objects, and convert the path to the $(objtree)# root and with a reasonable path.target-objs+=$$(addprefix $$(curdir)/,$$(target-obj-list))target-objs:=$$(foreach dir,$$(subst $(srctree),$(objtree),$$(target-objs)),\$$(call clean-path,$$(dir)))endef# Produce targets for a given library.define lib-templlib:=$(1)lib-target:=$$(objdir)/$$(lib)# Get a list of all the prerequisites needed to build the library.$$(eval $$(call all-prerequisites-templ,\$$(patsubst %/,%/obj.o,$$($$(lib)-objs))))$$(foreach flag,$(flags),$$(eval $$(call flags-per-target,$$(flag),$$(lib))))$$(foreach obj,$$(target-objs),\$$(eval $$(call flags-per-objects,$$(obj),$$(lib))))# Produce the real target, in $(objtree), and the user-friendly target,# with a relative path to $(srctree). Note that even when the two trees# are equal we define two targets; a possible optimization could be to# use relative paths for the object tree in this case, but the code can# become even less readable than it is now...$$(lib-target): $$(target-objs)$(call cmd,ar)short-lib-taget:=$$(subst $$(srctree)/,,$$(curdir)/$$(lib)).PHONY: $$(short-lib-target)$$(short-lib-target): $$(lib-target)# Update the $(subdirs) for $(curdir) and its target list.subdirs+=$$(filter %/,$$($$(lib)-objs))curdir-targets+=$$(lib-target).PHONY: clean-$$(lib-target)clean-$$(lib-target):$(call cmd,rm)curdir-clean-targets+= clean-$$(lib-target).PHONY: install-$$(lib-target)install-$$(lib-target): $$(lib-target)$(call cmd,install)curdir-install-targets+= install-$$(lib-target)endef# Produce the needed code for a given object.define obj-templobj:=$(1)obj-target:=$$(objdir)/$$(obj)obj-dep:=$$(objdir)/.$$(obj:.o=.c).deps# Handle dependencies.ifeq ($(goals-have-clean),)$$(obj-dep): $$(objdir-prereq)-include $$(obj-dep)endif# Produce the user shortcut for the real target (that does not need to# be produced, as it is handled by implicit rules.)short-obj-target:= $$(subst $$(srctree)/,,$$(curdir)/$$(obj)).PHONY: $$(short-obj-target)$$(short-obj-target): $$(obj-target)curdir-targets+=$$(obj-target).PHONY: clean-$$(obj-target) distclean-$$(obj-dep)clean-$$(obj-target):$(call cmd,rm)distclean-$$(obj-dep):$(call cmd,rm)curdir-clean-targets+= clean-$$(obj-target)curdir-distclean-targets+= distclean-$$(obj-dep)endef# Handle the flags for the current directory. for each *FLAGS variable# used by the implicit rules there are two variants:# o the local one, e.g., cflags:=-I. or cflags+=-I. changing the# flags used only by the current directory.# o The global one, e.g., exported-cflags:=-I$(srctree) changing the# flags for the current directory and all its subdirs.# The flag handling is split in three parts, one to be inserted before# including the current directory makefile, one before recurring into# subdirs, the other one after the recursion.define flags-save-templflag:=$(1)# Flags on input to this dir; they must be preserved for our sibling# directories.saved-$$(flag)-$$(curdir):= $$($$(flag))endefdefine flags-pre-templflag:=$(1)# For the current directory, use the user-specified flags (that may# come from our parent directory.) Extra flags are used to specify# library-specific flags.$$(flag)-$$(curdir):=$$($$(flag)) $$(exported-$$(flag))#to-print+= [ $$(flag)-$$(curdir) = $$($$(flag)-$$(curdir)) ] RET# Export to our children also the user exported flags.$$(flag):= $$(saved-$$(flag)-$$(curdir)) $$(exported-$$(flag))exported-$$(flag):=endefdefine flags-post-templflag:=$(1)# Restore the flags that our parent specified.$$(flag):= $$(saved-$$(flag)-$$(curdir))endef# Allow redefinition of flags on the basis of a single target. Each# target gets its own version of the flags, based on the ones of the# current directory and its own ones.define flags-per-targetflag:=$(1)target:=$(2)$$(flag)-$$(curdir)/$$(target):=$$($$(flag)-$$(curdir)) \$$($$(target)-$$(flag)) $$(extra-$$(flag)-$$(curdir)/$$(target))# Those are the flags coming from the upper directories, they are set for# obj.o targets, we must export them to our children, so we leave them here.exported-$$(flag)-$$(curdir)/$$(target):= $$($$(target)-$$(flag)) \$$(extra-$$(flag)-$$(curdir)/$$(target))$$(target)-$$(flag):=endefdefine flags-per-object# Generate flags only for objects in the current directory, as prerequisites# that come from ousdide are not compiled here.flag:=$(1)target:=$(3)ifeq ($(dir $(subst $(objtree),$(srctree),$(2))),$$(curdir)/)this-obj:=$(notdir $(2))# The flags for a given object are the ones specified for its target# plus any specific one.$$(flag)-$$(curdir)/$$(this-obj):=$$($$(flag)-$$(curdir)/$$(target)) \$$($$(this-obj)-$$(flag))$$(this-obj)-$$(flag):=#to-print+= [ $$(flag)-$$(curdir)/$$(this-obj) = $$($$(flag)-$$(curdir)/$$(this-obj)) ] RETendif# Pass the right flags to the subdirs we use to build $(target).ifeq ($$(notdir $(2)),obj.o)extra-$$(flag)-$(2):= $$(exported-$$(flag)-$$(curdir)/$$(target))endifendef# Allow the user to specify per-object flagsdefine flags-per-objects$$(foreach flag,$$(flags),\$$(eval $$(call flags-per-object,$$(flags),$(1),$(2))))endef# Helper to define per-library flags.define flags-per-libs$$(foreach flag,$$(flags),\$$(eval $$(call flags-per-lib,$$(flags),$(1),$(2))))endef# Disable default implicit rules..SUFFIXES:# The roots of our source and object trees. If an O=dir option is# passed to the toplevel makefile all the output of the building# process is in dir.srctree:=$(call clean-path,$(CURDIR))objtree:=$(if $(O),$(call clean-path,$(O)),$(srctree))ifeq ($(wildcard $(objtree)),)$(error Output directory $(objtree) does not exist)endifclean-targets:=distclean-targets:=install-targets:=goals-have-clean:=$(strip $(filter clean distclean,$(MAKECMDGOALS)))aflags:= $(AFLAGS)cflags:= $(CFLAGS)cppflags:= $(CPPFLAGS)ldflags:= $(LDFLAGS)flags:= aflags cflags cppflags ldflags# XXX debug onlyto-print:=# The following macro is used to do a standard set of operations# for every subdirectory we have to work on. It is instantiated# every time we change subdirectory, and generates a set of targets# specific to that directory.define recurse-templ# Remember where we are in the source and object tree. The clean-path# macro is used for user output and for generating targets independently# from directories being specified as dir or dir/ or with multiple slashes# and so on.curdir:=$$(call clean-path,$(1))objdir:=$(objtree)$$(subst $(srctree),,$$(curdir))# Save the flags our parent passed us.$$(foreach flag,$(flags),$$(eval $$(call flags-save-templ,$$(flag))))# A list of all the targets defined for the current directory. It is# used to produce an user-reachable target for submakes into source tree# subdirectories, e.g., if src/utils is a source directory, make src/utils# will build all the targets defined inside it. Start with the short path# to all subdirs.curdir-targets:=curdir-clean-targets:=curdir-distclean-targets:=curdir-install-targets:=# If the output directory does not exist every target that actually# needs it will have to create it.ifneq ($(objtree),$(srctree))ifeq ($$(wildcard $$(objdir)),)objdir-prereq:=$$(objdir)/.build$$(objdir)/.build:$(Q)if [ ! -d $$(dir $$@) ] ; then \mkdir -p $$(dir $$@) ; touch $$@ ; fiendifendif# Include the next subdirectory. Don't include the root makefile,# if we are at the first step of the recursion.include $$(subst $(srctree)/Makefile,,$$(curdir)/Makefile)# Figure out all the targets. We support three kind of targets:# - subdirectories# - libraries# - objects## Subdirectories are recursively processed, libraries are built using# the objects specified in their *.a-objs target (if it contains a# subdirectory the latter is processed and the resulting obj.o object# is included,) and objects are compiled and incrementally linked# together in a obj.o file.subdirs:=$$(filter %/, $$(targets))objs:=$$(filter %.o, $$(targets))libs:=$$(filter %.a, $$(targets))$$(eval $$(call all-prerequisites-templ, $$(subdirs)))subdir-targets:= $$(target-objs)# Recurse into all the subdirectories.curdir-targets+=$$(subst $(objtree)/,,$$(subdir-targets))# Look for prerequisites to build obj.o for the current directory.$$(eval $$(call all-prerequisites-templ,\$$(filter-out $$(exclude),$$(objs))))target-objs+=$$(addsuffix /obj.o,$$(subdir-targets))$$(foreach flag,$(flags),$$(eval $$(call flags-pre-templ,$$(flag))))# Produce a target for obj.o, even if not needed (it will be empty in# this case.)ifneq ($$(strip $$(target-objs)),)$$(foreach flag,$(flags),$$(eval $$(call flags-per-target,$$(flag),obj.o)))$$(foreach obj,$$(target-objs),\$$(eval $$(call flags-per-objects,$$(obj),obj.o)))$$(objdir)/obj.o: $$(target-objs)$(call cmd,ld-r)else$$(objdir)/obj.o:$(Q)touch $$@endifcurdir-targets+= $$(objdir)/obj.o# to-print+= [ [ $$(objdir)/obj.o ] $$(target-objs) ]# Produce the needed targets for each library.ifneq ($$(strip $$(libs)),)$$(foreach lib,$$(libs),$$(eval $$(call lib-templ,$$(lib))))endif# Produce a target for each local object. Build the list of all the# targets specified by the current subdir. It is given by all the local# objects in $(targets) or in a library contained in it. Non-local# objects can be specified as dependencies but must be built from the# directory containing them (if needed their directory can specify that# they are not to be included in the local obj.o putting them into# $(exclude); this may not seem straightforward but is to support a# few corner cases.)## First build a relative path for all the .o files in the targets (the# default one and the library ones,) taking care of not being confused# by relative directory specifications.all-local-objs-paths:=$$(subst $$(curdir)/,,\$$(abspath $$(addprefix $$(curdir)/,\$$(objs) $$(foreach lib,$$(libs),$$(filter %.o,$$($$(lib)-objs))))))# Then keep only those with a dir equal to ./ A local object is not# allowed to be specified with a path specifying a directory different# from the current one.all-local-objs:=$$(foreach obj, $$(all-local-objs-paths), \$$(if $$(subst ./,,$$(dir $$(obj))),,$$(obj)))# Produce one target per object, and the rules to build them along with# their dependencies.ifneq ($$(strip $$(all-local-objs)),)$$(foreach obj,$$(all-local-objs),$$(eval $$(call obj-templ,$$(obj))))$$(objdir)/%.o: $$(curdir)/%.c$(call cmd,cc)$$(objdir)/%.o: $$(curdir)/%.s$(call cmd,as)$$(objdir)/.%.c.deps: $$(curdir)/%.c$(call cmd,dep)endif# Produce the user-friendly target for the source dir, depending# on its obj.o, libs and local objects (only if they can be built.)curdir-target:= $$(subst $$(srctree)/,,$$(curdir)).PHONY: $$(curdir-target)$$(curdir-target): $$(curdir-targets)# Produce the clean and distclean targets for the current directory..PHONY: clean-$$(curdir-target) distclean-$$(curdir-target)clean-$$(curdir-target): $$(curdir-clean-targets)distclean-$$(curdir-target): clean-$$(curdir-target) \$$(curdir-distclean-targets)# to-print+=[ distclean-$$(curdir-target) ]clean-targets+= clean-$$(curdir-target)distclean-targets+= distclean-$$(curdir-target)# Produce the install target. This is very Shark specific....PHONY: install-$$(curdir-target)$$(curdir-install-targets): $(installdir)/.buildinstall-$$(curdir-target): $$(curdir-install-targets)install-targets+= install-$$(curdir-target)#to-print+=[ install-$$(curdir-target) = $$(curdir-install-targets) ]# Actually do the recursion, generating the code specified by# recurse-tmpl for every subdirectory needed from the one we are# leaving.ifneq ($$(strip $$(subdirs)),)$$(foreach dir,$$(subdirs),$$(eval $$(call recurse-templ,$(1)/$$(dir))))curdir:=$$(call clean-path,$(1))endif$$(foreach flag,$(flags),$$(eval $$(call flags-post-templ,$$(flag))))endef.DEFAULT_GOAL:= allinclude shark.cfginstalldir:=$(objtree)/.lib# Handle Shark configuration. Really insane, indeed.options:=TSC APIC BIOS TRACER FG FB COMPILERdefine strip-in-place$(1):=$(strip $($(1)))endef$(foreach cfgopt,$(options),$(eval $(call strip-in-place,$(cfgopt))))cpp-tsc-TRUE:= -D__TSC__cpp-apic-TRUE:= -D__APIC__cpp-bios-VM86:= -DVM86cpp-tracer-NEW:= -D__NEW_TRACER__cpp-tracer-OLD:= -D__OLD_TRACER__cpp-fg-FORCE_PXC:= -D__FORCE_PXC__cpp-fb-VESA:= -DCONFIG_FB_VESA -DCONFIG_LOGOcpp-fb-FINDPCI:= -DCONFIG_FB_RIVA -DCONFIG_FB_RADEON -DCONFIG_FB_MATROX \-DCONFIG_LOGO -DCONFIG_FB_MATROX_G100 \-DCONFIG_FB_MATROX_MILLENIUM -DCONFIG_FB_MATROX_MYSTIQUEcpp-fb-VGA16:= -DCONFIG_FB_VGA16include-dirs:= \-I$(srctree)/include -I$(srctree)/modules \-I$(srctree)/libc/arch/$(ARCH)/include \-I$(srctree)/tracer/include \-I$(srctree)/oslibconfig:= -D__LINUX__ \$(cpp-tsc-$(TSC)) $(cpp-apic-$(APIC)) $(cpp-bios-$(BIOS)) \$(cpp-tracer-$(TRACER)) $(cpp-fg-$(FG)) $(cpp-fb-$(FB))exported-cppflags:= $(include-dirs) $(config)exported-aflags:= -x assembler-with-cpp $(include-dirs) $(config)cc-compiler-GCC4:= -Wimplicit-function-declaration -Wno-attributes \-Wno-pointer-sign -Wall -O -fno-builtin -nostdinc \-minline-all-stringops -fno-stack-protectorcc-compiler-GCC3:= -Wimplicit-function-declaration -Wall -O \-fno-builtin -nostdinc -minline-all-stringopscc-compiler-DJGPP:= -Wimplicit-function-declaration -Wall -O \-fno-builtin -nostdinc -minline-all-stringopsexported-cflags:= $(cc-compiler-$(COMPILER))fs-YES:= fs/targets:= libgkern.a drivers/ libc/ ports/ tracer/ $(fs-$(SHARK_FS))libgkern.a-objs:= oslib/ kernel/ modules/# Let the good times roll...$(eval $(call recurse-templ,$(srctree)))all: $(srctree).PHONY: clean distcleanclean: $(clean-targets)distclean: $(distclean-targets)debug:@echo $(to-print).PHONY: install $(install-targets)$(installdir)/.build:$(Q)if [ ! -d $(dir $@) ] ; then \mkdir -p $(dir $@) ; touch $@ ; fiinstall: $(install-targets)