I'm fairly new to makefiles and am currently running with the following one that came with the code and that I extended by the options FFLAGS_EXT1, COMP_EXT1, and file1.F90 and file2.F90:
FC = gfortran
FFLAGS = -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
FFLAGS_EXT1 = -g -fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5 -Dno_nans -I ../ # Stricter compiler flags
LDFLAGS =
OBJ_EXT = o
EXE_EXT = x
COMP = $(FC) $(FFLAGS) -c -o $# $<
COMP_EXT1 = $(FC) $(FFLAGS_EXT1) -c -o $# $<
LINK = $(FC) $(LDFLAGS) -o $# $^
MAIN_MODULES = $(a list of file names without extensions)
OUR_MODULES = $(another list of file names without extensions)
# FORTRAN settings
.SUFFIXES: .F90 .$(OBJ_EXT)
# compilation rules
.F90.$(OBJ_EXT):
# $(COMP)
$(COMP_EXT1)
.PHONY: all
all: \
program1.$(EXE_EXT) program2.$(EXE_EXT) ...
program1.$(EXE_EXT): \
$(addsuffix .$(OBJ_EXT),$(MAIN_MODULES)) \
$(addsuffix .$(OBJ_EXT),$(OUR_MODULES)) \
file1.$(OBJ_EXT) \
file2.$(OBJ_EXT)
$(LINK)
...
This enables me to compile either all of the source files with FFLAGS or with the stricter FFLAGS_EXT1 depending on the choice of the compilation rule.
What I'd like to get is: use COMP as default (there are also other programs apart from the defined program1 which I must not break compatibility with) but use COMP_EXT1 or respectively FFLAGS_EXT1 specifically for file1 and file2 (the legacy code throws a lot of warnings I'd like to ignore and only focus on my new stuff - it is a fairly large project in total...).
I am aware of, e.g., this post, but I'm totally unaware of how to implement this in my case.
Any help would be highly appreciated!
EDIT:
Thanks to the hint by #Matt, I figured out the this changed version would do the trick:
FC = gfortran
FFLAGS = -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
FFLAGS_EXT1 = -g -fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5 -Dno_nans -I ../ # Stricter compiler flags
LDFLAGS =
OBJ_EXT = o
EXE_EXT = x
COMP = $(FC) $(FFLAGS) -c -o $# $<
LINK = $(FC) $(LDFLAGS) -o $# $^
MAIN_MODULES = $(a list of file names without extensions)
OUR_MODULES = $(another list of file names without extensions)
# FORTRAN settings
.SUFFIXES: .F90 .$(OBJ_EXT)
# compilation rules
.F90.$(OBJ_EXT):
$(COMP)
file1.$(OBJ_EXT):
$(FC) $(FFLAGS_EXT1) -c file1.F90 -o file1.$(OBJ_EXT)
file2.$(OBJ_EXT):
$(FC) $(FFLAGS_EXT1) -c file2.F90 -o file2.$(OBJ_EXT)
.PHONY: all
all: \
program1.$(EXE_EXT) program2.$(EXE_EXT) ...
program1.$(EXE_EXT): \
$(addsuffix .$(OBJ_EXT),$(MAIN_MODULES)) \
$(addsuffix .$(OBJ_EXT),$(OUR_MODULES)) \
file1.$(OBJ_EXT) \
file2.$(OBJ_EXT)
$(LINK)
...
However, this seems to be quite cumbersome once there are many rules and many files. Simply using something like $(COMP_EXT1) did not work, as it failed with a no input file error.
Is there a way to shorten this construct?
Well, by all means, this is a matter of style. But let's try something:
# prefer simple variables over recursive ones...
FC := gfortran
FFLAGS := -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
FFLAGS_EXTRA := -fbacktrace -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5
# ...unless we *do* require deferred expansion
COMP = $(FC) $(FFLAGS) $(FFLAGS_$#) -c -o $# $<
LINK = $(FC) $(LDFLAGS) -o $# $^
# this is a matter of choice but one-letter variables could be handy
O := o
X := x
# I assume both file1 and file2 are already mentioned here
MAIN_MODULES := $(a list of file names without extensions)
OUR_MODULES := $(another list of file names without extensions)
# use computed variables for maximum flexibility
FFLAGS_file1.$O := $(FFLAGS_EXTRA)
FFLAGS_file2.$O := $(FFLAGS_EXTRA)
.PHONY: all
all: program1.$X program2.$X ...
program1.$X: $(addsuffix .$O,$(MAIN_MODULES) $(OUR_MODULES))
$(LINK)
program2.$X: ...
$(LINK)
# it is recommended to use pattern rules instead of suffix rules
%.$O: %.F90
$(COMP)
...
Maybe you want to go a different route, namely to use gmtt which is a library for well, quite some things programming in GNUmake. It offers a table data structure which is aimed at build config tasks like yours:
include gmtt-master/gmtt.mk
FC = gfortran
FFLAGS = -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
LDFLAGS =
OBJ_EXT = o
EXE_EXT = x
COMP = $(FC) $(FFLAGS) -c -o $# $<
LINK = $(FC) $(LDFLAGS) -o $# $^
MAIN_MODULES = $(a list of file names without extensions)
OUR_MODULES = $(another list of file names without extensions)
# FORTRAN settings
.SUFFIXES: .F90 .$(OBJ_EXT)
# Construct a gmtt table. The one caveat is that we must escape the space characters in the
# second column until we select entries from the table.
define COMPILE_FLAGS_TBL
2
file1.$(OBJ_EXT) $(call spc-mask,-fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5)
file2.$(OBJ_EXT) $(call spc-mask,-fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5)
endef
# Special flags: "select column 2 from COMPILE_FLAGS_TBL where first column is string-equal to the target"
# ...and recover the space characters afterwards:
FFLAGS_SPECIAL = $(call spc-unmask,$(call select,2,$(COMPILE_FLAGS_TBL),$$(call str-eq,$$1,$#)))
# compilation rules
.PHONY: all
all: foo.o bar.o file1.o file2.o
%.F90:
touch $#
%.o: %.F90
#echo flags: $(FFLAGS) $(FFLAGS_SPECIAL)
Output:
$ make
touch foo.F90
flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
touch bar.F90
flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
touch file1.F90
flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../ -fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5
touch file2.F90
flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../ -fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5
rm bar.F90 file1.F90 foo.F90 file2.F90
You can have more flexible file selection by using globs:
include gmtt-master/gmtt-master/gmtt.mk
FFLAGS = -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
OBJ_EXT = o
# Construct a gmtt table. The one caveat is that we must escape the space characters in the
# second column until we select entries from the table.
define COMPILE_FLAGS_TBL
2
file1.$(OBJ_EXT) $(call spc-mask,-fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5)
file2.$(OBJ_EXT) $(call spc-mask,-fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5)
endef
define PATTERN_FLAGS_TBL
2
*_frobozz_[7-9].$(OBJ_EXT) $(call spc-mask,-ffrobozz)
X_frabazz_*.$(OBJ_EXT) $(call spc-mask,-ffrabazz -dwhatever)
endef
# Special flags: "select column 2 from COMPILE_FLAGS_TBL where first column is string-equal to the target"
# ...and recover the space characters afterwards:
FFLAGS_SPECIAL = $(call spc-unmask,$(call select,2,$(COMPILE_FLAGS_TBL),$$(call str-eq,$$1,$#)))
# Very special flags: "select column 2 from PATTERN_FLAGS_TBL where target matches glob in first column"
# ...and recover the space characters afterwards
FFLAGS_VERY_SPECIAL = $(call spc-unmask,$(call select,2,$(PATTERN_FLAGS_TBL),$$(call glob-match,$#,$$1)))
# compilation rules
.PHONY: all
all: foo.o bar.o file1.o file2.o A_frobozz_8.o A_frobozz_6.o X_frabazz_mike.o X_frabazz_mandy.o
%.F90:
#touch $#
%.o: %.F90
#echo $# flags: $(FFLAGS) $(FFLAGS_SPECIAL) $(FFLAGS_VERY_SPECIAL)
Output:
$ make
foo.o flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
bar.o flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
file1.o flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../ -fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5
file2.o flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../ -fbacktrace -ffpe-trap=zero,invalid,overflow,underflow -fbounds-check -fcheck=all -Wconversion -std=gnu -O3 -fmax-errors=5
A_frobozz_8.o flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../ -ffrobozz
A_frobozz_6.o flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../
X_frabazz_mike.o flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../ -ffrabazz -dwhatever
X_frabazz_mandy.o flags: -g -ffpe-trap=zero,invalid,overflow,underflow -Dno_nans -I ../ -ffrabazz -dwhatever
rm X_frabazz_mandy.F90 A_frobozz_8.F90 bar.F90 file1.F90 foo.F90 A_frobozz_6.F90 file2.F90 X_frabazz_mike.F90
Compiling error
I am quite new to Fortran coding.
Currently, I have a makefile which has been previously used by original authors to compile the Fortran codes in Linux. However, I cannot understand what needs to be changed in the previous makefile to run it in Windows-based compiler Silverfrost FTN95.
While trying to compile in FTN95 I encountered the following error:
C:\Users\Geo-TGS\Documents\landslidemodel\src\TRIGRS>MAKE TPX
mpif90 -w -O3 -w -O3 -c ssizgrd.f95
process_begin: CreateProcess(NULL, mpif90 -w -O3 -w -O3 -c ssizgrd.f95, ...) failed.
make (e=2): The system cannot find the file specified.
makefile:59: recipe for target `ssizgrd.o' failed
MAKE: *** [ssizgrd.o] Error 2
C:\Users\Geo-TGS\Documents\landslidemodel\src\TRIGRS>make trg
mpif90 -w -O3 -w -O3 -c grids.f95
process_begin: CreateProcess(NULL, mpif90 -w -O3 -w -O3 -c grids.f95, ...) failed.
make (e=2): The system cannot find the file specified.
makefile:59: recipe for target `grids.o' failed
make: *** [grids.o] Error 2
Below is the Makefile code:
TRG = trg
PRG = prg
TPX = tpx
OBJT90 = trigrs.o flux.o prpijz.o svxmdv.o svijz.o dzero_brac.o
OBJT95 = grids.o input_vars.o model_vars.o dsimps.o input_file_defs.o iverson.o pstpi.o satfin.o savage.o steady.o trini.o unsinf.o ivestp.o pstpf.o rnoff.o satinf.o smallt.o svgstp.o unsfin.o unsth.o ssizgrd.o svlist.o
OBJT77 = calerf.o dbsct.o derfc.o irdgrd.o irdswm.o isvgrd.o roots.o srdgrd.o srdswm.o ssvgrd.o
OBJP90 = trigrs_p.o partial_p.o flux.o flux_p.o prpijz.o svxmdv.o svijz.o dzero_brac.o srdgrd_p.o irdgrd_p.o
OBJP95 = modules_p.o grids.o input_vars.o model_vars.o dsimps.o input_file_defs.o iverson.o pstpi.o pstpi_p.o satfin.o satfin_p.o savage.o steady.o trini.o trini_p.o unsinf.o unsinf_p.o ivestp.o ivestp_p.o pstpf.o pstpf_p.o rnoff.o satinf.o satinf_p.o smallt.o svgstp.o svgstp_p.o unsfin.o unsfin_p.o unsth.o unsth_p.o ssizgrd.o ssizgrd_p.o svlist.o rnoff_p.o steady_p.o
OBJP77 = calerf.o dbsct.o derfc.o irdgrd.o irdswm.o irdswm_p.o isvgrd.o roots.o srdgrd.o srdswm.o srdswm_p.o ssvgrd.o
OBJX90 = tpindx.o nxtcel.o
OBJX95 = ssizgrd.o
OBJX77 = isvgrd.o mpfldr.o rdflodir.o sindex.o slofac.o srdgrd1.o
LIBS =
CC = gcc -O3
CCFLAGS = -lgsl -lgslcblas -lm
FC = ftn95 -w -O3
FFLAGS =
F90 = f95 -w -O3
MPIF90 = mpif90 -w -O3
F90FLAGS = -w -O3
LDFLAGS = -w -O3
all: $(TRG) $(PRG)
#-----------------------------------------------------------------
$(TRG): $(OBJT95) $(OBJT90) $(OBJT77)
$(F90) $(CCLIBS) $(LDFLAGS) -o $# $(OBJT95) $(OBJT90) $(OBJT77) $(CCFLAGS) $(LIBS)
$(PRG): $(OBJP95) $(OBJP90) $(OBJP77)
$(MPIF90) $(CCLIBS) $(LDFLAGS) -o $# $(OBJP95) $(OBJP90) $(OBJP77)
$(CCFLAGS) $(LIBS)
$(TPX): $(OBJX95) $(OBJX90) $(OBJX77)
$(F90) $(CCLIBS) $(LDFLAGS) -o $# $(OBJX95) $(OBJX90) $(OBJX77) $(CCFLAGS) $(LIBS)
#-----------------------------------------------------------------
clean:
rm -f $(TRG) $(TPX) $(PRG)
rm -rf $(OBJT95) $(OBJT90) $(OBJT77) $(OBJP95) $(OBJP90) $(OBJP77)
rm -rf $(OBJX95) $(OBJX90) $(OBJX77)
rm -rf *.mod *.exe *.stackdump
.SUFFIXES: $(SUFFIXES) .f90 .f .c .f95
.f90.o:
$(MPIF90) $(F90FLAGS) -c $<
.f.o:
$(MPIF90) $(F90FLAGS) -c $<
.c.o:
$(CC) $(CCINCLUDE) -c -w $<
.f95.o:
$(MPIF90) $(F90FLAGS) -c $<
What changes need to be made for the code to compile?
When trying to execute the default target, only setup and the o1 targets are executed. The remaining targets are not executed and I have no idea why.
Another potential clue: instead of make saying nothing needs to be done, make will always recompile.
Making the o1 o2 o3 or os targets on their own will complete successfully if the directories are created.
# tail call test Makefile
# written by mwolf
SRC= tco recurs iter
OBJS= $(SRC:=.o)
ASMS= $(SRC:=.s)
SRC_DIR= src
OUT_DIRS= o1 o2 o3 os
CC=gcc
INCLUDE= -I.
EXECUTABLE=
WARNINGS= -Wall -Wextra -Wfloat-equal -Wundef -Wshadow -Wpointer-arith \
-Wcast-align -Wstrict-overflow=5 -Wwrite-strings \
-Waggregate-return -Wcast-qual -Wswitch-default -Wswitch-enum \
-Wconversion -Wunreachable-code -Wformat=2 -Winit-self \
-Wuninitialized -Werror-implicit-function-declaration
CFLAGS= -c -pedantic $(WARNINGS)
SFLAGS= -S -pedantic $(WARNINGS)
LIBS=
all: setup
all: o1
all: o2
all: o3
setup:
mkdir -p $(OUT_DIRS)
o1: SFLAGS+= -O1
o1: OUT_DIR=o1
o1: $(ASMS)
o2: SFLAGS+= -O2
o2: OUT_DIR=o2
o2: $(ASMS)
o3: SFLATS+= -O3
o3: OUT_DIR=o3
o3: $(ASMS)
os: SFLAGS+= -Os
os: OUT_DIR=os
os: $(ASMS)
%.o: $(SRC_DIR)/%.c
$(CC) $(INCLUDE) $(CFLAGS) -c $< -o $#
%.s: $(SRC_DIR)/%.c
$(CC) $(INCLUDE) $(SFLAGS) -S $< -o $(OUT_DIR)/$#
clean:
rm -f *~
rm -f $(ASMS)
rm -f $(OBJS)
rm -rf $(OUT_DIRS)
Makefiles give make a dependency graph.
Your makefile tells make that:
all depends on o1
o1 depends on tco.s, recurs.s and iter.s
all also depends on o2
o2 also depends on tco.s, recurs.s and iter.s
etc.
Once make has built tco.s, recurs.s and iter.s,
then it has done all it needs to ensure that o1, o2, o3 and os are up-to-date.
BTW you shouldmust declare targets that do not correspond to real files as .PHONY
I have the following make file:
CC = gcc
CCDEPMODE = depmode=gcc3
CFLAGS = -g -O2 -W -Wall -Wno-unused -Wno-multichar
COMPONENTHEADER = Q_OBJECT
CPP = gcc -E
CPPFLAGS = -I/usr/include/Inventor/annex -D_REENTRANT -I/usr/share/qt3/include
CXX = g++
CXXCPP = g++ -E
CXXDEPMODE = depmode=gcc3
CXXFLAGS = -g -O2 -fno-exceptions -W -Wall -Wno-unused -Wno-multichar -Woverloaded- virtual
CYGPATH_W = echo
GUI = QT
Gui = Qt
INCLUDES =
LIBS = -lSoQt -lqt-mt -lXmu -lXi -lCoin -lGL -lXext -lSM -lICE -lX11 -ldl -lpthread -lm -lcxcore -lcv -lhighgui -lcvaux
OBJS = MathTools.o PointCloud.o ExtractFeatures.o Tile.o Shape.o RoadDynamic.o
SRCS = MathTools.cpp PointCloud.cpp ExtractFeatures.cpp Tile.cpp Shape.cpp RoadDynamic.cpp main.cpp
HDRS = constants.h Shape.h MathTools.h PointCloud.h ExtractFeatures.h Tile.h RoadDynamic.h
WIDGET = QWidget *
all: main
main: main.o ${OBJS}
${CC} ${CFLAGS} ${INCLUDES} -o $# main.o ${OBJS} ${LIBS}
.c.o:
${CC} ${CFLAGS} ${INCLUDES} -c $<
depend:
makedepend ${SRCS}
clean:
rm *.o core *~
tar:
tar cf code.tar Makefile *.c *.h testfile1
print:
more Makefile $(HDRS) $(SRCS) | enscript -2r -p listing.ps
I am wondering why when I run make the output is
g++ -g -O2 -fno-exceptions -W -Wall -Wno-unused -Wno-multichar -Woverloaded-virtual -I/usr/include/Inventor/annex -D_REENTRANT -I/usr/share/qt4/include -c -o main.o main.cpp
instead of:
gcc -g -O2 -W -Wall -Wno-unused -Wno-multichar ...
it seems the cxx variables are overriding the cc variables. Why is that?
also what does the "include =" do in this case? It doesn't seem to be set to anything.
Thank you
Because your object files are apparently built from .cpp files. You have no explicit rule for building .o files from .cpp files, so Make uses the implicit rule $(CXX) $(CPPFLAGS) $(CXXFLAGS) -c.
my c++ source file look for a specific variable passed from the makefile. when making a different target, this variable definition is different.
How can I define a variable in Makefile based on target.
Thanks
You can use target-specific variable values, they propagate to target's prerequisites:
all : foo bar
foo : CXXFLAGS += -DFOO
bar : CXXFLAGS += -DBAR
foo bar :
#echo target=$# CXXFLAGS=${CXXFLAGS}
.PHONY : all
Do you mean something like this:
$ cat Makefile
BUILD := debug
cxxflags.debug := -g -march=native
cxxflags.release := -g -O3 -march=native -DNDEBUG
CXXFLAGS := ${cxxflags.${BUILD}}
all :
#echo BUILD=${BUILD}
#echo CXXFLAGS=${CXXFLAGS}
.PHONY : all
Output:
$ make
BUILD=debug
CXXFLAGS=-g -march=native
$ make BUILD=release
BUILD=release
CXXFLAGS=-g -O3 -march=native -DNDEBUG
What about that?
ifeq ($(MAKECMDGOALS),release)
CFLAGS += -O3
else
CFLAGS += -O0 -ggdb
endif