RISC-V学习笔记（2）

作者：夏风喃喃
参考：计算机组成与设计：硬件/软件接口（RISC-V版）

第2章 计算机的语言

2.1 引言

2.2 计算机硬件的操作

RISC-V一个算术指令只执行一个操作，并且必须总是只有三个变量。

类似于加法的操作一般有三个操作数：两个被加到一起的数和一个放置总和的位置。

add  a, b, c             //The sum of b and c is placed in a

2.3 计算机硬件的操作数（加减指令）

RISC-V算术指令的三个操作数必须从32个64位寄存器（RV64）选择，RISC-V约定寄存器编号为x01-x31。
加法：

add  x19, x20, x21               //The sum of x20 and x21 is placed in x19

2.3.1 存储器操作数（存取指令）

内存和寄存器之间传输数据的指令，称为数据传输指令。

取双字：（取内存中的A[8]至寄存器x9，字节寻址8×8偏移地址为64）

ld   x9, 64(x22) //x22存放内存中数组的基址，偏移64，取出的数据A[8]存放至寄存器x9

存双字：（将寄存器x9中数据存至内存的A[12]，字节寻址8×12偏移地址为96）

sd   x9, 96(x22)     //x22存放内存中数组的基址，偏移96，寄存器x9的数据存至A[12]

2.3.2 常数或立即数操作数（立即数指令）

RISC-V算术指令有一个常数操作数的快速加指令称为立即数加。
立即数加：

addi x22, x22 4              //x22 = x22 + 4

2.4 有符号数与无符号数

64位无符号数：
( x 63 × 2 63 ) + ( x 62 × 2 62 ) + … … + ( x 1 × 2 1 ) + ( x 0 × 2 0 ) (x_{63}×2^{63})+(x_{62}×2^{62})+……+(x_{1}×2^{1})+(x_{0}×2^{0}) (x63​×263)+(x62​×262)+……+(x1​×21)+(x0​×20)
64位有符号数：
( x 63 × − 2 63 ) + ( x 62 × 2 62 ) + … … + ( x 1 × 2 1 ) + ( x 0 × 2 0 ) (x_{63}×-2^{63})+(x_{62}×2^{62})+……+(x_{1}×2^{1})+(x_{0}×2^{0}) (x63​×−263)+(x62​×262)+……+(x1​×21)+(x0​×20)

2.5 计算机中的指令表示（指令格式）

RISC-V的指令均为32位。

R（寄存器）型格式指令：（用于三个操作数均在寄存器）

opcode、funct3、funct7：操作码，指令的基本操作。
rd：目的操作数寄存器，用来存放操作结果。
rs1：第一个源操作数寄存器。
rs2：第二个源操作数寄存器。

I（立即数）型格式指令：（用于立即数操作或从内存取数据）

opcode、funct3：操作码，指令的基本操作。
rd：目的操作数寄存器，用来存放操作结果。
rs1：源操作数寄存器或基址寄存器。
immediate：立即数源操作数或偏移量。

S（存放）型格式指令：（用于向内存存数据）

opcode、funct3：操作码，指令的基本操作。
rs1：基址寄存器。
rs2：源操作数寄存器。
immediate：偏移量。

2.6 逻辑操作（移位，逻辑运算指令）

RISC-V的移位操作通常使用 I 型格式指令，因为64位寄存器数据移位不会大于63位，所以immediate的低6位被使用。

逻辑左移与右移：（移动的空位用0补充）

sll x11, x19, x10                //reg x11 = reg x19 << reg x10
slli x11, x19, 4                //reg x11 = reg x19 << 4 bits
srl x11, x19, x10               //reg x11 = reg x19 >> reg x10
srli x11, x19, 4                //reg x11 = reg x19 >> 4 bits

算术右移：（移动的空位用符号扩展补充）

sra x11, x19, x10                //reg x11 = reg x19 >> reg x10
srai x11, x19, 4                //reg x11 = reg x19 >> 4 bits

按位与，按位或：

and x9, x10, x11             //reg x9 = reg x10 & reg x11
andi x9, x10, 4                 //reg x9 = reg x10 & 4
or x9, x10, x11                 //reg x9 = reg x10 | reg x11
ori x9, x10, 4                  //reg x9 = reg x10 | 4

按位异或，按位取反：（取反等价于异或111……111）

