EBC Exercise 15 make - Revision history

Yoder: moved EBC Exercise 07a make to EBC Exercise 15 make

2012-07-17T19:27:19Z

moved EBC Exercise 07a make to EBC Exercise 15 make

Yoder: Added make part b

2012-07-17T19:25:57Z

Added make part b

Yoder: Added Header/Footer

2012-05-28T16:34:13Z

Added Header/Footer

Yoder: /* Lab Prep – Examine the directory contents and app.c */

2012-02-24T13:46:28Z

‎Lab Prep – Examine the directory contents and app.c

Yoder: /* Part A – Using the Command Line and Creating a Simple Makefile */ Formatting

2012-02-24T13:44:56Z

‎Part A – Using the Command Line and Creating a Simple Makefile: Formatting

Yoder: /* Lab Prep – Examine the directory contents and app.c */ Added git

2012-02-24T13:41:51Z

‎Lab Prep – Examine the directory contents and app.c: Added git

Yoder: /* Part A – Using the Command Line and Creating a Simple Makefile */ Various edits.

2011-12-07T20:23:18Z

‎Part A – Using the Command Line and Creating a Simple Makefile: Various edits.

Yoder: Added categories

2011-08-19T17:41:11Z

Added categories

Yoder: Adding Lab A

2011-08-19T17:22:45Z

Adding Lab A

New page

As your programs become more complex they will spread over multiple files. '''make''' is a utility that tells which files depend on which and how to compile them all together into an executable. This exercise walks you through how to create a Makefile.

This exercise is heavily based on TI's [http://processors.wiki.ti.com/index.php/OMAP%E2%84%A2/DaVinci%E2%84%A2_System_Integration_using_Linux_Workshop OMAP™/DaVinci™ System Integration using Linux Workshop].

== Basic make ==

In part A of the lab, you will build your first basic Makefile – basically turning command line execution into make rules. In Part B, you will increase the usability of your makefile by adding built-in variables and user-defined variables. This will provide you with a fundamental understanding of how makefiles work.

=== Lab Prep – Examine the directory contents and app.c ===

