Compiling Software - Revision history

Admin at 15:54, 28 May 2011

2011-05-28T15:54:38Z

@@ Line 306: / Line 306: @@
 =Advanced Topics=
 ==Compiler Specifications==
@@ Line 427: / Line 443: @@
-[[Category:Computers]]
+{{Programs}}
-[[Category:Programs]]
+{{Unix Programs}}
-[[Category:Unix]]

Admin: /* Conflicts */

2011-05-28T15:52:38Z

Conflicts

← Older revision		Revision as of 15:52, 28 May 2011
Line 376:		Line 376:
	<pre>		<pre>
	CC="/usr/bin/gcc -arch x86_64 -arch i386"		CC="/usr/bin/gcc -arch x86_64 -arch i386"
	</~~code~~>		</pre>

	and this would work fine.		and this would work fine.

Admin at 01:35, 19 May 2011

2011-05-19T01:35:25Z

← Older revision		Revision as of 01:35, 19 May 2011
Line 429:		Line 429:
	[[Category:Computers]]		[[Category:Computers]]
	[[Category:Programs]]		[[Category:Programs]]
			[[Category:Unix]]

Admin at 22:31, 18 May 2011

2011-05-18T22:31:18Z

← Older revision		Revision as of 22:31, 18 May 2011
Line 304:		Line 304:

	This will create a copy of the built executable in <code>/path/to/installation</code>, which you probably specified using the <code>--prefix=/path/to/installation</code> option while configuring. By default, programs are (usually) installed to <code>/usr/local/</code>.		This will create a copy of the built executable in <code>/path/to/installation</code>, which you probably specified using the <code>--prefix=/path/to/installation</code> option while configuring. By default, programs are (usually) installed to <code>/usr/local/</code>.

			=Advanced Topics=

			==Compiler Specifications==

			===Specifying Which Compiler===

			You can specify compilers when running configure by doing something like this:

			<source lang="bash">
			#!/bin/sh

			./configure \
			--option=something \
			\
			CC="/usr/bin/gcc" \
			CXX="/usr/bin/g++" \
			F77="/usr/bin/gfortran"
			</source>

			This specifies that the C compiler (specified with the CC variable) should be <code>/usr/bin/gcc</code>, the C++ compiler (specified with the CXX variable) should be <code>/usr/bin/g++</code>, and the Fortran compiler (specified with the F77 variable) should be <code>/usr/bin/gfortran</code>.

			===Specifying Compiler Flags===

			If you want to specify flags for the compilers, you can use the variables <code>CFLAGS</code> for C compiler flags, <code>CXXFLAGS</code> for C++ compiler flags, and <code>FFLAGS</code> for Fortran compiler flags.

			For example, if I wanted to specify that the compiler should use verbose warnings when I am compiling, I would use the <code>-Wall</code> flag for the compilers. To do this when configuring:

			<source lang="bash">
			#!/bin/sh

			./configure \
			--option=something \
			\
			CC="/usr/bin/gcc" \
			CXX="/usr/bin/g++" \
			F77="/usr/bin/gfortran"
			\
			CFLAGS="-Wall" \
			CXXFLAGS="-Wall"
			</source>

			If I wanted to specify that the compiler should build a 64-bit binary, I would specify this using the <code>-arch</code> flag:

			<source lang="bash">
			#!/bin/sh

			./configure \
			--option=something \
			\
			CC="/usr/bin/gcc" \
			CXX="/usr/bin/g++" \
			F77="/usr/bin/gfortran"
			\
			CFLAGS="-Wall -arch x86_64" \
			CXXFLAGS="-Wall -arch x86_64"
			</source>

			===Conflicts===

			There are potential conflicts that can come about using the compiler and flags variables. For example, if I want the compiler to build binaries that work for multiple architectures (say, 32-bit and 64-bit), I can specify this with two <code>-arch</code> flags:

			<pre>
			CFLAGS="-arch x86_64 -arch i386"
			</pre>

			but often the configure script will strip the second <code>-arch</code> flag, and this will cause errors like "File i386 does not exist".

			To get around this, I can add flags to the compiler command. The configure script will not strip flags from the compiler command, it will leave it alone. So I could say:

			<pre>
			CC="/usr/bin/gcc -arch x86_64 -arch i386"
			</code>

			and this would work fine.

			However, this will create problems when it comes time to run the preprocessor. The preprocessor is the part that deals with all of the

			<source lang="cpp">
			#include <Header1.h>
			#include <Header2.h>

			#ifdef SOME_VARIABLE
			#include <Variable.h>
			#endif
			</source>

			stuff. Normally, the C and C++ preprocessors are the C and C++ commands with the <code>-E</code> flag added on. But if you try and run a preprocessor command like

			<pre>
			/usr/bin/gcc -arch x86_64 -arch i386 -E
			</pre>

			then you're gonna have problems. You can get around this by specifying the preprocessor command, as shown in the next section.

			===Specifying the Preprocessor===

			You can specify the C or C++ preprocessor using the <code>CPP</code> and <code>CXXCPP</code> variables, like this:

			<source lang="bash">
			#!/bin/sh

			./configure \
			--option=something \
			\
			CC="/usr/bin/gcc -arch x86_64 -arch i386" \
			CXX="/usr/bin/g++ -arch x86_64 -arch i386" \
			F77="/usr/bin/gfortran"
			\
			CFLAGS="-Wall" \
			CXXFLAGS="-Wall" \
			\
			CPP="/usr/bin/gcc -E" \
			CXX="/usr/bin/g++ -E"
			</source>

			===Example===

			For an example of all of these pieces coming together when configuring and compiling a piece of software, see the [[FFTW]] page. The [[FFTW]] libraries required compilation of both 32-bit and 64-bit versions, and configure stripped off the second <code>-arch</code> flag, so I had to use all of the above techniques to get it to compile correctly.