xor x9, x10, x12             //reg x9 = reg x10 ^ reg x12
xori x9, x10, 4                 //reg x9 = reg x10 ^ 4
xor x9, x10, x11                //reg x9 = ~ reg x10，x11 = 111……111

2.7 用于决策的指令（条件判断分支指令）

分支跳转语句常用于 if 语句。

相等则分支：

beq rs1, rs2, L1     //if rs1 == rs2, branch to label L1

不相等则分支：

bne rs1, rs2, L1     //if rs1 ≠ rs2, branch to label L1

例：( if 条件语句C语言编译为RISC-V代码)

【C】
if (i == j) f = g + h; else f = g - h;
f,g,h,i,j分别对应x19-x23这5个寄存器【RISC-V】
bne x22, x23, Else      //go to Else if i ≠ j
add x19, x20, x21       //f = g + h (skipped if i ≠ j)
beq x0, x0, Exit        //if 0 == 0, go to Exit
Else: sub x19, x20, x21 //f = g - h (skipped if i = j)
Exit:

2.7.1 循环（循环判断分支指令）

循环的RISC-V代码也是通过分支跳转实现。

例：( while 循环语句C语言编译为RISC-V代码)

【C】
while (save[i] == k) i += 1;
i,k分别对应x22和x24寄存器，数组的基址保存在x25【RISC-V】
Loop: slli x10, x22, 3  //Temp reg x10 = i * 8
add x10, x10, x25       //x10 = address of save[i]
ld x9, 0(x10)           //Temp reg x9 = save[i]
bne x9, x24, Exit       //go to Exit if save[i] ≠ k
addi x22, x22, 1        //i = i + 1
beq x0, x0, Loop        //go to Loop
Exit:

2.7.2 边界检查的简便方法（其他条件判断分支指令）

小于则分支：

blt rs1, rs2, L1     //if rs1 < rs2, branch to label L1

大于等于则分支：

bge rs1, rs2, L1     //if rs1 ≥ rs2, branch to label L1

无符号小于则分支：

bltu rs1, rs2, L1        //if rs1 < rs2, branch to label L1

无符号大于等于则分支：

bgeu rs1, rs2, L1        //if rs1 ≥ rs2, branch to label L1

2.7.3 case/switch语句（条件判断跳转指令）

case条件语句可以使用分支地址表高效实现，使用跳转-链接指令（jalr）对寄存器中指定的地址执行无条件跳转。

间接跳转：

jalr x0, 0(x1)   //unconditionally branch to case address

分支地址表：也称作分支表，一种包含了不同指令序列地址的表。

2.8 计算机硬件对过程的支持（函数操作指令）

过程即函数的实现，RISC-V软件为过程调用分配寄存器时遵循约定：x10-x17八个参数寄存器，用于传递参数或返回值，x1一个返回地址寄存器，用于返回到起始点。

跳转-链接：

jal x1, ProcedureAddress
//jump to ProcedureAddress and write return address to x1

无条件跳转：

jal x0, Label    //unconditionally branch to Label, discard return address

2.8.1 使用更多的寄存器（函数操作寄存器换出指令）

当函数需要更多的参数时，需要更多的寄存器，将寄存器旧值换出至存储器以满足参数传递，函数调用结束后，需要恢复寄存器旧值，换出寄存器的数据结构是栈（stack），栈按照从高到低的地址顺序（高地址在上，低地址在下）增长，栈指针（stack pointer）是寄存器x2，也称为sp。

例：( 没有调用其他函数的C语言函数编译为RISC-V代码)

【C】
long long int leaf_example(long long int g, long long int h,
long long int i, long long int j)
{long long int f;f = (g + h) - (i + j);return f;
}
g,h,i,j分别对应x10-x13寄存器，f对应于x20【RISC-V】
leaf_example:
addi sp, sp, -24        //adjust stack to make room for 3 times
sd x5, 16(sp)           //save reg x5 for use afterwards
sd x6, 8(sp)            //save reg x6 for use afterwards
sd x20, 0(sp)           //save reg x20 for use afterwards
add x5, x10, x11        //reg x5 contains g + h
add x6, x12, x13        //reg x6 contains i + j
sub x20, x5, x6         //f = x5 - x6, which is (g + h) - (i + j)
addi x10, x20, 0        //returns f (x10 = x20 + 0)
ld x20, 0(sp)           //restore reg x20 for caller
ld x6, 8(sp)            //restore reg x6 for caller
ld x5, 16(sp)           //restore reg x5 for caller
addi sp, sp, 24         //adjust stack to delete 3 times
jalr x0, 0(x1)          //branch back to calling routine