* Download the '''make''' directory from [http://www.rose-hulman.edu/~yoder/Beagle/exercises/ here] and put it on your Beagle.
* Open a terminal on the Beagle and cd to the '''make''' directory and examine the contents.
* Examine app.c with gedit.

== Part A – Using the Command Line and Creating a Simple Makefile ==

In this part, we will simply use the GNU compiler (gcc) from the command line to build the “Hello World” example and run it. Then, we’ll place these commands into a basic makefile and run the makefile. In the next part, we’ll use built-in and user-defined variables.
* Build and run “Hello World” from the command line.
To compile app.c, type the following command:
<pre>
gcc –g –c app.c –o app.o
</pre>
<pre>
gcc = GNU C compiler (command)
–g = symbolic debug (compiler option)
–c = (fill in answer below)
app.c = file to compile (kind of “dependency” or “prerequisite”)
-o = output filename is next (compiler option)
app.o = output file (the “target”)
</pre>

In the above gcc command, can you name the target, dependency and command?
# Target = _______________
# Dependency = ________________
# Command = __________________

* On your host computer use the '''man''' command to look up gcc.
To find the parameters for any standard C functions or Linux commands, you can use the “man”
(short for “manual”) command. Let’s try it on gcc:
<pre>
man gcc
</pre>
What does the –c option (from the previous step) tell the compiler to do?

To quit the man page, type '''q''' at least once (depending on where you are in the page, you might need to type “q” multiple times).
* Link the object file and produce the final executable.
Next, link the object file (app.o) to create the executable app.arm:
<pre>
gcc –g app.o –o app.arm
</pre>
Now run the executable:
<pre>
./app.arm
</pre>
You should see “Hello World” displayed in the command window. The extension used for the output file (.arm) indicates we are building for the arm (or Beagle).

----
'''Note''': For those of you who know Linux well, you can skip this explanation. For the rest …

<code>./</code> before the name of an executable tells Linux to look for the program
in the current directory.
We use this as it is the proper way to specify the path of the file to be run.
----

* “Clean” the existing executable (.arm) and intermediate (.o) files.
Type the following to remove the files generated by the gcc commands you executed:
<pre>
rm –rf app.arm
rm –rf app.o
</pre>
This removal of files mirrors what a “clean” macro or rule might do. We’ll actually add a rule shortly
to accomplish this in our makefile.

* Examine “starter” makefile.
The current makefile simply contains comments and placeholders for the code you will write. Using your favorite editor, open the makefile. For example:
<pre>
gedit makefile
</pre>
* Create rules for app.arm and app.o in your makefile.
Remember, a rule is made up of a target, dependency(ies) and command(s). For example:
<pre>
target : dependency
CMD
</pre>
Also note that the commands are tabbed over (at least one tab).
Create the rule for app.o in the area of the makefile with the header comments specifying the intermediate (.o) rule (as shown below). We’ll help you with the rule for app.o, but app.arm is up to you.
For app.o, type in the following rule. We will use the absolute path of gcc for now and later turn it into a variable:
<pre>
# ---------------------------------------------------
# ------ intermeditate object files rule (.o) -------
# ---------------------------------------------------
app.o : app.c
/usr/bin/gcc –g –c app.c –o app.o
</pre>
<pre>
app.o = target
app.c = dependency
/usr/bin/gcc -g … = command
</pre>
* Type in the rule for .x.
Next, type in the rule for app.arm ABOVE the rule for app.o in the area specified for the (.x) rule. Make sure you use the –g compiler option in the .x rule.
* Test your makefile.
Close makefile and type the following:
<pre>
make
</pre>
After running make, list the current directory. Do you see a new app.armexecutable? Run it.

Do you see “Hello World”? If so, your rules work. Next, let’s add a few more rules…

* Open makefile in a different Linux process.
Stop. Before you open makefile again, try opening it in a different Linux process by typing in the following:
<pre>
gedit makefile &
</pre>
The “&” tells Linux to open the makefile in a separate process (window). When you edit a file, you can simply click Save, then click inside the terminal window and run it without having to re-open the makefile. Handy – and could save you some time.
* Create a “clean” rule in your makefile.
Whenever you run make, it will search and note the timestamps of the source files and executables and won’t run if everything is up to date. So, it is common to create a “clean” rule that removes the intermediate and executable files prior to the next build.

In the makefile (underneath the comment header for “clean all”), add the following .PHONY rule
for “clean” (these are the same commands you used earlier on the command line):
<pre>
.PHONY : clean
clean :
rm –rf ___.arm
rm –rf _______
</pre>
.PHONY tells make to NOT search for a file named “clean” because this is a phony target (i.e. it is not a file that needs to be searched for or created). In a large and complex makefile, this actually saves some compile time (plus, it is just good practice to use .PHONY when the target is not an actual file). The two files are the final executable and the intermediate object file.
* Create an “all” rule in your makefile.
When make runs without any rules specified (i.e. you just type “make” on the command line), it will make (by default) the first rule in the makefile. Therefore, it is common to create an “all” rule that is placed first in the makefile. Our example only has one final target (app.arm), so “all” doesn’t make as much sense now.

In the makefile (under the comment header for “make all”), add the following .PHONY rule for “all”:
<pre>
.PHONY : all
all : app.arm
</pre>
Close makefile and let’s run it…
* Run make to create the executable app.arm.
On the command line, type in the following:
<pre>
make
</pre>
make will probably tell you that the files are “up to date” and there is nothing to do. So, you must run “clean” before you build again. Type:
<pre>
make clean
</pre>
and then:
<pre>
make
</pre>
make runs the first rule in the makefile which is the “all” rule. This should successfully build the app.arm executable.

----
Note: make assumes the name of the make file is '''makefile''' or '''Makefile'''. make also looks for the FIRST makefile it finds. So, to be safe, you might want to capitalize Makefile because capital “M” comes before lower-case “m” alphabetically. You can also use a different name for the makefile – e.g. my_makefile.mak. In this case, you need to use the following command to “force” the use of a different make file name:
<pre>
make –f my_makefile.mak
</pre>
----

* Run app.arm.
You should see “Hello World” again. Ok, now that we have the simple makefile done, let’s turn it up a few notches…
* Review the different ways to run make.
As a review, you can run make in several ways:
<pre>
make (makes the first rule in the make file named makefile or Makefile)
make <rule> (makes the rule specified with <rule>, e.g. “make clean”)
make –f my_makefile (forces the use of a make file named my_makefile)
</pre>

@@ Line 174: / Line 174: @@
 make –f my_makefile (forces the use of a make file named my_makefile)
 </pre>
 {{YoderFoot}}

@@ Line 1: / Line 1: @@
 [[Category:EmbeddedBeagleClass]]
 [[Category:ECE497]]
 As your programs become more complex they will spread over multiple files. '''make''' is a utility that tells which files depend on which and how to compile them all together into an executable.  This exercise walks you through how to create a Makefile.
@@ Line 173: / Line 174: @@
 make –f my_makefile (forces the use of a make file named my_makefile)
 </pre>

@@ Line 17: / Line 17: @@
   beagle$ '''ls'''
   beagle$ '''gedit app.c'''
 == Part A – Using the Command Line and Creating a Simple Makefile ==

@@ Line 24: / Line 24: @@
 To compile app.c, type the following command:
-  beagle$ gcc –g –c app.c –o app.o
+  beagle$ '''gcc –g –c app.c –o app.o'''
 <pre>
@@ Line 44: / Line 44: @@
 (short for “manual”) command. Let’s try it on gcc:
-  host$ man gcc
+  host$ '''man gcc'''
 What does the '''–c''' option (from the previous step) tell the compiler to do?
@@ Line 52: / Line 52: @@
 Next, link the object file (app.o) to create the executable app.arm:
-  beagle$ gcc –g app.o –o app.arm
+  beagle$ '''gcc –g app.o –o app.arm'''
 Now run the executable:
-  beagle$ ./app.arm
+  beagle$ '''./app.arm'''
 You should see “Hello World” displayed in the command window. The extension used for the output file (.arm) indicates we are building for the arm (or Beagle).
@@ Line 71: / Line 71: @@
 Type the following to remove the files generated by the gcc commands you executed:
-  beagle$ rm –rf app.arm
+  beagle$ '''rm –rf app.arm'''
-  beagle$ rm –rf app.o
+  beagle$ '''rm –rf app.o'''
 This removal of files mirrors what a “clean” macro or rule might do. We’ll actually add a rule shortly to accomplish this in our makefile.
@@ Line 79: / Line 79: @@
 The current makefile  simply contains comments and placeholders for the code you will write. Using your favorite editor, open the makefile. For example:
-  beagle$ gedit makefile
+  beagle$ '''gedit makefile'''
 * Create rules for app.arm and app.o in your makefile.
@@ Line 107: / Line 107: @@
 Close makefile and type the following:
-  beagle$ make
+  beagle$ '''make'''
 After running make, list the current directory. Do you see a new app.arm executable? Run it.
@@ Line 116: / Line 116: @@
 Stop. Before you open makefile again, try opening it in a different Linux process by typing in the following:
-  beagle$ gedit makefile &
+  beagle$ '''gedit makefile &'''
 The “&” tells Linux to open the makefile in a separate process (window). When you edit a file, you can simply click Save, then click inside the terminal window and run it without having to re-open the makefile. Handy – and could save you some time.
@@ Line 143: / Line 143: @@
 On the command line, type in the following:
-  beagle$ make
+  beagle$ '''make'''
 make will probably tell you that the files are “up to date” and there is nothing to do. So, you must run “clean” before you build again. Type:
-  beagle$ make clean
+  beagle$ '''make clean'''
 and then:
-  beagle$ make
+  beagle$ '''make'''
 make runs the first rule in the makefile which is the “all” rule. This should successfully build the app.arm executable.
@@ Line 158: / Line 158: @@
 Note: make assumes the name of the make file is '''makefile''' or '''Makefile'''. make also looks for the FIRST makefile it finds. So, to be safe, you might want to capitalize Makefile because capital “M” comes before lower-case “m” alphabetically. You can also use a different name for the makefile – e.g. my_makefile.mak. In this case, you need to use the following command to “force” the use of a different make file name:
-  beagle$ make –f my_makefile.mak
+  beagle$ '''make –f my_makefile.mak'''
 ----

← Older revision		Revision as of 17:41, 19 August 2011
Line 1:		Line 1:
		+	[[Category:EmbeddedBeagleClass]]
		+	[[Category:ECE497]]
		+
	As your programs become more complex they will spread over multiple files. '''make''' is a utility that tells which files depend on which and how to compile them all together into an executable. This exercise walks you through how to create a Makefile.		As your programs become more complex they will spread over multiple files. '''make''' is a utility that tells which files depend on which and how to compile them all together into an executable. This exercise walks you through how to create a Makefile.

@@ Line 12: / Line 12: @@
 === Lab Prep – Examine the directory contents and app.c ===
-* Download the '''make''' directory from [http://www.rose-hulman.edu/~yoder/Beagle/exercises/ here] and put it on your Beagle.
+ beagle$ '''cd exercises'''
-* Open a terminal on the Beagle and cd to the '''make''' directory and examine the contents.
+ beagle$ '''git pull'''
-* Examine app.c with gedit.
+ beagle$ '''cd make'''
 == Part A – Using the Command Line and Creating a Simple Makefile ==