GCC背后的故事&C程序常量变量的地址分配

实验目的

掌握GCC背后的故事&C程序常量变量的地址分配

实验任务

任务1.学习并掌握可执行程序的编译、组装过程。

阅读、理解和学习材料“用gcc生成静态库和动态库.pdf”和“静态库.a与.so库文件的生成与使用.pdf”，请在Linux系统(Ubuntu)下如实仿做一遍。

在第一次作业的程序代码基础进行改编，除了x2x函数之外，再扩展写一个x2y函数（功能自定），main函数代码将调用x2x和x2y ；将这3个函数分别写成单独的3个 .c文件，并用gcc分别编译为3个.o 目标文件；将x2x、x2y目标文件用 ar工具生成1个 .a 静态库文件, 然后用 gcc将 main函数的目标文件与此静态库文件进行链接，生成最终的可执行程序，记录文件的大小。

将x2x、x2y目标文件用 ar工具生成1个 .so 动态库文件, 然后用 gcc将 main函数的目标文件与此动态库文件进行链接，生成最终的可执行程序，记录文件的大小，并与之前做对比。

任务2.Gcc不是一个人在战斗。请说明gcc编译工具集中各软件的用途，了解EFF文件格式。学习任务如下
阅读、理解和学习材料“Linux GCC常用命令.pdf”和“GCC编译器背后的故事.pdf”，如实仿做一遍

任务3.编写一个C程序，重温全局常量、全局变量、局部变量、静态变量、堆、栈等概念，在Ubuntu（x86）系统和STM32(Keil)中分别进行编程、验证（STM32 通过串口printf 信息到上位机串口助手) 。1）归纳出Ubuntu、stm32下的C程序中堆、栈、全局、局部等变量的分配地址，进行对比分析；2）加深对ARM Cortex-M/stm32F10x的存储器地址映射的理解。下图是一个Cortex-M4的存储器地址映射示意图（与Cortex-M3/stm32F10x基本相同，只存在微小差异）

实验内容

任务1

用gcc生成静态库和动态库，编辑生成例子程序 hello.h、hello.c 和 main.c
代码如下：

hello.h

#ifndef HELLO_H

#define HELLO_H

void hello(const char *name);

#endif //HELLO_H

hello.c

#include <stdio.h>

void hello(const char *name)

{

printf("Hello %s!\n", name);

}

main.c

#include "hello.h"

int main()

{

hello("everyone");

return 0;

}

将 hello.c 编译成.o 文件

gcc -c hello.c

ls //运行ls命令查看是否产生hello.o

由.o文件创建静态库

在程序中使用静态库

一、可执行程序的组装

1.1 用gcc生成.a静态库和.so动态库（test1）

（1）编辑生成例子程序 hello.h、hello.c 和 main.c

创建作业目录：

mkdir test1 //创建test1文件夹

ls //显示文件及目录

cd test1 //进入目录test1

用 vim创建hello.h、hello.c 和 main.c3 个文件。

hello.h

#ifndef HELLO_H

#define HELLO_H

void hello(const char *name);

#endif //HELLO_H

由.o文件创建静态库

ar -crv libmyhello.a hello.o //创建静态库

ls //运行ls命令查看结果

在程序中使用静态库

gcc main.c libmyhello.a -o hello

由.o 文件创建动态库文件

#gcc -shared -fPIC -o libmyhello.so hello.o //创建静态库

ls //运行ls命令查看结果

在程序中使用动态库；

gcc main.c libmyhello.so -o hello

./hello

任务2

用gcc生成.a静态库和.so动态库（test2）
编辑作业程序 a1.c 、a2.c、a.h和test.c

a1.c

#include <stdio.h>

void print1(int arg){

printf("A1 print arg:%d\n",arg);

}

a2.c

#include <stdio.h>

void print2(char *arg){

printf("A2 printf arg:%s\n", arg);

}

a.h

#ifndef A_H

#define A_H

void print1(int);

void print2(char *);

#endif

test2.c

#include <stdlib.h>

#include "A.h"

int main(){

print1(1);

print2("test");

exit(0);

}

静态库.a 文件的生成与使用

生成目标文件a1.o、a2.o

gcc -c a1.c a2.c          //用gcc生成.o文件

ls                        //查看

共享库.so 文件的生成与使用

生成目标文件a1.o / a2.o( 此处生成.o 文件必须添加"-fpic")

