#
# make.module.tmpl for test suite
# Not intended to be a seperate makefile, but to be used in conjunction with
# higher level, platform-specific makefiles in the build directories

RM = rm -f
RMDIR ?= rmdir
M_GCC ?= purify $(GCC)
M_GXX ?= $(GXX)
DEPCC ?= $(GCC)
DEPENDFLAGS ?= -MM -MT
DEPENDDIR = ./depends
VPATH 	= ../src $(DEPENDDIR) ../src/dyninst

IFLAGS = -I../../dyninstAPI/h -I../../symtabAPI/h -I../../dynutil/h -I../../instructionAPI/h -I../../proccontrol/h -I../../external
LFLAGS = -L../../common/$(PLATFORM) -L../../symtabAPI/$(PLATFORM) -L../../instructionAPI/$(PLATFORM) -L../../proccontrol/$(PLATFORM) -L../../dyninstAPI/$(PLATFORM)

#######################################################################
### We don't want all of the CFLAGS stuff that came from make.config.
### Strip away most of it.
#######################################################################

CFLAGS = $(UNIFIED_TEST_DEF:%=%_test) $(ARCH_FLAGS) $(AC_DEF) $(FIRST_INCLUDE) $(IFLAGS) -I../src -g $(BOOST_INCDIR)
CXXFLAGS = $(CFLAGS)
CXXFLAGS += $(PLATFORM_CXXFLAGS)
CFLAGS_NATIVE = $(CFLAGS)
CXXFLAGS_NATIVE = $(CXXFLAGS)
MUTATEE_CFLAGS_NATIVE ?= $(CFLAGS)
MUTATEE_CXXFLAGS_NATIVE ?= $(CXXFLAGS)


#######################################################################
###  Generate compiler id strings
###
###  COMPILERT_NATIVE_CC, COMPILERT_NATIVE_CXX must be defined prior to
###  inclusion of this file.  gcc/g++ are handled here as platform-indep
###
#######################################################################

EMPTY:=
BLANK:=$(EMPTY) $(EMPTY)
LPAREN:=(
RPAREN:=)
COMMA=,
RSQBRACK:=[
LSQBRACK:=]

COMPILERT_GCC = $(shell $(M_GCC) -v 2>&1 | grep version | head -1)
COMPILER1_GCC = $(subst $(BLANK),_,$(COMPILERT_GCC))
COMPILER2_GCC = $(subst $(LPAREN),_,$(COMPILER1_GCC))
COMPILER3_GCC = $(subst $(RSQBRACK),_,$(COMPILER2_GCC))
COMPILER4_GCC = $(subst $(LSQBRACK),_,$(COMPILER3_GCC))
COMPILER_GCC = $(subst $(RPAREN),_,$(COMPILER4_GCC))
MUTATEE_CFLAGS_GNU += -DCOMPILER='"$(COMPILER_GCC)"'
MUTATEE_LDFLAGS_GNU += $(LDFLAGS) -L.

COMPILERT_GXX = $(shell $(M_GCC) -v 2>&1 | grep version | head -1)
COMPILER1_GXX = $(subst $(BLANK),_,$(COMPILERT_GXX))
COMPILER2_GXX = $(subst $(LPAREN),_,$(COMPILER1_GXX))
COMPILER3_GXX = $(subst $(RSQBRACK),_,$(COMPILER2_GXX))
COMPILER4_GXX = $(subst $(LSQBRACK),_,$(COMPILER3_GXX))
COMPILER_GXX = $(subst $(RPAREN),_,$(COMPILER4_GXX))
MUTATEE_CXXFLAGS_GNU += -DCOMPILER='"$(COMPILER_GXX)"'

COMPILER1_NATIVE_CC = $(subst $(BLANK),_,$(COMPILERT_NATIVE_CC))
COMPILER2_NATIVE_CC = $(subst $(LPAREN),_,$(COMPILER1_NATIVE_CC))
COMPILER_NATIVE_CC = $(subst $(RPAREN),_,$(COMPILER2_NATIVE_CC))
MUTATEE_CFLAGS_NATIVE += -DCOMPILER='"$(COMPILER_NATIVE_CC)"'
MUTATEE_LDFLAGS_NATIVE += $(LDFLAGS) -L.

COMPILER1_NATIVE_CXX = $(subst $(BLANK),_,$(COMPILERT_NATIVE_CXX))
COMPILER2_NATIVE_CXX = $(subst $(LPAREN),_,$(COMPILER1_NATIVE_CXX))
COMPILER_NATIVE_CXX = $(subst $(RPAREN),_,$(COMPILER2_NATIVE_CXX))
MUTATEE_CXXFLAGS_NATIVE += -DCOMPILER='"$(COMPILER_NATIVE_CXX)"'

LIBDIR += $(LFLAGS)

#######################################################################
###  Basic definitions (filename prefixes)
#######################################################################

FORALL_MUTATORS =  

FORALL_MUTATEES = mutatee_util

SRCS_LIBTESTSUITE = test_lib.C \
                    test_lib_soExecution.C \
                    TestData.C \
                    TestMutator.C \
                    TestOutputDriver.C \
                    StdOutputDriver.C \
						  remotetest.C \
						  connection.C \
						  module.C

SRCS_LIBTESTLAUNCH = CmdLine.C \
							ParameterDict.C \
						  	ResumeLog.C \
							MutateeStart.C \
							test_info_new.C
# test_info_new.gen.C is also part of LIBTESTLAUNCH, but has special build rules

OBJS_LIBTESTLAUNCH = $(SRCS_LIBTESTLAUNCH:%.C=%.o)

SRCS_TEMPLATES = test_driver_templates.C 

OBJS_LIBTESTSUITE = $(SRCS_LIBTESTSUITE:%.C=%.o)
OBJS_TEMPLATES = $(SRCS_TEMPLATES:%.C=%.o)

