Thread: best process for cross compiling an application

Using only standard C headers will make it more portable.

NOTE: You can try compiling under CygWin with the CygWin C Compiler to test a little bit for doing Windows only code.

Tim S.

I recommend early testing on all your intended targets.

How often you re-test depends on what kinds of problems you encountered on your first test.

From your description, I suspect you're not really understanding what cross-compilation is. It is the process of compiling on one type of system (OS, hardware, etc) to produce objects, libraries, and (if you have a cross-linker) executables that run - preferably natively - on another. It does not refer to writing your code in a portable manner (which is a good idea, if possible, regardless) so you can distribute source and tell the recipient to build the program (which is usually not a good idea with anyone other than software developers).

As a general rule, if you can compile/build on a desired target, then it is better to do so, rather than resorting to cross-compilation. And then do required validation (e.g. testing) to determine if it behaves as intended on each target machine you care to support. That means you need representative machines for both building and validating your program.

Cross-compilation is usually employed when it is not possible or practical to get a development environment that targets the desired machine. For example, embedded devices. However, in rough terms, the process usually goes something like

1) Build using cross-compiler
2) Test program in some environment on development machine that emulates target machine
3) Transfer executable to actual target machine
4) Test it on that target machine with representative inputs.

Generally speaking, I would suggest you need to spend more time up front with analysis and design, before even cutting code.

A common trap to fall into is not testing enough on an actual target machine. Another common trap is reaching for a cross-compiler unless there is a reasonable need to. Cross-compilers are more likely to have incompatibilities and bugs than native compilers (getting a cross-compiler right takes more effort than getting a compiler right, because of dependencies on both development machine and target machine). Most emulators have incompatibilities, so passing tests in an emulator is not always sufficient to give assurance of passing tests on the actual target. Another trap is not compiling with all compiler diagnostics (warnings, errors) enabled, because the the problems that come up when porting code (i.e. writing code so it can be built on multiple machines) are magnified when doing cross-compilation.