The C Preprocessor Compiling and Linking Using MAKE

Transcription

1 All slides c Brandon Runnels, 2014 This presentation is not for general distribution; please do not duplicate without the author s permission. Under no circumstances should these slides be sold or used for profit. Author s brunnels@caltech.edu B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

2 MAKE It So: Understanding the Build Process Brandon Runnels Caltech, LANL July 16, 2014 B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

3 1 The C Preprocessor 2 Compiling and Linking 3 Using MAKE B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

4 Overview The C Preprocessor is a powerful language for processing code before it is compiled If used properly, the C Preprocessor can help make powerful, lexible, easy to read code If not understood, it can be responsible for some of the most baling compile errors you'll ever see B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

5 Basics The C Preprocessor is run before and independently of compilation The result of running the preprocessor can be seen by compiling with the -E lag The C Preprocessor is not just used for C; it is also used in FORTRAN, C++, and some other languages Commands (called directives) are always proceeded by a # sign We will look at Include Deine If, elif, endif, else B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

6 #include emacs: main.c emacs: myfile.txt Now Now is is the the time time for for all all good good men men to to come come to to the the aid aid of of their their country country Blah Blah blah blah blah... blah... #include #include my_file.txt Yadda Yadda yadda yadda yadda yadda The preprocessor physically copies and pastes all of the include iles. Running gcc with the -E option runs the preprocessor only and shows you the result. Terminal > gcc gcc -E -E main.c main.c Blah Blah blah blah blah... blah... Now Now is is the the time time for for all all good good men men to to come come to to the the aid aid of of their their country country Yadda Yadda yadda yadda yadda yadda B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

7 #define emacs: main.c Terminal #define #define MYNUMBER MYNUMBER I am am MYNUMBER MYNUMBER years years old old > gcc gcc -E -E main.c main.c I am am years years old old Deines are pretty easy. It's important, however, to remember the diference between a deine which is a macro and an actual language variable. B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

8 #ifdef Include Guards emacs: myheader.h #ifndef #ifndef HEADER_DEFINED #define #define HEADER_DEFINED header header file file #endif #endif emacs: main.h #include #include myheader.h main main header header file file emacs: main.c #include myheader.h #include #include main.h int int main() main() The solution is to add include guards. This is done in basically every C/C++ program ever to be compiled. B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

9 The C Preprocessor Some other C Preprocessor goodies: FILE : Macro for the current ile name LINE : Macro for the current line number DATE and TIME : macro for date and time at compilation Functions: #deine plus(a,b) A+B B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

10 The C Preprocessor Review The C Preprocessor processes source iles before they get to the compiler Preprocessor directives are used to make code more human readable They are also used to allow lexibility in compilation options Directives are often to blame for highly cryptic compilation errors The preprocessor is almost a language itself it is not to be underestimated! B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

11 1 The C Preprocessor 2 Compiling and Linking 3 Using MAKE B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

12 Compiling and Linking Overview: we will discuss The diference between compiling and linking The build process How to include libraries B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

13 main.c gcc a.out emacs: main.c #include myfunction.h int int main() main() { myfunction(); } emacs: myfunction.h #ifndef #ifndef MYFUNCTION_INCLUDED #define #define MYFUNCTION_INCLUDED #include <stdio.h> void void myfunction(); #endif #endif// // MYFUNCTION_INCLUDED emacs: myfunction.c #include #include myfunction.h void void myfunction() { printf( Hello, world\n ); } B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

14 main.c We've taken a simple problem and made it more complicated. How do we turn these three iles into an executable? myfunction.c? a.out myfunction.h First, we need to compile the code into object iles B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

15 myfunction.c gcc -c myfunction.o myfunction.h main.c myfunction.h gcc -c main.o COMPILING LINKING myfunction.o myfunction.o gcc a.out B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

16 Terminal We compile all of the iles into object iles the same way. Finally, we link all of the object iles together. (Note that there is no -c in the line) > gcc gcc main.c main.c Undefined reference to to 'myfunction' > gcc gcc main.c main.c Undefined reference to to 'myfunction' > gcc gcc -c -c main.c main.c > gcc gcc -c -c myfunction.c > gcc gcc main.o main.o myfunction.o B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

17 Shared vs. Static Libraries: A dynamic library is not compiled into the code. It contains precompiled code that will only be made available at runtime The size of a.out is independent of the size of the shared library a.out is not a complete program. It will only run on computers that have a copy of package.so available at runtime myfunction.o main.o package.so Linking a.out B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

18 Shared vs. Static Libraries: Running Terminal Hello, Hello, world world > ldd ldd./a.out./a.out linux-vdso.so.1 (0x00007fffed4f0000) libmylib.so => =>./libmylib.so (0x00007fa82cd85000) libc.so.6 => => /usr/lib/libc.so.6 (0x00007fa82c9d8000) /lib64/ld-linux-x86-64.so.2 (0x00007fa82cf86000) > The command ldd <executable_name> lists all of the libraries on which the executable depends B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

19 Shared vs. Static Libraries: Static Libraries Portable all code is self contained Fast all routines are already in memory at runtime Easy to use does not require system reconiguration to run Dynamic Libraries Flexible dependency upgrades do not require a recompilation Small Size of the binary executable is only as large as the unique code that it contains B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

20 1 The C Preprocessor 2 Compiling and Linking 3 Using MAKE B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

21 Using MAKE Overview: we will discuss What Make does How to write a simple Makeile B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

22 emacs: Makefile Terminal > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

23 emacs: Makefile Hello,world This is a target like a function but diferent as we'll see. When the target is executed, all of the indented text is fed right into the terminal Terminal > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

