编译器代码的顺序

⑴ C语言文件的编译与执行的四个阶段并分别描述

开发C程序有四个步骤：编辑、编译、连接和运行。

任何一个体系结构处理器上都可以使用C语言程序，只要该体系结构处理器有相应的C语言编译器和库，那么C源代码就可以编译并连接到目标二进制文件上运行。

1、预处理：导入源程序并保存（C文件）。

2、编译：将源程序转换为目标文件（Obj文件）。

3、链接：将目标文件生成为可执行文件（EXE文件）。

4、运行：执行，获取运行结果的EXE文件。

(1)编译器代码的顺序扩展阅读：

将C语言代码分为程序的几个阶段：

1、首先，源代码文件测试。以及相关的头文件，比如stdio。H、由预处理器CPP预处理为．I文件。预编译的。文件不包含任何宏定义，因为所有宏都已展开，并且包含的文件已插入。我归档。

2、编译过程是对预处理文件进行词法分析、语法分析、语义分析和优化，生成相应的汇编代码文件。这个过程往往是整个程序的核心部分，也是最复杂的部分之一。

3、汇编程序不直接输出可执行文件，而是输出目标文件。汇编程序可以调用LD来生成可以运行的可执行程序。也就是说，您需要链接大量的文件才能获得“a.out”，即最终的可执行文件。

4、在链接过程中，需要重新调整其他目标文件中定义的函数调用指令，而其他目标文件中定义的变量也存在同样的问题。

⑵ 编译器生成的汇编语句执行顺序为什么与C代码顺序不同

不影响语义的前提下编译器可以任意重排代码顺序；
在乱序执行（Out-of-Order）的CPU里，机器码的执行也可以不按照你在“汇编”层面上看到的顺序执行，只要不影响语义。
所以说这些中间步骤的顺序，作为底层细节平时不需要那么在意——它们多半跟原始源码的顺序是不一样的。

现代优化编译器优化的思路之一是“基于依赖的优化”（dependence-based optimization）。题主引用的CSAPP的例子：

int arith(int x, int y, int z) {
int t1 = x + y;
int t2 = z * 48;
int t3 = t1 & 0xFFFF;
int t4 = t2 * t3;
return t4;
}

所有涉及运算的值都是局部标量变量（local scalar variable），这是最便于编译器做分析的情况，所有依赖都可以显式分析。
由于整个函数没有分支，这里也不需要讨论控制依赖（control dependence），只要讨论数据依赖（data dependence）就好。
把数据依赖图画出来是个DAG（这里正好是棵树，特例了）：

x y z 48
\ / \ /
t1 0xFFFF t2
\ / /
t3 /
\ /
t4

优化必须要满足的约束是：每个节点求值之前，其子节点（依赖的数据源）必须要先求了值。
显然，t1和t2之间没有依赖关系，它们的相对求值顺序怎样重排都没关系。

有本我很喜欢的书，里面讲的是各种基于依赖的优化：Optimizing Compilers for Modern Architectures - A Dependence-based Approach

以上是理论部分。

================================================================

下面来看例子。

我们可以用一个实际编译器来看看CSAPP的例子编译出来的结果：

.text
# -- Begin arith
.p2align 4,,15
.globl arith
.type arith, @function
arith:
.p2align 4,,7
/*.L0:*/ /* Block BB[54:2] preds: none, freq: 1.000 */
movl 8(%esp), %edx /* ia32_Load T[139:10] -:1:22 */
addl 4(%esp), %edx /* ia32_Add Iu[141:12] -:2:14 */
movzwl %dx, %edx /* ia32_Conv_I2I Iu[142:13] -:4:15 */
imull 12(%esp), %edx /* ia32_IMul Iu[143:14] -:5:15 */
leal (%edx,%edx,2), %eax /* ia32_Lea Iu[144:15] -:5:15 */
shll $0x4, %eax /* ia32_Shl Iu[146:17] -:5:15 */
ret /* ia32_Return X[152:23] -:6:3 */
.size arith, .-arith
# -- End arith

这里用的是libFirm。可见它跟CSAPP书里所说的汇编的顺序又有所不同。这也是完全合理的。
这个编译结果的顺序是：

edx = y;
edx += x;
edx = zeroextend dx; // edx = edx & 0xFFFF
edx *= z;
eax = edx * 3;
eax <<= 4; // eax = eax * 16