gcc -c -fpic a1.c a2.c

生成共享库.so 文件

gcc -shared *.o -o libso.so

使用.so 库文件，创建可执行程序

gcc -o test test.c libso.so

./test

任务3

编辑生成例子程序 b.h、b1.c、b2 和 main.c

b1.c（a和b相加）

#include <stdio.h>

float x2x(int a,int  b)

{

  return a+b;

}

b2.c（a和b相乘）

#include <stdio.h>

float x2y(int a,int  b)

{

  return a*b;

}
b.h


#ifndef b_H

#define b_H

float x2x(int a,int  b);

float x2y(int a,int  b);

#endif

main.c


#include <stdlib.h>

#include "b.h"

int main()

{

int a=0,b=0;

scanf("%d%d",&a,&b);

printf("%d+%d=%f/n",a,b,x2x(a,b));

printf("%d+%d=%f/n",a,b,x2y(a,b));

exit(0);

}

将 b1.c/b2.c 编译成.o 文件

gcc -c b1.c b2.c

生成静态库文件libb.a

ar crv libb.a b1.o b2.o //由a1.o和a2.o生成静态库文件

ls //查看

（4）使用.a 库文件，创建可执行程序

gcc -o main main.c libb.a

./test

（5）静态库文件大小

size main

任务4

建立动态库

编辑生成例子程序 b.h、b1.c、b2 和 main.c（1.2已完成）

将 b1.c/b2.c 编译成.o 文件( 此处生成.o 文件必须添加"-fpic")

gcc -c -fpic b1.c b2.c

生成静态库文件libb.so

ar crv libb.so b1.o b2.o //由a1.o和a2.o生成静态库文件

ls //查看

（4）使用.a 库文件，创建可执行程序

gcc -o main main.c libb.so

mv libb.so /usr/libsi

./main

动态库大小

size libb.so

二、gcc编译工具中各软件的用途

1.1 Linux GCC常用命令

（1）简单的编译过程

1.1直接生成可执行文件

main.c

#include <stdio.h>

int main(void)

{

printf("Hello World!\n");

return 0;

}

预编译

gcc -E test.c -o test.i //生成预处理文件，test.i

gcc -E test.c //将预处理文件显示在命令行中

编译–编码为汇编语言

预处理之后，可直接对生成的 test.i 文件编译，生成汇编代码：

gcc -S test.i -o test.s

gcc 的-S 选项，表示在程序编译期间，在生成汇编代码后，停止，-o 输出汇编代码文件。

汇编

对于上一题中生成的汇编代码文件 test.s，

gas 汇编器负责将其编译为目标文件

连接

gcc 连接器是 gas 提供的，负责将程序的目标文件与所需的所有附加的目标文件连接起来，最终生

成可执行文件。附加的目标文件包括静态连接库和动态连接库。

对于上一小节中生成的 test.o，将其与Ｃ标准输入输出库进行连接，最终生成程序 test

gcc test.o -o test

（2）多个程序文件的编译

gcc可以同时编译多个源文件

gcc test1.c test2.c -o test

如果同时处理的文件不止一个，GCC 仍然会按照预处理、编译和链接的过程依次进行

上面这条命令大致相当于依次执行如下三条命令：

gcc -c test1.c -o test1.o

gcc -c test2.c -o test2.o

gcc test1.o test2.o -o test

（3）检错

常用的gcc检错命令有以下两种：

gcc -pedantic illcode.c -o illcode

gcc -Wall illcode.c -o illcode

在编译程序时带上-Werror 选项，那么 GCC 会在所有产生警告的地方停止编译，如下：

gcc -Werror test.c -o test

（4）链接

有目标文件链接成可执行文件：

gcc –L /usr/dev/mysql/lib –lmysqlclient test.o –o test //这里的路径，若不写，则默认在/usr/lib

1

若想让GCC 在链接时只用到静态链接库，可以使用下面的命令：

gcc –L /usr/dev/mysql/lib –static –lmysqlclient test.o –o test //-static 静态

1

也可以直接写出要使用的库如：

gcc -o main main.c libtest.a

1

1.2 GCC编译器背后的故事

（1）准备工作

#include <stdio.h>

//此程序很简单，仅仅打印一个 Hello World 的字符串。

int main(void)

{

printf(“Hello World! \n”);

return 0;

}

（2） 编译过程