ifdef USE_LIBTESTSUITE_EXT_A
LIBTESTSUITE = libtestSuite.a
LIBTESTLAUNCH = libtestlaunch.a
else
LIBTESTSUITE = libtestSuite.so
LIBTESTLAUNCH = libtestlaunch.so
endif

TESTDRIVER_LDFLAGS += $(DEMANGLER_EXEC_LINK)

ALL_COMP_DIRS = $(TO_CORE)/common/$(PLATFORM)
ALL_COMP_DIRS += $(TO_CORE)/testsuite/$(PLATFORM)
ALL_COMP_DIRS += $(TO_CORE)/parseAPI/$(PLATFORM)
ALL_COMP_DIRS += $(TO_CORE)/stackwalk/$(PLATFORM)
ALL_COMP_DIRS += $(TO_CORE)/proccontrol/$(PLATFORM)
ALL_COMP_DIRS += $(TO_CORE)/dyninstAPI/$(PLATFORM)
ALL_COMP_DIRS += $(TO_CORE)/symtabAPI/$(PLATFORM)
ALL_COMP_DIRS += $(TO_CORE)/instructionAPI/$(PLATFORM)

#######################################################
# Dyninst infrastructure components
#######################################################
SRCS_DYNINSTCOMP_LIB = dyninst/dyninst_comp.C \
                       dyninst/test_lib_mutateeStart.C \
                       dyninst/Callbacks.C \
                       dyninst/Process_data.C \
                       dyninst/ParseThat.C \
                       dyninst/test_lib_test7.C \
                       dyninst/test_lib_test9.C
OBJS_DYNINSTCOMP_LIB = $(notdir $(SRCS_DYNINSTCOMP_LIB:%.C=%.o))
SRCS_DYNINSTTESTLIB = libtestA.c \
                      libtestB.c \
                      dyninst/libTest12.c

#                      dyninst/libInstMe.c \
#                      dyninst/libLoadMe.c \

dyninst_MUTATOR_FLAGS = -L. -ltestdyninst -ldyninstAPI 

DYNINST_TESTLIBS = $(notdir $(SRCS_DYNINSTTESTLIB:%.c=%.so))
DYNINST_STATIC_TESTLIBS = $(notdir $(SRCS_DYNINSTTESTLIB:%.c=%.a))
ifdef M_ABI
DYNINST_TESTLIBS_ABI = $(addsuffix _$(M_ABI).so, $(notdir $(SRCS_DYNINSTTESTLIB:%.c=%)))
DYNINST_STATIC_TESTLIBS_ABI = $(addsuffix _$(M_ABI).a, $(notdir $(SRCS_DYNINSTTESTLIB:%.c=%)))
else
DYNINST_TESTLIBS_ABI =
DYNINST_STATIC_TESTLIBS_ABI = 
endif

ifdef USE_LIBTESTSUITE_EXT_A
LIBDYNINSTCOMP = libtestdyninst.a
else
LIBDYNINSTCOMP = libtestdyninst.so
endif

dyninst_MUTATOR_LIB = $(LIBDYNINSTCOMP)
dyninst_COMPONENT_LIB = $(LIBDYNINSTCOMP)

#######################################################
# Symtab infrastructure components
#######################################################
SRCS_SYMTABCOMP_LIB = symtab/symtab_comp.C
OBJS_SYMTABCOMP_LIB = $(notdir $(SRCS_SYMTABCOMP_LIB:%.C=%.o))
symtab_MUTATOR_FLAGS = -L. -ltestsymtab -lcommon

ifdef USE_LIBTESTSUITE_EXT_A
LIBSYMTABCOMP = libtestsymtab.a
else
LIBSYMTABCOMP = libtestsymtab.so
endif

symtab_MUTATOR_LIB = $(LIBSYMTABCOMP)
symtab_COMPONENT_LIB = $(LIBSYMTABCOMP)

#######################################################
# Instruction infrastructure components
#######################################################
SRCS_INSTRUCTIONCOMP_LIB = instruction/instruction_comp.C
OBJS_INSTRUCTIONCOMP_LIB = $(notdir $(SRCS_INSTRUCTIONCOMP_LIB:%.C=%.o))
instruction_MUTATOR_FLAGS = -L. -ltestinstruction -linstructionAPI -lcommon

ifdef USE_LIBTESTSUITE_EXT_A
LIBINSTRUCTIONCOMP = libtestinstruction.a
else
LIBINSTRUCTIONCOMP = libtestinstruction.so
endif

instruction_MUTATOR_LIB = $(LIBINSTRUCTIONCOMP)
instruction_COMPONENT_LIB = $(LIBINSTRUCTIONCOMP)

#######################################################
# ProcControlAPI infrastructure components
#######################################################
SRCS_PROCCONTROLCOMP_LIB = proccontrol/proccontrol_comp.C
OBJS_PROCCONTROLCOMP_LIB = $(notdir $(SRCS_PROCCONTROLCOMP_LIB:%.C=%.o))
proccontrol_MUTATOR_FLAGS += -L. -ltestproccontrol 

ifdef USE_LIBTESTSUITE_EXT_A
LIBPROCCONTROLCOMP = libtestproccontrol.a
else
LIBPROCCONTROLCOMP = libtestproccontrol.so
endif

proccontrol_MUTATOR_LIB = $(LIBPROCCONTROLCOMP)
proccontrol_COMPONENT_LIB = $(LIBPROCCONTROLCOMP)

######################################################################
### Main target
######################################################################

SPACE :=
SPACE +=
#COMPONENT_LDFLAGS += $(subst $(SPACE),,-Wl,--enable-new-dtags$(ALL_COMP_DIRS:%=,-rpath,%))
COMPONENT_LDFLAGS += $(subst $(SPACE),,-Wl$(ALL_COMP_DIRS:%=,-rpath,%))

