gcc构建交叉编译器

㈠ 如何建立linux下的ARM交叉编译环境

首先安装交叉编译器，网络“arm-linux-gcc”就可以一个编译器压缩包。
把压缩包放到linux系统中，解压，这样就算安装好了交叉编译器。
设置编译器环境变量，具体方式网络。如打开 /etc/bash.bashrc，添加刚才安装的编译器路径 export PATH=/home/。。。/4.4.3/bin:$PATH。这样是为了方便使用，用arm-linux-gcc即可，不然既要带全路径/home//bin/arm-linux-gcc,这样不方便使用。
编译c文件。和gcc编译相似，把gcc用arm-linu-gcc代替就是了。编译出来的就可以放到arm上运行了。</ol>

㈡ gcc交叉编译怎么找头文件及lib库的

是在specs里面读取的路径信息。
命令行中键入 gcc -v
Reading specs from /usr/lib/gcc/i686-pc-cygwin/3.4.4/specs
Configured with: /usr/build/package/orig/test.respin/gcc-3.4.4-3/configure --ver
bose --prefix=/usr --exec-prefix=/usr --sysconfdir=/etc --libdir=/usr/lib --libe
xecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --enable-langu
ages=c,ada,c++,d,f77,pascal,java,objc --enable-nls --without-included-gettext --
enable-version-specific-runtime-libs --without-x --enable-libgcj --disable-java-
awt --with-system-zlib --enable-interpreter --disable-libgcj-debug --enable-thre
ads=posix --enable-java-gc=boehm --disable-win32-registry --enable-sjlj-exceptio
ns --enable-hash-synchronization --enable-libstdcxx-debug
Thread model: posix
gcc version 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)

注意“--prefix=/usr” 以及“--libdir=/usr/lib ”
表示gcc ld as 等可执行文件安装在/usr/bin,而libc.a 等文件是在/usr/lib中。
解压缩交叉编译器时，也是要解压缩在在--prefix 指定的目录下。
比如 下载了arm-linux 的交叉编译器cross-3.3.2.tar.bz2,解压缩之后，运行 arm-linux-gcc -v
得到 --prefix=/usr/local/arm。那么就要把 bin lib 等所有的文件和文件夹到/usr/local/arm目录下。
否则到时候运行arm-linux-gcc hello.c会提示找不到stdio.h 或者 lib.so.6 等

HOWTO Use the GCC specs file

About Specs file
The "gcc" program invoked by users is a convenient front-end driver executable which will invoke other programs in the background such as cc1, as or ld to do its work according to the command line parameter given. A specs file is plain text used to control the default behavior for the "gcc" front-end. The specs file is usually built-in but for flexibility purposes, it can be overridden with an external version.
Basic Specs file modifications
CC will proce a specs file via the following command.
gcc -mpspecs > specs
You may use a text editor of your choice to inspect it. It may be confusing at first, but there are many places of interest. To use the specs file, invoke gcc with -specs= or place it at "/mingw/lib/gcc/mingw32//specs" to make GCC use it by default, where refers to the GCC version installed.
Adding include directories to the search path
& #160;he *cpp: section should be modified. It contains the following by default:
*cpp:
%{posix:-D_POSIX_SOURCE} %{mthreads:-D_MT}
If "z:\libx\include" needs to be added to the GCC includes search path, it should be changed to the following
*cpp:
%{posix:-D_POSIX_SOURCE} %{mthreads:-D_MT} -I/z/libx/include
Adding lib directories to the search path
& #160;he *link_libgcc: section should be modified. It contains the following by default:
*link_libgcc:
%D
& #160;f "z:\libx\lib" needs to be added to the GCC library search path, it should be changed to the following
*link_libgcc:
%D -L/z/libx/lib

㈢ LINUX交叉编译工具链和GCC是什么关系啊

编译工具链一般最简化的为
binutils
+
gcc
+
glibc
+
kernel-header
组合的环境。
GCC
就是编译器，他的输出每次安装只能有针对一个架构的指令输出。如果要多个架构输出，那就要装多个
GCC
，所以编译工具链里面会有一个
GCC
。
交叉编译就是跨架构编译，编译出来的程序不能在本机执行(当然有例外情况)。所以这个时候就需要交叉编译工具链。
工具链光有
GCC
是不行的，还需要一个
binutils
的二进制连接器，以及一个最基本的目标架构的
C
库，C
库还需要一个目标架构的内核源代码才能完全工作(当然不是必须的，但编译有的时候需要)
又因为
GCC
、binutils
不能实现单软件同时多架构输出，所以需要单独另装，又加上
C
库和内核头文件需要目标架构的东西而不能用本机本地架构的数据。
所以一个交叉编译工具链就是针对目标架构准备的单独安装单独使用的
binutils
+
gcc
+
glibc
+
kernel-header
的集合了。
PS:这个
kernel-header
并不一定就是
Linux
，他还可以是别的系统核心开发库，比如
FreeBSD
。