RISC-V软件将19个寄存器分为两组：x5-x7以及x28-x31是临时寄存器，在过程调用中不被被调用者保存；x8-x9以及x18-x27是保存寄存器，在过程调用中必须被保存。

2.8.2 嵌套过程（函数操作递归指令）

例：( 计算阶乘的C语言递归函数编译为RISC-V代码)

【C】
long long int fact (long long int n)
{if (n < 1) return (1);else return (n * fact (n - 1))
}
n对应x10参数寄存器【RISC-V】
fact:
addi sp, sp, -16        //adjust stack to make room for 2 times
sd x1, 8(sp)            //save the return address
sd x10, 0(sp)           //save the argument n
addi x5, x10, -1        //x5 = n - 1
bge x5, x0, L1          //if (n - 1) >= 0, go to L1
addi x10, x0, 1         //return 1
addi sp, sp, 16         //pop 2 items off stack
jalr x0, 0(x1)          //return to caller
L1:
addi x10, x10, -1       //n >= 1: argument gets (n - 1)
jal x1, fact            //call fact with (n - 1)
addi x6, x10, 0         //return from jal: move result of fact (n - 1) to x6
ld x10, 0(sp)           //restore argument n
ld x1, 8(sp)            //restore the return address
addi sp, sp, 16         //adjust stack pointer to pop 2 items
mul x10, x10, x6        //return n * fact (n - 1)
jalr x0, 0(x1)          //return to the caller

为了简化C语言中的静态全局变量的访问，RISC-V编译器保留了一个寄存器x3用作全局指针或gp。

例：( 计算累加的C语言递归函数编译为RISC-V代码)

【C】
long long int sum (long long int n, long long int acc)
{if (n > 0) return sum (n - 1, acc + n);else return acc
}
n,acc对应x10,x11寄存器, 结果放入x12【RISC-V】
sum:
ble x10, x0, sum_exit       //go to sum_exit if n <= 0
add x11, x11, x10           //add n to acc
addi x10, x10, -1           //subtract 1 from n
jal x0, sum                 //jump to sum
sum_exit:
addi x12, x11, 0            //return value acc
jalr x0, 0(x1)              //return to caller

2.9 人机交互（字符串操作指令）

例：( 字符串复制的C语言编译为RISC-V代码)

【C】
void strcpy (char x[], char y[])
{size_t i;i = 0;while ((x[i] = y[i] != '\0') /*copy & test byte*/ ) i += 1;
}
x,y基址对应x10,x11寄存器, i对应x19寄存器【RISC-V】
strcpy:
addi sp, sp, -8         //adjust stack for 1 more item
sd x19, 0(sp)           //save x19
add x19, x0, x0         //i = 0 + 0
L1:
add x5, x19, x11        //address of x[i] in x5
lbu x6, 0(x5)           //x[6] = y[i]
add x7, x19, x10        //address of x[i] in x7
sb x6, 0(x7)            //x[i] = y[i]
beq x6, x0, L2
addi x19, x19, 1        //i = i + 1
jal x0, L1              //go to L1
L2:
ld x19, 0(sp)           //restore old x19
addi sp, sp, 8          //pop 1 doubleword off stack
jalr x0, 0(x1)          //return

加载无符号字节：

lbu x12, 0(x10)  //Read byte from source

加载无符号字：

lwu x12, 0(x10)  //Read byte from source

2.10 对大立即数的RISC-V编址和寻址

2.10.1 大立即数（大立即数加载指令）

将64位常量加载到寄存器，需要使用lui（load upper immediate）指令，用于将20位常数加载到寄存器的第31位到第12位。将31位的值复制填充到最左边32位，最右边的12位用0填充。lui使用U型格式指令。

例：( 64位常量加载到寄存器x19编译为RISC-V代码)

00000000 00000000 00000000 00000000 00000000 00111101 00000101 00000000【RISC-V】
lui x19, 976            //976(decimal) = 0000 0000 0011 1101 0000
addi x19, x19, 1280     //1280(decimal) = 00000101 00000000

2.10.2 分支中的寻址