default: testlibs mutators mutatees_minimum drivers output_drivers components
	@echo "**********************************************************"
	@echo "* Build complete."
	@echo "*"
	@echo "* High optimization mutatees were not built, use 'make all'"
	@echo "* to build them."
	@echo "**********************************************************"

all: testlibs mutators mutatees drivers output_drivers components

#######################################################################
###  A list of all the targets we're building, for install purposes
#######################################################################

ALL_TARGETS_DEST		= $(addprefix $(TEST_DEST)/,$(ALL_TARGETS))
LIBTESTSUITE_DEST               = $(addprefix $(TEST_DEST)/,$(LIBTESTSUITE))

#######################################################################
###  Some pattern rules
#######################################################################

CXXTFLAGS := $(filter-out -fno-implicit-templates, $(CXXFLAGS))

#######################################################################
###  High level targets
#######################################################################

MUTATOR_LDFLAGS := $(LDFLAGS) $(LIBDIR) $(MUTATOR_LIBS) $(MUTATOR_LDFLAGS) -lpthread
MUTATOR_SO_LDFLAGS = $(filter-out -liberty, $(MUTATOR_LDFLAGS))
MUTATEE_NATIVE_FC_LDFLAGS += $(LDFLAGS)
MUTATEE_NATIVE_CXX_OMP_LDFLAGS += $(LDFLAGS)
TESTDRIVER_LDFLAGS += $(LDFLAGS)

# all: testlibs mutators mutatees drivers
# See also an addition to the 'all' rule at the end of the file

### Automatically generated variables; generated by makemake.py

include make.mutators.gen

include make.solo_mutatee.gen

mutatees:

mutators:

components:

testlibs:

#######################################################################
###  Filter results, if needed
#######################################################################

MINIMUM_BUILD_FILTER = %_max %_high %_low
BUILD_FILTER =
ifdef SKIP_BUILD_RTLIB_32
   BUILD_FILTER += %_32_none_max %_32_none_high %_32_none_low %_32_none_none %_32_pic_max %_32_pic_high %_32_pic_low %_32_pic_none
endif

include $(TO_CORE)/make.components

ifneq ($(wildcard ../src/dyninst), )
ifneq ($(findstring dyninstAPI,$(fullSystem)),)
mutatees: $(filter-out $(BUILD_FILTER), $(dyninst_SOLO_MUTATEES))
mutatees_minimum: $(filter-out $(BUILD_FILTER), $(filter-out $(MINIMUM_BUILD_FILTER), $(dyninst_SOLO_MUTATEES)))
mutators: $(dyninst_MUTATORS_SO)
components: $(LIBDYNINSTCOMP)
testlibs: $(DYNINST_TESTLIBS) $(DYNINST_STATIC_TESTLIBS)
ifndef SKIP_BUILD_RTLIB_32
testlibs: $(DYNINST_TESTLIBS_ABI) $(DYNINST_STATIC_TESTLIBS_ABI)
dyninst_targs = $(DYNINST_TESTLIBS_ABI) $(DYNINST_STATIC_TESTLIBS_ABI)
endif
dyninst_targs += $(filter-out $(BUILD_FILTER), $(filter-out $(MINIMUM_BUILD_FILTER), $(dyninst_SOLO_MUTATEES)))
dyninst_targs += $(dyninst_MUTATORS_SO) $(LIBDYNINSTCOMP) $(DYNINST_TESTLIBS) $(DYNINST_STATIC_TESTLIBS)
endif
endif

ifneq ($(wildcard ../src/symtab), )
ifneq ($(findstring symtabAPI,$(fullSystem)),)
mutatees: $(filter-out $(BUILD_FILTER), $(symtab_SOLO_MUTATEES))
mutatees_minimum: $(filter-out $(BUILD_FILTER), $(filter-out $(MINIMUM_BUILD_FILTER), $(symtab_SOLO_MUTATEES)))
mutators: $(symtab_MUTATORS_SO)
components: $(LIBSYMTABCOMP)
testlibs:
symtab_targs = $(filter-out $(BUILD_FILTER), $(filter-out $(MINIMUM_BUILD_FILTER), $(symtab_SOLO_MUTATEES)))
symtab_targs = $(symtab_MUTATORS_SO) $(LIBSYMTABCOMP)
endif
endif

ifneq ($(wildcard ../src/instruction), )
ifneq ($(findstring instructionAPI,$(fullSystem)),)
mutatees: $(filter-out $(BUILD_FILTER), $(instruction_SOLO_MUTATEES))
mutatees_minimum: $(filter-out $(BUILD_FILTER), $(filter-out $(MINIMUM_BUILD_FILTER), $(instruction_SOLO_MUTATEES)))
mutators: $(instruction_MUTATORS_SO)
ifneq ($(instruction_MUTATORS_SO), )
components: $(LIBINSTRUCTIONCOMP)
testlibs:
instruction_targs = $(LIBINSTRUCTIONCOMP)
endif
instruction_targs += $(filter-out $(BUILD_FILTER), $(filter-out $(MINIMUM_BUILD_FILTER), $(instruction_SOLO_MUTATEES)))
instruction_targs += $(instruction_MUTATORS_SO) $(LIBINSTRUCTIONCOMP)
endif
endif