㈣ 如何为嵌入式开发建立交叉编译环境

下面我们将以建立针对arm的交叉编译开发环境为例来解说整个过程，其他的体系结构与这个相类似，只要作一些对应的改动。我的开发环境是，宿主机 i386-redhat-7.2，目标机 arm。
这个过程如下
1. 下载源文件、补丁和建立编译的目录
2. 建立内核头文件
3. 建立二进制工具（binutils）
4. 建立初始编译器（bootstrap gcc）
5. 建立c库(glibc)
6. 建立全套编译器（full gcc）
下载源文件、补丁和建立编译的目录
1. 选定软件版本号
选择软件版本号时，先看看glibc源代码中的INSTALL文件。那里列举了该版本的glibc编译时所需的binutils 和gcc的版本号。例如在 glibc-2.2.3/INSTALL 文件中推荐 gcc 用 2.95以上，binutils 用 2.10.1 以上版本。
我选的各个软件的版本是：
linux-2.4.21+rmk2
binutils-2.10.1
gcc-2.95.3
glibc-2.2.3
glibc-linuxthreads-2.2.3
如果你选的glibc的版本号低于2.2，你还要下载一个叫glibc-crypt的文件，例如glibc-crypt-2.1.tar.gz。 Linux 内核你可以从www.kernel.org 或它的镜像下载。
Binutils、gcc和glibc你可以从FSF的FTP站点ftp://ftp.gun.org/gnu/ 或它的镜像去下载。 在编译glibc时，要用到 Linux 内核中的 include 目录的内核头文件。如果你发现有变量没有定义而导致编译失败，你就改变你的内核版本号。例如我开始用linux-2.4.25+vrs2，编译glibc-2.2.3 时报 BUS_ISA 没定义，后来发现在 2.4.23 开始它的名字被改为 CTL_BUS_ISA。如果你没有完全的把握保证你改的内核改完全了，就不要动内核，而是把你的 Linux 内核的版本号降低或升高，来适应 glibc。
Gcc 的版本号，推荐用 gcc-2.95 以上的。太老的版本编译可能会出问题。Gcc-2.95.3 是一个比较稳定的版本，也是内核开发人员推荐用的一个 gcc 版本。
如果你发现无法编译过去，有可能是你选用的软件中有的加入了一些新的特性而其他所选软件不支持的原因，就相应降低该软件的版本号。例如我开始用 gcc-3.3.2，发现编译不过，报 as、ld 等版本太老，我就把 gcc 降为 2.95.3。 太新的版本大多没经过大量的测试，建议不要选用。
回页首
2. 建立工作目录
首先，我们建立几个用来工作的目录：
在你的用户目录，我用的是用户liang，因此用户目录为 /home/liang，先建立一个项目目录embedded。
$pwd
/home/liang
$mkdir embedded
再在这个项目目录 embedded 下建立三个目录 build-tools、kernel 和 tools。
build-tools-用来存放你下载的 binutils、gcc 和 glibc 的源代码和用来编译这些源代码的目录。
kernel-用来存放你的内核源代码和内核补丁。
tools-用来存放编译好的交叉编译工具和库文件。
$cd embedded
$mkdir build-tools kernel tools
执行完后目录结构如下：
$ls embedded
build-tools kernel tools
3. 输出和环境变量
我们输出如下的环境变量方便我们编译。
$export PRJROOT=/home/liang/embedded
$export TARGET=arm-linux
$export PREFIX=$PRJROOT/tools
$export TARGET_PREFIX=$PREFIX/$TARGET
$export PATH=$PREFIX/bin:$PATH
如果你不惯用环境变量的，你可以直接用绝对或相对路径。我如果不用环境变量，一般都用绝对路径，相对路径有时会失败。环境变量也可以定义在.bashrc文件中，这样当你logout或换了控制台时，就不用老是export这些变量了。
体系结构和你的TAEGET变量的对应如下表