RISC-V分支指令格式为SB型。

SB（分支）型格式指令：（如bne x10, x11, 2000）

无条件跳转-链接指令（jal）是唯一使用UJ型格式的指令。

UJ（无条件跳转）型格式指令：(如jal x0, 2000 )

分支中的寻址使用PC相对寻址，它的地址是PC和指令中的常量之和。

2.10.3 RISC-V寻址模式总结

RISC-V有4种寻址模式：

1. 立即数寻址：操作数是指令本身的常量。
2. 寄存器寻址：操作数在寄存器中。
3. 基址寻址：操作数于内存中，其地址是寄存器和指令中的常量之和。
4. PC相对寻址：分支地址是PC和指令中常量之和。

2.10.4 机器语言译码

从机器语言到汇编语言的译码需要编码表和指令格式表来查找。

RISC-V指令的编码：

RISC-V指令格式：

2.11 指令与并行性：同步

当来自两个线程的访存请求出现数据竞争时，通常需要以原子交换原语形式构建基本同步原语。它是构建同步机制的典型操作，它将寄存器中的值与存储器中的值进行交换。

假设构建一个简单的锁变量，其中值0表示锁变量可用，值1表示锁变量被占用。处理器尝试通过将寄存器中的1与该锁变量对应的内存地址中的值进行交换来加锁。如果其他处理器已访问该锁变量，则交换指令返回值1，表明该锁已被占用，否则为0，表示加锁成功，且锁变量被交换为1，以防止其他处理器也加锁成功。

在RISC-V中，使用指令对保留加载（load-reserved）双字（lr.d）和条件存储（store-conditional）双字（sc.d）实现原子交换。

例：(在寄存器x20中指定的内存位置上实现原子交换编译为RISC-V代码)

【RISC-V】
addi x12, x0, 1         //copy locked value
again:
lr.d x10, (x20)         //load-reserved to read lock
bne x10, x0, again      //check if it is 0 yet
sc.d x11, x12, (x20)    //attempt to store new value
bne x11, x0, again      //branch if store fails
sd x0, 0(x20)           //free lock by writting 0

2.12 翻译并启动程序

C程序转换为计算机上可运行程序需要四个步骤：

文件名后缀：

2.12.1 编译器

编译器将C程序转换为机器能理解的符号形式——汇编语言程序（assembly language program）。

2.12.2 汇编器

汇编器将汇编语言转换为目标文件，该目标文件是机器指令、数据和将指令正确放入内存所需信息的组合。

汇编器还可以处理机器指令的常见变体，这类指令称为伪指令。如li x9, 123 //load immediate value 123 into register x9汇编器将其转化为addi x9, x0, 123；mv x10, x11 //reg x10 gets reg x11汇编器将其转化为addi x9, x10, 0；and x9, x10, 15汇编器将其转化为andi x9, x10, 15。

2.12.3 链接器

链接器将所有独立汇编的机器语言程序“缝合”在一起。由于独立编译和汇编每个过程，因此更改一行代码只需要编译和汇编一个过程，链接器有用的原因是修正代码要比重新编译和重新汇编快得多。

2.12.4 加载器

将可执行程序放在主存中以准备执行的系统程序。

2.12.5 动态链接库

动态链接库（DLL）是在执行期间链接到程序的库例程。DLL需要额外的空间来存储动态链接所需的信息，但不要求复制或链接整个库。它们在第一次调用历程时会付出大量的开销，但此后只需一个间接跳转。

2.13 以C排序程序为例的汇总整理

2.13.1 swap过程

例：( swap过程的C语言编译为RISC-V代码)

【C】
void swap (long long int v[], size_t k)
{long long int temp;temp = v[k];v[k] = v[k+1];v[k+1] = temp;
}
v,k对应x10,x11寄存器【RISC-V】
swap:
slli x6, x11, 3         //reg x6 = k * 8
add x6, x10, x6         //reg x6 = v + (k * 8)
ld x5, 0(x6)            //reg x5 (temp) = v[k]
ld x7, 8(x6)            //reg x7 = v[k + 1]
sd x7, 0(x6)            //v[k] = reg x7
sd x5, 8(x6)            //v[k + 1] = reg x5 (temp)
jalr x0, 0(x1)          //return to calling routine

2.13.2 sort过程

例：( 冒泡sort过程的C语言编译为RISC-V代码)

