Here is a short example for the Makefile I’m currently using to compile and test my VHDL project:

.PHONY: all clean testbench
 
VCDFILE = tmp
STOPTIME = 42ns
DEBUG = --vcd=$(VCDFILE) --stop-time=$(STOPTIME)
CLEANUP = rm -f $(VCDFILE)
OBJS = clock.o
TARGET =
 
all:
        make test
 
clean:
        ghdl --clean
 
testbench:
        ghdl -m $(TARGET)
        ghdl -r $(TARGET) $(DEBUG)
        gtkwave $(VCDFILE)
        $(CLEANUP)


Which is used in a terminal (providing you have gtkwave and ghdl installed) as follows:

$ make testbench TARGET=Chien_tb

Hoping to be useful, I’ll retire. I’ll be back in a few weeks with more details.

To play with C on Windows, I’m using nmake. Nmake comes with Visual C++ 2008 Express Edition, which is free as in beer.

I am working with two C files: the archetypal “Hello World”, and a program explaining pointer operators. I could type

cl /nologo /W4 [filename]

at a command line every time I need to compile, or I could describe what I want in a Makefile once and type nmake when needed. Nmake will build whichever files I edited since the last run automatically. Note: /nologo suppresses the Microsoft copyright message, and /W4 provides a large set of warnings.

Taking the Makefile route:

# Matt Stephenson's nmake Makefile
# build from build/ directory

cc = cl
cflags = /nologo /W4

all: hello.exe pointers.exe

hello.exe: ../hello.c
    $(cc) $(cflags) ../hello.c

pointers.exe: ../pointers.c
    $(cc) $(cflags) ../pointers.c

clean:
    del *.exe *.obj

We define a C compiler and its options independently, then nmake substitutes each when specified. The first “target” specified is all; an nmake invocation without arguments will build the first target it finds. In the directory containing this Makefile, running nmake and nmake all are functionally equivalent.

all is really a pseudotarget, it instructs nmake to run the hello.exe and pointers.exe targets in that order. Each of these targets describes a single call to cl, which does the compile and link phases for us. We could specify nmake pointers.exe and run only that target.

When defining a target, filenames after the colon specify dependencies. Nmake rebuilds a target when one of its dependencies have been updated since the last build.

Finally, we describe a clean step that erases the results of any of the other targets.

For an example of linking against external libraries, see this Makefile.

The other day, I was working with an unfamiliar build and I needed to get familiar with it in a hurry. In this case, I was dealing with a makefile generated by the Perl utility h2xs, but the trick I’ll show you here works any time you need to find your way around a new build system, whether it’s something you just downloaded or an internal project you just transferred to.

What I wanted to do was add a few object files to the link command. Here’s the build log, with the link command highlighted:

gcc -c  -I. -D_REENTRANT -D_GNU_SOURCE -DDEBIAN -fno-strict-aliasing -pipe -I/usr/local/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -O2 -g   -DVERSION=\"0.01\" -DXS_VERSION=\"0.01\" -fPIC "-I/usr/lib/perl/5.10/CORE"   mylib.c
rm -f blib/arch/auto/mylib/mylib.so
gcc  -shared -O2 -g -L/usr/local/lib mylib.o   -o blib/arch/auto/mylib/mylib.so   \
                \

chmod 755 blib/arch/auto/mylib/mylib.so

Should be easy, right? I just needed to find that command in the makefile and make my changes. Wrong. Read on to see how annotation helped solve this problem.

The thing is, the command I’m looking for doesn’t appear anywhere in the makefile. All of the rules look like this:

$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c

There’s not a single useful literal string in sight, so grep is right out. And it’s not like you could just start reading the makefile top-to-bottom to figure out which variables contribute to the command line that produces the output that you see in the log. The makefile is nearly a thousand lines long with literally hundreds of variable definitions:

# This Makefile is for the mylib extension to perl.
#
# It was generated automatically by MakeMaker version
# 6.42 (Revision: 41145) from the contents of
# Makefile.PL. Don't edit this file, edit Makefile.PL instead.
#
#       ANY CHANGES MADE HERE WILL BE LOST!
#
#   MakeMaker ARGV: ()
#
#   MakeMaker Parameters:

#     ABSTRACT_FROM => q[lib/mylib.pm]
#     AUTHOR => q[Eric Melski ]
#     DEFINE => q[]
#     INC => q[-I.]
#     LIBS => [q[]]
#     NAME => q[mylib]
#     PREREQ_PM => {  }
#     VERSION_FROM => q[lib/mylib.pm]

# --- MakeMaker post_initialize section:

# --- MakeMaker const_config section:

# These definitions are from config.sh (via /usr/lib/perl/5.10/Config.pm)

# They may have been overridden via Makefile.PL or on the command line
AR = ar
CC = gcc
CCCDLFLAGS = -fPIC
CCDLFLAGS = -Wl,-E
DLEXT = so
DLSRC = dl_dlopen.xs
EXE_EXT =
FULL_AR = /usr/bin/ar
LD = gcc
LDDLFLAGS = -shared -O2 -g -L/usr/local/lib
LDFLAGS =  -L/usr/local/lib
LIBC = /lib/libc-2.9.so
LIB_EXT = .a
OBJ_EXT = .o
OSNAME = linux
OSVERS = 2.6.24-23-server
RANLIB = :
SITELIBEXP = /usr/local/share/perl/5.10.0
SITEARCHEXP = /usr/local/lib/perl/5.10.0
SO = so
VENDORARCHEXP = /usr/lib/perl5
VENDORLIBEXP = /usr/share/perl5

