交叉编译环境搭建

‘壹’ 如何建立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>

‘贰’ 建立交叉编译环境需要配置哪些服务

基于Linux操作系统的应用开发环境一般是由目标系统硬件（开发板）和宿主PC机所构成。目标硬件开发板用于运行操作系统和系统应用软件。

这种情况下，在 ARM 平台上进行本机编译就不太可能了，这是因为一般的编译工具链（compilation tool chain）需要很大的存储空间，并需要很强的 CPU 运算能力。为了解决这个问题，交叉编译工具就应运而生了。

比如，我们在 Windows 平台上，可使用 Visual C++开发环境，编写程序并编译成可执行程序。这种方式下，我们使用 PC 平台上的 Windows 工具开发针对 Windows 本身的可执行程序，这种编译过程称为 native compilation，中文可理解为本机编译。

然而，在进行嵌入式系统的开发时，则不能直接编译。运行程序的目标平台通常具有有限的存储空间和运算能力，比如常见的 ARM 平台，其一般的静态存储空间大概是 16 到 32 MB，而 CPU 的主频大概在 100MHz 到 500MHz 之间。

‘叁’ 如何安装arm-liunx交叉编译环境

sh ./arm-elf-tools-20040427.sh安装
----------------------------------------------
一、准备工作

首先需要一台运行Linux操作系统的PC以完成我们的编译工作。

其次要准备如下一些源文件。

1、源文件准备

binutils-2.14.tar.gz

ftp://ftp.gnu.org/gnu/binutils/binutils-2.14.tar.gz

gcc-core-2.95.3.tar.gz

ftp://ftp.gnu.org/gnu/gcc/gcc-2.95.3/gcc-core-2.95.3.tar.gz

gcc-g++2.95.3.tar.gz

ftp://ftp.gnu.org/gnu/gcc/gcc-2.95.3/gcc-g++-2.95.3.tar.gz

glibc-2.2.4.tar.gz

ftp://ftp.gnu.org/gnu/glibc/glibc-2.2.4.tar.gz

glibc-linuxthreads-2.2.4.tar.gz

ftp://ftp.gnu.org/gnu/glibc/glibc-linuxthreads-2.2.4.tar.gz

linux-2.4.21.tar.gz

ftp://ftp.kernle.org/pub/linux/kernel/v2.4/linux-2.4.21.tar.gz

patch-2.4.21-rmk1.gz # linux kernel patch for arm

ftp://ftp.arm.linux.org.uk/pub/linux/arm/kernel/v2.4/patch-2.4.21-rmk1.gz

binutils-2.14.tar.gz这个压缩包包含有ld,ar,as等一些产生或者处理二进制文件的工具。

gcc-core-2.95.3.tar.gz这个压缩包是GCC的主体部分，GCC是GNU Compiler Collection的简称，顾名思义，它能够编译很多种高级语言，例如C、C++，java等，而这个压缩包中含有C编译器，及公共部分，而对其他语言的支持，采用另外的压缩包单独发布。

gcc-g++2.95.3.tar.gz，这个压缩包就是为使GCC能够编译C++程序而单独发布的。

glibc-2.2.4.tar.gz，libc是很多用户层应用都要用到的库，kernel和bootloader不需要这个库的支持，这个库主体部分封装在这个压缩包内。

glibc-linuxthreads-2.2.4.tar.gz，这是Libc用于支持Posix线程而单独发布的一个压缩包。

linux-2.4.21.tar.gz，这个压缩包就是Linux的内核。

patch-2.4.21-rmk1.gz，这个压缩包是用来给Linux内核打补丁，以使其可以支持ARM的硬件平台。

2、工作目录搭建

我们创建如下的目录树结构

mkdir arm

mkdir tool-chain

mkdir build-dir

mkdir src-dir

mkdir setup-dir

mkdir kernel

arm这个目录是我们的最顶层工作目录，我们所有的编译工作都在这里完成。

tool-chain这个目录是我们交叉编译工具的安装位置，它下面的bin子目录存放我们创建好的编译器，汇编器，连接器，以及编译好的C库也会安装到这个目录之下。

setup-dir这个目录用来存放我们下载的压缩包。

src-dir这个目录用于存放binutils,gcc,glibc解压之后的源文件。

kernel这个目录用来存放内核文件，对内核的配置、编译工作将在这个目录中完成。

