Programming/Tools/Make - Revision history

Admin at 21:02, 24 December 2020

2020-12-24T21:02:32Z

← Older revision		Revision as of 21:02, 24 December 2020
Line 563:		Line 563:

	= Building a shared library =		= Building a shared library =

			Static libraries, while reusable across multiple programs, are locked into a program at compile-time. '''Dynamic''' or '''shared libraries''' exist as separate files outside of the executable file.

			The code of a static library is locked into the executable file and cannot be modified without a re-compile. In contrast, a dynamic library can be modified without a need to recompile. If a dynamic library becomes corrupt, the executable file may no longer work. A static library, however, is untouchable because it lives inside the executable file. The upside of using a dynamic library is that multiple running applications can use the same library without the need for each to have its own copy.

			Let us see how we can build a shared library using Make.

	<pre>		<pre>
Line 593:		Line 599:
	</pre>		</pre>

	Here <tt>-fpic</tt> tells the compiler to produce '''position-independent code (PIC)'''.		Here <tt>-fpic</tt> tells the compiler to produce '''position-independent code (PIC)'''. Such code, being placed somewhere in the primary memory, executes properly regardless of its absolute address. PIC is commonly used for shared libraries, so that the same library code can be loaded in a location in each program's address space where it doesn't overlap with other memory in use (e.g. other shared libraries).

	Let us		Let us
Line 652:		Line 658:
	</pre>		</pre>

	Note that the <tt>-lsphere</tt> option is not looking for <tt>sphere.so</tt> but <tt>libsphere.so</tt>. GCC assumes that all libraries start with <tt>lib</tt> and end with <tt>.a</tt> or <tt>.so</tt> (<tt>.a</tt> is for archive or statically linked libraries, <tt>.so</tt> is for shared object or shared libraries).		Note that the <tt>-lsphere</tt> option is not looking for <tt>sphere.so</tt> but <tt>libsphere.so</tt>. GCC assumes that all libraries start with <tt>lib</tt> and end with <tt>.a</tt> or <tt>.so</tt> (<tt>.a</tt> for archive or statically linked libraries, <tt>.so</tt> for shared object or shared libraries).

	Now let's try running <tt>hello</tt>:		Now let's try running <tt>hello</tt>:

Admin: /* Make */

2020-12-24T16:12:36Z

Make

