Systems Programming. laboratory. Compilation automation. make ceedling

Size: px

Start display at page:

Download "Systems Programming. laboratory. Compilation automation. make ceedling"

Jonathan Griffin
5 years ago
Views:

1 Systems Programming 2 nd laboratory Compilation automation make ceedling

2 Compilation automation Large SW projects are composed of diferent su-systems with links and dependencies among them Libraries/ cliens/servers/interfaces In codind: there are hierarchical dependencies between modules The correct compiling and linking requires temporal ordering of the compilation Librraies should be compilded after edited a Programm should be linked after all libraries (and.o) were compiled Efficient compilation only changed files should be compiled

3 Make Make produces a coherent output only compiles/links the required files those changed and with dependencies The configuration file is called makefile. makefiles contain rules: target1 [target2...]: [pre-req-1 pre-req-2...] [command1 command2...] A rule terminates with a line not started by \t or # usually a blank line The first rule of the makefile should produce the final file (program) Comment begins with a # and lasts till the end of the line. Long line can be broken and continued in several lines via a back-slash (\).

4 Make exemple all: hello.exe Default Rule evaluated with make # $@ matches the target; $< matches the first dependent hello.exe: hello.o gcc -o $@ $< Variable begin with $ hello.o: hello.c gcc -c $< clean: rm hello.o hello.exe Artificial target does not represent a file standard phony targets are: all, clean, install

