中文手册

常用的Shell命令

本手册页内容摘自 GNU C 编写翻译器的完全文书档案,只限于解释选项的含义.
风流浪漫旦开采手册页和Info 文件之间有着反感,请核对 Info 文件(权威文档卡塔尔(قطر‎

GCC编译器

当顾客登入到字符界面系统或选择极限模拟窗口时,正是在和称为shell的指令解释程序进行通讯。当客户在键盘上输入一条命令时,shell程序将对命令举办解释并完毕相应的动作。这种动作恐怕是进行客户的应用程序,或许是调用贰个编辑器、GNU/Linux实用程序或其余规范程序,大概是一条错误音讯,告诉客商输入了错误的授命。

GCC

gcc GNU 工程的 C 编译器
g++ GNU 工程的 C++编译器

gcc[option|filename ]…
g++[option|filename ]…

GCC(GNU Compiler
Collection)是生龙活虎套功效强盛、质量优质的编制程序语言编写翻译器,它是GNU布署的代表作品之豆蔻年华。GCC是Linux平台下最常用的编写翻译器,GCC原名叫GNU
C Compiler,即GNU C语言编写翻译器,它是GNU项目中相符ANSI
C规范的编写翻译系统,能够编写翻译用C、C++和Object
C等语言编写的程序。GCC不唯有作用十二分强盛,构造也不行灵活。它的称呼也渐渐渐形成为了GNU
Compiler Collection。

1.索引操作

描述(DESCRIPTION)

C 和 C++编写翻译器是合二为生龙活虎的
都要用4个步骤中的八个或多个管理输入文件:
预处理 (preprocessing)      cpp -Egcc -E
编译(compilation)        cc1 -Sgcc -S
汇编(assembly)          as
链接(linking)          ld

GCC是GNU项目标编写翻译器组件之黄金年代,也是GNU最具备代表性的小说。在GCC设计之初仅仅看做一个C语言的编译器,然则经过十多年的上进,GCC已经不止能扶持C语言;它以往还协助Ada语言、C++语言、Java语言、Objective
C语言,帕斯Carl语言、COBOL语言,以至援救函数式编制程序和逻辑编制程序的Mercury语言等等。而GCC也不再单是GNU
C Compiler,而是GNU Compiler
Collection也即GNU编译器亲族,如今早已改为Linux下最要紧的编写翻译工具之后生可畏。

mkdir  abc          成立叁个索引abc

源文件后缀名标记源文件的语言,不过对编写翻译器来讲,后缀名调节着缺省设置:
  • gcc 以为预管理后的文本(.i卡塔尔国是 C 文件,何况设定 C 方式的连接.

  • g++ 感觉预管理后的文本(.i卡塔尔国是 C++文件,况兼设定 C++形式的连接.

GCC的编译流程分为八个步骤:

cd   abc            将专门的学业目录改造到abc

源文件后缀名提议语言连串甚至早先时期的操作:

.c       C源程序        预处理,编译,汇编
.C      C++源程序       预处理,编译,汇编
.cc      C++源程序       预处理,编译,汇编
.cxx      C++源程序       预处理,编译,汇编
.m       Objective-C源程序   预处理,编译,汇编
.i       预管理后的C文件     编写翻译,汇编
.ii      预管理后的C++文件   编写翻译,汇编
.s      汇编语言源程序     汇编
.S      汇编语言源程序     预管理,汇编
.h      预微电脑文件      日常不出今后指令行上

◆ 预处理(Pre-Processing) cpp

cd                  退换当前目录到主目录

其余后缀名的文件被传送给连接器(linker卡塔尔(英语:State of Qatar).经常包蕴:

.o     指标文件(Object file卡塔尔(قطر‎
.a     归档库文件(Archive file卡塔尔

除非接纳了-c, -S,或-E
选项(恐怕编写翻译错误阻止了全体的进度卡塔尔,不然连接总是最终的步骤.
在连年阶段中,全部对应于源程序的.o 文件, -l
库文件,不或然识其余文件名(满含钦赐的 .o 目 标文件和.a
库文件卡塔尔(قطر‎按命令行中的顺序传递给连接器.

◆ 编译(Compiling)            cc1

ls                  列出当前目录的剧情

例子

hello.c源代码:

#include<stdio.h>  

int main()  
{  
      printf("Hello! This is our embedded world!n");  

      return 0;  
}  

(1)预管理阶段
预管理阶段 首要管理#include和#define

  • #include编译器把#include.h文件 包蕴到源代码中
  • #define概念的 源代码中其实使用到的 宏 用实际的字符串代替

预管理阶段 可领略为简易的文件相加/替换:
hello.c + .h文件源码 替换宏定义define —> hello.i

◆ 汇编(Assembling)          as

ls  -l              输出当前目录内容的长列表,每种目录或文件占风华正茂行

gcc命令的相似格式

gcc [选项] 要编译的文件 [选项] [目标文件]
( -o 参数省略时,Gcc默许生成可举行的文件:编写翻译文件.out )

例子
Gcc –E hello.c –o hello.i
gcc -E 代表只实行预管理(不进行末端的3个等级卡塔尔国
-o 指指标文件(gcc输出的文件)
.i 文件为早已过预管理的C原始程序 hello.i的内容如下:

# 1 "hello.c"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 330 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "hello.c" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 64 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 587 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_symbol_aliasing.h" 1 3 4
# 588 "/usr/include/sys/cdefs.h" 2 3 4
# 653 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_posix_availability.h" 1 3 4
# 654 "/usr/include/sys/cdefs.h" 2 3 4
# 65 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/Availability.h" 1 3 4
# 184 "/usr/include/Availability.h" 3 4
# 1 "/usr/include/AvailabilityInternal.h" 1 3 4
# 185 "/usr/include/Availability.h" 2 3 4
# 66 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/_types.h" 1 3 4
# 27 "/usr/include/_types.h" 3 4
# 1 "/usr/include/sys/_types.h" 1 3 4
# 33 "/usr/include/sys/_types.h" 3 4
# 1 "/usr/include/machine/_types.h" 1 3 4
# 32 "/usr/include/machine/_types.h" 3 4
# 1 "/usr/include/i386/_types.h" 1 3 4
# 37 "/usr/include/i386/_types.h" 3 4
typedef signed char __int8_t;



typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;

typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
# 70 "/usr/include/i386/_types.h" 3 4
typedef int __darwin_ct_rune_t;





typedef union {
 char __mbstate8[128];
 long long _mbstateL;
} __mbstate_t;

typedef __mbstate_t __darwin_mbstate_t;


typedef long int __darwin_ptrdiff_t;







typedef long unsigned int __darwin_size_t;





typedef __builtin_va_list __darwin_va_list;





typedef int __darwin_wchar_t;




typedef __darwin_wchar_t __darwin_rune_t;


typedef int __darwin_wint_t;




typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
# 33 "/usr/include/machine/_types.h" 2 3 4
# 34 "/usr/include/sys/_types.h" 2 3 4
# 55 "/usr/include/sys/_types.h" 3 4
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;

typedef __darwin_ino64_t __darwin_ino_t;



typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
typedef char __darwin_uuid_string_t[37];


# 1 "/usr/include/sys/_pthread/_pthread_types.h" 1 3 4
# 57 "/usr/include/sys/_pthread/_pthread_types.h" 3 4
struct __darwin_pthread_handler_rec {
 void (*__routine)(void *);
 void *__arg;
 struct __darwin_pthread_handler_rec *__next;
};

struct _opaque_pthread_attr_t {
 long __sig;
 char __opaque[56];
};

struct _opaque_pthread_cond_t {
 long __sig;
 char __opaque[40];
};

struct _opaque_pthread_condattr_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_mutex_t {
 long __sig;
 char __opaque[56];
};

struct _opaque_pthread_mutexattr_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_once_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_rwlock_t {
 long __sig;
 char __opaque[192];
};

struct _opaque_pthread_rwlockattr_t {
 long __sig;
 char __opaque[16];
};

struct _opaque_pthread_t {
 long __sig;
 struct __darwin_pthread_handler_rec *__cleanup_stack;
 char __opaque[8176];
};

typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t __darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t __darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t *__darwin_pthread_t;
# 81 "/usr/include/sys/_types.h" 2 3 4
# 28 "/usr/include/_types.h" 2 3 4
# 39 "/usr/include/_types.h" 3 4
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;

typedef __uint32_t __darwin_wctype_t;
# 68 "/usr/include/stdio.h" 2 3 4



# 1 "/usr/include/sys/_types/_va_list.h" 1 3 4
# 31 "/usr/include/sys/_types/_va_list.h" 3 4
typedef __darwin_va_list va_list;
# 72 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_size_t.h" 3 4
typedef __darwin_size_t size_t;
# 73 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/sys/_types/_null.h" 1 3 4
# 74 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/sys/stdio.h" 1 3 4
# 39 "/usr/include/sys/stdio.h" 3 4
int renameat(int, const char *, int, const char *) __attribute__((availability(macosx,introduced=10.10)));






int renamex_np(const char *, const char *, unsigned int) __attribute__((availability(macosx,introduced=10.12))) __attribute__((availability(ios,introduced=10.0))) __attribute__((availability(tvos,introduced=10.0))) __attribute__((availability(watchos,introduced=3.0)));
int renameatx_np(int, const char *, int, const char *, unsigned int) __attribute__((availability(macosx,introduced=10.12))) __attribute__((availability(ios,introduced=10.0))) __attribute__((availability(tvos,introduced=10.0))) __attribute__((availability(watchos,introduced=3.0)));
# 76 "/usr/include/stdio.h" 2 3 4

typedef __darwin_off_t fpos_t;
# 88 "/usr/include/stdio.h" 3 4
struct __sbuf {
 unsigned char *_base;
 int _size;
};


struct __sFILEX;
# 122 "/usr/include/stdio.h" 3 4
typedef struct __sFILE {
 unsigned char *_p;
 int _r;
 int _w;
 short _flags;
 short _file;
 struct __sbuf _bf;
 int _lbfsize;


 void *_cookie;
 int (* _Nullable _close)(void *);
 int (* _Nullable _read) (void *, char *, int);
 fpos_t (* _Nullable _seek) (void *, fpos_t, int);
 int (* _Nullable _write)(void *, const char *, int);


 struct __sbuf _ub;
 struct __sFILEX *_extra;
 int _ur;


 unsigned char _ubuf[3];
 unsigned char _nbuf[1];


 struct __sbuf _lb;


 int _blksize;
 fpos_t _offset;
} FILE;


extern FILE *__stdinp;
extern FILE *__stdoutp;
extern FILE *__stderrp;
# 231 "/usr/include/stdio.h" 3 4
void clearerr(FILE *);
int fclose(FILE *);
int feof(FILE *);
int ferror(FILE *);
int fflush(FILE *);
int fgetc(FILE *);
int fgetpos(FILE * restrict, fpos_t *);
char *fgets(char * restrict, int, FILE *);



FILE *fopen(const char * restrict __filename, const char * restrict __mode) __asm("_" "fopen" );

int fprintf(FILE * restrict, const char * restrict, ...) __attribute__((__format__ (__printf__, 2, 3)));
int fputc(int, FILE *);
int fputs(const char * restrict, FILE * restrict) __asm("_" "fputs" );
size_t fread(void * restrict __ptr, size_t __size, size_t __nitems, FILE * restrict __stream);
FILE *freopen(const char * restrict, const char * restrict,
                 FILE * restrict) __asm("_" "freopen" );
int fscanf(FILE * restrict, const char * restrict, ...) __attribute__((__format__ (__scanf__, 2, 3)));
int fseek(FILE *, long, int);
int fsetpos(FILE *, const fpos_t *);
long ftell(FILE *);
size_t fwrite(const void * restrict __ptr, size_t __size, size_t __nitems, FILE * restrict __stream) __asm("_" "fwrite" );
int getc(FILE *);
int getchar(void);
char *gets(char *);
void perror(const char *);
int printf(const char * restrict, ...) __attribute__((__format__ (__printf__, 1, 2)));
int putc(int, FILE *);
int putchar(int);
int puts(const char *);
int remove(const char *);
int rename (const char *__old, const char *__new);
void rewind(FILE *);
int scanf(const char * restrict, ...) __attribute__((__format__ (__scanf__, 1, 2)));
void setbuf(FILE * restrict, char * restrict);
int setvbuf(FILE * restrict, char * restrict, int, size_t);
int sprintf(char * restrict, const char * restrict, ...) __attribute__((__format__ (__printf__, 2, 3))) __attribute__((__availability__(swift, unavailable, message="Use snprintf instead.")));
int sscanf(const char * restrict, const char * restrict, ...) __attribute__((__format__ (__scanf__, 2, 3)));
FILE *tmpfile(void);

__attribute__((__availability__(swift, unavailable, message="Use mkstemp(3) instead.")))

__attribute__((deprecated("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tmpnam(3), it is highly recommended that you use mkstemp(3) instead.")))

char *tmpnam(char *);
int ungetc(int, FILE *);
int vfprintf(FILE * restrict, const char * restrict, va_list) __attribute__((__format__ (__printf__, 2, 0)));
int vprintf(const char * restrict, va_list) __attribute__((__format__ (__printf__, 1, 0)));
int vsprintf(char * restrict, const char * restrict, va_list) __attribute__((__format__ (__printf__, 2, 0))) __attribute__((__availability__(swift, unavailable, message="Use vsnprintf instead.")));
# 297 "/usr/include/stdio.h" 3 4
char *ctermid(char *);





FILE *fdopen(int, const char *) __asm("_" "fdopen" );

int fileno(FILE *);
# 321 "/usr/include/stdio.h" 3 4
int pclose(FILE *) __attribute__((__availability__(swift, unavailable, message="Use posix_spawn APIs or NSTask instead.")));



FILE *popen(const char *, const char *) __asm("_" "popen" ) __attribute__((__availability__(swift, unavailable, message="Use posix_spawn APIs or NSTask instead.")));
# 342 "/usr/include/stdio.h" 3 4
int __srget(FILE *);
int __svfscanf(FILE *, const char *, va_list) __attribute__((__format__ (__scanf__, 2, 0)));
int __swbuf(int, FILE *);
# 353 "/usr/include/stdio.h" 3 4
inline __attribute__ ((__always_inline__)) int __sputc(int _c, FILE *_p) {
 if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != 'n'))
  return (*_p->_p++ = _c);
 else
  return (__swbuf(_c, _p));
}
# 379 "/usr/include/stdio.h" 3 4
void flockfile(FILE *);
int ftrylockfile(FILE *);
void funlockfile(FILE *);
int getc_unlocked(FILE *);
int getchar_unlocked(void);
int putc_unlocked(int, FILE *);
int putchar_unlocked(int);



int getw(FILE *);
int putw(int, FILE *);


__attribute__((__availability__(swift, unavailable, message="Use mkstemp(3) instead.")))

__attribute__((deprecated("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tempnam(3), it is highly recommended that you use mkstemp(3) instead.")))

char *tempnam(const char *__dir, const char *__prefix) __asm("_" "tempnam" );
# 417 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/sys/_types/_off_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_off_t.h" 3 4
typedef __darwin_off_t off_t;
# 418 "/usr/include/stdio.h" 2 3 4


int fseeko(FILE * __stream, off_t __offset, int __whence);
off_t ftello(FILE * __stream);





int snprintf(char * restrict __str, size_t __size, const char * restrict __format, ...) __attribute__((__format__ (__printf__, 3, 4)));
int vfscanf(FILE * restrict __stream, const char * restrict __format, va_list) __attribute__((__format__ (__scanf__, 2, 0)));
int vscanf(const char * restrict __format, va_list) __attribute__((__format__ (__scanf__, 1, 0)));
int vsnprintf(char * restrict __str, size_t __size, const char * restrict __format, va_list) __attribute__((__format__ (__printf__, 3, 0)));
int vsscanf(const char * restrict __str, const char * restrict __format, va_list) __attribute__((__format__ (__scanf__, 2, 0)));
# 442 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/sys/_types/_ssize_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_ssize_t.h" 3 4
typedef __darwin_ssize_t ssize_t;
# 443 "/usr/include/stdio.h" 2 3 4


int dprintf(int, const char * restrict, ...) __attribute__((__format__ (__printf__, 2, 3))) __attribute__((availability(macosx,introduced=10.7)));
int vdprintf(int, const char * restrict, va_list) __attribute__((__format__ (__printf__, 2, 0))) __attribute__((availability(macosx,introduced=10.7)));
ssize_t getdelim(char ** restrict __linep, size_t * restrict __linecapp, int __delimiter, FILE * restrict __stream) __attribute__((availability(macosx,introduced=10.7)));
ssize_t getline(char ** restrict __linep, size_t * restrict __linecapp, FILE * restrict __stream) __attribute__((availability(macosx,introduced=10.7)));
# 458 "/usr/include/stdio.h" 3 4
extern const int sys_nerr;
extern const char *const sys_errlist[];

int asprintf(char ** restrict, const char * restrict, ...) __attribute__((__format__ (__printf__, 2, 3)));
char *ctermid_r(char *);
char *fgetln(FILE *, size_t *);
const char *fmtcheck(const char *, const char *);
int fpurge(FILE *);
void setbuffer(FILE *, char *, int);
int setlinebuf(FILE *);
int vasprintf(char ** restrict, const char * restrict, va_list) __attribute__((__format__ (__printf__, 2, 0)));
FILE *zopen(const char *, const char *, int);





FILE *funopen(const void *,
                 int (* _Nullable)(void *, char *, int),
                 int (* _Nullable)(void *, const char *, int),
                 fpos_t (* _Nullable)(void *, fpos_t, int),
                 int (* _Nullable)(void *));
# 498 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/secure/_stdio.h" 1 3 4
# 31 "/usr/include/secure/_stdio.h" 3 4
# 1 "/usr/include/secure/_common.h" 1 3 4
# 32 "/usr/include/secure/_stdio.h" 2 3 4
# 42 "/usr/include/secure/_stdio.h" 3 4
extern int __sprintf_chk (char * restrict, int, size_t,
     const char * restrict, ...);
# 52 "/usr/include/secure/_stdio.h" 3 4
extern int __snprintf_chk (char * restrict, size_t, int, size_t,
      const char * restrict, ...);







extern int __vsprintf_chk (char * restrict, int, size_t,
      const char * restrict, va_list);







extern int __vsnprintf_chk (char * restrict, size_t, int, size_t,
       const char * restrict, va_list);
# 499 "/usr/include/stdio.h" 2 3 4
# 2 "hello.c" 2

int main()
{
      printf("Hello! This is our embedded world!n");

      return 0;
}

◆ 链接(Linking)                ld

pwd                 展现当前目录的全路线

(2)编写翻译阶段(最要紧的等第卡塔尔(قطر‎

可接受.c和.i类型的公文 —> .s文件

gcc -S hello.i -o hello.s
gcc -S只进行编写翻译(而不开展汇编,生成汇编代码卡塔尔

编译阶段gcc首先要检查代码的标准性、是或不是有语法错误等,以鲜明代码的骨子里要做的劳作。

反省正确后gcc把代码翻译成汇编语言 *.i编译成*.s文件

hello.s 内容如下:

    .section    __TEXT,__text,regular,pure_instructions
    .macosx_version_min 10, 12
    .globl  _main
    .align  4, 0x90
_main:                                  ## @main
    .cfi_startproc
## BB#0:
    pushq   %rbp
Ltmp0:
    .cfi_def_cfa_offset 16
Ltmp1:
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
Ltmp2:
    .cfi_def_cfa_register %rbp
    subq    $16, %rsp
    leaq    L_.str(%rip), %rdi
    movl    $0, -4(%rbp)
    movb    $0, %al
    callq   _printf
    xorl    %ecx, %ecx
    movl    %eax, -8(%rbp)          ## 4-byte Spill
    movl    %ecx, %eax
    addq    $16, %rsp
    popq    %rbp
    retq
    .cfi_endproc

    .section    __TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
    .asciz  "Hello! This is our embedded world!n"


.subsections_via_symbols

GCC是多少个陆续平台的编写翻译器,如今支撑大致全数主流CPU微处理器平台,它能够产生从C、C++、Objective
C等源文件向运营在一定cpu硬件上的靶子代码的更动,GCC不止成效特别强大,布局也丰裕灵活,便携性(protable)与跨平台扶植(cross-plantform.
support)性格是GCC的明显优点。

2.文件展现实用程序

(2)编写翻译阶段(最根本的等级卡塔尔(قطر‎

可接纳.c和.i类型的公文 —> .s文件

gcc -S hello.i -o hello.s
gcc -S只进行编写翻译(而不举行汇编,生成汇编代码卡塔尔

编写翻译阶段gcc首先要检查代码的规范性、是不是有语法错误等,以分明代码的实在要做的行事。

反省精确后gcc把代码翻译成汇编语言 *.i编译成*.s文件

hello.s 内容如下:

    .section    __TEXT,__text,regular,pure_instructions
    .macosx_version_min 10, 12
    .globl  _main
    .align  4, 0x90
_main:                                  ## @main
    .cfi_startproc
## BB#0:
    pushq   %rbp
Ltmp0:
    .cfi_def_cfa_offset 16
Ltmp1:
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
Ltmp2:
    .cfi_def_cfa_register %rbp
    subq    $16, %rsp
    leaq    L_.str(%rip), %rdi
    movl    $0, -4(%rbp)
    movb    $0, %al
    callq   _printf
    xorl    %ecx, %ecx
    movl    %eax, -8(%rbp)          ## 4-byte Spill
    movl    %ecx, %eax
    addq    $16, %rsp
    popq    %rbp
    retq
    .cfi_endproc

    .section    __TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
    .asciz  "Hello! This is our embedded world!n"


.subsections_via_symbols
扩展名 对应语言 编译流程
.c C源程序 预处理、编译、汇编
.C/.cc/.cxx C++源程序 预处理、编译、汇编
.m Objective-C源程序 预处理、编译、汇编
.i 经过预处理的C源程序 编译、汇编
.ii 经过预处理的C++源程序 编译、汇编
.s/.S 汇编语言源程序 汇编
.h 预处理文件(头文件) 预处理
.o 目标文件 链接
.a/.so 静态/动态库文件 链接

cat  mx.c            展现mx.c文件内容

(3)汇编阶段

汇编阶段可抽取 .c .i .s 类型的文件 —> .o文件

把 .s文件 翻译成 二进制机器指令 .o文件:
gcc -c hello.s -o hello.o

-c告诉gcc实行汇编管理。
那步生成的文书是二进制文件,用文件工具张开看见的将是“乱码”,使用反汇编工具(如GDB)才具读懂它。

 

more  mx.c           分屏突显mx.c内容

(4)链接阶段

链接阶段。
在那间提到到三个主要的定义:函数库。

链接的效能
事例的源码中并不曾定义”printf”的函数达成,且预编写翻译中包含进的”stdio.h”中也唯有该函数的宣示,而从未定义函数的兑现。
那就是说哪里实现了”printf”函数?动态库文件libc.so.6
系统把那几个函数完毕都完毕名叫libc.so.6的库文件中,在一向不特意钦定期,Gcc会到系统私下认可的查究路线”/usr/lib”下进展查找,链接到libc.so.6库函数中就能够促成函数”printf”

函数库日常分为静态库和动态库三种。Gcc在编写翻译时默许使用动态库

静态库:指编写翻译链接时,把库文件的代码方方面面步入到可实行文件中,运转时也就不再必要库文件,由此生成的文件一点都相当的大。
后缀名日常为”.a”

动态库:编写翻译链接时并未有把库文件的代码插手到可推行文件中,而是在程序实践时由运转时链接文件加载库,节省系统的付出。
动态库经常后缀名称为”.so”
如前方所述的libc.so.6正是动态库。

改动静态库:
·ar cr libxxx.a file1.o file2.o
把file1.o和file2.o打包 生成libxxx.a静态库

变迁动态库:
gcc -fPIC -shared file1.c -o libtest.so
也得以分为两部来写:
gcc -fPIC file1.c -c //这一步生成file1.o
gcc -shared file1.o -o libtest.so

使用
gcc test.c -L/path -libxxx -o test

成效是相符的。
动用动态库,运路程序时要钦命动态库的职分,
用场境变量来钦命export LD_LIBRARY_PATH=path
要不会提醒找不到动态库的职分

链接动态库/静态库 使用的方法是如出豆蔻梢头辙的,
风度翩翩旦在库中有同名的静态库文件和动态库文件,如libtest.a和libtest.so
gcc链接时暗中同意优先选项动态库 即 链接libtest.so
强迫gcc链接静态库文件(如libtest.a):加选项-static

静态库链接时找寻路径顺序:

  1. ld会去找GCC命令中的参数-L
  2. 再找gcc的条件变量LIBRA奇骏Y_PATH
  3. 再找内定目录 /lib /usr/lib /usr/local/lib 那是当年compile
    gcc时写在程序内的
    动态链接时、实践时追寻路线顺序:
  4. 编写翻译指标代码时钦命的动态库搜索路径
  5. 条件变量LD_LIBRARY_PATH钦点的动态库寻找路线
  6. 安插文件/etc/ld.so.conf中内定的动态库寻觅路线
  7. 暗许的动态库寻找路线/lib
  8. 默许的动态库找出路线/usr/lib

至于境况变量:
LIBRARY_PATH情形变量:钦点程序静态链接库文件寻觅路线
LD_LIBRARY_PATH情形变量:内定程序动态链接库文件搜索路线

形成了链接之后,Gcc就能够改动可实施文件,如下所示。
gcc hello.o -o hello

运维该可试行文件,现身不利的结果如下。
./hello

Hello! This is our embedded world!

GCC是风华正茂组编写翻译工具的总称,其软件包里带有众多的工具,按其连串,主要有以下的归类。

tail  mx.c           展现文件后几行

选项(OPTIONS)

分选必需分立给出: -dr 完全差异于-d -r

  C编译器cc,gcc

cat  file1  file2    连接file1 和file2

  C++编译器c++,g++

head  filename       显示文件filename的上马10行

  源代码预管理程序cpp

wc  filename         计算文件filename中的行数、单词数和字符数

  库文件libgcc.a,libgcc_eh.a,libgcc_s.so,libiberty.a,libstdc++.[a,so],libsupc++.a

od  文件             查看非文本文件

编写翻译器通进程序的恢宏名来识别编写源程序所运用的语言,由于不一致程序所急需实行的编写翻译步骤是见仁见智的,由此依照分歧的扩展名展开对应的管理。

3.文本管理实用程序

gcc首先调用cpp举行预管理,在预管理进程中,对源代码文件中的文件富含(include卡塔尔国、预编写翻译语句(如宏定义define等卡塔尔实行剖判。接着调用cc1进行编写翻译,那些阶段根据输入文件生成以.o为后缀的靶子文件。汇编进度是本着汇编语言的步调,调用as进行职业,日常来说,.S为后缀的汇编语言源代码文件和汇编、.s为后缀的汇编语言文件通过预编写翻译和汇编之后都生成以.o为后缀的指标文件。当全数的靶子文件都转移之后,gcc就调用ld来完毕最终的本位专门的工作,那么些品级便是三翻五次。在连年阶段,全部的靶子文件被布置在可执路程序中的伏贴的岗位,同一时候,该程序所调用到的库函数也从各自所在的档案库中连到合适的地点。

cp  file1  file2     将文件1复制到文件2

常用编译选项

mv  file1  file2     将文件重命名称为file2

  • l
    -c选项:那是GCC命令的常用选项。-c选项报告GCC仅把源程序编写翻译为对象代码而不做链接专门的学业,所以利用该选用的编写翻译指令不会变卦最后的可执路程序,而是转换贰个与源程序文件名相符的以.o为后缀的指标文件。举个例子三个Test.c的源程序经过下边的编写翻译之后会生成多个Test.o文件
  • l -E选项:预管理后即停止,不举办编写翻译、汇编及连接
    l
    -S选项:使用该选项会生成叁个后缀名字为.s的汇编语言文件,可是相仿不会扭转可执路程序。
  • l
    -e选项:-e选项只对文本实行预管理,预管理的出口结果被送到正规输出(比方荧屏)。
  • l -v选项:在Shell的晋升标识下键入gcc
    -v,显示器上就能够显示出当下正值利用的gcc版本的音讯
  • l -x language:强逼编写翻译器钦定的语言编写翻译器来编译有个别源程序。
  • l -o选项: 钦命输出文件file

rm  filename         删除文件filename

 这里有生机勃勃段轻巧的C语言程序,该程序由三个公文组成,此中“hello.h”为头文件,在“hello.c”中包涵了“hello.h”,其源文件如下所示。

rm  -i  filename     恳求客户确认删除

/* hello.h */

4.数额操作实用程序

#ifndef_HELLO_H_

    tty                  展现当前极端的路子和文件名

#define_HELLO_H_

    who                  突显当前登陆顾客的列表

typedef unsigned long val32_t;

    sort  filename       呈现文件filename中的行的排序结果

#endif

    spell  filename      检查文件filename中的拼写错误

/* hello.c */

5.别样实用程序

#include <stdio.h>

    date                 输出系统日期和岁月

#include <stdlib.h>

    cal                  呈现本月的日历。cal 2000 展现二〇〇一年的日历

#include “hello.h”

    clear                清除终端屏幕

int main(int argc, char *argv[])

    history              呈现你在此之前试行过的吩咐的列表

{

    man
                 展现实用程序的有用音信,并提供该实用程序的中央用法

         val32_t I = 5;

    echo                 读取参数并把它写到输出

         printf(“hello,embedded world%dn”, i);

4、熟悉gcc编译器

}

GNU/Linux中日常使用的C编写翻译器是GNU gcc。编写翻译器把源程序编写翻译生成靶子代码的天职责为以下4步:

A.         预管理阶段

a. 预管理,把预管理命令扫描管理完成;

GCC的选项“-E”能够使编写翻译器在预管理实现时就终止编写翻译,选项“-o”是内定GCC输出的结果

b. 编译,把预管理后的结果编写翻译成汇编恐怕指标模块;

#gcc –E –o [指标文件] [编译文件]

c. 汇编,把编译出来的结果汇编成具体CPU上的靶子代码模块;

后缀名称为“.i”的公文是通过预管理的C原始程序。要小心,“hello.h”文件是不能够开展编写翻译的,因而,使编写翻译器在预管理后停下的指令

d. 连接,把八个对象代码模块连接生成八个大的对象模块;

#gcc –E –o hello.i hello.c

1.行使语法:

在这里处,选项‘-o’是指指标文件,而‘.i’文件为曾经过预管理的C原始程序。以下列出了hello.i文件的有的内容。

  gcc [ option | filename
]…

#2″hello.c”2

  当中 option 为 gcc
使用时的选项,而 filename
为 gcc要拍卖的文本。 

#1″hello.h”1

2.GCC选项

typedef unsigned long val32_t;

    GCC的选项有超级多类,那类选项决定着GCC程序的周转,以高达一定的编译指标。

#3″hello.c”2

⑴全局选项(OVERALL OPTIONS卡塔尔国

int main()

   
全局按键用来调整在“GCC成效介绍”中的GCC的4个步骤的运作,在缺省的状态下,那4个步骤都以要施行的,可是当给定一些大局开关后,那几个步骤就能在
某一步甘休施行,那发生中间结果,比方恐怕你只是须求中间生成的预管理的结果大概是汇编文件(例如你的指标是为着看有个别CPU上的汇编语言怎么写卡塔尔。

{

①  –x  language 

val32_t i=5;

   
对于源文件是用什么样语言编写的,能够因而文件名的后缀来标示,也能够用那开关。钦点输入文件是怎么语言编写的,language
能够是之类的内容

printf(“hello,embedded world%dn”,i);

a.  c

}

b. objective-c

        
一句话来说,GCC确实举行了预管理,它把“hello.h”的原委插入到hello.i文件中了。

c. c-header

B.         编写翻译阶段

d. c++

编写翻译器在预管理终结之后,就进去编写翻译阶段,GCC在编写翻译阶段首先要检查代码的标准性、是还是不是有语法错误等,以分明代码的实在要做的行事,在自小编研讨精确后,就开端把代码翻译成汇编语言,GCC的选项“-S”能使编写翻译器在开展完汇编以前就止住。“.s”是汇编语言原始程序,因而,此处的对象文件就可设为“.s”类型。

e.cpp-output

以下列出了hello.s的剧情,可知GCC已经将其转会为汇编了。

f.assembler

#gcc –S –o hello.s hello.i

g.assembler-with-cpp

.file”hello.c”

②–x none 

.section.rodata

把-x开关都给关掉了。

.LC0:

③  –c 

.string”hello,embedded world%dn”

编写翻译成把源文件目的代码,不做连接的动作。

.text

④–S 

.globl main

把源文件编写翻译成汇编代码,不做汇编和连接的动作。

.type main,@function

⑤–E 

main:

只把源文件进行预管理今后的结果输出来。不做编写翻译,汇编,连接的动作。

pushl%ebp

⑥ –o file (常用)

movl%esp,%ebp

指明输出文件名是file。

subl$8,%esp

⑦–v 

andl$-16,%esp

把一切编写翻译进度的输出音讯都给打字与印刷出来。

movl$0,%eax

⑧–pipe 

addl$15,%eax

是因为gcc的办事分为好几步才成就,所以要求在进度中生成一时文件,使用-pipe就是用管道替换不经常文件。

addl$15,%eax

⑵ 语言相关选项(Language Options卡塔尔

shrl$4,%eax

用来管理和言语相关的选项。

sall$4,%eax

①–ansi 

subl%eax,%esp

    这么些开关让GCC编写翻译器把持有的GNU的编写翻译器特性都给关掉,让您的前后相继能够和ansi标准极度。

movl$5,-4(%ebp)

②–include file 

subl$8,%esp

   
在编写翻译此前,把file满含进去,约等于在具备编写翻译的源文件最前面插手了贰个#include
<file>语句,

pushl-4(%ebp)

③–C 

pushl$.LC0

    同-E参数协作使用。让预管理后的结果,把注释保留,令人可以比较好读它。

call printf

⑶连接按钮(Linker Options卡塔尔(英语:State of Qatar)

addl$16,%esp

    用来决定连接进程的开关选项。

leave

① –llibrary 

ret

    连接库文件按钮。比方-lugl,则是把程序同libugl.a文件进行连接。

.size main,.-main

② –lobjc 

.section.note.GNU-stack,””,@progbits

    那些开关用在面向对象的C语言文件的库文件管理中。

..ident”GCC:(GNU)4.0.0 20050519(Red Hat 4.0.0-8)”

③ –nostartfiles 

        
这一小段C语言的次第在汇编中曾经复杂比较多了,那也是C语言作为高档语言的优势所在

    在接连的时候不把系统相关的起步代码连接进来。

C.         汇编阶段

④ –nostdlib 

汇编阶段是把编写翻译阶段生成的“.s”文件生成目的文件,使用接纳“-c”就可看见汇编代码已转向为“.o”的二进制指标代码了。

    在一而再再三再四的时候不把系统有关的起步文件和体系相关的库连接进来。

# gcc –c hello.s –o hello.o

⑤–static 

D.         链接阶段

    在有个别类别上支撑动态连接,这么些开关则分歧意动态连接。

在中标编写翻译之后,就步入了链接阶段。将转换的指标文件与此外目的文件(或库文件)连接成可实行的二进制代码文件

⑥shared 

静态链接:将所急需的函数库中的目标代码静态增添到可试行文件中

    生成可分享的被其余程序连接的目的模块。  

动态链接:将所需函数库的函数名,路线消息等丰富到可实行文件中,施行进程中动态加载所需函数库

⑷目录相关开关(Directory Options卡塔尔

在那处提到一个器重的定义:函数库。

    用于定义与目录操作相关的开关。

主题素材:在这里个顺序中并不曾定义“printf”的函数完结,在预编写翻译中带有进的“stdio.h”中也独有该函数的宣示,而未有定义函数的贯彻,那么,是在哪里完毕“printf”函数的吗?

–Ldir

答案:

    搜寻库文件(*.a)的路径。  

系统把这么些函数完成都已被放入名叫libc.so.6的库文件中去了,在未曾特地指准时,GCC会到系统暗中同意的探求路线“/usr/lib”下张开检索,也正是链接到libc.so.6库函数中去,这样就会落成函数“printf”了,而那也等于链接的功能。

⑸调节和测验按钮(Debugging Options卡塔尔(قطر‎

         完毕了链接之后,GCC就能够转移可履行文件

–g

# gcc hello.o –o hello

    把调节和测验开关展开,让编写翻译的目的文件有调节和测验消息。

运转该可施行文件,现身不利的结果

–V version

# ./hello

用来报告编写翻译器使用它的有个别版本的功能,version参数用来代表版本。

hello,embedded world 5

5、通晓Linux下C程序编写制定运营进度

 

Linux下编写C程序要通过以下多少个步骤:

       
-static选项:GCC在暗许情形下链接的是动态库,一时为了把有个别函数静态编写翻译到程序中,而无需链接动态库就接收-static选项,它会强逼造进度序连接静态库
       
-g,发生符号调节和测验工具(GNU的gdb卡塔尔所必须的符号资源音信,要想对源代码进行调治将养,我们就非得步入那么些选项。
       
-O,对前后相继开展优化编写翻译、连接,选用这一个选项,整个源代码会在编写翻译、连接进度中展开优化管理,那样爆发的可试行文件的实施功用能够抓牢,但是,编写翻译、连接的快慢就相应地要慢一些。
        -O2,比-O更好的优化编写翻译、连接,当然整个编写翻译、连接进度会更加慢。
       
-Idirname,将dirname所提出的目录参预到程序头文件目录列表中,是在预编写翻译进度中选用的参数。

⑴运营常用的编辑器,键入C源程序代码。

C程序的文件包蕴二种情景∶
        A)#include <stdio.h>
        B)#include “myinc.h”
        当中,A类使用尖括号(<>卡塔尔(英语:State of Qatar),B类使用双引号(“
”卡塔尔(قطر‎。对于A类,预管理程序cpp在系统预设包罗文件目录(如/usr/include卡塔尔中找找相应的公文,而对此B类,cpp在当前目录中搜寻头文件,那么些选项的效果与利益是告诉cpp,如若在当前目录中从未找到须要的文书,就到钦点的dirname目录中去查究。在前后相继设计中,假诺大家要求的这种带有文件分别布满在区别的目录中,就要求各个使用-I选项给出寻找路线。
       
-Ldirname,将dirname所提出的目录参预到程序函数档案库文件的目录列表中,是在接连进程中运用的参数。在预设状态下,连接程序ld在系统的预设路径中(如/usr/lib卡塔尔国搜索所必要的档案库文件,这一个选项告诉连接程序,首先到-L钦定的目录中去寻觅,然后到系统预设路径中寻觅,固然函数库存放在多少个目录下,就要求各样使用这一个选项,给出相应的寄放目录。
       
-lname,在连年时,装载名称为“libname.a”的函数库,该函数库坐落于系统预设的目录可能由-L选项规定的目录下。例如,-lm表示连接名称叫“libm.a”的数学函数库。

例如,点击应用程序/附属类小零器件/文本编辑器,进入编辑景况,输入C源程序,保存并取名字为hello.c

 

# include <stdio.h>

扭转(函数)库文件:日常可大分为二种函数库文件
静态函数库与动态(分享)函数库

void main(void)

创立静态函数库进度:  gcc -c   example1.c -I(所需头文件所在目录卡塔尔(英语:State of Qatar) -o
example1.o

{

                                 gcc -c   example2.c
-I(所需头文件所在目录卡塔尔 -o example2.o

Printf(“Hello world!n”);

                                ar -rv libexample.a  example1.o
example2.o (创制静态函数库,将那八个目的文件增添至函数库中卡塔尔(قطر‎

}

                                ar -tv libexample.a      
(查看函数库汉语件)

⑵编写翻译源程序

 

点击应用程序/附属类小零部件/终端,步入命令行。用gcc编写翻译器对C源程序进行编写翻译,以生成四个可推行文件。方法:

 成立动态函数库进度:  gcc  -fPIC -c   example1.c -I(所需头文件所在目录卡塔尔-o example1.o 

gcc  -o  hello.out  hello.c ↙

                                 gcc  – fPIC -c   example2.c
-I(所需头文件所在目录卡塔尔国 -o example2.o

⑶运转可奉行文件

                             gcc -shared example1.o example2.o -o
libexample.so  (创制动态函数库,将那多少个目的文件加多至函数库中卡塔尔国

   ·/hello.out ↙

 

注:命令行中
-o选项表示供给编写翻译器输出可实践文件名称叫hello.out文件,hello.c是源程序文件。

静态链接函数库:      gcc   example.c -I(所需头文所在目录卡塔尔-L(所需函数库所在目录卡塔尔 -lexample(钦赐所需的函数库名) -o example

动态链接函数库: gcc   -s example.c -I(所需头文所在目录)-L(所需函数库所在目录卡塔尔国 -lexample(钦赐所需的函数库名) -o example

 

小心要钦赐LD_LIBRARY_PATH至函数库文件所在目录,才具健康使用函数库

 

GCC具有优化代码的效果,首要的优化增选富含如下:

-O0:不开展优化处理。
-O或-O1:进行基本的优化,线程跳转和延迟退栈等。这个优化在大部分气象下都会使程序奉行得更快。
-O2:除了完结-O1等级的优化外,还要一些附加的调解工作,如Computer指令调整等,那是GNU发布软件的暗中同意优化品级。
-O3:除了完毕-O2品级的优化外,还开展巡回的扩充以致其它界分与Computer本性相关的优化办事。
-Os:生成最小的可实践文件,重要用以在嵌入式领域。
 

诚如的话,优化等级越高,生成可实施文件的运转速度也越快,但消耗在编写翻译上的时辰就越长,因而在支付的时候最佳不用采纳优化增选,独有到软件发行或开拓截至的时候才构思对终极生成的代码实行优化。

-finline-functions:允许编写翻译器将部分简洁明了的函数在其调用途举行。
-funswitch-loops:将循环体中值不退换的变量移到循环体外。

         -g选项:生成调节和测量检验新闻,GNU调节和测量检验器能够应用该音信。GCC编译器使用该选项进行编写翻译时,将调节和测验信息参预到目的文件中,那样gdb调节和测量试验器就足以依赖那一个调节和测量检验新闻来跟中等射程序的实市价况。

         -pg选项:编写翻译完结后,额外发生贰特性子解析所需新闻。

瞩目:使用调节和测量试验选项都会使末段生成的二进制文件的抑扬顿挫能够扩展,相同的时间扩张程序在执行时的费用,因而调节和测量检验选项统常推荐仅仅在前后相继开拓和调节和测验阶段中应用。

 

发表评论