【C】
void sort (long long int v[], size_t int k)
{size_t i,j;for (i = 0; i < n; i += 1){for (j = 1 - 1; j >= 0 && v[j] > v[j + 1]; j -= 1){swap(v,j);}}
}
v,n对应x10,x11寄存器，i,j对应x19,x20寄存器【RISC-V】
*******************保存寄存器************************
sort:
addi sp, sp, -40        //make room on stack for 5 registers
sd x1, 32(sp)           //save return address on stack
sd x22, 24(sp)          //save x22 on stack
sd x21, 16(sp)          //save x21 on stack
sd x20, 8(sp)           //save x20 on stack
sd x19, 0(sp)           //save x19 on stack
*********************过程体**************************
//移动参数
mv x21, x10             //copy parameter x10 into x21
mv x22, x11             //copy parameter x10 into x22
//外循环
li x19, 0               //i = 0
for1tst:
bge x19, x22, exit1     //go to exit1 if i >= n
//内循环
addi x20, x19, -1       //j = i - 1
for2tst:
blt x20, x0, exit2      //go to exit2 if j < 0
slli x5, x20, 3         //x5 = j * 8
add x5, x21, 3          //x5 = v + (j * 8)
ld x6, 0(x5)            //x6 = v[j]
ld x7, 8(x5)            //x7 = v[j + 1]
ble x6, x7, exit2       //go to exit2 if x6 < x7
//参数传递和调用
mv x10, x21             //first swap parameter is v
mv x11, x20             //second swap parameter is j
jal x1, swap            //call swap
//内循环
addi x20, x20, -1       //j = j - 1
j for2tst               //go to for2tst
//外循环
exit2:
addi x19, x19, 1        //i += 1
j for1tst               //go to for1tst
*******************恢复寄存器********************
exit1:
ld x19, 0(sp)           //restore x19 from stack
ld x20, 8(sp)           //restore x20 from stack
ld x21, 16(sp)          //restore x21 from stack
ld x22, 24(sp)          //restore x22 from stack
ld x1, 32(sp)           //restore return address from stack
addi sp, sp, 40         //restore stack pointer
********************过程返回*********************
jalr x0, 0(x1)          //return to calling routine

2.14 数组与指针

例：( 清除内存中一个双字序列的C语言编译为RISC-V代码)

【C】
//数组实现
clear1 (long long int array[], size_t int size)
{size_t i;for (i = 0; i < size; i += 1)array[i] = 0;
}
//指针实现
clear2 (long long int *array, size_t int size)
{long long int *p;for (p = &array[0]; p < &array[size]; p = p + 1)*p = 0;
}

2.14.1 用数组实现clear

【RISC-V】
li x5, 0                //i = 0
loop1:
slli x6, x5, 3          //x6 = i * 8
add x7, x10, x6         //x7 = address of array[i]
sd x0, 0(x7)            //array[i] = 0
addi x5, x5, 1          //i = i + 1
blt x5, x11, loop1      //if (i < size) go to loop1

2.14.2 用指针实现clear

【RISC-V】
mv x5, x10              //p = address of array[0]
slli x6, x11, 3         //x6 = size * 8
add x7, x10, x6         //x7 = address of array[size]
loop2:
sd x0, 0(x5)            //memory[p] = 0
addi x5, x5, 8          //p = p + 8
bltu x5, x7, loop2      //if (p < &array[size]) go to loop2

2.18 实例：RISC-V指令系统的剩余部分

RISC-V指令系统体系结构分为基本ISA（称作I）以及五个标准扩展：M、A、F、D、C。

RISC-V的基本体系结构及其扩展共有184条指令及13条系统指令。

RISC-V学习笔记（2）相关推荐

1. GoKit3(V)学习笔记02_自定义产品数据点

   跟着Gokit3使用说明书的教程顺利地让设备跑了起来,家里一下子热闹了起来,玛丽玛丽的声音此起披伏,多多儿还不会讲话,也跟着maaa地叫着.这是GoKit3给生活带来的快乐. 言归正传,这篇开始讲述G ...

2. 计组学习笔记2（RISC v版）

   指令集解释 (规定:R[r]表示通用寄存器r的内容,M[addr]表示存储单元addr的内容,SEXT[imm]表示对imm进行符号扩展,ZEXT[imm]表示对imm进行零扩展) 整数运算类 -U型 ...