5 Make rule evaluation make rebuilds targets in depth( depth-first Dependency search is done from the left to the right from target1 to targetn if the dependency list is empty the rule is always executed make clean always removes the auxiliary files If a target file is dependent on a another e.g. hello.exe depends on hello.o the dependency search is suspended and search goes down a level hello.o is evaluated If a pre-req file is news thar the target file make executes the command specified in the rule

6 Make rule evaluation when calling make by omission the first target to be buil is the pone on the first rule To build another target call make with the target name Exemplo: make builds hello.exe make hello.o builds hello.o make clean remove auxiliary files

7 Make rule evaluation prg: aux.o main.o gcc -o prg aux.o main.o prg aux.o: aux.c defs.h gcc -c aux.c aux.o main.o main.o: main.c gcc -c main.c aux.c defs.h main.c clean: rm prg *.o

8 Make rule evaluation Considering the follwing modification dates: what files are compiled if make is executed at 18:00?

9 Make Variables A variable begins with a $ and is enclosed within parentheses (...) or braces {...}. Single character variables do not need the parentheses. For example, $(CC), $(CC_FLAGS), $@, $^. Automatic variables are set by make after a rule is matched: $@: the target filename. $*: the target filename without the file extension. $<: the first prerequisite filename. $^: the filenames of all the prerequisites, separated by spaces, discard duplicates. $+: similar to $^, but includes duplicates. $?: the names of all prerequisites that are newer than the target, separated by spaces.

10 Variables A variable will be replaced when used in a rule Target / pre-req / command Static valid on the whole makefile Declaration: ID=texto Uso: $(ID) Example: CC=gcc # changes compiler CFLAGS=-Wall -ansi - pedantic main.o: main.c $(CC) $(CFLAGS) -c main.c

11 Variables Variables can be defined in the comamnd line: $ make CC=lcc variables defined in the command line overwrite those in the makefile

12 Pattern Rules Use pattern matching character '%' as the filename, can be applied to create a target, if there is no explicit rule. example: %.o: %.c $(CC) $(CFLAGS) $< %: %.o $< $(CC) $^ $(LDFLAGS) -o $@ the first prerequisite filename $^ the filenames of all the prerequisites $@ the target filename.

13 Implicit rules Tell make how to use customary techniques so that you do not have to specify them in detail when you want to use them. File names determine which implicit rules are run. For example, there is an implicit rule for C compilation The built-in implicit rules use several variables in their recipes so that, by changing the values of the variables, you can change the way the implicit rule works. For example, the variable CFLAGS controls the flags given to the C compiler by the implicit rule for C compilation.

14 Implicit variables implicit rules make liberal use of certain predefined variables. You can alter the values of these variable without redefining the rules themselves recipe used to compile a C source file actually says $(CC) -c $(CFLAGS) $(CPPFLAGS).

15 File locations When using implicit rules make searches for files in specifi directories usually the current directory (. ) vpath %.ext DIR defines the directory those files are available vpath %.c src/ vpath %.o obj/ vpath %.h include/.c.o: $(CC) $(CFLAGS) -c I include/ -o obj/$@ $< Directories used when searching for targets and pre-req target: f1.o $(CC) -o obj/f1.o f1.o: f1.c defs.h Commands require path

16 Make Links Tutorial www3.ntu.edu.sg/home/ehchua/programming/cpp/gcc_make.html Manual gnu.org/software/make/manual/ gnu.org/software/make/manual/html_node/implicit-rules.html

17 Make Exercise Consider the files available on FENIX Analyse the directory structure Analyze the source code files From the suplied code it is possible to compile two different executables The sexta program depend on files aux1.c e aux2.c. The file aux2.c depends on aux2.h. Determine the dependencies of program final, as described for sexta. Create a makefile that allow to compile the two programs maintain the proposed directory hirarchy Use variables, implicit rules and explicit rules The.o files soud be placed in the./obj directory The final programs should be place in the./bin If compileing with the -Wall and -pedantic option, the compiler will issue warnings Identify and correct them

18 Ceedling Assembling build environments for C projectsis hard especially with automated unit test Whether it's Make or Rake or Premake set up with an all-purpose build environment tool is tedious and requires considerable glue code to pull together the necessary tools and libraries. Ceedling allows you to generate an entire test and build environment for a C project from a single YAML configuration file. Ceedling is written in Ruby and works with the Rake build tool plus other goodness like Unity and Cmoc the unit testing and mocking frameworks for C. Ceedling and its complementary tools can support the tiniest of embedded processors, the beefiest 64 bit power houses available, and everything in between. depending on the compiler

19 Ceedling Build system for C projects extension around Ruby s Rake (make-ish) build system. Primarily targeted at Test-Driven Development in C designed to pull together CMock, Unity, and CException Ceedling is more powerful as a unit test build environment than it is a general purpose release build environment complicated projects including separate bootloaders or multiple library builds, etc. are not its strong suit

20 Ceedling Usual steps Create a new project (one command) Configure project (one file edit) Add modules (one command) Add tests (write code) Add code (write code) Compile/Teste (one command) Repeat

21 Ceedling comes with a command-line tool that can be used to generate a project. $ ceedling Commands: ceedling example PROJ_NAME [DEST] # new specified example project (in DEST... ceedling examples # list available example projects ceedling help [COMMAND] # Describe available commands or one spe... ceedling new PROJECT_NAME # new a new ceedling project

22 Project Creation $ ceedling new example1... Project 'example1' created! - Tool documentation is located in vendor/ceedling/docs - Execute 'rake -T' to view available test & build tasks $ cd example1 $ tree -L 1. build project.yml rakefile.rb src test vendor 4 directories, 2 files

23 Project Creation example1 project directory example1/src source code example1/build build products (.o binaries) example1/vendor auxiliary apps project.yml Next slide

24 Configuration Configure overall project: :project: :use_exceptions: FALSE :use_test_preprocessor: TRUE Automatic dependency checking (.h) :use_deep_dependencies: TRUE :use_auxiliary_dependencies: TRUE :build_root: build :release_build: TRUE :test_file_prefix: test_ allow the compilation of all source code in src directory These changes allow the compilation of all source code in src directory Automatic dependency checking (.h)

25 Configuration Project compilation: :release_build: :output: main Name of the executable :use_assembly: FALSE Definition of output name

26 Configuration Copy the follwing line to the end of the file :tools: :test_dependencies_generator: :executable: gcc :release_compiler: :executable: gcc :arguments: - -x c - -c - "${1}" - -o "${2}" - -Wall :release_linker: :executable: gcc :arguments: - ${1} - -o ${2}.bin Definition of the compilers to use gcc Arguments for compilations Arguments for linkage Dependency tester / compiler / linker

27 Compilation $ rake -T rake clean # Delete all build artifacts and temp rake clobber # Delete all generated files (and bui rake environment # List all configured environment var rake files:header # List all collected header files. rake files:source # List all collected source files. rake files:test # List all collected test files. rake logging # Enable logging rake module:create[module_path] # Generate module (sourc rake paths:source # List all collected source paths. rake paths:support # List all collected support paths. rake paths:test # List all collected test paths. rake release # Build release target. rake version # Display build environment version I Rake Ruby make

28 Development $ rake release rake release Release build 'main' Linking main... clang: error: no input files ERROR: Shell command failed. The project does not contain any source files Modules should be added

29 Module inclusion inclusion of modules (.c.h) $ rake module:create[main] creates src/main.c and src/main.h rake release compiles correctly (+-) int main()... is missing rake finds correct dependencies and compiles only the required files Source code directory is defined in configuration file Dependecies are automatcally calculated

30 Problem Create a new project with rake Implement a program that operates over imaginary numbers Create a module called imaginary Define the necessary data structures Define and implement the following functions: imaginary atoimag(char *str) str * imagtoa( imaginary I) imag imag_mult(imag i1, imag i2) The main program should print on the screen: The product of 3-1.5i and 4+0.3i

31 Informação

Makefiles SE 2XA3. Term I, 2018/19

Makefiles SE 2XA3. Term I, 2018/19 Makefiles SE 2XA3 Term I, 2018/19 Outline Example Calling make Syntax How it works Macros Suffix rules Command line options Example Assume we have files main.c, test.c, and lo.asm Consider the makefile