你可以在通过glibc下的config.sub脚本来知道，你的TARGET变量是否被支持，例如：
$./config.sub arm-linux
arm-unknown-linux-gnu
在我的环境中，config.sub 在 glibc-2.2.3/scripts 目录下。
网上还有一些 HOWTO 可以参考，ARM 体系结构的《The GNU Toolchain for ARM Target HOWTO》，PowerPC 体系结构的《Linux for PowerPC Embedded Systems HOWTO》等。对TARGET的选取可能有帮助。
4. 建立编译目录
为了把源码和编译时生成的文件分开，一般的编译工作不在的源码目录中，要另建一个目录来专门用于编译。用以下的命令来建立编译你下载的binutils、gcc和glibc的源代码的目录。
$cd $PRJROOT/build-tools
$mkdir build-binutils build-boot-gcc build-gcc build-glibc gcc-patch
build-binutils-编译binutils的目录
build-boot-gcc-编译gcc 启动部分的目录
build-glibc-编译glibc的目录
build-gcc-编译gcc 全部的目录
gcc-patch-放gcc的补丁的目录
gcc-2.95.3 的补丁有 gcc-2.95.3-2.patch、gcc-2.95.3-no-fixinc.patch 和gcc-2.95.3-returntype-fix.patch，可以从 http://www.linuxfromscratch.org/ 下载到这些补丁。
再将你下载的 binutils-2.10.1、gcc-2.95.3、glibc-2.2.3 和 glibc-linuxthreads-2.2.3 的源代码放入 build-tools 目录中
看一下你的 build-tools 目录，有以下内容：
$ls
binutils-2.10.1.tar.bz2 build-gcc gcc-patch
build-binutls build-glibc glibc-2.2.3.tar.gz
build-boot-gcc gcc-2.95.3.tar.gz glibc-linuxthreads-2.2.3.tar.gz
回页首
建立内核头文件
把你从 www.kernel.org 下载的内核源代码放入 $PRJROOT /kernel 目录
进入你的 kernel 目录：
$cd $PRJROOT /kernel
解开内核源代码
$tar -xzvf linux-2.4.21.tar.gz
或
$tar -xjvf linux-2.4.21.tar.bz2
小于 2.4.19 的内核版本解开会生成一个 linux 目录，没带版本号，就将其改名。
$mv linux linux-2.4.x
给 Linux 内核打上你的补丁
$cd linux-2.4.21
$patch -p1 < ../patch-2.4.21-rmk2
编译内核生成头文件
$make ARCH=arm CROSS_COMPILE=arm-linux- menuconfig
你也可以用 config 和 xconfig 来代替 menuconfig，但这样用可能会没有设置某些配置文件选项和没有生成下面编译所需的头文件。推荐大家用 make menuconfig，这也是内核开发人员用的最多的配置方法。配置完退出并保存，检查一下的内核目录中的 include/linux/version.h 和 include/linux/autoconf.h 文件是不是生成了，这是编译 glibc 是要用到的，version.h 和 autoconf.h 文件的存在，也说明了你生成了正确的头文件。
还要建立几个正确的链接
$cd include
$ln -s asm-arm asm
$cd asm
$ln -s arch-epxa arch
$ln -s proc-armv proc
接下来为你的交叉编译环境建立你的内核头文件的链接
$mkdir -p $TARGET_PREFIX/include
$ln -s $PRJROOT/kernel/linux-2.4.21/include/linux $TARGET_PREFIX/include/linux
$in -s $PRJROOT/kernel/linux-2.4.21/include/asm-arm $TARGET_PREFIX/include/asm
也可以把 Linux 内核头文件拷贝过来用
$mkdir -p $TARGET_PREFIX/include
$cp -r $PRJROOT/kernel/linux-2.4.21/include/linux $TARGET_PREFIX/include
$cp -r $PRJROOT/kernel/linux-2.4.21/include/asm-arm $TARGET_PREFIX/include
回页首
建立二进制工具（binutils）
binutils是一些二进制工具的集合，其中包含了我们常用到的as和ld。
首先，我们解压我们下载的binutils源文件。
$cd $PRJROOT/build-tools
$tar -xvjf binutils-2.10.1.tar.bz2
然后进入build-binutils目录配置和编译binutils。
$cd build-binutils
$../binutils-2.10.1/configure --target=$TARGET --prefix=$PREFIX
--target 选项是指出我们生成的是 arm-linux 的工具，--prefix 是指出我们可执行文件安装的位置。
会出现很多 check，最后产生 Makefile 文件。
有了 Makefile 后，我们来编译并安装 binutils，命令很简单。
$make
$make install
看一下我们 $PREFIX/bin 下的生成的文件
$ls $PREFIX/bin
arm-linux-addr2line arm-linux-gasp arm-linux-objmp arm-linux-strings
arm-linux-ar arm-linux-ld arm-linux-ranlib arm-linux-strip
arm-linux-as arm-linux-nm arm-linux-readelf
arm-linux-c++filt arm-linux-obj arm-linux-size
我们来解释一下上面生成的可执行文件都是用来干什么的
add2line - 将你要找的地址转成文件和行号，它要使用 debug 信息。
Ar-产生、修改和解开一个存档文件
As-gnu 的汇编器
C++filt-C++ 和 java 中有一种重载函数，所用的重载函数最后会被编译转化成汇编的标号，c++filt 就是实现这种反向的转化，根据标号得到函数名。
Gasp-gnu 汇编器预编译器。
Ld-gnu 的连接器
Nm-列出目标文件的符号和对应的地址
Obj-将某种格式的目标文件转化成另外格式的目标文件
Objmp-显示目标文件的信息
Ranlib-为一个存档文件产生一个索引，并将这个索引存入存档文件中
Readelf-显示 elf 格式的目标文件的信息
Size-显示目标文件各个节的大小和目标文件的大小
Strings-打印出目标文件中可以打印的字符串，有个默认的长度，为4
Strip-剥掉目标文件的所有的符号信息
回页首
建立初始编译器（bootstrap gcc）
首先进入 build-tools 目录，将下载 gcc 源代码解压
$cd $PRJROOT/build-tools
$tar -xvzf gcc-2.95.3.tar.gz
然后进入 gcc-2.95.3 目录给 gcc 打上补丁
$cd gcc-2.95.3
$patch -p1< ../gcc-patch/gcc-2.95.3.-2.patch
$patch -p1< ../gcc-patch/gcc-2.95.3.-no-fixinc.patch
$patch -p1< ../gcc-patch/gcc-2.95.3-returntype-fix.patch
echo timestamp > gcc/cstamp-h.in
在我们编译并安装 gcc 前，我们先要改一个文件 $PRJROOT/gcc/config/arm/t-linux，把
TARGET_LIBGCC2-CFLAGS = -fomit-frame-pointer -fPIC
这一行改为
TARGET_LIBGCC2-CFLAGS = -fomit-frame-pointer -fPIC -Dinhibit_libc -D__gthr_posix_h
你如果没定义 -Dinhibit，编译时将会报如下的错误
../../gcc-2.95.3/gcc/libgcc2.c:41: stdlib.h: No such file or directory
../../gcc-2.95.3/gcc/libgcc2.c:42: unistd.h: No such file or directory
make[3]: *** [libgcc2.a] Error 1
make[2]: *** [stmp-multilib-sub] Error 2
make[1]: *** [stmp-multilib] Error 1
make: *** [all-gcc] Error 2
如果没有定义 -D__gthr_posix_h，编译时会报如下的错误
In file included from gthr-default.h:1,
from ../../gcc-2.95.3/gcc/gthr.h:98,
from ../../gcc-2.95.3/gcc/libgcc2.c:3034:
../../gcc-2.95.3/gcc/gthr-posix.h:37: pthread.h: No such file or directory
make[3]: *** [libgcc2.a] Error 1
make[2]: *** [stmp-multilib-sub] Error 2
make[1]: *** [stmp-multilib] Error 1
make: *** [all-gcc] Error 2
还有一种与-Dinhibit同等效果的方法，那就是在你配置configure时多加一个参数-with-newlib，这个选项不会迫使我们必须使用newlib。我们编译了bootstrap-gcc后，仍然可以选择任何c库。
接着就是配置boostrap gcc， 后面要用bootstrap gcc 来编译 glibc 库。
$cd ..; cd build-boot-gcc
$../gcc-2.95.3/configure --target=$TARGET --prefix=$PREFIX \
>--without-headers --enable-languages=c --disable-threads
这条命令中的 -target、--prefix 和配置 binutils 的含义是相同的，--without-headers 就是指不需要头文件，因为是交叉编译工具，不需要本机上的头文件。-enable-languages=c是指我们的 boot-gcc 只支持 c 语言。--disable-threads 是去掉 thread 功能，这个功能需要 glibc 的支持。
接着我们编译并安装 boot-gcc
$make all-gcc
$make install-gcc
我们来看看 $PREFIX/bin 里面多了哪些东西
$ls $PREFIX/bin
你会发现多了 arm-linux-gcc 、arm-linux-unprotoize、cpp 和 gcov 几个文件。
Gcc-gnu 的 C 语言编译器
Unprotoize-将 ANSI C 的源码转化为 K&R C 的形式，去掉函数原型中的参数类型。
Cpp-gnu的 C 的预编译器
Gcov-gcc 的辅助测试工具，可以用它来分析和优程序。
使用 gcc3.2 以及 gcc3.2 以上版本时，配置 boot-gcc 不能使用 --without-headers 选项，而需要使用 glibc 的头文件。
回页首
建立 c 库(glibc)
首先解压 glibc-2.2.3.tar.gz 和 glibc-linuxthreads-2.2.3.tar.gz 源代码
$cd $PRJROOT/build-tools
$tar -xvzf glibc-2.2.3.tar.gz
$tar -xzvf glibc-linuxthreads-2.2.3.tar.gz --directory=glibc-2.2.3
然后进入 build-glibc 目录配置 glibc
$cd build-glibc
$CC=arm-linux-gcc ../glibc-2.2.3/configure --host=$TARGET --prefix="/usr"
--enable-add-ons --with-headers=$TARGET_PREFIX/include
CC=arm-linux-gcc 是把 CC 变量设成你刚编译完的boostrap gcc，用它来编译你的glibc。--enable-add-ons是告诉glibc用 linuxthreads 包，在上面我们已经将它放入了 glibc 源码目录中，这个选项等价于 -enable-add-ons=linuxthreads。--with-headers 告诉 glibc 我们的linux 内核头文件的目录位置。
配置完后就可以编译和安装 glibc
$make
$make install_root=$TARGET_PREFIX prefix="" install
然后你还要修改 libc.so 文件
将
GROUP ( /lib/libc.so.6 /lib/libc_nonshared.a)
改为
GROUP ( libc.so.6 libc_nonshared.a)
这样连接程序 ld 就会在 libc.so 所在的目录查找它需要的库，因为你的机子的/lib目录可能已经装了一个相同名字的库，一个为编译可以在你的宿主机上运行的程序的库，而不是用于交叉编译的。
回页首
建立全套编译器（full gcc）
在建立boot-gcc 的时候，我们只支持了C。到这里，我们就要建立全套编译器，来支持C和C++。
$cd $PRJROOT/build-tools/build-gcc
$../gcc-2.95.3/configure --target=$TARGET --prefix=$PREFIX --enable-languages=c,c++
--enable-languages=c,c++ 告诉 full gcc 支持 c 和 c++ 语言。
然后编译和安装你的 full gcc
$make all
$make install
我们再来看看 $PREFIX/bin 里面多了哪些东西
$ls $PREFIX/bin
你会发现多了 arm-linux-g++ 、arm-linux-protoize 和 arm-linux-c++ 几个文件。
G++-gnu的 c++ 编译器。
Protoize-与Unprotoize相反，将K&R C的源码转化为ANSI C的形式，函数原型中加入参数类型。
C++-gnu 的 c++ 编译器。
到这里你的交叉编译工具就算做完了，简单验证一下你的交叉编译工具。
用它来编译一个很简单的程序 helloworld.c
#include <stdio.h>
int main(void)
{
printf("hello world\n");
return 0;
}
$arm-linux-gcc helloworld.c -o helloworld
$file helloworld
helloworld: ELF 32-bit LSB executable, ARM, version 1,
dynamically linked (uses shared libs), not stripped
上面的输出说明你编译了一个能在 arm 体系结构下运行的 helloworld，证明你的编译工具做成功了。
转载仅供参考，版权属于原作者