# --- MakeMaker constants section:
AR_STATIC_ARGS = cr
DIRFILESEP = /
DFSEP = $(DIRFILESEP)
NAME = mylib
NAME_SYM = mylib
VERSION = 0.01
VERSION_MACRO = VERSION
VERSION_SYM = 0_01
DEFINE_VERSION = -D$(VERSION_MACRO)=\"$(VERSION)\"
XS_VERSION = 0.01
XS_VERSION_MACRO = XS_VERSION
XS_DEFINE_VERSION = -D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"
INST_ARCHLIB = blib/arch
INST_SCRIPT = blib/script
INST_BIN = blib/bin
INST_LIB = blib/lib
INST_MAN1DIR = blib/man1
INST_MAN3DIR = blib/man3
MAN1EXT = 1p
MAN3EXT = 3pm
INSTALLDIRS = site
DESTDIR =
PREFIX = /usr
PERLPREFIX = $(PREFIX)
SITEPREFIX = $(PREFIX)/local
VENDORPREFIX = $(PREFIX)
INSTALLPRIVLIB = $(PERLPREFIX)/share/perl/5.10
DESTINSTALLPRIVLIB = $(DESTDIR)$(INSTALLPRIVLIB)
INSTALLSITELIB = $(SITEPREFIX)/share/perl/5.10.0
DESTINSTALLSITELIB = $(DESTDIR)$(INSTALLSITELIB)
INSTALLVENDORLIB = $(VENDORPREFIX)/share/perl5
DESTINSTALLVENDORLIB = $(DESTDIR)$(INSTALLVENDORLIB)
INSTALLARCHLIB = $(PERLPREFIX)/lib/perl/5.10
DESTINSTALLARCHLIB = $(DESTDIR)$(INSTALLARCHLIB)
INSTALLSITEARCH = $(SITEPREFIX)/lib/perl/5.10.0
DESTINSTALLSITEARCH = $(DESTDIR)$(INSTALLSITEARCH)
INSTALLVENDORARCH = $(VENDORPREFIX)/lib/perl5
DESTINSTALLVENDORARCH = $(DESTDIR)$(INSTALLVENDORARCH)
INSTALLBIN = $(PERLPREFIX)/bin
DESTINSTALLBIN = $(DESTDIR)$(INSTALLBIN)
INSTALLSITEBIN = $(SITEPREFIX)/bin
DESTINSTALLSITEBIN = $(DESTDIR)$(INSTALLSITEBIN)
INSTALLVENDORBIN = $(VENDORPREFIX)/bin
DESTINSTALLVENDORBIN = $(DESTDIR)$(INSTALLVENDORBIN)
INSTALLSCRIPT = $(PERLPREFIX)/bin
DESTINSTALLSCRIPT = $(DESTDIR)$(INSTALLSCRIPT)
INSTALLSITESCRIPT = $(SITEPREFIX)/bin
DESTINSTALLSITESCRIPT = $(DESTDIR)$(INSTALLSITESCRIPT)
INSTALLVENDORSCRIPT = $(VENDORPREFIX)/bin
DESTINSTALLVENDORSCRIPT = $(DESTDIR)$(INSTALLVENDORSCRIPT)
INSTALLMAN1DIR = $(PERLPREFIX)/share/man/man1
DESTINSTALLMAN1DIR = $(DESTDIR)$(INSTALLMAN1DIR)
INSTALLSITEMAN1DIR = $(SITEPREFIX)/man/man1
DESTINSTALLSITEMAN1DIR = $(DESTDIR)$(INSTALLSITEMAN1DIR)
INSTALLVENDORMAN1DIR = $(VENDORPREFIX)/share/man/man1
DESTINSTALLVENDORMAN1DIR = $(DESTDIR)$(INSTALLVENDORMAN1DIR)
INSTALLMAN3DIR = $(PERLPREFIX)/share/man/man3
DESTINSTALLMAN3DIR = $(DESTDIR)$(INSTALLMAN3DIR)
INSTALLSITEMAN3DIR = $(SITEPREFIX)/man/man3
DESTINSTALLSITEMAN3DIR = $(DESTDIR)$(INSTALLSITEMAN3DIR)
INSTALLVENDORMAN3DIR = $(VENDORPREFIX)/share/man/man3
DESTINSTALLVENDORMAN3DIR = $(DESTDIR)$(INSTALLVENDORMAN3DIR)
PERL_LIB = /usr/share/perl/5.10
PERL_ARCHLIB = /usr/lib/perl/5.10
LIBPERL_A = libperl.a
FIRST_MAKEFILE = Makefile
MAKEFILE_OLD = Makefile.old
MAKE_APERL_FILE = Makefile.aperl
PERLMAINCC = $(CC)
PERL_INC = /usr/lib/perl/5.10/CORE
PERL = /usr/bin/perl
FULLPERL = /usr/bin/perl
ABSPERL = $(PERL)
PERLRUN = $(PERL)
FULLPERLRUN = $(FULLPERL)
ABSPERLRUN = $(ABSPERL)
PERLRUNINST = $(PERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"
FULLPERLRUNINST = $(FULLPERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"
ABSPERLRUNINST = $(ABSPERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"
PERL_CORE = 0
PERM_RW = 644
PERM_RWX = 755

MAKEMAKER   = /usr/share/perl/5.10/ExtUtils/MakeMaker.pm
MM_VERSION  = 6.42
MM_REVISION = 41145

# FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
# DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
MAKE = make
FULLEXT = mylib
BASEEXT = mylib
PARENT_NAME =
DLBASE = $(BASEEXT)
VERSION_FROM = lib/mylib.pm
INC = -I.
DEFINE =
OBJECT = $(BASEEXT)$(OBJ_EXT)
LDFROM = $(OBJECT)
LINKTYPE = dynamic
BOOTDEP = 

# Handy lists of source code files:
XS_FILES = mylib.xs
C_FILES  = mylib.c
O_FILES  = mylib.o
H_FILES  = ppport.h
MAN1PODS =
MAN3PODS = lib/mylib.pm

# Where is the Config information that we are using/depend on
CONFIGDEP = $(PERL_ARCHLIB)$(DFSEP)Config.pm $(PERL_INC)$(DFSEP)config.h

# Where to build things
INST_LIBDIR      = $(INST_LIB)
INST_ARCHLIBDIR  = $(INST_ARCHLIB)

INST_AUTODIR     = $(INST_LIB)/auto/$(FULLEXT)
INST_ARCHAUTODIR = $(INST_ARCHLIB)/auto/$(FULLEXT)

INST_STATIC      = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
INST_DYNAMIC     = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
INST_BOOT        = $(INST_ARCHAUTODIR)/$(BASEEXT).bs

# Extra linker info
EXPORT_LIST        =
PERL_ARCHIVE       =
PERL_ARCHIVE_AFTER = 

TO_INST_PM = lib/mylib.pm

PM_TO_BLIB = lib/mylib.pm \
	blib/lib/mylib.pm

# --- MakeMaker platform_constants section:
MM_Unix_VERSION = 6.42
PERL_MALLOC_DEF = -DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc -Dfree=Perl_mfree -Drealloc=Perl_realloc -Dcalloc=Perl_calloc

# --- MakeMaker tool_autosplit section:
# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
AUTOSPLITFILE = $(ABSPERLRUN)  -e 'use AutoSplit;  autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1)' --

# --- MakeMaker tool_xsubpp section:

XSUBPPDIR = /usr/share/perl/5.10/ExtUtils
XSUBPP = $(XSUBPPDIR)$(DFSEP)xsubpp
XSUBPPRUN = $(PERLRUN) $(XSUBPP)
XSPROTOARG =
XSUBPPDEPS = /usr/share/perl/5.10/ExtUtils/typemap typemap $(XSUBPP)
XSUBPPARGS = -typemap /usr/share/perl/5.10/ExtUtils/typemap -typemap typemap
XSUBPP_EXTRA_ARGS = 

# --- MakeMaker tools_other section:
SHELL = /bin/sh
CHMOD = chmod
CP = cp
MV = mv
NOOP = $(SHELL) -c true
NOECHO = @
RM_F = rm -f
RM_RF = rm -rf
TEST_F = test -f
TOUCH = touch
UMASK_NULL = umask 0
DEV_NULL = > /dev/null 2>&1
MKPATH = $(ABSPERLRUN) "-MExtUtils::Command" -e mkpath
EQUALIZE_TIMESTAMP = $(ABSPERLRUN) "-MExtUtils::Command" -e eqtime
ECHO = echo
ECHO_N = echo -n
UNINST = 0
VERBINST = 0
MOD_INSTALL = $(ABSPERLRUN) -MExtUtils::Install -e 'install({@ARGV}, '\''$(VERBINST)'\'', 0, '\''$(UNINST)'\'');' --
DOC_INSTALL = $(ABSPERLRUN) "-MExtUtils::Command::MM" -e perllocal_install
UNINSTALL = $(ABSPERLRUN) "-MExtUtils::Command::MM" -e uninstall
WARN_IF_OLD_PACKLIST = $(ABSPERLRUN) "-MExtUtils::Command::MM" -e warn_if_old_packlist
MACROSTART =
MACROEND =
USEMAKEFILE = -f
FIXIN = $(PERLRUN) "-MExtUtils::MY" -e "MY->fixin(shift)"

# --- MakeMaker makemakerdflt section:
makemakerdflt : all
	$(NOECHO) $(NOOP)

# --- MakeMaker dist section:
TAR = tar
TARFLAGS = cvf
ZIP = zip
ZIPFLAGS = -r
COMPRESS = gzip --best
SUFFIX = .gz
SHAR = shar
PREOP = $(NOECHO) $(NOOP)
POSTOP = $(NOECHO) $(NOOP)
TO_UNIX = $(NOECHO) $(NOOP)
CI = ci -u
RCS_LABEL = rcs -Nv$(VERSION_SYM): -q
DIST_CP = best
DIST_DEFAULT = tardist
DISTNAME = mylib
DISTVNAME = mylib-0.01

# --- MakeMaker macro section:

# --- MakeMaker depend section:

# --- MakeMaker cflags section:

CCFLAGS = -D_REENTRANT -D_GNU_SOURCE -DDEBIAN -fno-strict-aliasing -pipe -I/usr/local/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64
OPTIMIZE = -O2 -g
PERLTYPE =
MPOLLUTE = 

# --- MakeMaker const_loadlibs section:

# mylib might depend on some other libraries:
# See ExtUtils::Liblist for details
#

# --- MakeMaker const_cccmd section:
CCCMD = $(CC) -c $(PASTHRU_INC) $(INC) \
	$(CCFLAGS) $(OPTIMIZE) \
	$(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \
	$(XS_DEFINE_VERSION)

# --- MakeMaker post_constants section:

# --- MakeMaker pasthru section:

PASTHRU = LIBPERL_A="$(LIBPERL_A)"\
	LINKTYPE="$(LINKTYPE)"\
	OPTIMIZE="$(OPTIMIZE)"\
	PREFIX="$(PREFIX)"\
	PASTHRU_DEFINE="$(PASTHRU_DEFINE)"\
	PASTHRU_INC="$(PASTHRU_INC)"

# --- MakeMaker special_targets section:
.SUFFIXES : .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT)

.PHONY: all config static dynamic test linkext manifest blibdirs clean realclean disttest distdir

# --- MakeMaker c_o section:

.c.i:
	cc -E -c $(PASTHRU_INC) $(INC) \
	$(CCFLAGS) $(OPTIMIZE) \
	$(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \
	$(XS_DEFINE_VERSION) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c > $*.i

.c.s:
	$(CCCMD) -S $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c

.c$(OBJ_EXT):
	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c

.cpp$(OBJ_EXT):
	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cpp

.cxx$(OBJ_EXT):
	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cxx

.cc$(OBJ_EXT):
	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cc

.C$(OBJ_EXT):
	$(CCCMD) $*.C

# --- MakeMaker xs_c section:

.xs.c:
	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c

# --- MakeMaker xs_o section:

.xs$(OBJ_EXT):
	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c

# --- MakeMaker top_targets section:
all :: pure_all manifypods
	$(NOECHO) $(NOOP)

pure_all :: config pm_to_blib subdirs linkext
	$(NOECHO) $(NOOP)

subdirs :: $(MYEXTLIB)
	$(NOECHO) $(NOOP)

config :: $(FIRST_MAKEFILE) blibdirs
	$(NOECHO) $(NOOP)

$(O_FILES): $(H_FILES)

help :
	perldoc ExtUtils::MakeMaker

# --- MakeMaker blibdirs section:
blibdirs : $(INST_LIBDIR)$(DFSEP).exists $(INST_ARCHLIB)$(DFSEP).exists $(INST_AUTODIR)$(DFSEP).exists $(INST_ARCHAUTODIR)$(DFSEP).exists $(INST_BIN)$(DFSEP).exists $(INST_SCRIPT)$(DFSEP).exists $(INST_MAN1DIR)$(DFSEP).exists $(INST_MAN3DIR)$(DFSEP).exists
	$(NOECHO) $(NOOP)

# Backwards compat with 6.18 through 6.25
blibdirs.ts : blibdirs
	$(NOECHO) $(NOOP)

$(INST_LIBDIR)$(DFSEP).exists :: Makefile.PL
	$(NOECHO) $(MKPATH) $(INST_LIBDIR)
	$(NOECHO) $(CHMOD) 755 $(INST_LIBDIR)
	$(NOECHO) $(TOUCH) $(INST_LIBDIR)$(DFSEP).exists

$(INST_ARCHLIB)$(DFSEP).exists :: Makefile.PL
	$(NOECHO) $(MKPATH) $(INST_ARCHLIB)
	$(NOECHO) $(CHMOD) 755 $(INST_ARCHLIB)
	$(NOECHO) $(TOUCH) $(INST_ARCHLIB)$(DFSEP).exists

$(INST_AUTODIR)$(DFSEP).exists :: Makefile.PL
	$(NOECHO) $(MKPATH) $(INST_AUTODIR)
	$(NOECHO) $(CHMOD) 755 $(INST_AUTODIR)
	$(NOECHO) $(TOUCH) $(INST_AUTODIR)$(DFSEP).exists

$(INST_ARCHAUTODIR)$(DFSEP).exists :: Makefile.PL
	$(NOECHO) $(MKPATH) $(INST_ARCHAUTODIR)
	$(NOECHO) $(CHMOD) 755 $(INST_ARCHAUTODIR)
	$(NOECHO) $(TOUCH) $(INST_ARCHAUTODIR)$(DFSEP).exists

$(INST_BIN)$(DFSEP).exists :: Makefile.PL
	$(NOECHO) $(MKPATH) $(INST_BIN)
	$(NOECHO) $(CHMOD) 755 $(INST_BIN)
	$(NOECHO) $(TOUCH) $(INST_BIN)$(DFSEP).exists

$(INST_SCRIPT)$(DFSEP).exists :: Makefile.PL
	$(NOECHO) $(MKPATH) $(INST_SCRIPT)
	$(NOECHO) $(CHMOD) 755 $(INST_SCRIPT)
	$(NOECHO) $(TOUCH) $(INST_SCRIPT)$(DFSEP).exists

$(INST_MAN1DIR)$(DFSEP).exists :: Makefile.PL
	$(NOECHO) $(MKPATH) $(INST_MAN1DIR)
	$(NOECHO) $(CHMOD) 755 $(INST_MAN1DIR)
	$(NOECHO) $(TOUCH) $(INST_MAN1DIR)$(DFSEP).exists

$(INST_MAN3DIR)$(DFSEP).exists :: Makefile.PL
	$(NOECHO) $(MKPATH) $(INST_MAN3DIR)
	$(NOECHO) $(CHMOD) 755 $(INST_MAN3DIR)
	$(NOECHO) $(TOUCH) $(INST_MAN3DIR)$(DFSEP).exists

# --- MakeMaker linkext section:

linkext :: $(LINKTYPE)
	$(NOECHO) $(NOOP)

# --- MakeMaker dlsyms section:

# --- MakeMaker dynamic section:

dynamic :: $(FIRST_MAKEFILE) $(INST_DYNAMIC) $(INST_BOOT)
	$(NOECHO) $(NOOP)

# --- MakeMaker dynamic_bs section:
BOOTSTRAP = $(BASEEXT).bs

# As Mkbootstrap might not write a file (if none is required)
# we use touch to prevent make continually trying to remake it.
# The DynaLoader only reads a non-empty file.
$(BOOTSTRAP) : $(FIRST_MAKEFILE) $(BOOTDEP) $(INST_ARCHAUTODIR)$(DFSEP).exists
	$(NOECHO) $(ECHO) "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
	$(NOECHO) $(PERLRUN) \
		"-MExtUtils::Mkbootstrap" \
		-e "Mkbootstrap('$(BASEEXT)','$(BSLOADLIBS)');"
	$(NOECHO) $(TOUCH) $@
	$(CHMOD) $(PERM_RW) $@

$(INST_BOOT) : $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DFSEP).exists
	$(NOECHO) $(RM_RF) $@
	- $(CP) $(BOOTSTRAP) $@
	$(CHMOD) $(PERM_RW) $@

# --- MakeMaker dynamic_lib section:

# This section creates the dynamically loadable $(INST_DYNAMIC)
# from $(OBJECT) and possibly $(MYEXTLIB).
ARMAYBE = :
OTHERLDFLAGS =
INST_DYNAMIC_DEP =
INST_DYNAMIC_FIX = 

$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DFSEP).exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
	$(RM_F) $@
	$(LD)  $(LDDLFLAGS) $(LDFROM) $(OTHERLDFLAGS) -o $@ $(MYEXTLIB)	\
	  $(PERL_ARCHIVE) $(LDLOADLIBS) $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST)	\
	  $(INST_DYNAMIC_FIX)
	$(CHMOD) $(PERM_RWX) $@