build-dir用来编译src-dir中的源文件，具体就是binutils，gcc，glibc的编译工作将在这个目录下完成。这种源文件目录和编译目录分离的编译方式是GNU所推荐的。

cd ./src-dir

tar –xvzf ../setup-dir/ binutils-2.14.tar.gz

tar –xvzf ../setup-dir/ gcc-core-2.95.3.tar.gz

tar –xvzf ../setup-dir/ glibc-2.2.4.tar.gz

tar –xvzf ../setup-dir/ glibc-linuxthreads-2.2.4.tar.gz –directory=./glibc-2.2.4

这样我们在src-dir目录下就形成了3个源文件目录binutils-2.14,gcc-core-2.95,3,glibc-2.2.4，其中分别存放着binutils tools，gcc，glibc的源代码。接下来我们到build-dir中创建3个与这三个源文件目录对应的编译目录。

cd ../build-dir

mkdir ../build-dir/build-binutils

mkdir ../build-dir/build-gcc

mkdir ../build-dir/build-glibc

我们将在这三个目录中完成对binutils tools, gcc, glibc的配置和编译工作。下面还要把内核文件解压到kernel目录下，并打补丁。

cd ../kernel

tar –xvzf ../setup-dir/ linux-2.4.21.tar.gz

cd ./linux-2.4.21

patch –p1 < ../../setup-dir/ patch-2.4.21-rmk1

二、开始创建

1、 确定几个系统变量

cd ../../

export TARGET=arm-linux

export PREFIX=../arm/tool-chain

export TARGET_PREFIX=$PREFIX/$TARGET

export KERNEL_SOURCE_LOCATION=../arm/kernel/linux-2.4.21

export PATH=$PREFIX/bin:$PATH

几个系统变量经常要用到，TARGET定义了目标机，PREFIX是工具链的安装目录，KERNEL_SOURCE_LOCATION是内核文件位置。

TARGET这个变量对于ARM体系的目标机来说取值为arm-linux,对于其他体系结构的机器如ppc,mips的取值的详细清单可以参见glibc目录下的INSTALL文档.

2、 创建binutils

运行如下命令来创建binutils

cd ./build-dir/build-binutils

configure ../../src-dir/binutils-2.14/configure –target=$TARGET –prefix=$PREFIX

make

make install

这时$PREFIX/bin下创建了一些文件，包括arm-linux-ld,arm-linux-as等。

3、 编译内核

cd ../../kernel/linux-2.4.21

改Makefile文件使

ARCH = arm

CROSS_COMPILE=arm-linux-

make menuconfig

在System Types中选择正确的硬件类型

make dep

之后执行如下操作

mkdir $TARGET_PREFIX/include

cp dR $KERNEL_SOURCE_LOCATION/include/arm-asm \

RGET_PREFIX/include/asm

cp dR $KERNEL_SOURCE_LOCATION/include/linux \

RGET_PREFIX/include/linux

4、 创建boot-trap gcc，这个GCC没有glibc库的支持，所以只能用于编译内核，bootloader等，后面创建C库也要用到这个编译器，所以创建它主要是为创建C库做准备，如果只想编译内核和bootloader那么，就可以到此结束。

cd ../../build-dir/build-gcc

../../src-dir/gcc-2.95.3/configure –target=$TARGET –prefix=$PREFIX \

--with-headers=$ERNEL_SOURCE_LOCATION/include –enable-language=c \

--disable-threads

然后修改src-dir/gcc-2.95.3/gcc/config/arm/t-linux文件，在

TARGET_LIBGCC2_CFLAGS中添加如下两个定义

-Dinhibit-libc –D__gthr_posix_h

make

make install

这时$PREFIX/bin下创建了一些文件，主要创建了arm-linux-gcc。

5、 创建gblic

cd ../build-glibc

export CC=arm-linux-gcc

../../src-dir/glibc-2.2.4/configure –host=$TARGET –prefix=$TARGET_PREFIX \

--enable-add-ons

make

make install

将glibc库安装完之后,我们要到$TARGET_PREFIX/lib这个目录下修改libc.so文件,将其中

GROUP(/lib/libc.so.6 /lib/libc_noshared.a)

这个命令脚本中的/lib 的绝对路径去掉, 也就是改为如下的形式

GROUP(libc.so.6 libc_noshared.a)

这样下一步创建完整的编译器时,才不至于导致错误.

6、 创建功能健全的GCC，并创建G++