㈤ 如何在ubuntu中搭建交叉编译环境toolchain

1.安装交叉编译环境 sudo apt-get install gcc g++ libcc1 libg++ make gdb
2.安装交叉编译器 f
tp:
//ftp.
arm.linux.org.uk/pub/armlinux/toolchain/ 下载 cross -3.2.tar.bz2或者懒得去找干脆
wget f
tp://ftp.
arm.linux.org.uk/pub/armlinux/toolchain/ cross -3.2.tar.bz2
解压
sudo tar jxvf /home/zhaifang/cross -3.2.tar.bz2
sudo mv /home/zhaifang/usr/local/arm /usr/local
3.交叉编译器加入路径 sudo vi /etc/bash.bashrc后面加入
if [ -d /usr/local/arm ] ; then
PATH=/usr/local/arm/bin:'${PATH}'
fi
4.使环境生效 #source /etc/profile
5.检查 echo $PATH 出现/usr/local/arm/bin说明成功了
6.测试 arm-linux-gcc -v

㈥ arm-linux-gcc交叉编译器的制作，以及版本选择问题。

，需要必须有足够动经验来支持。
另外，用 RH9 的都是高手，我想你的知识不需要来提问了吧？

1、在 PC 上编译 arm 的程序当然需要较差编译器，这个需要自己安装，或者着现成的交叉编译器环境，一般是一个特殊参数编译出来的 gcc + binutils + glibc + linux-header。这个每个人动环境不同，一般都需要自己编译一个，当然没有特殊需求，也可以找现成的。不过很难找，因为这套环境还要和你动系统搭配，不然环境不匹配，连这个环境都不能运行，那就更谈不上编译东西了。
有关自己编译搭建交叉编译环境，可以看看一个特殊的 Linux 发行版 LFS 的分支： CLFS 。