也是完全符合依赖关系的约束的一种顺序。
之所以用libFirm举例是因为它的中间表示（Intermediate Representation）是一种程序依赖图（Program Dependence Graph），可以很方便的看出控制与数据依赖。把CSAPP那里例子对应的libFirm IR画出来，是这个样子的：
（这张图跟我前面画的数据依赖图正好是左右翻转的，不过意思一样。（这张图跟我前面画的数据依赖图正好是左右翻转的，不过意思一样。
Arg 0、1、2分别代表x、y、z。白色方块是普通数据节点，黄色方块是常量节点，蓝色方块是内存相关节点，红色方块是控制流节点，粉红色方块是特殊的开始/结束节点。）

某版LLVM生成的代码：

; MoleID = '/tmp/webcompile/_16355_0.bc'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-ellcc-linux"

; Function Attrs: nounwind readnone
define i32 @arith(i32 %x, i32 %y, i32 %z) #0 {
entry:
%add = add nsw i32 %y, %x
%mul = mul nsw i32 %z, 48
%and = and i32 %add, 65535
%mul1 = mul nsw i32 %mul, %and
ret i32 %mul1
}

attributes #0 = { nounwind readnone "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }

!llvm.ident = !{!0}

!0 = !{!"ecc 0.1.10 based on clang version 3.7.0 (trunk) (based on LLVM 3.7.0svn)"}

最终生成的x86汇编：

.text
.file "/tmp/webcompile/_15964_0.c"
.globl arith
.align 16, 0x90
.type arith,@function
arith: # @arith
# BB#0: # %entry
movl 8(%esp), %eax
addl 4(%esp), %eax
movzwl %ax, %eax
imull 12(%esp), %eax
shll $4, %eax
leal (%eax,%eax,2), %eax
retl
.Ltmp0:
.size arith, .Ltmp0-arith

.ident "ecc 0.1.10 based on clang version 3.7.0 (trunk) (based on LLVM 3.7.0svn)"
.section ".note.GNU-stack","",@progbits

GCC 4.9.2 x86-64：

arith(int, int, int):
leal (%rdx,%rdx,2), %eax
addl %edi, %esi
movzwl %si, %esi
sall $4, %eax
imull %esi, %eax
ret

Zing VM Server Compiler x86-64：

# edi: x
# esi: y
# edx: z
movl %edx, %eax
shll $0x4, %eax
leal (%rsi, %rdi, 1), %ecx
shll $0x5, %edx
addl %edx, $eax
movzwl %ecx, %edx
imull %edx, %eax

⑶ stm32cubeide设置文件编译顺序

对一个加法函数的库项目的建立和编译整个过程如下：
1、这里就要选择ARMMCU的GCC编译器了。
2、选择和MCU型号的绑定关系了，毕竟编译的库是给MCU项目所用，这里选择STM32F401CCU6的芯片。
2、添加源文件编写加法函数，编写加法函数进行编译。
3、编译成功，在工程目录里就可以找到编译好的库文件了，库文件的调用，配置一个对应MCU的基本工程，建立一个STM32F401CCU6的工程，并配置USART2作为串口输出。
4、保存后产生基本工程代码，重载printf函数方便打印输出，参考STM32UART串口printf函数应用及浮点打印代码空间节省。
5、在工程的core/inc/目录新建一个和库文件同名的头文件，将库文件libLib_C_Demo.a放置到工程的源文件目录core/src/，则在工程目录树立可以看到。
6、因为编译器默认只是识别C语言源代码（.c文件），还需要进行库文件的指定，这样编译器才会对二进制库文件（.a）进行识别。
7、先打开属性菜单，进行库文件所在目录和库文件名的添加指定，注意库文件名前需要加冒号，ApplyandClose后，就可以在工程文件里对库文件进行调用，首先要引入库文件的头文件。
8、在while循环里进行打印输出，打印数据为库函数调用的加法和，编译下载到STM32F401CCU6芯片后运行，通过串口工具观察打印结果，输出打印结果正确，库函数正常调用成功。

⑷ c/c++中，编译器编译文件的顺序和规则

#include <filename>从磁盘安装根目录查找文件；#include "filename"从编译文件的当前目录查找文件。

⑸ C语言程序的运行顺序