1.1已经详细的介绍了gcc的编译过程，这里不再赘叙

直接gcc hello.c -o hello

（3）分析 ELF 文件

1.ELF 文件的段

位于 ELF Header 和 Section Header Table 之间的都是段（Section）。

一个典型的 ELF 文件包含下面几个段：

.text：已编译程序的指令代码段。

.rodata：ro 代表 read only，即只读数据（譬如常数 const）。

.data：已初始化的 C 程序全局变量和静态局部变量。

.bss：未初始化的 C 程序全局变量和静态局部变量。

.debug：调试符号表，调试器用此段的信息帮助调试。

可以使用 readelf -S 查看其各个 section 的信息如下：

readelf -S hello

2.反汇编 ELF

由于 ELF 文件无法被当做普通文本文件打开，如果希望直接查看一个 ELF 文件包含的指令和数据，需要使用反汇编的方法。

使用 objdump -D 对其进行反汇编如下：

objdump -D hello

使用 objdump -S 将其反汇编并且将其 C 语言源代码混合显示出来：

gcc -o hello -g hello.c //要加上-g 选项

objdump -S hello

2.1 nasm的使用

NASM是一个为可移植性与模块化而设计的一个80x86的汇编器。它支持相当多的目标文件格式，包括Linux和’‘NetBSD/FreeBSD’’,’‘a.out’’,’‘ELF’’,’‘COFF’’,微软16位的’‘OBJ’‘和’‘Win32’’。

（1）安装nasm

apt-get install nasm

（2）下载asm文件

（3）将asm编译为可执行文件

nasm -f elf32 hello.sam -o hello.o

ld -m elf_i386 hello.o -o hello

./hello

（4）查看可执行文件大小

size hello

（5）与c语言编译文件大小比较

vim hello.c

gcc hello.c -o hellol

./hellol

任务5

编写一个C程序，重温全局常量、全局变量、局部变量、静态变量、堆、栈等概念.

#include <stdio.h>

#include <stdlib.h>

//定义全局变量

int init_global_a = 1;

int uninit_global_a;

static int inits_global_b = 2;

static int uninits_global_b;

void output(int a)

{

       printf("hello");

       printf("%d",a);

       printf("\n");

}

int main( )

{  

       //定义局部变量

       int a=2;

       static int inits_local_c=2, uninits_local_c;

    int init_local_d = 1;

    output(a);

    char *p;

    char str[10] = "lmy";

    //定义常量字符串

    char *var1 = "1234567890";

    char *var2 = "qwertyuiop";

    //动态分配

    int *p1=malloc(4);

    int *p2=malloc(4);

    //释放

    free(p1);

    free(p2);

    printf("栈区-变量地址\n");

    printf("                a：%p\n", &a);

    printf("                init_local_d：%p\n", &init_local_d);

    printf("                p：%p\n", &p);

    printf("              str：%p\n", str);

    printf("\n堆区-动态申请地址\n");

    printf("                   %p\n", p1);

    printf("                   %p\n", p2);

    printf("\n全局区-全局变量和静态变量\n");

    printf("\n.bss段\n");

    printf("全局外部无初值 uninit_global_a：%p\n", &uninit_global_a);

    printf("静态外部无初值 uninits_global_b：%p\n", &uninits_global_b);

    printf("静态内部无初值 uninits_local_c：%p\n", &uninits_local_c);

    printf("\n.data段\n");

    printf("全局外部有初值 init_global_a：%p\n", &init_global_a);

    printf("静态外部有初值 inits_global_b：%p\n", &inits_global_b);

    printf("静态内部有初值 inits_local_c：%p\n", &inits_local_c);

    printf("\n文字常量区\n");

    printf("文字常量地址     ：%p\n",var1);

    printf("文字常量地址     ：%p\n",var2);

    printf("\n代码区\n");

    printf("程序区地址       ：%p\n",&main);

    printf("函数地址         ：%p\n",&output);

    return 0;

}

使用gedit text.c命令创建text.c程序编译输出

STM32中代码演示在栈区和堆区的地址值是从上往下的在减小与Ubuntu下刚好相反。

实验总结

C程序编译的可执行程序体积比nasm大出许多。

C文件生成可执行文件，会经过预处理，编译阶段编译成汇编指令，再经过汇编阶段变成二进制文件，之后再链接阶段，形成可运行文件。