← Older revision		Revision as of 16:12, 24 December 2020
Line 1:		Line 1:
	= Make =		= Make =

	[https://www.gnu.org/software/make/ '''Make'''] is a build automation tool that automatically builds executable programs and libraries from source code by reading files called '''Makefiles''' which specify how to derive the target program. Though integrated development environments and language-specific compiler features can also be used to manage a build process, Make remains widely used, especially on Unix and Unix-like (e.g. Linux) operating systems.		[https://www.gnu.org/software/make/ '''Make'''] is a '''build system''' ('''build automation tool''') that automatically builds executable programs and libraries from source code by reading files called '''Makefiles''' which specify how to derive the target program. Though integrated development environments and language-specific compiler features can also be used to manage a build process, Make remains widely used, especially on Unix and Unix-like (e.g. Linux) operating systems.

	Besides building programs, Make can be used to manage any project where some files must be updated automatically from others whenever the others change.		Besides building programs, Make can be used to manage any project where some files must be updated automatically from others whenever the others change.
Line 14:		Line 14:
	—Stuart Feldman, [https://amzn.to/3mRIeh3 The Art of Unix Programming], Eric S. Raymond, 2003.		—Stuart Feldman, [https://amzn.to/3mRIeh3 The Art of Unix Programming], Eric S. Raymond, 2003.
	</blockquote>		</blockquote>

	~~Make is what is known as a '''build system'''—a build automation tool.~~

	= Alternatives and complementary utilities =		= Alternatives and complementary utilities =

Admin at 16:10, 24 December 2020

2020-12-24T16:10:28Z

← Older revision		Revision as of 16:10, 24 December 2020
Line 17:		Line 17:
	Make is what is known as a '''build system'''—a build automation tool.		Make is what is known as a '''build system'''—a build automation tool.

	= Alternatives =		= Alternatives and complementary utilities =

	Nowadays there are alternatives to Make, as well as build utilities that work alongside Make. See [https://medium.com/@julienjorge/an-overview-of-build-systems-mostly-for-c-projects-ac9931494444 An overview of build systems (mostly for C++ projects)] by [https://medium.com/@julienjorge Julien Jorge].		Nowadays there are alternatives to Make, as well as build utilities that work alongside Make. See [https://medium.com/@julienjorge/an-overview-of-build-systems-mostly-for-c-projects-ac9931494444 An overview of build systems (mostly for C++ projects)] by [https://medium.com/@julienjorge Julien Jorge].
Line 35:		Line 35:
	* [https://ant.apache.org/ Ant]		* [https://ant.apache.org/ Ant]
	* [https://gradle.org/ Gradle]		* [https://gradle.org/ Gradle]

			Whereas Make is a build system, which drives the compiler and other build tools to build your code, some of the above utilities, such as [https://cmake.org/ CMake], are generators of build systems. For example, CMake can produce Makefiles, [https://ninja-build.org/ Ninja] build files, [https://www.kdevelop.org/ KDEvelop] or [https://developer.apple.com/xcode/ Xcode] projects, and [https://visualstudio.microsoft.com/ Visual Studio] solutions from the same starting point—the same <tt>CMakeLists.txt</tt> file. So if you have a platform-independent project, CMake is a way to make it build system-independent as well.

			We won't consider CMake in this tutorial, but you will find information on it in the dedicated [[Programming/Tools/CMake\|CMake tutorial]].

	= Preliminaries =		= Preliminaries =

Admin at 15:58, 24 December 2020

2020-12-24T15:58:45Z

← Older revision		Revision as of 15:58, 24 December 2020
Line 19:		Line 19:
	= Alternatives =		= Alternatives =

	Nowadays there are alternatives to ~~using~~ Make as well as ~~software products~~ that work alongside Make. See [https://medium.com/@julienjorge/an-overview-of-build-systems-mostly-for-c-projects-ac9931494444 An overview of build systems (mostly for C++ projects)] by [https://medium.com/@julienjorge Julien Jorge].		Nowadays there are alternatives to Make, as well as build utilities that work alongside Make. See [https://medium.com/@julienjorge/an-overview-of-build-systems-mostly-for-c-projects-ac9931494444 An overview of build systems (mostly for C++ projects)] by [https://medium.com/@julienjorge Julien Jorge].

	We will list some of them here:		We will list some of them here:

Admin at 15:58, 24 December 2020

2020-12-24T15:58:01Z

@@ Line 5: / Line 5: @@
 Besides building programs, Make can be used to manage any project where some files must be updated automatically from others whenever the others change.
-Make was originally created by [https://en.wikipedia.org/wiki/Stuart_Feldman Stuart Feldman] in April 1976 at [https://en.wikipedia.org/wiki/Bell_Labs Bell Labs]. Feldman received the 2003 ACM Software System Award for the authoring of this tool.
+Make was originally created by [https://en.wikipedia.org/wiki/Stuart_Feldman Stuart Feldman] in April 1976 at [https://en.wikipedia.org/wiki/Bell_Labs Bell Labs]. Feldman received the 2003 [https://www.acm.org/ Association for Computing Machinery (ACM)] [https://awards.acm.org/software-system Software System Award] for the authoring of this tool.
 Feldman was inspired to write Make by the experience of a coworker in futilely debugging a program of his where the executable was accidentally not being updated with changes:
@@ Line 14: / Line 14: @@
 &mdash;Stuart Feldman, [https://amzn.to/3mRIeh3 The Art of Unix Programming], Eric S. Raymond, 2003.
 </blockquote>
 = Preliminaries =

Admin: /* Building a shared library */

2020-12-24T00:32:10Z

Building a shared library

@@ Line 621: / Line 621: @@
 clean:
          rm -f *.o *.a *.so $(TARGET)
 </pre>

Admin: /* Building a shared library */

2020-12-24T00:25:34Z

Building a shared library

@@ Line 542: / Line 542: @@
 <pre>
-# Building a static library and an executable.
+# Building a shared library and an executable.
 TARGET = hello
 MAINOFILE = main.o
@@ Line 549: / Line 549: @@
 CFLAGS = -Wall
-$(TARGET) : main.o sphere.so
+$(TARGET) : main.o libsphere.so
          $(CC) $(CFLAGS) -o $@ $< -lsphere
@@ Line 555: / Line 555: @@
          $(CC) $(CFLAGS) -c $< -o $@
-sphere.so : $(LIBOFILES)
+libsphere.so : $(LIBOFILES)
          $(CC) -shared -o $@ $^
@@ Line 567: / Line 567: @@
 clean:
-         rm -f *.o $(TARGET)
+         rm -f *.o *.a *.so $(TARGET)
 </pre>

Admin: /* Building a static library */

2020-12-24T00:15:52Z

Building a static library

← Older revision		Revision as of 00:15, 24 December 2020
Line 517:		Line 517:

	clean:		clean:
	rm -f *.o $(TARGET)		rm -f .o .a $(TARGET)
	</pre>		</pre>

Admin: /* Building a static library */

2020-12-24T00:13:52Z

Building a static library

← Older revision		Revision as of 00:13, 24 December 2020
Line 499:		Line 499:
	CFLAGS = -Wall		CFLAGS = -Wall

	$(TARGET) : main.o ~~sphere~~.a		$(TARGET) : main.o libsphere.a
	$(CC) $(CFLAGS) -o $@ $^		$(CC) $(CFLAGS) -o $@ $^

Line 505:		Line 505:
	$(CC) $(CFLAGS) -c $< -o $@		$(CC) $(CFLAGS) -c $< -o $@

	~~sphere~~.a : $(LIBOFILES)		libsphere.a : $(LIBOFILES)
	ar rcs $@ $^		ar rcs $@ $^

Line 533:		Line 533:
	gcc -Wall -c geometry.c -o geometry.o		gcc -Wall -c geometry.c -o geometry.o
	gcc -Wall -c simple_io.c -o simple_io.o		gcc -Wall -c simple_io.c -o simple_io.o
	ar rcs ~~sphere~~.a geometry.o simple_io.o		ar rcs libsphere.a geometry.o simple_io.o
	gcc -Wall -o hello main.o ~~sphere~~.a		gcc -Wall -o hello main.o libsphere.a
	</pre>		</pre>

	We notice that this time <tt>~~sphere~~.a</tt> has been created alongside the executable. The object files inside it have been linked into the executable and there is no need to distribute <tt>~~sphere~~.a</tt> alongside <tt>hello</tt>—everything that we need is inside <tt>hello</tt>.		We notice that this time <tt>libsphere.a</tt> has been created alongside the executable. The object files inside it have been linked into the executable and there is no need to distribute <tt>libsphere.a</tt> alongside <tt>hello</tt>—everything that we need is inside <tt>hello</tt>.

	= Building a shared library =		= Building a shared library =

Admin at 00:11, 24 December 2020

2020-12-24T00:11:20Z

← Older revision		Revision as of 00:11, 24 December 2020
Line 538:		Line 538:

	We notice that this time <tt>sphere.a</tt> has been created alongside the executable. The object files inside it have been linked into the executable and there is no need to distribute <tt>sphere.a</tt> alongside <tt>hello</tt>—everything that we need is inside <tt>hello</tt>.		We notice that this time <tt>sphere.a</tt> has been created alongside the executable. The object files inside it have been linked into the executable and there is no need to distribute <tt>sphere.a</tt> alongside <tt>hello</tt>—everything that we need is inside <tt>hello</tt>.

			= Building a shared library =

			<pre>
			# Building a static library and an executable.
			TARGET = hello
			MAINOFILE = main.o
			LIBOFILES = geometry.o simple_io.o
			CC = gcc
			CFLAGS = -Wall

			$(TARGET) : main.o sphere.so
			$(CC) $(CFLAGS) -o $@ $< -lsphere

			main.o : main.c
			$(CC) $(CFLAGS) -c $< -o $@

			sphere.so : $(LIBOFILES)
			$(CC) -shared -o $@ $^

			geometry.o : geometry.c
			$(CC) $(CFLAGS) -fpic -c $< -o $@

			simple_io.o : simple_io.c
			$(CC) $(CFLAGS) -fpic -c $< -o $@

			$(MAINOFILE) $(LIBOFILES) : sphere.h

			clean:
			rm -f *.o $(TARGET)
			</pre>