ifneq ($(wildcard ../src/proccontrol), )
ifneq ($(findstring proccontrol,$(fullSystem)),)
mutatees: $(filter-out $(BUILD_FILTER), $(proccontrol_SOLO_MUTATEES)) 
mutatees_minimum: $(filter-out $(BUILD_FILTER), $(filter-out $(MINIMUM_BUILD_FILTER), $(proccontrol_SOLO_MUTATEES)))
mutators: $(proccontrol_MUTATORS_SO)
ifneq ($(proccontrol_MUTATORS_SO), )
components: $(LIBPROCCONTROLCOMP)
testlibs: $(PROCCONTROL_TESTLIBS) $(PROCCONTROL_TESTLIBS_ABI) $(DYNINST_TESTLIBS) $(DYNINST_TESTLIBS_ABI)
proccontrol_targs = $(LIBPROCCONTROLCOMP) $(PROCCONTROL_TESTLIBS) $(PROCCONTROL_TESTLIBS_ABI) $(DYNINST_TESTLIBS) $(DYNINST_TESTLIBS_ABI)
endif
proccontrol_targs += $(filter-out $(BUILD_FILTER), $(filter-out $(MINIMUM_BUILD_FILTER), $(proccontrol_SOLO_MUTATEES)))
proccontrol_targs += $(proccontrol_MUTATORS_SO)
endif
endif

common_infra: drivers output_drivers

dyninstAPI: common_infra $(dyninst_targs) $(symtab_targs) $(instruction_targs) $(proccontrol_targs)

symtabAPI: common_infra $(symtab_targs)

instructionAPI: common_infra $(instruction_targs)

proccontrol: common_infra $(proccontrol_targs)

install: default

symlink: all

clean: clean_solo_mutatees dyninst_clean_solo_mutatees
	@$(RM) *.da *.bb. *.bbg 
	@$(RM) $(TESTLIBS) $(TESTLIBS_ABI) $(LIBTESTSUITE) test_driver runTests libTest12.so testdriver_wrapper
	@$(RM) $(dyninst_MUTATORS_SO)
	@$(RM) $(symtab_MUTATORS_SO)
	@$(RM) $(symtab_SOLO_MUTATEES)
	@$(RM) $(instruction_MUTATORS_SO)
	@$(RM) $(instruction_SOLO_MUTATEES)
	@$(RM) $(proccontrol_MUTATORS_SO)
	@$(RM) $(proccontrol_SOLO_MUTATEES)
	@$(RM) $(OUTPUT_DRIVERS)
	@$(RM) $(LIBDYNINSTCOMP)
	@$(RM) $(LIBSYMTABCOMP)
	@$(RM) $(LIBINSTRUCTIONCOMP)
	@$(RM) $(LIBPROCCONTROLCOMP)
	@$(RM) $(DYNINST_TESTLIBS) $(DYNINST_STATIC_TESTLIBS) $(DYNINST_TESTLIBS_ABI) $(DYNINST_STATIC_TESTLIBS_ABI)
	@$(RM) *.o
	@$(RM) test11
	@$(RM) imagefile
	@$(RM) core core.*
	@$(RM) -r _dyninstsaved*
	@$(RM) *.ii *.ti
	@$(RM) .__afs*
 