# --- MakeMaker static section:

## $(INST_PM) has been moved to the all: target.
## It remains here for awhile to allow for old usage: "make static"
static :: $(FIRST_MAKEFILE) $(INST_STATIC)
	$(NOECHO) $(NOOP)

# --- MakeMaker static_lib section:

$(INST_STATIC) : $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)$(DFSEP).exists
	$(RM_RF) $@
	$(FULL_AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
	$(CHMOD) $(PERM_RWX) $@
	$(NOECHO) $(ECHO) "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld

# --- MakeMaker manifypods section:

POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--"
POD2MAN = $(POD2MAN_EXE)

manifypods : pure_all  \
	lib/mylib.pm
	$(NOECHO) $(POD2MAN) --section=$(MAN3EXT) --perm_rw=$(PERM_RW) \
	  lib/mylib.pm $(INST_MAN3DIR)/mylib.$(MAN3EXT) 

# --- MakeMaker processPL section:

# --- MakeMaker installbin section:

# --- MakeMaker subdirs section:

# none

# --- MakeMaker clean_subdirs section:
clean_subdirs :
	$(NOECHO) $(NOOP)

# --- MakeMaker clean section:

# Delete temporary files but do not touch installed files. We don't delete
# the Makefile here so a later make realclean still has a makefile to use.

clean :: clean_subdirs
	- $(RM_F) \
	  *$(LIB_EXT) core \
	  core.[0-9] $(INST_ARCHAUTODIR)/extralibs.all \
	  core.[0-9][0-9] $(BASEEXT).bso \
	  pm_to_blib.ts core.[0-9][0-9][0-9][0-9] \
	  $(BASEEXT).x $(BOOTSTRAP) \
	  perl$(EXE_EXT) tmon.out \
	  *$(OBJ_EXT) pm_to_blib \
	  $(INST_ARCHAUTODIR)/extralibs.ld blibdirs.ts \
	  core.[0-9][0-9][0-9][0-9][0-9] mylib.c \
	  *perl.core core.*perl.*.? \
	  $(MAKE_APERL_FILE) $(BASEEXT).def \
	  perl core.[0-9][0-9][0-9] \
	  mon.out lib$(BASEEXT).def \
	  perlmain.c perl.exe \
	  so_locations $(BASEEXT).exp
	- $(RM_RF) \
	  blib
	- $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) $(DEV_NULL)

# --- MakeMaker realclean_subdirs section:
realclean_subdirs :
	$(NOECHO) $(NOOP)

# --- MakeMaker realclean section:
# Delete temporary files (via clean) and also delete dist files
realclean purge ::  clean realclean_subdirs
	- $(RM_F) \
	  $(OBJECT) $(MAKEFILE_OLD) \
	  $(FIRST_MAKEFILE)
	- $(RM_RF) \
	  $(DISTVNAME) 

# --- MakeMaker metafile section:
metafile : create_distdir
	$(NOECHO) $(ECHO) Generating META.yml
	$(NOECHO) $(ECHO) '--- #YAML:1.0' > META_new.yml
	$(NOECHO) $(ECHO) 'name:                mylib' >> META_new.yml
	$(NOECHO) $(ECHO) 'version:             0.01' >> META_new.yml
	$(NOECHO) $(ECHO) 'abstract:            Perl extension for blah blah blah' >> META_new.yml
	$(NOECHO) $(ECHO) 'license:             ~' >> META_new.yml
	$(NOECHO) $(ECHO) 'author:              ' >> META_new.yml
	$(NOECHO) $(ECHO) '    - Eric Melski ' >> META_new.yml
	$(NOECHO) $(ECHO) 'generated_by:        ExtUtils::MakeMaker version 6.42' >> META_new.yml
	$(NOECHO) $(ECHO) 'distribution_type:   module' >> META_new.yml
	$(NOECHO) $(ECHO) 'requires:     ' >> META_new.yml
	$(NOECHO) $(ECHO) 'meta-spec:' >> META_new.yml
	$(NOECHO) $(ECHO) '    url:     http://module-build.sourceforge.net/META-spec-v1.3.html' >> META_new.yml
	$(NOECHO) $(ECHO) '    version: 1.3' >> META_new.yml
	-$(NOECHO) $(MV) META_new.yml $(DISTVNAME)/META.yml

# --- MakeMaker signature section:
signature :
	cpansign -s

# --- MakeMaker dist_basics section:
distclean :: realclean distcheck
	$(NOECHO) $(NOOP)