2、移植分很多意思，移植有可能就意味着这套源代码不能在目标系统上面编译，需要你根据相应的知识去修改源代码来让这套代码适应目标编译器的要求，比如源代码有 SSE4 的优化，这套程序在非 SSE4 CPU 上无法编译运行，但目标机器连 SSE1 都不支持。那么就需要移植。
或者移植仅仅是根据新的环境进行编译，不需要进行源代码修改，只需要进行一下编译就能运行的程序，也可以称为移植，就是从一个环境、架构 -》另一个环境、架构。都可以称为移植，但真正的移植意味着修改程序源代码来适应新环境。你说的这种移植是最简单的移植。

3、决定目标硬件环境 -》搭建目标编译器 -》制作目标环境（内核，基础软件库）-》进行应用移植（移植需要的软件、主应用程序）-》搭建系统文件系统 -》导入目标系统-》启动目标系统&应用。说起来很简单，因为这是完全没有问题的条件下。
至于超级终端。那是用来控制目标系统的。目标系统有可能不能插键盘鼠标显示器，这就需要一个远程网络链接来进行控制。以及通过远程链接来发送数据。这都需要终端的支持。

虚拟机下面进行开发，不能发挥你的计算机的性能。而且因为隔着 VMware 的软件模拟层，可能还不会很方便的让你链接目标设备。

