Build System - Revision history

Amallen at 22:45, 17 June 2008

2008-06-17T22:45:53Z

Amallen at 22:40, 17 June 2008

2008-06-17T22:40:47Z

Michael: Created page describing the build system of Embedded XINU

2008-02-05T23:29:21Z

Created page describing the build system of Embedded XINU

New page

Building [[Embedded XINU]] is as simple as typing <code>make</code> in the <code>compile</code> directory. However, if you want to understand how the build system works you'll need acquaint yourself with the <code>Makefile</code>. It should be noted that this is not a recursive build process (make only calls another make process when building the libraries and a few other special cases), but rather a single Makefile that sources rules to build logically separated components.

This is a description of the build process for building XINU from [[trunk]] and may not be applicable to all versions.

== Makefile ==

Open <code>compile/Makefile</code> and you'll discover numerous variables and settings for building XINU. The first is the directive to <code>include mipsVars</code>. This simply adds the contents of the <code>compile/mipsVars</code> file to the Makefile. We chose to <code>include</code> this file so that moving from system to system is easier by storing dynamic variables in an external file. The less we change the Makefile the better.

<code>mipsVars</code> defines the location of the [[cross-compiler]] and various flags for compiling C and assembly source files.

After the local configuration is included we set a number of variables giving the final compiled image name, an archive file to create (if requested), where the main program is located, flags to pass to the loader, and file locations. Then there is the default make target which will be called when <code>make</code> with no arguments is typed at the shell prompt.

Now, the next two variables are very important. <code>COMPS</code> is a listing of the major system [[components]] we should include while building. Similarly <code>LIBS</code> is a listing of the libraries we will include when building the system. From the <code>COMPS</code> line we use another <code>include</code> directive, this time sourcing a <code>Makerules</code> file located in the directory to which each component points. Each Makerules file will append the source files to build that component into the kernel image. After all the source files are loaded, the Makefile converts the collection of C source files and assembly files to make one massive listing of object files.

Now, that all the important variables are set up there are a number of targets that can be executed. The most common target is <code>${BOOTIMAGE}</code> (which is typically <code>xinu.boot</code>), this depends on all the object files, library files, and the loader script. Then it will link all the object files together to create the boot image. There is also a <code>objects</code> target that will only build the object files for the system (and not link them).

There are several ways of cleaning the source tree. <code>make clean</code> will remove all the object files and the bootimage. <code>make libclean</code> will call the clean target for all the libraries. <code>make depclean</code> removes all the header file dependencies from the Makefile. <code>make docclean</code> will remove the documentation generated by the <code>make docs</code> command. <code>make realclean</code> will do all of the above and remove the <code>vn</code> and <code>version</code> files as well.

Moving above and beyond those targets, there are also a few special targets that can be called. <code>make [component]</code> will create object files only for the specified subsystem (useful during development). <code>make [libname]</code> will build the library archive, and <code>make [libname]-clean</code> will clean the library.

== Makerules ==

As mentioned above a <code>Makerules</code> file resides in each component directory. This file will append a listing of the source files for the component. There are two important factors about this file:
# At the top of the file, make sure that <code>COMP</code> is the name of the component '''and''' the name of the directory.
# Make sure you append all the files to the <code>COMP_SRC</code> variable and that they are prefixed with the proper directory (so gcc can find them.)

Within the file itself you can breakup files as you see fit. Typically, assembly files are stored in local <code>S_FILES</code> variables while C source is stored in <code>C_FILES</code> variables. This is not strictly needed, but makes it easier to read in some cases.

== Library ==

XINU libraries are built using the recursive make paradigm. Since the libraries do not change commonly they are not removed between builds unless specially requested. In the master Makefile all relevant variables are exported (including the location of the cross-compiler, C and assembly flags), the library Makefile then uses those to build its files and create an archive of the object files.

This allows all important build variables to be in one location and not leave possible dependency issues if something were to change in the build system.

@@ Line 1: / Line 1: @@
 Building [[Embedded XINU]] is as simple as typing <code>make</code> in the <code>compile</code> directory.  However, if you want to understand how the build system works you'll need to acquaint yourself with the <code>Makefile</code>.  It should be noted that this is not a recursive build process (make only calls another make process when building the libraries and a few other special cases), but rather a single Makefile that sources rules to build logically separated components.
-This is a description of the build process for building XINU from [[trunk]] and may not be applicable to all versions.
+This is a description of the build process for building the [[trunk]] version of XINU and may not be applicable to all versions.
 == Makefile ==

← Older revision		Revision as of 22:40, 17 June 2008
Line 1:		Line 1:
−	Building [[Embedded XINU]] is as simple as typing <code>make</code> in the <code>compile</code> directory. However, if you want to understand how the build system works you'll need acquaint yourself with the <code>Makefile</code>. It should be noted that this is not a recursive build process (make only calls another make process when building the libraries and a few other special cases), but rather a single Makefile that sources rules to build logically separated components.	+	Building [[Embedded XINU]] is as simple as typing <code>make</code> in the <code>compile</code> directory. However, if you want to understand how the build system works you'll need to acquaint yourself with the <code>Makefile</code>. It should be noted that this is not a recursive build process (make only calls another make process when building the libraries and a few other special cases), but rather a single Makefile that sources rules to build logically separated components.

	This is a description of the build process for building XINU from [[trunk]] and may not be applicable to all versions.		This is a description of the build process for building XINU from [[trunk]] and may not be applicable to all versions.