24 emacs: Makefile Hello,world This is a target like a function but diferent as we'll see. When the target is executed, all of the indented text is fed right into the terminal Terminal > make make Hello, Hello, world world > make make default default Hello, Hello, world world > echo echo Hello, Hello, world world Hello Hello world world B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

25 emacs: Makefile default: default: #This #This is is a comment comment echo echo Hello,world Even comments get fed to the terminal. The # character is ignored by the shell. Adding before a command suppresses the actual command in the shell useful for echo. Terminal > make make #This #This is is a comment comment echo echo Hello, Hello, world world Hello, Hello, world world > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

26 emacs: Makefile default: default: gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Makeiles are usually used to compile code This is something that could be done with a script. However, Make is far more powerful than that... Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

27 emacs: Makefile default: default: Compile complete! compile: gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o A dependency. Before default is executed, Make looks for targets that match its dependency and executes those targets irst. Targets can be labels, variables, or ilenames. Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Compile Compile complete! > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

28 emacs: Makefile default: default: Compile complete! compile: main.o main.o myfunction.o gcc gcc main.o main.o myfunction.o main.o: main.o: gcc gcc -c -c main.c main.c myfunction.o: gcc gcc -c -c myfunction.c A target can be a ilename as well. A target called ile.ext is a rule for making ile.ext Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Compile Compile complete! > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

29 SRC SRC = myfunction.c main.c main.c OBJ OBJ = myfunction.o main.o main.o default: Compile complete! compile: compile: ${OBJ} ${OBJ} gcc gcc ${OBJ} ${OBJ} emacs: Makefile main.o: main.o: gcc gcc -c -c main.c main.c myfunction.o: gcc gcc -c -c myfunction.c Variables are declared directly Variables are called with ${...} (just like environment variables) Undeined variables have value Make will not complain Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Compile Compile complete! > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

30 SRC SRC = myfunction.c main.c main.c OBJ OBJ = myfunction.o main.o main.o default: Compile complete! compile: compile: ${OBJ} ${OBJ} gcc gcc ${OBJ} ${OBJ} main.o: main.o: main.c main.c gcc gcc -c -c main.c main.c myfunction.o: myfunction.c gcc gcc -c -c myfunction.c main.c: main.c: myfunction.c: emacs: Makefile Targets are only executed if their dependencies are up to date Now, main.c will only compiled if it has been changed since main.o All dependencies require targets; otherwise Make will complain no rule to make target main.c Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Compile Compile complete! > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

31 SRC SRC = myfunction.c main.c main.c OBJ OBJ = myfunction.o main.o main.o default: Compile complete! compile: compile: ${OBJ} ${OBJ} gcc gcc ${OBJ} ${OBJ} main.o: main.o: main.c main.c gcc gcc -c -c main.c main.c myfunction.o: myfunction.c gcc gcc -c -c myfunction.c main.c: main.c: myfunction.c: emacs: Makefile So far: we've taken a simple, scriptable sequence of commands and turned it into a mess. Fortunately, Make provides some very nifty tricks to collapse most of this. Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Compile Compile complete! > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

32 SRC SRC = ${wildcard *.c} *.c} OBJ OBJ = ${SRC:.c=.o} default: Compile complete! compile: compile: ${OBJ} ${OBJ} gcc gcc ${OBJ} ${OBJ} main.o: main.o: main.c main.c gcc gcc -c -c main.c main.c myfunction.o: myfunction.c gcc gcc -c -c myfunction.c main.c: main.c: myfunction.c: emacs: Makefile So far: we've taken a simple, scriptable sequence of commands and turned it into a mess. Fortunately, Make provides some very nifty tricks to collapse most of this. Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Compile Compile complete! > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

33 SRC SRC = ${wildcard *.c} *.c} OBJ OBJ = ${SRC:.c=.o} default: Compile complete! compile: compile: ${OBJ} ${OBJ} gcc gcc ${OBJ} ${OBJ} main.o: main.o: main.c main.c gcc gcc -c -c main.c main.c myfunction.o: myfunction.c gcc gcc -c -c myfunction.c %.c: %.c: emacs: Makefile So far: we've taken a simple, scriptable sequence of commands and turned it into a mess. Fortunately, Make provides some very nifty tricks to collapse most of this. Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Compile Compile complete! > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

34 SRC SRC = ${wildcard *.c} *.c} OBJ OBJ = ${SRC:.c=.o} default: Compile complete! compile: compile: ${OBJ} ${OBJ} gcc gcc ${OBJ} ${OBJ} %.o: %.o:%.c %.c gcc gcc -c -c $< $< %.c: %.c: emacs: Makefile %.o: General target for any target of the form ilename.c %.c: Replaces.c with.o on ilename.c $<: The irst dependancy Terminal > make make gcc gcc -c -c myfunction.c gcc gcc -c -c main.c main.c gcc gcc main.o main.o myfunction.o Compile Compile complete! > B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

35 SRC SRC = ${wildcard *.c} *.c} OBJ OBJ = ${SRC:.c=.o} default: Compile complete! compile: compile: ${OBJ} ${OBJ} gcc gcc ${OBJ} ${OBJ} %.o: %.o:%.c %.c gcc gcc -c -c $< $< %.c: %.c: emacs: Makefile PITFALL: Make knows that your executable depends on the object iles which depend on their corresponding source iles. If you change a source ile Make knows to recompile. This does not work for header iles. Changing a header ile will not trigger Make to recompile: you must do that manually. B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

36 Using MAKE Review Make is a powerful but specialized system for managing the compilation of a complicated code Make is the de facto system for building large code packages it pays to learn it! B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37

37 Thanks! B. Runnels ( Caltech, LANL ) MAKE It So 7/16/ / 37