至于用 socket ，我还没见到你的目标需要这个东西，因为所有的东西都是现成的源代码。不需要你从 0 开始写，当然你想自己写一个系统内核，或者服务器程序，或者全套的系统+应用，我绝对不拦你，但希望你写完这套东西，能把源代码发布出来。
ads 可以认为是一个支持环境，他本身不是一个系统的开发 SDK 。
-------------------------------------
ads 没用过，印象里他还有模拟器，调试器什么的程序。功能上要比 Linux 开发环境，WinCE 环境下面的东西更多更偏向于硬件方面，毕竟 ads 是 arm 出品的，不太可能偏向于软件部分设计。Linux 和 WinCE 都是系统而不是硬件工具。

你可以认为交叉编译器是一个应用程序，一个输出器。把源代码输出为 arm 的代码，这个应用程序的输出，是靠他自己的环境，而不是当前系统的环境的。
当前系统的各个软件的版本，不能影响交叉编译器输出的环境（理论上，现实有的时候总是从别的地方给你打击……），交叉编译器一般至少有 gcc 、binutils 、glibc 库、linux kernel 头文件。

在软件需求上。
头文件谁都不依赖，glibc 只需要内核头文件，其他程序全都依赖于 glibc 。也就是所有程序都不依赖内核，仅仅是依赖于内核头文件。

gcc 和 binutils 是把程序源代码根据上面各个环节的需提供的功能来输出为上面环节里面的二进制程序。依赖你当前环境的，只有 gcc 和 binutils 两个程序的执行、控制环节。只有他们两个依赖的，而不是你的交叉编译后的程序。

至于编译器版本的选择，新版本功能更好，旧版本兼容更好。
这个要看你的实际需要了。应用程序源代码也调编译器的，同时也依赖于软件库的功能。

arm 开发建议稳定、兼容优先。当然也可以尝试最新的编译环境，来获取更好的优化（前提是还有什么代码优化的话）。
另外,团IDC网上有许多产品团购,便宜有口碑

㈦ 如何制作arm-linux-gcc编译工具

一、下载源文件
源代码文件及其版本：
binutils-2.19.tar.bz2, gcc-core-4.4.4.tar.bz2 gcc-g++-4.4.4.tar.bz2 Glibc-2.7.tar.bz2 Glibc-ports-2.7.tar.bz2 Gmp-4.2.tar.bz2 mpfr-2.4.0.tar.bz2mpc-1.0.1.tar.gz Linux-2.6.25.tar.bz2 （由于我在编译出错的过程中，根据出错的信息修改了相关的C代码，故而没有下载相应的补丁）
一般一个完整的交叉编译器涉及到多个软件，主要包括bilinguals、cc、glibc等。其中，binutils主要生成一些辅助工具；gcc是用来生成交叉编译器，主要生成arm-linux-gcc交叉编译工具，而glibc主要提供用户程序所需要的一些基本函数库。

二、建立工作目录
编译所用主机型号 fc14.i686，虚拟机选的是VM7.0，Linux发行版选的是Fedora9,
第一次编译时用的是root用户（第二次用一般用户yyz）, 所有的工作目录都在/home/yyz/cross下面建立完成，首先在/home/yyz目录下建立cross目录，然后进入工作目录，查看当前目录。命令如下：