3. oracle v$ 表,【学习笔记】Oralce视图 查找分析V$PARAMETER视图的基表

   天萃荷净 分享一篇关于查找分析V$PARAMETER视图的基表的案例方法 1.使用trace查找show parameter执行语句 alter session set events '10046 t ...

4. 查看oracle 导出进程,【学习笔记】Oracle 通过v$session查看imp进程信息的案例

   天萃荷净 运维DBA反映需求在执行Oracle imp导入时需要查看导入的进程信息,通过v$session分析imp导入进程在服务器端v$session中的username列不是imp登陆用户名,而是 ...

5. oracle in查询 一直等待,学习笔记:Oracle awr 分析解决inactive transaction branch等待事件...

   天萃荷净 通过Oracle AWR报告分析inactive transaction branch等待事件的原因 分析一份awr,发现不太熟悉的等待事件"inactive transactio ...

6. 《汇编语言》学习笔记

   <汇编语言>学习笔记 by 张悠慧教授(清华大学),课程链接 https://www.bilibili.com/video/av27895807/?p=1 ,大概有十几个小时的视频.看完课 ...

7. MIT 6.s081学习笔记

   MIT 6.s081学习笔记 introduction 计算机组织结构: 最底部是一些硬件资源,包括了CPU,内存,磁盘,网卡 最上层会运行各种应用程序,比如vim,shell等,这些就是正在运行的所 ...

8. 嵌入式学习笔记——概述

   嵌入式系统概述 前言 "嵌入式系统"概念 1.是个啥? 2.可以干啥? 3.有哪些入坑方向? 4.入坑后可以有多少薪资? 单片机 1.什么是单片机? 2.架构简介 3.基于ARM架 ...

9. 计算机汇编语言运用哪个进制,《汇编语言》学习笔记

   另外,我觉得学习汇编语言之前最好先了解 计算机组成 的相关知识,否则遇到一些 CPU 寄存器 内存寻址 等相关概念时,可能会听着有点懵. 前言 学完 计算机组成原理 之后接下来再学什么?通过本课程一开 ...

10. RISC-V 指令学习笔记（基于CH32V103）

    文章目录 RISC-V 指令学习笔记(基于CH32V103) 一.指令结构分类 二.寄存器功能 三.加载存储指令 四.算数运算指令 五.移位指令 六.逻辑操作指令 七.跳转指令 7.1 条件跳转 7. ...

最新文章

1. lamp-安装脚本-修订版2
2. aFleX脚本常见错误
3. C# Azure 存储-分布式缓存Redis的新建配置查看
4. 带你学python基础：字符串
5. js中的bool值转换及 、||、 !!详解
6. IT职场的一些处事之道
7. Python可变与不可变类型及垃圾回收机制
8. 如何破解“中国开源拿来主义”？包云岗的几点分析
9. BGP——路由汇总造成次优选路问题
10. 【转】WCF、Net remoting、Web service概念及区别
11. Linux挂载windos共享提示error
12. PHP根据开始、结束时间：计算开始、结束时间占当月总天数的百分比
13. Python敏感词过滤DFA算法+免费附带敏感词库
14. C语言程序——标准输出格式
15. 第7章 航空公司客户价值分析
16. Html提交表单的制作
17. 大地GhostXP_SP3_2013极速装机5月版
18. 收藏 | 42 款 Chrome 插件神器，你必须知道！
19. nfs linux 权限不够,nfs Permission denied 的一种情况
20. 【报错】ImportError: libpng16-57e5e0a0.so.16.37.0: cannot open shared object file: No such file or direc

热门文章

1. 为什么Lido的stETH可能会出现高溢价？
2. U3D VideoPlayer播放视频和坑点
3. c语言wsastartup源代码,c – 可以从几个线程调用WSAStartup()导致死锁吗？
4. 大话数据结构与算法(一)
5. 五岳核心版上线，这份阿里开发手册核心版又将被多少人疯狂转载？
6. Session详解，学习Session，这篇文章就够了(包含底层分析和使用)
7. pcie中文入门学习文档资料
8. 总有欢聚就是为了离别。
9. 2021年中国航空运输行业发展回顾及2022年中国航空运输行业发展趋势分析[图]
10. 怎么拆分捆绑的软件_用Excel捆绑RANK拆分高尔夫奖金