distcheck :
	$(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck

skipcheck :
	$(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck

manifest :
	$(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest

veryclean : realclean
	$(RM_F) *~ */*~ *.orig */*.orig *.bak */*.bak *.old */*.old 

# --- MakeMaker dist_core section:

dist : $(DIST_DEFAULT) $(FIRST_MAKEFILE)
	$(NOECHO) $(ABSPERLRUN) -l -e 'print '\''Warning: Makefile possibly out of date with $(VERSION_FROM)'\''' \
	  -e '    if -e '\''$(VERSION_FROM)'\'' and -M '\''$(VERSION_FROM)'\''  $(DISTVNAME).tar$(SUFFIX)_uu

$(DISTVNAME).tar$(SUFFIX) : distdir
	$(PREOP)
	$(TO_UNIX)
	$(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
	$(RM_RF) $(DISTVNAME)
	$(COMPRESS) $(DISTVNAME).tar
	$(POSTOP)

zipdist : $(DISTVNAME).zip
	$(NOECHO) $(NOOP)

$(DISTVNAME).zip : distdir
	$(PREOP)
	$(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
	$(RM_RF) $(DISTVNAME)
	$(POSTOP)

shdist : distdir
	$(PREOP)
	$(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
	$(RM_RF) $(DISTVNAME)
	$(POSTOP)

# --- MakeMaker distdir section:
create_distdir :
	$(RM_RF) $(DISTVNAME)
	$(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
		-e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"

distdir : create_distdir distmeta
	$(NOECHO) $(NOOP)

# --- MakeMaker dist_test section:
disttest : distdir
	cd $(DISTVNAME) && $(ABSPERLRUN) Makefile.PL
	cd $(DISTVNAME) && $(MAKE) $(PASTHRU)
	cd $(DISTVNAME) && $(MAKE) test $(PASTHRU)

# --- MakeMaker dist_ci section:

ci :
	$(PERLRUN) "-MExtUtils::Manifest=maniread" \
	  -e "@all = keys %{ maniread() };" \
	  -e "print(qq{Executing $(CI) @all\n}); system(qq{$(CI) @all});" \
	  -e "print(qq{Executing $(RCS_LABEL) ...\n}); system(qq{$(RCS_LABEL) @all});"

# --- MakeMaker distmeta section:
distmeta : create_distdir metafile
	$(NOECHO) cd $(DISTVNAME) && $(ABSPERLRUN) -MExtUtils::Manifest=maniadd -e 'eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } ' \
	  -e '    or print "Could not add META.yml to MANIFEST: $${'\''@'\''}\n"' --

# --- MakeMaker distsignature section:
distsignature : create_distdir
	$(NOECHO) cd $(DISTVNAME) && $(ABSPERLRUN) -MExtUtils::Manifest=maniadd -e 'eval { maniadd({q{SIGNATURE} => q{Public-key signature (added by MakeMaker)}}) } ' \
	  -e '    or print "Could not add SIGNATURE to MANIFEST: $${'\''@'\''}\n"' --
	$(NOECHO) cd $(DISTVNAME) && $(TOUCH) SIGNATURE
	cd $(DISTVNAME) && cpansign -s

# --- MakeMaker install section:

install :: pure_install doc_install
	$(NOECHO) $(NOOP)

install_perl :: pure_perl_install doc_perl_install
	$(NOECHO) $(NOOP)

install_site :: pure_site_install doc_site_install
	$(NOECHO) $(NOOP)

install_vendor :: pure_vendor_install doc_vendor_install
	$(NOECHO) $(NOOP)

pure_install :: pure_$(INSTALLDIRS)_install
	$(NOECHO) $(NOOP)

doc_install :: doc_$(INSTALLDIRS)_install
	$(NOECHO) $(NOOP)

pure__install : pure_site_install
	$(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site

doc__install : doc_site_install
	$(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site

pure_perl_install :: all
	$(NOECHO) umask 022; $(MOD_INSTALL) \
		$(INST_LIB) $(DESTINSTALLPRIVLIB) \
		$(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \
		$(INST_BIN) $(DESTINSTALLBIN) \
		$(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
		$(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \
		$(INST_MAN3DIR) $(DESTINSTALLMAN3DIR)
	$(NOECHO) $(WARN_IF_OLD_PACKLIST) \
		$(SITEARCHEXP)/auto/$(FULLEXT)

pure_site_install :: all
	$(NOECHO) umask 02; $(MOD_INSTALL) \
		read $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist \
		write $(DESTINSTALLSITEARCH)/auto/$(FULLEXT)/.packlist \
		$(INST_LIB) $(DESTINSTALLSITELIB) \
		$(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \
		$(INST_BIN) $(DESTINSTALLSITEBIN) \
		$(INST_SCRIPT) $(DESTINSTALLSITESCRIPT) \
		$(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \
		$(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR)
	$(NOECHO) $(WARN_IF_OLD_PACKLIST) \
		$(PERL_ARCHLIB)/auto/$(FULLEXT)

pure_vendor_install :: all
	$(NOECHO) umask 022; $(MOD_INSTALL) \
		$(INST_LIB) $(DESTINSTALLVENDORLIB) \
		$(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \
		$(INST_BIN) $(DESTINSTALLVENDORBIN) \
		$(INST_SCRIPT) $(DESTINSTALLVENDORSCRIPT) \
		$(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \
		$(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR)

doc_perl_install :: all

doc_site_install :: all
	$(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLSITEARCH)/perllocal.pod
	-$(NOECHO) umask 02; $(MKPATH) $(DESTINSTALLSITEARCH)
	-$(NOECHO) umask 02; $(DOC_INSTALL) \
		"Module" "$(NAME)" \
		"installed into" "$(INSTALLSITELIB)" \
		LINKTYPE "$(LINKTYPE)" \
		VERSION "$(VERSION)" \
		EXE_FILES "$(EXE_FILES)" \
		>> $(DESTINSTALLSITEARCH)/perllocal.pod

doc_vendor_install :: all

uninstall :: uninstall_from_$(INSTALLDIRS)dirs
	$(NOECHO) $(NOOP)

uninstall_from_perldirs ::

uninstall_from_sitedirs ::
	$(NOECHO) $(UNINSTALL) $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist

uninstall_from_vendordirs ::

# --- MakeMaker force section:
# Phony target to force checking subdirectories.
FORCE :
	$(NOECHO) $(NOOP)

# --- MakeMaker perldepend section:

PERL_HDRS = \
	$(PERL_INC)/EXTERN.h		\
	$(PERL_INC)/INTERN.h		\
	$(PERL_INC)/XSUB.h		\
	$(PERL_INC)/av.h		\
	$(PERL_INC)/cc_runtime.h	\
	$(PERL_INC)/config.h		\
	$(PERL_INC)/cop.h		\
	$(PERL_INC)/cv.h		\
	$(PERL_INC)/dosish.h		\
	$(PERL_INC)/embed.h		\
	$(PERL_INC)/embedvar.h		\
	$(PERL_INC)/fakethr.h		\
	$(PERL_INC)/form.h		\
	$(PERL_INC)/gv.h		\
	$(PERL_INC)/handy.h		\
	$(PERL_INC)/hv.h		\
	$(PERL_INC)/intrpvar.h		\
	$(PERL_INC)/iperlsys.h		\
	$(PERL_INC)/keywords.h		\
	$(PERL_INC)/mg.h		\
	$(PERL_INC)/nostdio.h		\
	$(PERL_INC)/op.h		\
	$(PERL_INC)/opcode.h		\
	$(PERL_INC)/patchlevel.h	\
	$(PERL_INC)/perl.h		\
	$(PERL_INC)/perlio.h		\
	$(PERL_INC)/perlsdio.h		\
	$(PERL_INC)/perlsfio.h		\
	$(PERL_INC)/perlvars.h		\
	$(PERL_INC)/perly.h		\
	$(PERL_INC)/pp.h		\
	$(PERL_INC)/pp_proto.h		\
	$(PERL_INC)/proto.h		\
	$(PERL_INC)/regcomp.h		\
	$(PERL_INC)/regexp.h		\
	$(PERL_INC)/regnodes.h		\
	$(PERL_INC)/scope.h		\
	$(PERL_INC)/sv.h		\
	$(PERL_INC)/thread.h		\
	$(PERL_INC)/unixish.h		\
	$(PERL_INC)/util.h

$(OBJECT) : $(PERL_HDRS)

mylib.c : $(XSUBPPDEPS)

# --- MakeMaker makefile section:

$(OBJECT) : $(FIRST_MAKEFILE)

# We take a very conservative approach here, but it's worth it.
# We move Makefile to Makefile.old here to avoid gnu make looping.
$(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP)
	$(NOECHO) $(ECHO) "Makefile out-of-date with respect to $?"
	$(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..."
	-$(NOECHO) $(RM_F) $(MAKEFILE_OLD)
	-$(NOECHO) $(MV)   $(FIRST_MAKEFILE) $(MAKEFILE_OLD)
	- $(MAKE) $(USEMAKEFILE) $(MAKEFILE_OLD) clean $(DEV_NULL)
	$(PERLRUN) Makefile.PL
	$(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt.  Please rerun the $(MAKE) command.  <=="
	false

# --- MakeMaker staticmake section:

# --- MakeMaker makeaperl section ---
MAP_TARGET    = perl
FULLPERL      = /usr/bin/perl

$(MAP_TARGET) :: static $(MAKE_APERL_FILE)
	$(MAKE) $(USEMAKEFILE) $(MAKE_APERL_FILE) $@

$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE) pm_to_blib
	$(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
	$(NOECHO) $(PERLRUNINST) \
		Makefile.PL DIR= \
		MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
		MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=

# --- MakeMaker test section:

TEST_VERBOSE=0
TEST_TYPE=test_$(LINKTYPE)
TEST_FILE = test.pl
TEST_FILES = t/*.t
TESTDB_SW = -d

testdb :: testdb_$(LINKTYPE)

test :: $(TEST_TYPE) subdirs-test

subdirs-test ::
	$(NOECHO) $(NOOP)

test_dynamic :: pure_all
	PERL_DL_NONLAZY=1 $(FULLPERLRUN) "-MExtUtils::Command::MM" "-e" "test_harness($(TEST_VERBOSE), '$(INST_LIB)', '$(INST_ARCHLIB)')" $(TEST_FILES)

testdb_dynamic :: pure_all
	PERL_DL_NONLAZY=1 $(FULLPERLRUN) $(TESTDB_SW) "-I$(INST_LIB)" "-I$(INST_ARCHLIB)" $(TEST_FILE)

test_ : test_dynamic

test_static :: pure_all $(MAP_TARGET)
	PERL_DL_NONLAZY=1 ./$(MAP_TARGET) "-MExtUtils::Command::MM" "-e" "test_harness($(TEST_VERBOSE), '$(INST_LIB)', '$(INST_ARCHLIB)')" $(TEST_FILES)

testdb_static :: pure_all $(MAP_TARGET)
	PERL_DL_NONLAZY=1 ./$(MAP_TARGET) $(TESTDB_SW) "-I$(INST_LIB)" "-I$(INST_ARCHLIB)" $(TEST_FILE)

# --- MakeMaker ppd section:
# Creates a PPD (Perl Package Description) for a binary distribution.
ppd :
	$(NOECHO) $(ECHO) '<SOFTPKG NAME="$(DISTNAME)" VERSION="0,01,0,0">' > $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '    <TITLE>$(DISTNAME)</TITLE>' >> $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '    <ABSTRACT>Perl extension for blah blah blah</ABSTRACT>' >> $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '    <AUTHOR>Eric Melski <ericm@></AUTHOR>' >> $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '    <IMPLEMENTATION>' >> $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '        <OS NAME="$(OSNAME)" />' >> $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '        <ARCHITECTURE NAME="i486-linux-gnu-thread-multi-5.1" />' >> $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '        <CODEBASE HREF="" />' >> $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '    </IMPLEMENTATION>' >> $(DISTNAME).ppd
	$(NOECHO) $(ECHO) '</SOFTPKG>' >> $(DISTNAME).ppd

# --- MakeMaker pm_to_blib section:

pm_to_blib : $(TO_INST_PM)
	$(NOECHO) $(ABSPERLRUN) -MExtUtils::Install -e 'pm_to_blib({@ARGV}, '\''$(INST_LIB)/auto'\'', '\''$(PM_FILTER)'\'')' -- \
	  lib/mylib.pm blib/lib/mylib.pm
	$(NOECHO) $(TOUCH) pm_to_blib

# --- MakeMaker selfdocument section:

# --- MakeMaker postamble section:

# End.

It seems hopeless. This makefile suffers from a classic problem: unless you’re the guy who wrote it in the first place, it’s an impenetrable fog. You’re in for a world of hurt when you try to understand it, or worse, try to modify it. Lucky for me — and for you if you ever find yourself in this situation — there’s a powerful new tool in your toolbox: emake’s annotated build logs, or simply annotation.

If you have ElectricAccelerator or SparkBuild, a free gmake- and NMAKE-compatible make replacement, you just need to enable annotation on your next build:

emake --emake-annodetail=basic > build.xml 2>&1

Now you can search build.xml for the log output or the command-line that you’re interested in. You can use ElectricInsight or SparkBuild Insight, of course, but for a simple query like this I just use less. Searching for the log output of the command I’m looking for (gcc -shared) leads me to this:

...
<job id="J09be71b8" thread="b7b34940" type="rule" name="blib/arch/auto/mylib/mylib.so" file="Makefile" line="469" neededby="J09be7138">
<output><![CDATA[]]></output>
<command line="470">
<argv><![CDATA[rm -f blib/arch/auto/mylib/mylib.so]]></argv>
<output><![CDATA[rm -f blib/arch/auto/mylib/mylib.so
]]></output>
<output src="prog"><![CDATA[]]></output>
</command>
<command line="471-473">
<argv><![CDATA[gcc  -shared -O2 -g -L/usr/local/lib mylib.o  -o blib/arch/auto/mylib/mylib.so      \
                \
          ]]></argv>
<output><![CDATA[gcc  -shared -O2 -g -L/usr/local/lib mylib.o  -o blib/arch/auto/mylib/mylib.so    \
                \

]]></output>
<output src="prog"><![CDATA[]]></output>
</command>
...

Now, I just scan back a few lines to find the start of the <job> tag containing that text. The file attribute tells me which makefile contains the rule definition, and the line attribute tells me which line it starts on:

...
<job id="J09be71b8" thread="b7b34940" type="rule" name="blib/arch/auto/mylib/mylib.so" file="Makefile" line="469" neededby="J09be7138">
...

Bingo! The rule I want starts on line 469 of the file Makefile. Using that as an anchor it’s now trivial to see how to modify the makefile to produce the result I’m after.

The best tool for the job

Trying to figure out how a build system is put together can feel like being dropped in the middle of a dense jungle. Annotated build logs are like a map leading you back to daylight. There’s nothing else like them.

Como parte de uno de los cursos que estoy llevando este semestre tuvimos que realizar un módulo cargable “en tiempo de ejecución” en Linux. Este aparte de mostrar mensajes de carga y descarga mediante dmesg, tenía que crear un archivo en el directorio /proc. A continuación la solución.

Primeramente hay que crear el archivo con el código fuente del módulo y agregar el código para el mismo. Abrimos una terminal de comandos y creamos una carpeta para tener un mejor orden y ahí dentro creamos el archivo.

mkdir modulo

cd modulo

nano primerModulo.c

A continuación el código fuente para el módulo.

/* El nombre del archivo es primerModulo */
#include <linux/module.h>          //para los detalles del modulo (Author, License…)
#include <linux/kernel.h>          //para usar la macro printk, KERN_INFO y KERN_ALERT
#include <linux/sched.h>           //para usar la estructura “task_struct”
#include <linux/proc_fs.h>    //para poder hacer la escritura en el archivo que estara en /proc

struct proc_dir_entry *structDirEntrada= NULL;
#define procfs_name “miprimermodulo”    //Nombre del archivo que se creara en /proc
char buff[500];        //buffer para escribir al archivo /proc/miprimermodulo

/*A continuacion viene la funcion de escritura en el archivo en /proc*/
int procfile_read(char *buffer, char **buffer_location, off_t offset, int buffer_length, int *eof, void *data){
int len;
static int count=1;
static char bufo[500];
if(offset>0)
return 0;
len=sprintf(bufo, “%s”, buff);
count++;
*buffer_location=bufo;
return len;
}

static int cargar(void){
//create_proc_entry lleva parametros nombre, modo, y padre de la estructura a la que se hace la asignacion.
structDirEntrada = create_proc_entry(procfs_name, 0644, NULL);

if (structDirEntrada == NULL) {
remove_proc_entry(buff, structDirEntrada);
printk(KERN_ALERT “Error: Could not initialize /proc/%s\n”, procfs_name);
return -ENOMEM;
}

//Ingresa el texto que se guardara en el archivo al buffer “buff”
sprintf(buff, “\n*** Hola soy el primer modulo de G10 – 200413044 ***\n\n”);

//A continuacion se setean varios de los parametros a los elementos de la estructura proc_dir_entry
structDirEntrada->read_proc = procfile_read;
structDirEntrada->owner = THIS_MODULE;
structDirEntrada->mode = S_IFREG | S_IRUGO;
structDirEntrada->uid = 0;
structDirEntrada->gid = 0;
structDirEntrada->size = 100000; //Se establece el tamaño del archivo en /proc (bytes)

//Lo siguiente tiene que ir hasta aca porque el estandar ISO C90 prohíbe las declaraciones mezcladas y código
printk(KERN_INFO “********************************************************\n”);
printk(KERN_INFO “* Hola, ahora se inicia la carga del modulo…\n”);
printk(KERN_INFO “* El user space del proceso es ‘%s’\n”, current->comm);
printk(KERN_INFO “* El PID del programa que lo inserto… %i\n”, current->pid);
printk(KERN_INFO “********************************************************\n”);
printk(KERN_INFO “——————————————————–\n”);
printk(KERN_INFO “——————————————————–\n”);
return 0;    //Se retorna 0 para indicar que todo salio bien, de lo contrario retorna != 0
}

static void descargar(void){
printk(KERN_INFO “#######################################\n”);
printk(KERN_INFO “# Se inicia la descarga del modulo… #\n”);
printk(KERN_INFO “#######################################\n”);
remove_proc_entry(buff, structDirEntrada);
}

module_init(cargar);    // Lo que se debe llamar al cargar un modulo
module_exit(descargar);    // Lo que se debe llamar al remover un modulo

MODULE_AUTHOR(“G10 – 200413044″);
MODULE_LICENSE(“Dual MIT/GPL”);
MODULE_DESCRIPTION(“Este es un modulo para la practica 3 de Sistemas Operativos 2.”);
MODULE_VERSION(“1:1.0-Beta1″);
//Existen mas licencias en module.h, y es quiza uno de los paramatros mas importantes.

Cuando terminanos de agregar el código, guardamos y cerramos el archivo. A continuación debemos crear el archivo make para la construcción del modulo. Esto se hace con los comandos siguientes.

nano Makefile

#Codigo del Makefile para la compilacion del modulo…
ifeq ($(KERNELRELEASE),)
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
.PHONY: build clean
build:
#— Importante la linea siguiente debe ir tabulada —
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
#— Importante la linea siguiente debe ir tabulada —
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c
else
$(info Building with KERNELRELEASE = ${KERNELRELEASE})
obj-m :=    primerModulo.o
endif

Guardamos y cerramos el archivo, a continuación para construirlo, en la terminal de comandos tecleamos el comando. Esto nos crea varios archivos, entre ellos uno con extensión .ko, el cual es módulo a cargar en sí.

make

Podemos ver las propiedades del modulo con el comando

modinfo primerModulo.ko

A continuación montamos/insertamos el módulo en el sistema, esto se hace con el comando

sudo insmod primerModulo.ko

Podemos ver los mensajes de bitacora del módulo con el comando

dmesg

Con el modulo ya cargado podemos ver que en /proc se creó el archivo que tiene como objetivo el módulo, este lo podemos abrir con programas como nano, cat o less. Cabe mencionar que este archivo es accesible unicamente mientras el módulo este cargado, cuando se descarga aparece, pero no es accesible.

cat /proc/miprimermodulo

Ahora tenemos que descargar el módulo, esto se hace con el comando.

sudo rmmod primerModulo

Para ver todos los mensajes de bitácora del módulo, podemos teclear el comando siguiente.

tail /var/log/messages

Este es un módulo bastante básico, sin embargo, bastante interesante para iniciarse en la programación de los mismo o simplemente para saber como funcionan los mismos.

Referencias:

• http://casidiablo.net/desarrollar-compilar-modulo-linux/
• http://doc.ubuntu-es.org/El_Kernel
• http://www.linuxtopia.org/online_books/Linux_Kernel_Module_Programming_Guide/

I’ve heard it said that the best programmer is a lazy programmer. I’ve always taken that to mean that the best programmers avoid unnecessary work, by working smarter and not harder; and that they focus on building only those features that are really required now, not allowing speculative work to distract them.

I wouldn’t presume to call myself a great programmer, but I definitely hate doing unnecessary work. That’s why the concept of build avoidance is so intriguing. If you’ve spent any time on the build speed problem, you’ve probably come across this term. Unfortunately it’s been conflated with the single technique implemented by tools like ccache and ClearCase winkins. I say “unfortunate” for two reasons: first, those tools don’t really work all that well, at least not for individual developers; and second, the technique they employ is not really build avoidance at all, but rather object reuse. But by co-opting the term build avoidance and associating it with such lackluster results, many people have become dismissive of build avoidance.

Subbuilds are a more literal, and more effective, approach to build avoidance: reduce build time by building only the stuff required for your active component. Don’t waste time building the stuff that’s not related to what you’re working on now. It seems so obvious I’m almost embarrassed to be explaining it. But the payoff is anything but embarrassing. On my project, after making changes to one of the prerequisites libraries for the application I’m working on, a regular incremental takes 10 minutes; a subbuild incremental takes just 77 seconds:

Not bad! Read on for more about how subbuilds work and how you can get SparkBuild, a free gmake- and NMAKE-compatible build tool, so you can try subbuilds yourself.

What is a subbuild?

A subbuild is just the smallest part of a full build tree that must be built in order to completely build a single component of the build, including all its prerequisites. For example, my project consists of several applications and the libraries they depend on. Each of these components resides in a separate directory, and we use recursive make invocations to build everything. (Nota bene: if you have a non-recursive make then you probably already enjoy many of the benefits of subbuilds, but you should definitely still check out the other features of SparkBuild!)

The dependency graph for my project looks like this:

You can see that to build the agent component, for example, we only need to build the util, xml, and http libraries, and the agent application code, of course:

This subset defines the agent subbuild.

Subbuilds and developers

What makes subbuilds really interesting for developers is the realization that usually you’re working on just one component at a time. For example, on any given day I might be working on the agent component, or the cm, but rarely both. Most of the edits I make will be on code in the agent directory, with occassional edits to the agent’s prerequisites. As I’m running through the edit-compile-test cycle, I have some choices about how to run the build. The most natural thing for me is to simply run make in the agent directory. After all, most of the changes I make are in that directory, so that will do the right thing most of the time. Of course, if I have made changes to any of the prerequisites, or if I resync with the source depot and pick up somebody else’s changes in one of those prerequisites, I’ll probably get a busted build.

The next most obvious approach is a rebuild from the root of my source tree. This ensures that I always update all the pieces I need for the agent, but at the cost of also building components that are irrelevant to my current focus: if I’m just trying to rebuild to run the agent’s unit tests, there’s no need for me to rebuild the cm application, or the ldap library.

The best choice is the agent subbuild, the minimum set of things that must be built to be sure that the agent component is fully up-to-date. But although it’s possible on a small project like this to execute the subbuild manually, it’s a nuisance, and on a bigger project it may not be practical or even possible. You need a build tool that can automatically determine which parts of the build make up the subbuild for any component, and then automatically execute that subbuild. That tool is SparkBuild emake.

Subbuilds with SparkBuild

Subbuilds with SparkBuild start with a full build, during which emake captures information about which targets are produced by each submake. In subsequent builds, emake references that database anytime it can’t find a rule to build a particular target. If a match is found, emake runs the corresponding submake before proceeding. For example, the rule for the actual agent target looks like this:

$(OUT)/agent/agent: $(OUT)/agent/*.o $(OUT)/xml/xml.a $(OUT)/http/http.a
	g++ -o $@ $^

In a normal build, gmake would see the dependency on $(OUT)/xml/xml.a and use that file if it existed already, regardless of whether it was actually up-to-date; or report “no rule to make” if the file did not exist. With SparkBuild, emake checks the subbuild database for an entry matching $(OUT)/xml/xml.a and sees that it must run make in the xml directory before proceeding. Like magic, each of the agent’s prerequisites is updated without requiring me to take any action other than swapping emake –emake-subbuild-db=my.db for gmake in my build command-line.

Still not convinced that it’s worth a look? Here’s some more concrete results comparing a few different build scenarios from my project. These comparisons assume that I’m actively working on the agent component, and that I ran either a standard incremental, from the root of the source tree, or a subbuild using SparkBuild emake:

Conclusion and Availability

Tools like ccache and ClearCase winkins have co-opted the term build avoidance, but in fact they do object reuse, not build avoidance, and they are not very useful for developer builds. Subbuilds are a simple but highly effective approach to build avoidance that save significant time during developer builds by literally skipping parts of the build tree that are unrelated to your current focus.

If you want to try out subbuilds yourself, you can download SparkBuild from www.sparkbuild.com. It’s completely free (as in beer), so you’ve got nothing to lose… except those long coffee breaks, of course!

For those interested in programming electronic components there is always the possibility to use Xilinx if you are on Windows. Of course, there is a Xilinx port for Linux but it is buggy application and a very large download. This article aims to give an alternative to this application. One that will need only a few KB of download from an apt-get source.

Of course, we are speaking about Icarus Verilog (iverilog), GHDL and GtkWave.

After installing each of them (command line, download, whatever), you can start desgning. Suppose we have the following source:

module bser(en, clk, in, out, done);
        input en, clk;
        input [7:0]in;
        output out, done;
        reg [2:0]cst;
        reg out, done;
 
        initial
        begin
                done = 0;
                cst = 3'b0;
                out = 0;
        end
 
        always @(posedge en)
        begin
                done = 0;
                cst = 3'b0;
                out = 0;
        end
 
        always @(posedge clk)
                if (en)
                begin
                        out = in[cst];
                        cst = cst + 1;
                        if (cst ==
                        begin
                                done = 1;
                                cst = 0;
                        end
                end
endmodule


We need to test our source manually, so we will write a benchmark file (consult the documentation for the syntax) in which we will introduce two lines for dumping information about variables:

module bser_tb;
        reg en, clk;
        reg [7:0]in;
        bser g(en, clk, in, out, done);
        initial
        begin
                en = 0; in=8'b00010111; clk=0;
                $dumpfile("bser_tb");
                $dumpvars;
                #10000 $finish;
        end
 
        always
        begin
                #1 clk = ~clk;
        end
 
        initial
        begin
                #2 en=1;
        end
endmodule


Now, we will compile the source, run it and then use gtkwave to see the results. All of this is very repetitive, so a Makefile was needed:


test_bser:
        iverilog bser.v bser_tb.v
        ./a.out
        gtkwave bser_tb
        rm -f a.out bser_tb


This is what we will obtain after a few milliseconds:

That’s all.

Mengkompile source code satu persatu menggunakan command line bisa jadi akan sangat membosankan, terutama jika berhadapan dengan beberapa include file dan keharusan mengetikkan command tiap kali akan melakukan compiling. Namun  telah dibuat suatu cara untuk mempermudah pekerjaan tersebut, yaitu dengan penggunaan makefile. Makefile adalah suatu format file yang digunakan bersama dengan make untuk membantu membangun dan memanage project secara otomatis.

Tentang Make

Jika kita menjalankan

make

Program ini akan mencari sebuah file bernama makefile pada direktori, lalu mengeksekusinya. Jika terdapat beberapa makefile, maka dapat pula dieksekusi dengan perintah :

make –f makefile

Adapun lebih lengkap mengenai make dapat dilihat dengan man make.

Proses Build

Proses yang terjadi ketika build program adalah kompiler akan mengambil file source untuk menghasilkan file object, kemudian linker mengambil file object dan menghasilkan executable file.

Teknik dasar melakukan kompilasi file dan mendapatkan executable adalah dengan menjalankan perintah :

gcc filename.c -o filename

Dasar makefile

makefile pada dasarnya berisikan :

target: dependencies

[tab] system command

Sebagai contoh aplikasi dari sintaks ini :

all :

gcc filename.c –o filename

Pada contoh ini dapat kita lihat bahwa target adalah all. Ini adalah target default dari makefile. Make akan mengeksekusi target jika tidak ada target lain yang ditentukan. Dapat dilihat pula bahwa tidak ada dependensi untuk target all sehingga make dapat mengeksekusi system command dengan aman.

Menggunakan dependencies

Kita dapat melakukan pengaturan dependencies apabila kita ingin melakukan modifikasi terhadap sebuah file, namun tidak ingin melakukan recompile terhadap seluruh file yang ada. Sebagai contoh :

all: hello

hello: main.o hello.o

gcc main.o hello.o –o hello

main.o: main.c

gcc –c –Wall main.c

hello.o: hello.c

gcc –c –Wall hello.c

clean:

rm –rf *o hello

Dapat dilihat bahwa target all hanya memiliki dependencies tanpa system command. Make dapat mengeksekusi secara tepat ketika seluruh dependencies dari target terpenuhi. Tiap dependencies dipanggil dan dieksekusi apabila ditemukan. Pada contoh diatas terdapat target clean yang berfungsi untuk menghapus seluruh file object dan executable.

Menggunakan variabel dan komentar

Dalam pembuatan makefile dapat pula melibatkan variabel dan komentar yang akan mempermudah misalkan dalam pendefinisian compiler maupun optionnya.

# komentar 1, pendefinisian compiler yang digunakan

CC=gcc

# komentar2, pendefinisian option yang akan dilewatkan kedalam compiler

CFLAGS =-c –Wall

all: hello

hello: main.o hello.o

$(CC) $(CFLAGS) main.o hello.o –o hello

main.o: main.c

$(CC)  $(CFLAGS) main.c

hello.o: hello.c

$(CC)  $(CFLAGS) hello.c

clean:

rm –rf *o hello

Nilai variable dapat didefinisikan sebelum pendefinisian target dengan operator dereference $(VAR), sedangkan untuk penggunaan komentar diawali dengan #.

Demikian penjelasan singkat mengenai makefile, untuk keterangan lebih lanjut dapat dirujuk ke make documentation.

*nb : ada yg tau cara masukin [tab] ketika posting di wordpress?

I became desperate yesterday night to do some useful things, anything. Had a long offline Puja Holidays. I was struggling to understand “How to write Makefiles”, and yesterday it clicked and I ended up writing a Makefile for the ongoing fedX project. Though the makefile which I wrote is not that great, but I have a start now. Committed the changes to the fedX repository at

http://gitorious.org/~rtnpro/fedx/rtnpros-fedx-clone/

It was around 4:00 AM in the morning already. Made some changes in my gitorious project clones. Apart from that, I was trying to download the rpmfusion repositories for Fedora 11. I was using rsync on multiple screens for the purpose. But again and again, rsync used to stop downloading after working for sometime. Then I tried a Firefox addon “DownThemAll” and was very happy to see it work. All I needed was to browse the repository page listing all the packages, right click and select DownThemAll. And then I just needed to select where I want to save the downloaded files and start it. It downloads multiple files simultaneously and does not halt when one of the files cannot be downloaded, rather it pauses it and moves to others. It also supports resume, and has an option to skip the already downloaded files.

But I could not download the directories with DownThemAll. I guess it works only for files. Need to do some research on it. Any way, you can try to use DownThemAll. I think you will like it.

Finally, I went to sleep at 4:45 AM with my laptop running DownThemAll to download the rpmfusion repository. When I got up today morning, it was running fine.

I’ve been experimenting with CUDA and OCTAVE; there is at least one company who have produced GPU enabled MEX functions. The big difficulty is of course that there is no support for internal floats within OCTAVE (afaik) and similarly with Matlab. However if one can leave the data and work with it on the device for some time, then there are only two explicit conversions btwn float <-> double needed. Or you could sacrifice some performance in CUDA in return for using doubles. At any rate here’s an example Makefile, happy experimenting. For this example I gutted the matrix Mul example from the CUDA sdk; the wrapper *oct source code (*cc, really C++ with octave extensions) contains an extern C section which references the cuda kernel (*cu). Don’t forget to indent instructions under ‘all’ with a single tab for make.

#! /usr/bin/env make
#make file for octfile/cuda
#Mac OSX 10.5.8 intel core 2 duo
#cuda include/lib
CUDA_INC_PATH=/usr/local/cuda/include
CUDA_LIB_PATH=/usr/local/cuda/lib
#octfile compiler
CC=mkoctfile
#basic flags
CFLAGS= -I$(CUDA_INC_PATH)
LDFLAGS= -L$(CUDA_LIB_PATH) -lcudart -lcuda

all:
$(CC) $(CFLAGS) -c cudaMatrixMul.cc -o cudaMatrixMul.o
nvcc  -c matMul_kernel.cu -o matMul_kernel.o -Wall
$(CC) $(LDFLAGS) cudaMatrixMul.o matMul_kernel.o -o cudaMatrixMul.oct

#clean:
rm -f  cudaMatrixMul.o matMul_kernel.o

First thing to know about makefiles is that the contents are basically arranged as:

TARGET: DEPENDENCIES
RULE

where TARGET is the product of this set, whose production is dependent on DEPENDENCIES, and the process of production is stated in RULE.
Makefile usually starts with the ultimate product of the whole project and is followed by the set for producing the dependency files using the same structure. For example:

myProduct: main.o file1.o file2.o
gcc -o myProduct main.o file1.o file2.o

main.o: src/main.c src/file1.h
gcc -c -o main.o src/main.c

file1.o: src/file1.c src/file1.h
gcc -c -o file1.o src/file1.c

file2.o: src/file2.c src/file2.h
gcc -c -o file2.o src/file2.c

Good thing about make is that it can do incremental compiling and linking based upon the files’ timestamp information.
Next thing to know is about variables. make allows the use of variables to ease writing large files. The syntax is really easy. Just declare a variable name followed by an equal sign and then arbitrarily long string of characters. Then, to refer to that variable use ${variable-name}. Concatanation of variable values is possible using plus (+) sign. for example:

MY_VAR = hello there
ANOTHER_VAR += how are you

There are also some string manipulation functions available for substituting, sorting etc. Substitution can be used to automatically generate header and object file names from the source file names. For example:

SRC_FILES=main.c file1.c file2.c
OBJ_FILES=$(patsubst %.c, %.o, ${SRC_FILES})
DEP_FILES=$(patsubst %.c, %.dep, ${SRC_FILES})

Next interesting thing is pattern matching characters provided by GNU make. These characters can be used to avoid repeatedly write similar commands and rules. Consider:

CFLAGS = -c -g
%.o:%.c
gcc ${CFLAGS} -o $@ $

Here, first the necessary switches for compiling are kept in a variable. This allows changing of switches without having to modify all the commands in the makefile. Next the interesting part begins. The command %.o:%.c indicates how .o files have to be produced from .c files in general. And then the rule to produce is given in the line below. Where we use some more predefined characters of make. $@ indicates the left hand side pattern matching (i.e. %.o) and $ means the right hand side pattern matching characters (i.e. %.c). Therefore, for each object file (.o) make will use this generic command and create respective .o files from each .c file. However, to find these .c files, make just checks the current directory. If the source files are in some other directory, then we are in trouble. But, the predefined VPATH variable is the solution. It provides make with the listing of directories that it needs to include in its search path. So, we should write VPATH = src, to make MAKE search in src folder also for source files.
Dependency check is also a very powerful feature of MAKE, but I will study them a li’l bit more before writing anything about them.

I have been learning C back from basics. Recently i tried out a simple program myHello.c , which contained the following code :

1. //myHello.c

2. #include”hello.h”

3. int main(void)

4. {

5. hello(“WORLD”);

6. return 0;

7. }

next, i created hello.h that contained the following code :

1. //hello.h

2. void hello(const char* name);

Finally i created helloFunc.c that contained the declaration for hello() :

1. //helloFunc.c

2. #include<stdio.h>

3. #include”hello.h”

4. void hello(const char* name)

5. {

6. printf(“hello, %s \n”,name);

7. }

I compiled the C sources as follow :

gcc -Wall myHello.c helloFunc.c -o newHello

I received the following error :

/usr/lib/gcc/i486-linux-gnu-4.3.3/../../../../libcrt1.o: In function ‘_start’ :

/build/buildd/libc-2.9/csu/../sysdeps/i386/elf/start.S:115: undefined reference to ‘main’

collect2: ld returned 1 exit status

Solution:

just use a Makefile.

You need to build them using:

gcc -c helloFunc.c -o helloFunc.o

gcc -c myHello.c -o myHello.o

gcc myHello.o helloFunc.o -o hello

Navegando na net achei este ótimo artigo sobre makefile, nem muito complexo nem muito básico, e ainda trata sobre latex .

Introdução ao make:
http://jfmitre.com/2009/06/uma-introducao-ao-comando-make.html

makefile detalhado:
http://jfmitre.com/2009/06/apresentando-um-makefile-em-detalhes.html

Like any system that has evolved over many years, GNU Make is rife with appendages of questionable utility. One area this is especially noticeable is the collection of built-in rules in gmake. These rules make it possible to do things like compile a C source file to an executable without even having a makefile, or compile and link several source files with a makefile that simply names the executable and each of the objects that go into it.

But this convience comes at a price. Although some of the built-in rules are still relevant in modern environments, many are obsolete or uncommonly used at best. When’s the last time you compiled Pascal code, or used SCCS or RCS as your version control system? And yet every time you run a build, gmake must check every source file against each of these rules, on the off chance that one of them might apply. A simple tweak to your GNU Make command-line is all it takes to get a performance improvement of up to 30% out of your makefiles. Don’t believe me? Read on.

Let’s look at a trivial example:

all: input
	@echo done

Touch the file input, then run gmake with the -d option, so you can see as gmake tries each of the built-in rules. GMake will ramble on for hundreds of lines, as you’ll see. Here’s a sample of that output:

Considering target file `all'.
 File `all' does not exist.
  Considering target file `input'.
   Looking for an implicit rule for `input'.
   ... many lines omitted ... 
   Trying pattern rule with stem `input'.
   Trying implicit prerequisite `RCS/input,v'.
   Trying pattern rule with stem `input'.
   Trying implicit prerequisite `RCS/input'.
   Trying pattern rule with stem `input'.
   Trying implicit prerequisite `s.input'.
   Trying pattern rule with stem `input'.
   Trying implicit prerequisite `SCCS/s.input'.
   Trying pattern rule with stem `input'.
   ... hundreds more lines omitted ...
  No implicit rule found for `input'.
  Finished prerequisites of target file `input'.

What’s going on here? Well, we didn’t provide a rule describing how to build the file input, so gmake is checking to see if any of the built-in rules could be used to generate it. Of course none of them do, so this is all wasted effort. Lucky for us, a single command-line option is all you need to tell gmake not to bother with the default built-in rules: -r. Try that trivial makefile again, this time with -d -r:

Considering target file `all'.
 File `all' does not exist.
  Considering target file `input'.
   Looking for an implicit rule for `input'.
   No implicit rule found for `input'.
   Finished prerequisites of target file `input'.

All the extra nonsense is gone! And even on this toy example, there is a measurable performance improvement: originally, this makefile runs in about 0.015s (average over three runs); with the built-in rules disabled, it’s just 0.012s. But I can see you won’t be convinced by such a trivial example. So let’s try something a bit bigger:

SOURCES:=$(wildcard sub/*.x)
TARGETS:=$(SOURCES:.x=.o)
all: $(TARGETS)
        @echo done

%.o: %.x
        @echo $@

The directory sub contains 15,000 files named 00001.x through 15000.x. With the built-in rules (and redirecting output to /dev/null), this makefile runs in about 60.2s; without the built-in rules, 42.9s — 28% faster.

Finally, let’s try this optimization on a real build. I built one component of the Accelerator project completely, then ran “no-op” builds (ie, no work to be done, just checking that everything is up-to-date). With built-in rules, this took 6.0s; without, it took 5.2s — 13% faster:

Now, if your build actually relies on built-in rules obviously you can’t simply disable them. But you could explicitly define just those rules that you require and disable the rest. For example, if you use the default %.o: %.cpp rule, you could add just that rule to your makefiles:

%.o: %.cpp
	$(COMPILE.cpp) $(OUTPUT_OPTION) $<

Once you’ve done that, you can add -r to your command-line and enjoy the benefits. If you go this route, you can see the list of built-in rules by running gmake -p; the built-ins are marked as “built-in” in that output.

Conclusion

Disabling gmake’s array of built-in rules is an easy way to squeeze extra performance out of your makefiles, particularly on large builds and on no-op builds. All you have to do is add -r to your commmand-line. (NB: If you prefer more descriptive command-lines, you can use –no-builtin-rules instead!)

• Makefile performance: recursive make
• Makefile performance: $(shell)
• Makefile performance: pattern-specific variables
• Makefile performance: built-in rules (this post)

Introduction.

In this blog post I will try to explain to you the anatomy of a typical make file, as most of the new comers to Unix/Linux arena often find it difficult comprehend the philosophy behind the make & they often do get imitated by its weird looking syntax and structure. We’ll first describe why a make is needed and then I will highlight the basic structure and syntax of a make file and will then we will wrap up the post by presenting some examples to make your concepts clear.

The case for make

Make is a tool that is used to control the build process of your software.

Make automates what is built, how it gets built, when it gets built etc. A makefile is a place where you store all of your commands to build the software.

Similar concept exists in the Java world in shape of Ant and more recently Maven that even provide more functionality and flexibility to compile, test & even deploy your applications through simple xml files.

Suppose you have multiple source files that require long & complex compiler invocations, “make” simplifies this by storing these commands in a single makefile so that they can be managed from a single location. You can also specify which files & directories you want create and delete based upon certain circumstances. Like for example you want all your library files to be compiled into the lib folder of the installation directory. “Make” also makes it easier for other people who want to compile and execute your application; in place of creating huge documentation on how to build your software you can just tell them to run make & it would take care of the rest.

Finally as the final argument in favor of make I think it really speeds up the build process of your application. Make is intelligent enough to recognize which files have changed and thus only builds those files whose components have changed. Plus makefiles also constitute a database of dependency information allowing you to automatically verify that all the files for the build are present.

Anatomy of a MakeFile

A make file is a simple text file containing rules that tell make what to build and how to build it. A makefile consists of number of rules, at its basic the general structure of make looks likes this:-

# Comments use the hash symbol

Target : dependency [dependency] [ … ]

Command 1

Command

…

…

Command n

Target is what we are trying to build a binary or an object file. Dependency is a list of one or more files required for the compilation, commands are the steps either compiler invocations or shell scripts required to create the target.

The spaces before commands are TABS & should be used as such, empty spaces would not suffice in their place & you would get the missing separator error. This is the most common problem people new to make get stucked with.

Example of a Make File

edit : main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

cc -o edit main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

main.o : main.c defs.h

              cc -c main.c

kbd.o : kbd.c defs.h command.h

              cc -c kbd.c

command.o : command.c defs.h command.h

              cc -c command.c

display.o : display.c defs.h buffer.h

              cc -c display.c

insert.o : insert.c defs.h buffer.h

              cc -c insert.c

search.o : search.c defs.h buffer.h

              cc -c search.c

files.o : files.c defs.h buffer.h command.h

              cc -c files.c

utils.o : utils.c defs.h

              cc -c utils.c

clean :

      rm edit main.o kbd.o command.o display.o \                               
      insert.o search.o files.o utils.o

Two long lines are split into two by using backslash-newline. This make file will create an executable “edit”.

To compile the program simply just type make on the command prompt.

This make file has 10 rules. The first target edit is the default target which is the binary we are trying to create. Edit has eight dependencies from main.o to utils.o, all of these files must exist to create the edit binary. The next line is the command that make executes to actually create the binary. Here make would actually build the executable from all these object files that are named .o.

When make encounters a dependency and it does not exists make executes the command to build it & if the dependency has further dependencies make tries to find them & if they does not exist make tries to build them using the command specified and so likewise make is able to traverse through all of the dependencies if present and build the software smoothly.

Clean target as you can see is the simple command that removes all the object files and as well as the final binary using the rm command.

Phony Targets

A phony target is one that is not really the name of a file. It is just a name for some commands to be executed when you make an explicit request. There are two reasons to use a phony target: to avoid a conflict with a file of the same name, and to improve performance.

Like for example there is a file named clean it would be disregarded by make. Phony targets are defined like this in a make file for example

.PHONY : clean zip

rm abc.o xyz

zip : clean

zip abc.zip *.c *.h Makefile

There are a lot of command line arguments that make can take the following is a short list of useful command options.

-f file                         Read the file name file instead of standard names

-n                         Display the commands make would executes without actually executing them

-s                        Execute silently ie not printing the commands make executes

-w                        print directory names when make changes directory

-r                         disable all of makes built-in rules.

-d                         print lots of debugging information

-k                         keep executing even if one target fails to build.

-jN                        Run N commands in parallel, where n is an non-zero integer.

More exhaustive list can be found at http://www.gnu.org/software/make/manual/make.html#Options-Summary

Variables

To simplify editing and maintenance make allows us to use variables. There are four kinds of variables

1. User defined variables
2. Environment variables
3. Automatic variables and
4. Pre-defined variables

User-Defined Variables

We define variables using the general form:

VARNAME = value [ … ]

It is a convention to use upper case letters for variables names, to obtain a variables value we just parenthesize the variable and add a dollar sign as a prefix.

There are two kinds of variables in “make” simply expanded variables and recursively expanded variables. Recursively expanded variables as the name suggest expands variables within variables until there are no further variables. For example

HOME_DIR = /home/asad

DEV_DIR = $(HOME-DIR)/development

PROJ_DIR = $(HOME-DIR)$(DEV-DIR)/project

SRC_DIR = $(HOME-DIR)$(DEV-DIR)$(PROJ_DIR)/src

If you use SRC_DIR variable somewhere all of the variables would get expanded.

Simply expanded variables are scanned once where they are defined and all embedded variable references are immediately resolved. Syntax is slightly different

CC := gcc

CC += -g

This would result in gcc –g when resolved.

If you consider using recursively expanded variables for this for example

CC = gcc

CC = $(CC) – g

We would get stuck in an infinite loop as $(CC) would keep on getting resolved to the same expression $(CC) & make would throw an error.

Environment Variables

Every environment variable that make sees when it starts up is transformed into a make variable with the same name and value. However, an explicit assignment in the makefile, or with a command argument, overrides the environment. $(HOME) variable for example can be used in make to refer to the users home directory.

Automatic Variables

Automatic variables are those variables whose value is evaluated each time a rule is executed, based on target and dependencies of that rule. Automatic variables are used to create pattern rules, patterns are generic instructions on how to compile an arbitrary .c file to its corresponding .o file.

Here is a partial list of automatic variables

$@                        The file name of the target of the rule.

$<                        The name of the first prerequisite/dependency.

$?                        The names of all the prerequisites that are newer than the target, with spaces between them.

$*                         The basename (or stem) of a filename.

$^                        Expands to a space-delimited list of all of a rules depedencies.

$(@D)                        The directory part of targets path name, if named target is in the sub-directory.

$(@F)                        The file part of targets path name, if named target is in the sub-directory.

For an exhaustive list please visit

http://www.gnu.org/software/make/manual/make.html#Automatic-Variables

example:

CFLAGS := -g

CC := gcc

.c .o:

$(CC) $CFLAGS –c $* .c

lock: lock.c

$(CC) $(CFLAGS) $< -o $@

for each filename ending in .c make would create an object file ending with .o, while executing $< would be replace with lock.c similarly target name $@ will be replaced by lock.

Pre-Defined Variables

These are the variables that as the name suggests are predefined by make. A few of them are listed below.

AR                        Archive-maintaining program; default `ar’.

AS                        Program for compiling assembly files; default `as’.

CC                        Program for compiling C programs; default `cc’.

CO                        Program for checking out files from RCS; default `co’.

CXX                        Program for compiling C++ programs; default `g++’.

CO                         Program for extracting a file from RCS; default `co’.

CPP                        Program for running the C preprocessor, with results to standard output; default `$(CC) -E’.

RM                        Command to remove a file; default `rm -f’.

ARFLAGS            Flags to give the archive-maintaining program; default `rv’.

ASFLAGS            Extra flags to give to the assembler (when explicitly invoked on a `.s’ or `.S’ file).

CFLAGS            Extra flags to give to the C compiler.

For an exhaustive list please see

http://www.gnu.org/software/make/manual/make.html#Implicit-Variables

Conditional Statements

Conditional expressions can be applied to a make file so that parts of make file execute or not based on certain conditions. Generic syntax is as follows

conditional-directive

text-if-true

else

text-if-false

endif

The following example of a conditional tells make to use one set of libraries if the CC variable is `gcc’, and a different set of libraries otherwise. It works by controlling which of two command lines will be used as the command for a rule. The result is that `CC=gcc’ as an argument to make changes not only which compiler is used but also which libraries are linked.

libs_for_gcc = -lgnu

normal_libs =

foo: $(objects)

ifeq ($(CC),gcc)

$(CC) -o foo $(objects) $(libs_for_gcc)

else

$(CC) -o foo $(objects) $(normal_libs)

endif

This conditional uses three directives: one ifeq, one else and one endif.

Last Example

In the last example I would like to show you how to create install, dist and uninstall targets that you can most probably use while distributing your applications.

Hello: hello.c

install : hello

install $< $(HOME)

.PHONY : dist unistall

dist :

$(RM) hello *.o core

tar czvf hello.tar.gz hello.c Makefile

uninstall:

$(RM) $(HOME)/hello

and you can use make install, make dist & make uninstall commands for respective functions.

With this I think we should wrap up our tutorial on make. This is not a fully exhaustive tutorial but it would place you on the right grounds & will get you started with make hopefully. If you have any questions please don’t hesitate to ask and If you want to know more about specific details & I don’t impress you much you can always access the online documentation at http://www.gnu.org/software/make/manual/.

Nobody would ever claim that GNU Make is a general purpose programming language, but with a little work, we can coerce it into generating Fibonacci numbers for us. Why bother? Because we can.

First, let me give a simple demonstration. Here’s the makefile:

16:=x x x x x x x x x x x x x x x x
input_int:=$(foreach a,$(16),$(foreach b,$(16),$(foreach c,$(16),$(16))))
decode=$(words $1)
encode=$(wordlist 1,$1,$(input_int))
decr=$(wordlist 2,$(words $1),$1)
decr2=$(wordlist 3,$(words $1),$1)
eq=$(filter $(words $1),$(words $2))
g0:=
g1:=x

fib=$(if $(filter-out undefined,$(origin f$1)),\
           $(f$1),\
           $(if $(call eq,$1,$(g0)),\
	          $(eval f$1:=$(g0))$(g0),\
                  $(if $(call eq,$1,$(g1)),\
                         $(eval f$1:=$(g1))$(g1),\
                         $(eval f$1:=$(call fib,$(call decr2,$1)) $(call fib,$(call decr,$1)))$(f$1))))

print=$(if $1,\
$(call print,$(call decr,$1))$(info $(call decode,$1): $(call decode,$(f$1))),\
$(info 0: 0))

%:
	@:$(if x$(call fib,$(call encode,$@)),$(call print,$(call encode,$@)),)

Invoke it with a single argument, the length of the sequence to generate:

ericm@chester:~/blog/fibonacci$ gmake 10
0: 0
1: 1
2: 1
3: 2
4: 3
5: 5
6: 8
7: 13
8: 21
9: 34
10: 55

Nifty!

Now, although this demonstration is not especially practical, it does make use of a few advanced gmake concepts: arithmetic; caching dynamically generated variables; and recursive functions.

Arithmetic

None of this would be possible without support for arithmetic operations. Here’s a brief explanation of how this works (for more details, the Mr. Make article Learning GNU Make Functions with Arithmetic): we use strings of space-separated x characters to represent values; for example, the number five is represented as x x x x x. To add numbers together, we concatenate the string representations, and to subtract, we trim the appropriate number of x’s from the string. To convert from the string representation to the numeric value, we just count the number of x’s in the string, using the $(words) builtin, and finally, to convert from the numeric value to the string representation we extract the appropriate number of x’s from a canonical string that just has a series of several thousand x’s.

This is inefficient, in both memory and time. The representation of a number requires double the value in bytes, so the number 50,000 requires 100,000 bytes of storage. Converting to a numeric value from the string representation is a linear operation that scales with the magnitude of the value — the bigger the value, the longer the conversion takes. These factors together limit the range of numbers that you can practically work with using this scheme, although it works fine for small values (up to around 10,000 or so). For the Fibonacci makefile, the inefficiencies mean that we can only generate the sequence out to about the 40th value. At that point, gmake has already sucked up 1.4 GB of memory!

Caching dynamic values

Because it is time-consuming to compute Fibonacci numbers this way, we’d like to cache the results, so we don’t ever duplicate work. But the values are dynamically generated. For that matter, the variables themselves must be dynamically generated — we don’t know beforehand which Fibonacci numbers we’re going to have to compute. So how do you dynamically generate variables and cache their values in gmake? With $(eval). You can read all about it in another Mr. Make article, $(eval) and macro caching. In our Fibonacci makefile, you can see that as we determine each Fibonacci number, we invoke $(eval) to save the value. The fib function is then setup to first check for the existence of a cached value and only bother with the computation if there is no cache entry.

Recursive functions

The Fibonacci sequence is defined recursively as f(n) = f(n – 1) + f(n – 2), so naturally we use a recursive function in our implementation. The fib function takes one argument, the index of the Fibonacci number to compute, encoded using the scheme described above. After checking the cache, fib checks if the current index is either zero or one. By convention, these Fibonacci numbers are defined to have value zero and one, respectively, so there is no need to compute them. This also serves as a terminating condition so we don’t recurse infinitely.

If the current index is neither zero nor one, then fib calls itself recursively twice, to compute the two preceding Fibonacci values. The recursive results are combined, cached, and returned as the overall result of the fib function itself.

Conclusion

I’m surprised at how quickly gmake computes the sequence, actually. On my laptop, gmake computes the first 30 values in a fraction of a second. After that the inefficiencies in the arithmetic operations really come into play: it takes about 3.5 seconds to compute 35 values, and 25 seconds to compute 39 values. Still, considering the limitations of the environment, I think it’s impressive that it works at all.

I recently wrote an article for CM Crossroads exploring various strategies for handling rules that generate multiple output files in GNU make. If you’ve ever struggled with this problem, you should check out the article. I don’t want to spoil the exciting conclusion, but it turns out that the only way to really correctly capture this relationship in GNU make syntax is with pattern rules. That’s great if your input and output files share a common stem (eg, “parser” in parser.i, parser.c and parser.h), but if your files don’t adhere to that convention, you’re stuck with one of the alternatives, each of which have some strange caveats and limitations.

Here’s a question for you: if ElectricAccelerator had an extension that allowed you to explicitly mark a non-pattern rule as having multiple outputs, would you use it? For example:

#pragma multi
something otherthing: input
	@echo Generating something and otherthing from input...

What do you think? Comments encouraged.

Sandwich webcomic from xkcd.com

If you like this comic from xkcd.com, you are now able to reproduce the conversation in your shell. You only need this makefile:
me a:
    @true
sandwich.:
ifeq ($(shell if touch / 2> /dev/null; then id -u; fi),0)
    @echo "Okay."
else
    @echo "What? Make it yourself."
endif
.PHONY: me a sandwich.
Download the Makefile from my sandwich branch or copy & paste the text above into your preferred editor (you have to convert the spaces to tabs) and save it as Makefile. Then you can run “make me a sandwich.” in your terminal and see what happens.