创建工具链文件夹：
[root@localhost cross]# mkdir embedded-toolchains
下面在此文件夹下建立如下几个目录：
setup-dir：存放下载的压缩包；
src-dir：存放binutils、gcc、glibc解压之后的源文件；
Kernel：存放内核文件，对内核的配置和编译工作也在此完成；
build-dir ：编译src-dir下面的源文件，这是GNU推荐的源文件目录与编译目录分离的做法；
tool-chain：交叉编译工具链的安装位；
program：存放编写程序；
doc:说明文档和脚本文件；
下面建立目录，并拷贝源文件。
[root@localhost cross] #cd embedded- toolchains
[root@localhost embedded- toolchains] #mkdir setup-dir src-dir kernel build-dir tool-chain program doc
[root@localhost embedded- toolchains] #ls
build-dir doc kernel program setup-dir src-dir tool-chain
[root@localhost embedded- toolchains] #cd setup-dir
拷贝源文件：
这里我们采用直接拷贝源文件的方法，首先应该修改setup-dir的权限
[root@localhost embedded- toolchains] #chmod 777 setup-dir
然后直接拷贝/home/yyz目录下的源文件到setup-dir目录中，如下图：

建立编译目录：
[root@localhost setup-dir] #cd ../build-dir
[root@localhost build -dir] #mkdir build-binutils build-gcc build-glibc
三、输出环境变量
输出如下的环境变量方便我们编译。
为简化操作过程。下面就建立shell命令脚本environment-variables：
[root@localhost build -dir] #cd ../doc
[root@localhost doc] #mkdir scripts
[root@localhost doc] #cd scripts
用编辑器vi编辑环境变量脚本envionment-variables：[root@localhost scripts]
#vi envionment-variables
export PRJROOT=/home/yyz/cross/embedded-toolchains
export TARGET=arm-linux
export PREFIX=$PRJROOT/tool-chain
export TARGET_PREFIX=$PREFIX/$TARGET
export PATH=$PREFIX/bin:$PATH
截图如下：
执行如下语句使环境变量生效：
[root@localhost scripts]# source ./environment-variables
四、建立二进制工具（binutils）
下面将分步介绍安装binutils-2.19.1的过程。
[root@localhost script] # cd $PRJROOT/src-dir
[root@localhost src-dir] # tar jxvf ../setup-dir/binutils-2.19.1.tar.bz2
[root@localhost src-dir] # cd $PRJROOT/build-dir/build-binutils
创建Makefile：
[root@localhost build-binutils] #../../src-dir/binutils-2.19.1/configure --target=$TARGET --prefix=$PREFIX
在build-binutils目录下面生成Makefile文件，然后执行make，make install,此过程比较缓慢，大约需要一个15分钟左右。完成后可以在$PREFIX/bin下面看到我们的新的binutil。
输入如下命令
[root@localhost build-binutils]#ls $PREFIX/bin

㈧ 如何构建MIPS交叉编译工具链

第一步 创建目录以及环境变量
在当前用户目录下创建target-project文件夹，在该文件夹下创建mips-mole文件夹，在mips-mole文件夹下创建三个文件夹：build-tools，kernel，tools，最后，在build-tools文件夹下创建build-gcc，build-boot-gcc，build-glibc，build-binutils文件夹。命令如下：

$ cd ~
$ mkdir -p ./target-project/mips-mole/{kernel/,tools/,build-tools/{build-gcc,build-boot-gcc,build-glibc,build-binutils}}
$ tree ./target-project/mips-mole/

使用脚本构建环境变量
#! /bin/bash

注意修改/home/用户名，修改正确后，使用source使脚本生效

$ cd target-project
$ chmod +x mips.sh
$ source mips.sh
可以使用echo査看相关变量名以观察环境变量是否生效。
最后把linux-2.6.38.tar.bz2下载放置在kernel文件夹下，binutils-2.22.tar.gz，gcc-4.6.2.tar.gz，glibc-2.14.tar.gz，glibc-ports-2.14.tar.gz，gmp-5.0.4.tar.gz，mpc-0.9.tar.gz，mpfr-3.0.1.tar.gz下载放置在build-tools文件夹下。

第二步 安装基于MIPS的linux头文件

$ cd $PRJROOT/kernel
$ tar -xjvf linux-2.6.38.tar.bz2
$ cd linux-2.6.38
在指定路径下创建include文件夹，用来存放相关头文件。

$ mkdir -p $TARGET_PREFIX/include
保证linux源码是干净的。

$ make mrproper
生成需要的头文件。
$ make ARCH=mips headers_check

$ make ARCH=mips INSTALL_HDR_PATH=dest headers_install
将dest文件夹下的所有文件复制到指定的include文件夹内。