1、这个涉及到函数的调用约定
运行结果跟编译器有一定的关系，不同的编译器参数的入栈的顺序不同
一般的编译器是从右到左
如fun(a,b)这个函数调用，是先计算参数b，入栈，再计算参数a，入栈
2、printf("%d
%d",
a++,++a);
//先计算++a，先自增，a的值变为2，将2入栈
再来计算a++，将a的值2入栈，再使a自增，a的值变为3
printf("
%d\n",a);
//a的值已经变为3了
3、printf(%d
%d",
++a.a++);//先计算a++，将a的值1入栈，再使a自增，a的值变为2，再来计算++a，先自增，a的值为3，将3入栈，输出3
1
printf("
%d\n",a);
//输出3
4、三种调用约定：
__stdcall调用约定。两者实质上是一致的，即函数的参数自右向左通过栈传递，被调用的函数在返回前清理传送参数的内存栈，但不同的是函数名的修饰部分（关于函数名的修饰部分在后面将详细说明）。
C调用约定（即用__cdecl关键字说明）和__stdcall调用约定有所不同，虽然参数传送方面是一样的，但对于传送参数的内存栈却是由调用者来维护的（也正因为如此，实现可变参数的函数只能使用该调用约定），另外，在函数名修饰约定方面也有所不同。
__fastcall调用约定是“人”如其名，它的主要特点就是快，因为它是通过寄存器来传送参数的（实际上，它用CX和EDX传送前两个双字或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈），在函数名修饰约定方面，它和前两者均不同。

⑹ c++编译器以何种顺序编译文件的，先cpp文件，还是.h文件

1. 编译阶段 (头文件 .h)
d工程中在头文件中对导出内容(function, class, type, object, variable)进行定义.

2. 链接阶段 (库文件 .lib)
d工程在link阶段会生成.lib
用户link时需要 这个.lib 解决link时的代码定位.
3. 运行阶段
.exe

⑺ 请问一下当编译软件编译代码的时候是按照怎么的顺序执行的呀

编译代码首先是进行预处理，然后编译，再链接，生成可执行程序

程序执行从main函数开始，程序顺序执行。如有以下代码：
#include <stdio.h>
#include <stdlib.h>

int add(int a, int b)
{
return a + b;
}

int sum(int a, int b)
{
return add(a, b);
}

int main(void)
{
int a = 1, b = 2, c = 3, d = 4;
int vaule1, vaule2;

vaule1 = sum(a, b);
vaule2 = add(c, d);

system("pause");
return 0;
}

则执行过程为
1、首先进入main函数
2、遇到第一个调用函数sum,则进入sum函数
3、在进入sum函数后，sum又调用了add函数，则进入add函数
4、add函数将 a+ b的值返回至sum函数；
5、sum函数返回至主函数，至此sum函数调用结束
6、在main函数中接下来开始进入调用函数add
7、add函数返回a+b的值至主函数，
8、程序执行结束

⑻ 编译器编译代码时， 他的顺序是怎样的

先定义全局变量，再按照从左至右，从上至下的顺序将源代码（也就是你写的代码）编译成机器能识别的机器码，最后再执行编译好的机器码.

⑼ 编译程序包括哪几个主要组成部分

编译过程分为分析和综合两个部分，并进一步划分为词法分析、语法分析、语义分析、代码优化、存储分配和代码生成等六个相继的逻辑步骤。这六个步骤只表示编译程序各部分之间的逻辑联系，而不是时间关系。

编译过程既可以按照这六个逻辑步骤顺序地执行，也可以按照平行互锁方式去执行。在确定编译程序的具体结构时，常常分若干遍实现。对于源程序或中间语言程序，从头到尾扫视一次并实现所规定的工作称作一遍。每一遍可以完成一个或相连几个逻辑步骤的工作。

(9)编译器代码的顺序扩展阅读：

对于c编译程序来说，其语言的特点如下：

1、c语言是一种结构化语言。它层次清晰，便于按模块化方式组织程序，易于调试和维护，而且表现能力和处理能力极强。

2、c语言具有丰富的运算符和数据类型，便于实现各类复杂的数据结构。它还可以直接访问内存的物理地址，进行位(bit)一级的操作。

3、由于c语言实现了对硬件的编程操作，因此集高级语言和低级语言的功能于一体。它既可用于系统软件的开发，也适合于应用软件的开发。

4、此外，c语言还具有效率高、可移植性强等特点。因此它广泛地移植到了各类各型计算机上，从而形成了多种版本。