Admin at 07:13, 10 March 2011

2011-03-10T07:13:09Z

← Older revision		Revision as of 07:13, 10 March 2011
Line 307:		Line 307:


	[[~~Categories~~:Computers]]		[[Category:Computers]]
	[[~~Categories~~:Programs]]		[[Category:Programs]]

Admin: /* Making Your Program */

2010-10-07T22:40:28Z

Making Your Program

← Older revision		Revision as of 22:40, 7 October 2010
Line 293:		Line 293:
	This will display a list of different packages that can be made (also called "make targets"). Running "make" makes the default targets, and running "make all" makes all targets.		This will display a list of different packages that can be made (also called "make targets"). Running "make" makes the default targets, and running "make all" makes all targets.

	Typing <code>make</code> or <code>make all</code> will compile the source code in-place~~, creating libraries, objects, etc in the source code directory. One~~ additional step is ~~required~~ to ~~actually~~ use the program~~, and that is to install the program to the correct place~~.		Typing <code>make</code> or <code>make all</code> will compile the source code in-place - so one additional step is necessary to install and use the program.

	== Installing Your Program ==		== Installing Your Program ==

Admin: /* Making Your Program */

2010-10-07T22:39:56Z

Making Your Program

← Older revision		Revision as of 22:39, 7 October 2010
Line 293:		Line 293:
	This will display a list of different packages that can be made (also called "make targets"). Running "make" makes the default targets, and running "make all" makes all targets.		This will display a list of different packages that can be made (also called "make targets"). Running "make" makes the default targets, and running "make all" makes all targets.

			Typing <code>make</code> or <code>make all</code> will compile the source code in-place, creating libraries, objects, etc in the source code directory. One additional step is required to actually use the program, and that is to install the program to the correct place.

	== Installing Your Program ==		== Installing Your Program ==

Admin: /* Downloading The Source Package */

2010-10-07T22:36:33Z

Downloading The Source Package

← Older revision		Revision as of 22:36, 7 October 2010
Line 33:		Line 33:
	This creates a folder called 'program-version'. This folder contains all the source code that will be compiled in order to run the program.		This creates a folder called 'program-version'. This folder contains all the source code that will be compiled in order to run the program.

	When you move into the folder that was created and list the files in the directory, you'll probably see several files with names like README or INSTALL. It is a good idea to read these, as the instructions given here will not work for ~~buil ding~~ every program. The README ~~and~~ INSTALL files will give you some basic instructions on how to build and configure the program.		When you move into the folder that was created and list the files in the directory, you'll probably see several files with names like README or INSTALL. It is a good idea to read these, as the instructions given here will not work for building every program. The README or INSTALL files will give you some basic instructions on how to build and configure the program.



	== Configuring the Program for Installation ==		== Configuring the Program for Installation ==

Admin at 23:24, 4 October 2010

2010-10-04T23:24:00Z

← Older revision		Revision as of 23:24, 4 October 2010
Line 306:		Line 306:

	This will create a copy of the built executable in <code>/path/to/installation</code>, which you probably specified using the <code>--prefix=/path/to/installation</code> option while configuring. By default, programs are (usually) installed to <code>/usr/local/</code>.		This will create a copy of the built executable in <code>/path/to/installation</code>, which you probably specified using the <code>--prefix=/path/to/installation</code> option while configuring. By default, programs are (usually) installed to <code>/usr/local/</code>.



			[[Categories:Computers]]
			[[Categories:Programs]]

Admin: /* Installing Your Program */

2010-10-02T03:21:46Z

Installing Your Program

← Older revision		Revision as of 03:21, 2 October 2010
Line 299:		Line 299:
	== Installing Your Program ==		== Installing Your Program ==

	Typing make will only compile each source code file in-place - meaning, if you specify that you want to the program to install to <~~pre~~>/path/to/installation</~~pre~~>, and you are running configure and make in <~~pre~~>/path/to/source/code</~~pre~~>, then when you type make, and when once make finishes, the finished product will reside in <~~pre~~>/path/to/source/code</~~pre~~>, and not in <~~pre~~>/path/to/installation</~~pre~~>. In these cases, you must issue a second command:		Typing make will only compile each source code file in-place - meaning, if you specify that you want to the program to install to <code>/path/to/installation</code>, and you are running configure and make in <code>/path/to/source/code</code>, then when you type make, and when once make finishes, the finished product will reside in <code>/path/to/source/code</code>, and not in <code>/path/to/installation</code>. In these cases, you must issue a second command:

	<pre>		<pre>
Line 305:		Line 305:
	</pre>		</pre>

	This will create a copy of the built executable in <~~pre~~>/path/to/installation</~~pre~~>, which you probably specified using the <~~pre~~>--prefix=/path/to/installation</~~pre~~> option while configuring. By default, programs are (usually) installed to <~~/pre~~>/usr/local/</~~pre~~>.		This will create a copy of the built executable in <code>/path/to/installation</code>, which you probably specified using the <code>--prefix=/path/to/installation</code> option while configuring. By default, programs are (usually) installed to <code>/usr/local/</code>.