$ cp -rv dest/include/* $TARGET_PREFIX/include
最后删除dest文件夹
$ rm -rf dest
$ ls -l $TARGET_PREFIX/include

第三步 安装binutils-2.22

$ cd $PRJROOT/build-tools
$ tar -xzvf binutils-2.22.tar.gz
$ cd build-binutils
$ ../binutils-2.22/configure --target=$TARGET --prefix=$PREFIX
$ make
$ make install

再安装automake。

$ tar -xzvf automake-1.11.1.tar.gz
$ cd automake-1.11.1
$ ./configure
$ make
$ sudo make install
下面开始修改相关文件，主要是去掉-Werror。
$ cd $PRJROOT/build-tools/binutils-2.22/gas
$ ge dit configure
将下面内容
# Enable -Werror by default when using gcc
if test "${GCC}" = yes -a -z "${ERROR_ON_WARNING}" ; then
ERROR_ON_WARNING=yes
fi
修改为
# Enable -Werror by default when using gcc
if test "${GCC}" = yes -a -z "${ERROR_ON_WARNING}" ; then
ERROR_ON_WARNING=no
fi
但是，需要重新configure生成Makefile.in。

$ ./configure (在binutils/gas路径下的configure)
$ make distclean (切记)
然后重新执行第三步，这次编译可过。

第四步 安装gcc引导器

$ cd $PRJROOT/build-tools
$ tar -xzvf gcc-4.6.2.tar.gz
$ tar -xjvf gmp-5.0.4.tar.bz2
$ mv gmp-5.0.4 ./gcc-4.6.2/gmp
$ tar -xzvf mpc-0.9.tar.gz
$ mv mpc-0.9 ./gcc-4.6.2/mpc
$ tar -xzvf mpfr-3.0.1.tar.gz
$ mv mpfr-3.0.1 ./gcc-4.6.2/mpfr
$ cd build-boot-gcc
$ ../gcc-4.6.2/configure --target=$TARGET --prefix=$PREFIX --disable-shared <br>--without-headers --with-newlib --enable-languages=c --disable-decimal-float <br>--disable-libgomp --disable-libmudflap --disable-libssp --disable-threads --disable-multilib
编译并安装gcc引导器、libgcc库。

$ make all-gcc
$ make all-target-libgcc
$ make install-gcc
$ make install-target-libgcc

第五步 编译glibc

$ cd $PRJROOT/build-tools
$ tar xzvf glibc-2.14.tar.gz
$ cd glibc-2.14
删除Makefonfig文件中的内容-lgcc_eh。

$ cp -v Makeconfig{,.b肠花斑拘职饺办邪暴矛k}
$ sed -e 's/-lgcc_eh//g' Makeconfig.bk > Makeconfig
$ cd ..
$ tar -xjvf glibc-ports-2.14.tar.bz2
$ mv glibc-ports-2.14 ./glibc-2.14/ports
$ cd build-glibc
$ CC=mipsel-linux--gcc ../glibc-2.14/configure --host=$TARGET --prefix="/usr" <br>--enable-add-ons --with-headers=$TARGET_PREFIX/include libc_cv_forced_unwind=yes <br>libc_cv_c_cleanup=yes
注意：此时如何设置了LD_LIBRARY_PATH环境变量会configure error，需要删除该变量重新configure。

$ make
$ make install_root=$TARGET_PREFIX prefix=”” install
第六步 完全安装gcc
首先，也是很重要的是去掉libc等库文件的绝对路径。

$ cd $TARGET_PREFIX/lib
备份一下。

$ cp libc.so libc.so.bk
$ gedit libc.so
将原内容
GROUP ( /lib/libc.so.6 /lib/libc_nonshared.a AS_NEEDED ( /lib/ld.so.1 ) )
修改为
GROUP ( libc.so.6 libc_nonshared.a AS_NEEDED ( ld.so.1 ) )

$ cp libpthread.so libpthread.so.bk
$ gedit libpthread.so
将原内容
GROUP ( /lib/libpthread.so.0 /lib/libpthread_nonshared.a )
修改为
GROUP ( libpthread.so.0 libpthread_nonshared.a )
然后可以完全编译gcc。

㈨ 交叉编译器的举例

交叉编译
1、在Windows PC上，利用ADS（ARM开发环境），使用armcc编译器，则可编译出针对ARM CPU的可执行代码。
2、在Linux PC上，利用arm-linux-gcc编译器，可编译出针对Linux ARM平台的可执行代码。
3、在Windows PC上，利用cygwin环境，运行arm-elf-gcc编译器，可编译出针对ARM CPU的可执行代码。
4、在Windows系统上，利用Keil Uvison工具，开发出运行在89C51单片机上的程序。
5、在Windows系统上，利用CodeWarrior IDE工具，开发出运行在Freescale XS128单片机上的程序。