distclean: clean
	@if [ -d $(DEPENDDIR) ]; then \
	  $(RM) $(DEPENDDIR)/*.dep; \
          rmdir $(DEPENDDIR); \
         fi

specclean:
	$(RM) *.gen *.pl tuples test_info_new.gen.C

ifdef M_ABI
$(CALL35_1_OBJ_ABI): $(CALL35_1_SRC_ABI)
	$(M_GCC) $(M_ABI_FLAG) -c $< $(CFLAGS) $(MUTATEE_CFLAGS_GNU) -o $@ 
endif

testlibs: $(LIBTESTSUITE)

drivers: test_driver runTests testdriver_wrapper

.PHONY: clean install distclean mutators mutatees testlibs gnu_mutatees native_mutatees echo all

#######################################################################
###  Build command for test libraries
#######################################################################

$(dyninst_OBJS_ALL_MUTATORS): %.o : dyninst/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ -I../src/dyninst ../src/dyninst/$*.C
$(symtab_OBJS_ALL_MUTATORS): %.o : symtab/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ -I../src/symtab ../src/symtab/$*.C
$(instruction_OBJS_ALL_MUTATORS): %.o : instruction/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ -I../src/instruction ../src/instruction/$*.C
$(proccontrol_OBJS_ALL_MUTATORS): %.o : proccontrol/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ -I../src/proccontrol ../src/proccontrol/$*.C

TESTLIB_CC ?= $(CC)
$(DYNINST_TESTLIBS): %.so : %.c $(DEPENDDIR)/%.dep
ifdef MAKE_SHARED_LIB
	@echo Compiling $@
	$(HIDE_COMP)$(TESTLIB_CC) $(LDFLAGS) -c $(CFLAGS) $(CFLAGS_TESTLIBS) $(filter %.c, $^) -o $*.o
	$(HIDE_COMP)$(MAKE_SHARED_LIB) $(TESTLIB_FLAGS) $*.o -o $@
else
	@echo Compiling $@
	$(HIDE_COMP)$(TESTLIB_CC) $(LDFLAGS) $(TESTLIB_FLAGS) -I../src/ $(filter %.c,$^) -o $@
endif

$(DYNINST_STATIC_TESTLIBS): %.a : %.c $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(TESTLIB_CC) $(LDFLAGS) -c $(CFLAGS) $(CFLAGS_TESTLIBS) $(filter %.c, $^) -o $*.o
	$(HIDE_COMP)$(AR) rcs $@ $*.o

ifdef M_ABI
$(DYNINST_TESTLIBS_ABI): %_$(M_ABI).so : %.c $(DEPENDDIR)/%.dep
ifdef MAKE_SHARED_LIB
	@echo Compiling $@
	$(HIDE_COMP)$(TESTLIB_CC) $(LDFLAGS) -c $(CFLAGS) $(CFLAGS_TESTLIBS) $(filter %.c, $^) -o $*.o
	$(HIDE_COMP)$(MAKE_SHARED_LIB) $(LDFLAGS) $(TESTLIB_FLAGS) $*.o -o $@
else
	@echo Compiling $@
	$(HIDE_COMP)$(TESTLIB_CC) $(M_ABI_FLAG) $(LDFLAGS) $(TESTLIB_FLAGS) -I../src/ $(filter %.c,$^) -o $@
endif

ifdef cap_instruction_api
    INSNAPI_LINK = -linstructionAPI
endif

$(DYNINST_STATIC_TESTLIBS_ABI): %_$(M_ABI).a : %.c $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(TESTLIB_CC) -c $(CFLAGS) $(LDFLAGS) $(CFLAGS_TESTLIBS) $(filter %.c, $^) -o $*.o
	$(HIDE_COMP)$(AR) rcs $@ $*.o
endif

$(OBJS_TEMPLATES): %.o : ../src/%.C
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -o $@ $(CXXTFLAGS) -I../src/ ../src/$*.C

test_lib_templates.o : ../src/test_lib_templates.C
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -o $@ -fPIC $(CXXTFLAGS) -I../src/ ../src/$*.C

$(OBJS_DYNINSTCOMP_LIB): %.o : ../src/dyninst/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ ../src/dyninst/$*.C

$(OBJS_SYMTABCOMP_LIB): %.o : ../src/symtab/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ ../src/symtab/$*.C

$(OBJS_INSTRUCTIONCOMP_LIB): %.o : ../src/instruction/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ ../src/instruction/$*.C

$(OBJS_PROCCONTROLCOMP_LIB): %.o : ../src/proccontrol/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ ../src/proccontrol/$*.C

$(OBJS_LIBTESTSUITE): %.o : ../src/%.C $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ ../src/$*.C

# test_info_new.gen.o is special-cased because it makes use of the
# COMPILER_CONTROL_DEFS to determine which mutatees to enable for compilers
# that are not present at all sites.
test_info_new.gen.o: test_info_new.gen.C
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -fPIC -o $@ $(CXXFLAGS) $(COMPILER_CONTROL_DEFS) -I../src/ test_info_new.gen.C

$(OBJS_LIBTESTLAUNCH): %.o :  ../src/%.C ../src/%.h $(DEPENDDIR)/%.dep
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -fPIC -o $@ $(CXXFLAGS) -I../src/ ../src/$*.C

$(LIBDYNINSTCOMP) : $(OBJS_DYNINSTCOMP_LIB) $(LIBTESTSUITE)
	@echo Linking $<
	$(HIDE_COMP)$(CXX) -shared $(TESTSUITE_FLAGS) $(LIBDIR) $(OBJS_DYNINSTCOMP_LIB) -o $@ -L. -ltestSuite -ldyninstAPI -lsymtabAPI -lcommon -linstructionAPI $(COMPONENT_LDFLAGS)

$(LIBSYMTABCOMP) : $(OBJS_SYMTABCOMP_LIB) $(LIBTESTSUITE)
	@echo Linking $<
	$(HIDE_COMP)$(CXX) -shared $(TESTSUITE_FLAGS) $(LIBDIR) $(OBJS_SYMTABCOMP_LIB) -o $@ -L. -ltestSuite -lsymtabAPI -lcommon $(COMPONENT_LDFLAGS)

$(LIBINSTRUCTIONCOMP) : $(OBJS_INSTRUCTIONCOMP_LIB) $(LIBTESTSUITE)
	@echo Linking $<
	$(HIDE_COMP)$(CXX) -shared $(TESTSUITE_FLAGS) $(LIBDIR) $(OBJS_INSTRUCTIONCOMP_LIB) -o $@ -L. -ltestSuite -linstructionAPI -lcommon $(COMPONENT_LDFLAGS)

$(LIBPROCCONTROLCOMP) : $(OBJS_PROCCONTROLCOMP_LIB) $(LIBTESTSUITE)
	@echo Linking $<
	$(HIDE_COMP)$(CXX) -shared $(TESTSUITE_FLAGS) $(LIBDIR) $(OBJS_PROCCONTROLCOMP_LIB) -o $@ -L. -ltestSuite -lpcontrol -lcommon $(COMPONENT_LDFLAGS)

$(LIBTESTSUITE) : $(OBJS_LIBTESTSUITE) test_lib_templates.o test_lib.h
	@echo Linking $<
	$(HIDE_COMP)$(CXX) -shared $(TESTSUITE_FLAGS) $(LIBDIR) $(LIBS_LIBTESTSUITE) $(OBJS_LIBTESTSUITE) test_lib_templates.o -o $@ $(COMPONENT_LDFLAGS)

$(LIBTESTLAUNCH) : $(OBJS_LIBTESTLAUNCH) test_info_new.gen.o
	@echo Linking $@
	$(HIDE_COMP)$(CXX) -shared $(TESTUITE_FLAGS) $(LIBDIR) -o $@ $^
#
# Native Fortran mutatees
# 
# There is no real advantage to generality here since there is only one fortran mutatee
# (ie for test1), thus all constituent files are built explicitly

ifdef NATIVE_FC 
test1.mutatee_$(NATIVE_FC).o: ../src/test1.mutateeFort.F
	$(NATIVE_FC)  $(MUTATEE_NATIVE_FFLAGS) -c -o $@ $^ 
test1.mutateeFortC_$(NATIVE_FC).o: ../src/test1.mutateeFortC.c
	$(NATIVE_FORTRAN_CC) $(MUTATEE_NATIVE_FC_CFLAGS) -c $(filter %.c,$^) -o $@

$(MUTATEES_NATIVE_FC): test%.mutatee_$(NATIVE_FC) : test%.mutatee_$(NATIVE_FC).o test1.mutateeFortC_$(NATIVE_FC).o test1.mutateeCommon_$(NATIVE_FORTRAN_CC).o mutatee_util_$(NATIVE_FORTRAN_CC).o $(DEPENDDIR)/test%.mutatee_$(NATIVE_FC).dep
	$(NATIVE_FC) -o $@ $(filter %.o,$^) $(MUTATEE_NATIVE_FC_LDFLAGS) $(MUTATEE_LIBS) 
endif

# Native OpenMP mutatees
# There is no real advantage to generality here since there is only one OpenMP mutatee
# (ie for test16), thus all constituent files are built explicitly
ifdef NATIVE_CXX_OMP 
test16.mutatee_$(NATIVE_CXX_OMP).o: ../src/test16.mutatee.c
	$(NATIVE_CXX_OMP)  $(MUTATEE_NATIVE_CXX_CFLAGS) -o $@ $^ 

$(MUTATEES_NATIVE_CXX_OMP): test%.mutatee_$(NATIVE_CXX_OMP) : test%.mutatee_$(NATIVE_CXX_OMP).o $(DEPENDDIR)/test%.mutatee_$(NATIVE_CXX_OMP).dep
	$(NATIVE_CXX_OMP) $(MUTATEE_NATIVE_CXX_OMP_LDFLAGS) -o $@ $(filter %.o,$^) $(MUTATEE_LIBS) 

#$(MUTATEES_NATIVE_CXX_OMP): ../src/test16.mutatee.c
#	$(NATIVE_CXX_OMP)  $(MUTATEE_NATIVE_CXX_CFLAGS) -o $@ $^ 

endif


# Install directory
$(TEST_DEST): 
	mkdir $(TEST_DEST)

#######################################################################
###  Generic Mutator build rule:
###
###  resorts to pattern matching test% (matches test1, test2, ... etc)
###  to generate correct, minimal set of prerequisites for each test.
###  It would be nicer to just match something simpler that wasn't 
###  name-dependant, but gnu make is not making this easy.
###
#######################################################################

MUTATEE_DEFS := -Dgnu_cc=_gcc -Dgnu_cxx=_g++

ifdef M_ABI
MUTATEE_DEFS += -Dgnu_abi_cc=_gcc_$(M_ABI) -Dgnu_abi_cxx=_g++_$(M_ABI) -Dm_abi
endif

ifdef M_G77
MUTATEE_DEFS += -Dgnu_fc=_g77
endif

ifdef NATIVE_CC
MUTATEE_DEFS += -Dnative_cc=_$(NATIVE_CC)
endif

ifdef NATIVE_CXX
MUTATEE_DEFS += -Dnative_cxx=_$(NATIVE_CXX)
endif

ifdef NATIVE_FC
MUTATEE_DEFS += -Dnative_fc=_$(NATIVE_FC)
endif

runTests.o: ../src/runTests.C $(DEPENDDIR)/runTests.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ $(CXXFLAGS) $(MUTATEE_DEFS) ../src/runTests.C
runTests_static.o: ../src/runTests.C $(DEPENDDIR)/runTests.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ $(CXXFLAGS) $(MUTATEE_DEFS) -DSTATIC_TEST_DRIVER ../src/runTests.C

runTests-utils.o: ../src/runTests-utils.C $(DEPENDDIR)/runTests-utils.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ $(CXXFLAGS) $(MUTATEE_DEFS) ../src/runTests-utils.C

runTests: runTests.o runTests-utils.o test_driver_templates.o  $(LIBTESTLAUNCH)
	@echo Linking $@
	$(HIDE_COMP)$(CXX) $(CXXFLAGS) -o $@ runTests.o runTests-utils.o test_driver_templates.o -L.
runTests_static: runTests_static.o runTests-utils.o test_driver_templates.o 
	@echo Linking $@
	$(HIDE_COMP)$(CXX) $(CXXFLAGS) -o runTests runTests_static.o runTests-utils.o test_driver_templates.o 

test_driver.o: ../src/test_driver.C $(DEPENDDIR)/test_driver.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ $(CXXFLAGS) $(MUTATEE_DEFS) ../src/test_driver.C

testdriver_be.o: ../src/testdriver_be.C $(DEPENDDIR)/testdriver_be.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ $(CXXFLAGS) $(MUTATEE_DEFS) $(LAUNCHMON_BE_CFLAGS) ../src/testdriver_be.C

testdriver_wrapper.o: ../src/testdriver_wrapper.C ../src/remotetest.h
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -g -c -o $@ $(CXXFLAGS) ../src/testdriver_wrapper.C -Wall

dynlmon.o: ../src/dynlmon.C $(DEPENDDIR)/dynlmon.dep
	$(HIDE_COMP)$(CXX) -c -o $@ $(CXXFLAGS) $(MUTATEE_DEFS) $(LAUNCHMON_FE_CFLAGS) -I../../ ../src/dynlmon.C

test_driver_static.o: ../src/test_driver.C $(DEPENDDIR)/test_driver_static.dep
	@echo Compiling $@
	$(HIDE_COMP)$(CXX) -c -o $@ -DSTATIC_TEST_DRIVER $(CXXFLAGS) $(MUTATEE_DEFS) ../src/test_driver.C

test_driver: test_driver.o test_driver_templates.o dynlmon.o testdriver_be.o test_info_new.gen.o $(DEPENDDIR)/test_driver.dep $(LIBTESTSUITE) $(LIBTESTLAUNCH)
	@echo Linking $@ 
	$(HIDE_COMP)$(CXX) -o $@ test_driver.o test_driver_templates.o test_info_new.gen.o testdriver_be.o dynlmon.o -L. -ltestSuite $(MUTATOR_LDFLAGS) $(LIBS) $(TESTDRIVER_LDFLAGS) -lcommon -ltestlaunch $(LAUNCHMON_LINK) $(COMPONENT_LDFLAGS) ; $(TESTDRIVER_EXTRA_LINK_STEP)

testdriver_wrapper: connection.o testdriver_wrapper.o
	@echo Linking $@
	$(HIDE_COMP)$(CXX) -o $@ connection.o testdriver_wrapper.o $(LAUNCHMON_BE_LINK)

######################################################################
### Output Drivers
######################################################################

OUTPUT_DRIVERS = DatabaseOutputDriver.so

DatabaseOutputDriver.o : ../src/DatabaseOutputDriver.C # $(DEPENDDIR)/DatabaseOutputDriver.dep
	@echo Compiling $@
	$(HIDE_COMP)$(M_GXX) -c -o $@ -fPIC $(CXXFLAGS) -I../src/ ../src/$*.C

DatabaseOutputDriver.so: DatabaseOutputDriver.o $(LIBTESTSUITE) # $(DEPENDDIR)/DatabaseOutputDriver.dep
	@echo Linking $@
	$(HIDE_COMP)$(CXX) -o $@ -shared $(filter %.o,$^) $(MUTATOR_SO_LDFLAGS) $(LIBDIR) $(LIBS) -L. -ltestSuite
ifndef NO_OPT_FLAG
ifdef STRIP_SO
	$(STRIP_SO) $@
endif
endif

.PHONY: output_drivers
output_drivers: $(OUTPUT_DRIVERS)

#######################################################################
###  Depends
#######################################################################

DEPS_MUTATORS           += $(DEPENDDIR)/test_driver.dep
DEPS_MUTATORS           += $(DEPENDDIR)/testdriver_be.dep
DEPS_MUTATORS           += $(DEPENDDIR)/dynlmon.dep
DEPS_MUTATORS           += $(DEPENDDIR)/runTests.dep $(DEPENDDIR)/runTests-utils.dep
DEPS_SYMTAB_MUTATORS    += $(addprefix $(DEPENDDIR)/,$(symtab_OBJS_ALL_MUTATORS:%.o=%.dep))
DEPS_DYNINST_MUTATORS    += $(addprefix $(DEPENDDIR)/,$(dyninst_OBJS_ALL_MUTATORS:%.o=%.dep))
DEPS_INSTRUCTION_MUTATORS    += $(addprefix $(DEPENDDIR)/,$(instruction_OBJS_ALL_MUTATORS:%.o=%.dep))
DEPS_PROCCONTROL_MUTATORS    += $(addprefix $(DEPENDDIR)/,$(proccontrol_OBJS_ALL_MUTATORS:%.o=%.dep))

DEPS_MUTATEES_GCC	+= $(addprefix $(DEPENDDIR)/,$(addsuffix _gcc.dep, $(MUTATEES_C)))
DEPS_MUTATEES_GXX	+= $(addprefix $(DEPENDDIR)/,$(addsuffix _g++.dep, $(MUTATEES_CXX)))
DEPS_MUTATEES_GXX	+= $(addprefix $(DEPENDDIR)/,$(addsuffix _g++.dep, $(MUTATEES_CXX_ONLY)))
DEPS_DYNINST_TESTLIBS	= $(addprefix $(DEPENDDIR)/,$(DYNINST_TESTLIBS:%.so=%.dep))
DEPS_LIBTESTSUITE        = $(addprefix $(DEPENDDIR)/,$(SRCS_LIBTESTSUITE:%.C=%.dep))
DEPS_LIBTESTLAUNCH        = $(addprefix $(DEPENDDIR)/,$(SRCS_LIBTESTLAUNCH:%.C=%.dep))
DEPS_DYNINSTCOMP       =  $(addprefix $(DEPENDDIR)/,$(notdir $(SRCS_DYNINSTCOMP_LIB:%.C=%.dep)))
DEPS_SYMTABCOMP        = $(addprefix $(DEPENDDIR)/,$(notdir $(SRCS_SYMTABCOMP_LIB:%.C=%.dep)))
DEPS_INSTRUCTIONCOMP        = $(addprefix $(DEPENDDIR)/,$(notdir $(SRCS_INSTRUCTIONCOMP_LIB:%.C=%.dep)))
DEPS_PROCCONTROLCOMP        = $(addprefix $(DEPENDDIR)/,$(notdir $(SRCS_PROCCONTROLCOMP_LIB:%.C=%.dep)))

ifdef M_G77
DEPS_MUTATEES_G77	+= $(addprefix $(DEPENDDIR)/,$(addsuffix _g77.dep, $(MUTATEES_FORTRAN)))
endif

ifdef NATIVE_FC
DEPS_MUTATEES_NATIVE_FC	+= $(addprefix $(DEPENDDIR)/,$(addsuffix _$(NATIVE_FC).dep, $(MUTATEES_FORTRAN)))
endif

ifdef NATIVE_CXX_OMP
DEPS_MUTATEES_NATIVE_CXX_OMP += $(addprefix $(DEPENDDIR)/,$(addsuffix _$(NATIVE_CXX_OMP).dep, $(MUTATEES_OPENMP)))
endif

ifdef NATIVE_CC
DEPS_MUTATEES_NATIVE_CC	+= $(addprefix $(DEPENDDIR)/,$(addsuffix _$(NATIVE_CC).dep, $(MUTATEES_C)))
endif

ifdef NATIVE_CXX
DEPS_MUTATEES_NATIVE_CXX += $(addprefix $(DEPENDDIR)/,$(addsuffix _$(NATIVE_CXX).dep, $(MUTATEES_CXX)))
DEPS_MUTATEES_NATIVE_CXX += $(addprefix $(DEPENDDIR)/,$(addsuffix _$(NATIVE_CXX).dep, $(MUTATEES_CXX_ONLY)))
endif

depend: $(DEPS_MUTATORS)

depend_dir:
	@echo "mut deps: $(DEPS_MUTATORS)"
	@if [ -d $(DEPENDDIR) ]; then \
          echo "Directory \"$(DEPENDDIR)\" already exists..."; \
         else \
          mkdir -p $(DEPENDIR); \
          echo "Made \"$(DEPENDDIR)\" directory..."; \
         fi

$(DEPENDDIR)/test_driver_static.dep: test_driver.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) $< $(MUTATOR_CXXFLAGS) -DSTATIC_TEST_DRIVER $(DEPENDFLAGS) $*.o > $@

$(DEPS_MUTATORS): $(DEPENDDIR)/%.dep : %.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_SYMTAB_MUTATORS): $(DEPENDDIR)/%.dep : symtab/%.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_INSTRUCTION_MUTATORS): $(DEPENDDIR)/%.dep : instruction/%.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_PROCCONTROL_MUTATORS): $(DEPENDDIR)/%.dep : proccontrol/%.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_DYNINST_MUTATORS): $(DEPENDDIR)/%.dep : dyninst/%.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_MUTATEES_GCC): $(DEPENDDIR)/test%.mutatee_gcc.dep : test%.mutatee.c $(SRCS_FORALL_MUTATEES)
	@mkdir -p $(DEPENDDIR)
	$(M_GCC) $(CFLAGS) $< $(MUTATEE_CFLAGS) $(DEPENDFLAGS) test$*.mutatee_gcc.o > $@

$(DEPS_MUTATEES_GXX): $(DEPENDDIR)/test%.mutatee_g++.dep : $(wildcard test%.mutatee.*) $(SRCS_FORALL_MUTATEES)
	@mkdir -p $(DEPENDDIR)
	$(M_GXX) $(CXXFLAGS) $< $(MUTATEE_CXXFLAGS) $(DEPENDFLAGS) test$*.mutatee_gxx.o > $@

$(DEPS_MUTATEES_G77): $(DEPENDDIR)/test%.mutatee_g77.dep : test%.mutateeFort.F $(SRCS_FORALL_MUTATEES)
	@mkdir -p $(DEPENDDIR)
	$(M_G77) $(CFLAGS) $< $(MUTATEE_CFLAGS) $(DEPENDFLAGS) test$*.mutateeFort_g77.o > $@


# Use gcc to generate deps for native compilers

ifdef NATIVE_CC
$(DEPS_MUTATEES_NATIVE_CC): $(DEPENDDIR)/test%.mutatee_$(NATIVE_CC).dep : test%.mutatee.c $(SRCS_FORALL_MUTATEES)
	@mkdir -p $(DEPENDDIR)
	$(M_GCC) $(CFLAGS) $< $(MUTATEE_CFLAGS) $(DEPENDFLAGS) test$*.mutatee_$(NATIVE_CC).o > $@
endif

ifdef NATIVE_CXX
$(DEPS_MUTATEES_NATIVE_CXX): $(DEPENDDIR)/test%.mutatee_$(NATIVE_CXX).dep : $(wildcard test%.mutatee.*) $(SRCS_FORALL_MUTATEES)
	@mkdir -p $(DEPENDDIR)
	$(M_GXX) $(CXXFLAGS) $< $(MUTATEE_CXXFLAGS) $(DEPENDFLAGS) test$*.mutatee_$(NATIVE_CXX).o > $@
endif

ifdef NATIVE_FC
$(DEPS_MUTATEES_NATIVE_FC): $(DEPENDDIR)/test%.mutatee_$(NATIVE_FC).dep : test%.mutateeFort.F $(SRCS_FORALL_MUTATEES)
	@mkdir -p $(DEPENDDIR)
	$(M_G77) $(CFLAGS) $< $(MUTATEE_CFLAGS) $(DEPENDFLAGS) test$*.mutateeFort_$(NATIVE_FC).o > $@
endif

ifdef NATIVE_CXX_OMP
$(DEPS_MUTATEES_NATIVE_CXX_OMP): $(DEPENDDIR)/test%.mutatee_$(NATIVE_CXX_OMP).dep : test%.mutatee.c $(SRCS_FORALL_MUTATEES)
	@mkdir -p $(DEPENDDIR)
	$(M_GXX) $(CFLAGS) $< $(MUTATEE_CFLAGS) $(DEPENDFLAGS) test$*.mutatee_$(NATIVE_CXX_OMP).o > $@
endif


$(DEPS_DYNINST_TESTLIBS): $(DEPENDDIR)/lib%.dep : lib%.c 
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) lib$*.so > $@

$(DEPS_LIBTESTLAUNCH) $(DEPS_LIBTESTSUITE): $(DEPENDDIR)/%.dep : %.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) -I../src $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_DYNINSTCOMP): $(DEPENDDIR)/%.dep : dyninst/%.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) -I../src -I../src/dyninst $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_SYMTABCOMP): $(DEPENDDIR)/%.dep : symtab/%.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) -I../src -I../src/symtab $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_INSTRUCTIONCOMP): $(DEPENDDIR)/%.dep : instruction/%.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) -I../src -I../src/instruction $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

$(DEPS_PROCCONTROLCOMP): $(DEPENDDIR)/%.dep : proccontrol/%.C
	@mkdir -p $(DEPENDDIR)
	$(HIDE_COMP)$(DEPCC) $(CXXFLAGS) -I../src -I../src/proccontrol $< $(MUTATOR_CXXFLAGS) $(DEPENDFLAGS) $*.o > $@

# do not include dep files for "clean" targets
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
ifneq ($(MAKECMDGOALS),echo)

-include $(DEPS_MUTATORS)
# -include $(DEPS_MUTATEES_GCC)
# -include $(DEPS_MUTATEES_GXX)
# -include $(DEPS_TESTLIBS)

ifdef M_G77
# -include $(DEPS_MUTATEES_G77)
endif

ifdef NATIVE_CC
# -include $(DEPS_MUTATEES_NATIVE_CC)
endif

ifdef NATIVE_CXX
-include $(DEPS_MUTATEES_NATIVE_CXX)
endif

ifdef NATIVE_FC
-include $(DEPS_MUTATEES_NATIVE_FC)
endif

ifdef NATIVE_CXX_OMP
-include $(DEPS_MUTATEES_NATIVE_CXX_OMP)
endif

endif
endif
endif