在成功创建了libc之后，我们就可以创建功能丰富的GCC编译器了，并且可以创建支持编译C++程序的G++。

cd ../../src-dir

tar –xvzf ../setup-dir/ gcc-g++2.95.3.tar.gz

cd ../build-dir/build-gcc

export CC=gcc

../../src-dir/gcc-2.95.3/configure –target=$TARGET –prefix=$PREFIX \

–enable-language=c,c++

然后修改src-dir/gcc-2.95.3/gcc/config/arm/t-linux文件，在

TARGET_LIBGCC2_CFLAGS中去除如下两个定义

-Dinhibit-libc –D__gthr_posix_h

make

make install

7，至此我们成功的创建了ARM Linux的交叉编译工具。

------------------------------------------------------
可以去www.arm16.com看看

‘肆’ 如何搭建交叉编译环境

交叉编译环境就是在Windows下的东西拿到Linux下编译运行吧，我个人是在Linux启动了samba服务器，然后将文件夹映射到Windows下，在Windows下使用vc 6.0编程序然后到Linux下编译的。不知道能不能对你有些帮助。

下载的rpm包，可以使用rpm -ivh 包路径进行安装

‘伍’ 如何构建交叉编译环境。

你说的是我下面的回答吗？下面就一些问题作一个说明，以期抛砖引玉。
基于Linux操作系统的应用开发环境一般是由目标系统硬件（开发板）和宿主PC机所构成。目标硬件开发板用于运行操作系统和系统应用软件，而目标板所用到的操作系统的内核编译、应用程序的开发和调试则需要通过宿主PC机来完成（所以称为交叉编译）。双方之间一般通过串口，并口或以太网接口建立连接关系。
但在此我建议构建如下的交叉编译环境，适合个人或研发小组使用：单独拿出一台PC机（PII以上即可，就用以前淘汰的旧机器就可以），在该PC上安装桌面的Linux操作系统（如Red Hat Linux 8.0及以上），可以采用默认的安装选项（注意要包含FTP服务），这台PC作为Linux服务器，除管理员以外，一般不直接让其他人去操作。
将该Linux服务器接入局域网，并新建一些合法用户，以便其他的PC机（在此我们将其称为工作站）的合法用户能访问到Linux服务器。而其他的PC机（工作站）仍然使用Windows操作系统,原来干啥继续干啥。
需要的软件工具包括：
1、FTP客户端程序（如Cuteftp，可到网上下载）。
2、Telnet工具（如SecureCRT，可到网上下载）。
3、移植到某一特定ARM平台的Linux操作系统内核源码（一般由销售商整理提供）。
4、GNU编译工具，可由相关网站下载，或由销售商整理提供。
在工作站安装：
在某工作站PC上安装FTP客户端程序和Telnet工具，安装完毕后应该可以在该工作站PC和Linux服务器之间进行文件的传输，并在工作站PC可以通过Telnet登陆到Linux服务器（可能需要将Linux服务器的防火墙服务关闭才能完成）。
在Linux服务器安装：
将工作站PC上的Linux操作系统内核源码压缩包和GNU编译工具通过FTP传送到Linux服务器的某个目录（如合法的用户目录），然后在该目录下解压，并将GNU编译工具安装到默认的工作目录即可，以上工作通过在工作站PC使用Telnet工具完成，而不需要在Linux服务器上进行。
Linux操作系统内核的编译：
Linux操作系统内核的编译一般有一个比较固定的步骤，会根据MakeFile文件的不同而略有差异，可参考相关文档，编译的工作在工作站PC使用Telnet工具完成。

‘陆’ 如何在centos上搭建交叉编译环境

最简单的可以使用lnmp一键包 也可以通过源安装 yum install apache mysql php(其中可能包名有部分出入，可以先search一下) 最后如果有特殊需求可以通过源码来编译安装各个包 教程的话有很多吧，这里发布了外部链接，你需要的话我可以私聊发你。

‘柒’ 如何在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

‘捌’ 建立linux交叉编译环境的步骤

什么交叉编译环境？
arm？mips？ppc？

初学可以看看friendlyarm提供的说明书，里面讲到fedora上建立交叉编译环境，redhat上也一样的
http://www.arm123.com.cn/mini2440/mini2440-um-20090514.rar

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

下面我们将以建立针对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，证明你的编译工具做成功了。
转载仅供参考，版权属于原作者