程序的机器级表示part2——访问信息

七月不远.

已于 2023-02-12 13:08:11 修改

阅读量1k

点赞数 2

分类专栏： linux 计算机系统文章标签：数据结构

于 2023-01-13 15:53:54 首次发布

本文链接：https://blog.csdn.net/weixin_58165485/article/details/128659456

版权

计算机系统同时被 2 个专栏收录

11 篇文章 4 订阅

订阅专栏

linux

9 篇文章 0 订阅

订阅专栏

1. 整数寄存器

一个x86-64的CPU包含一组16个存储64位值的通用目的寄存器(general-purpose registers)

x86-64的CPU是64位的，因此相应的寄存器长度与机器字长(数据总线位宽)相同，也为64位。而每一个寄存器又能分为不同的几个部分，供不同的操作使用，这是由于指令集的不断发展导致的

最初的8086中有8个16位的寄存器，即图中的%ax-%sp

扩展到IA32架构时，这些寄存器也扩展32位，标号%eax-%esp

扩展到x86-64后，寄存器进一步扩展到64位，即%rax-%rsp，并新增了8个寄存器：%r8-%r15

对于%rax、%rbx、%rcx和%rdx寄存器，低16位又可分为两部分

一条指令可以使用寄存器的低1、2、4、8字节，分别对应字节级操作、16位操作、32位操作和64位操作

当指令以寄存器作为目标时，对于生成小于8字节结果的指令，有如下规则：

生成1字节和2字节数字的指令会保持剩下的字节不变
生成4字节数字的指令会把高位4个字节置0

例题：

在x86-64计算机中，若地址0x1300~0x1307的8个内存字节的数值依次时0x40、0x41、0x42、0x43、0x44、0x45、0x46、0x47，寄存器%rbx=0x1020304050607080，则

(1) 执行汇编指令"mov $0x1300, %ebx"后，寄存器 rbx 的数值是多少？

(2) 继续执行指令"mov 2(%ebx), %eax"后，寄存器 ah 的数值是多少？

(3) 继续执行指令"add (%ebx), %eax"后，寄存器 ah 的数值是多少？

1. 首先注意到汇编指令"mov $0x1300, %ebx"没有给出操作数大小后缀，并且观察到目标操作数为寄存器%ebx，是一个32位寄存器，因此实际上是将0x00001300这样一个四字节数传送到%ebx内，这样的操作会使得寄存器%rbx内原来的高位字节置0，此时%rbx内的值位0x0000000000001300，故答案是0x1300

2. 在1的基础上继续执行"mov 2(%ebx), %eax"，将地址(0x1300+2)处开始，四字节的值传送到%eax内，同样将高4位置0，%eax内的值为0x45444342(和上图方向相同，从左到右由高位到低位)，则%ah内存放0x43

3.在2的基础上继续执行"add (%ebx), %eax"，将地址(0x1300)处开始，四字节的值与寄存器%eax中的值相加，同样将高4位置0，实际上是0x40414243+0x42434445 = 0x82848688，因此%ah内存放0x84

从上图中还能看出，每个寄存器都有自己的作用，特别的比如栈指针%rsp，用来执行函数栈帧结束的位置，后面将会频繁使用这些寄存器，届时会对这些寄存器有更深的理解

2. 操作数指示符与寻址模式

大多数指令有一个或多个操作数(operand)，指示出一个操作中要使用的源数据值，以及放置结果的目的位置

比如一条指令，根据AT&T汇编代码的格式，左边是源操作数，右边是目的操作数，这条指令执行的操作是将100这个立即数放到寄存器%rax中，100是源数据值，寄存器%rax是目的位置

addq  $100  %rax

x86-64支持多种操作数格式。其中，源操作数可以是

以常数形式给出(上述指令中源操作数为常数100)
从寄存器中读出
从内存中读出

结果可以存放在

寄存器(上述指令中将结果放在寄存器中)
内存

因此，各种不同的操作数被分为三种类型：

立即数( immediate )，整型常数，以$开头如$2023、$0x23。AT&T汇编要在立即数前加$
寄存器( register )，加前缀%，如%eax、%rcx。表示某个寄存器的内容
内存引用( memory reference )，指定内存地址开始的连续字节，地址的指定方式有多种

在x86-64中，

对于寄存器，我们用符号ra来表示一个寄存器，R[ra]来表示寄存器内的值
对于内存，我们用符号M[Addr]来表示对内存的引用

寻址模式分很多种，如下表所示，允许不同内存的引用。最一般情况的表达式是Imm(rb, ri, s)，它有四个组成部分—— 一个立即数Imm用来表示偏移量，一个基址寄存器rb，一个变址寄存器ri和一个比例因子s(这里的s必须为1、2、4或8，一般s用于数组的索引，数组元素类型为char、short、int、double对应的比例因子就是1、2、4和8)。有效地址的计算方法为 Imm + R[rb]+ R[ri] * s

举个例子，一个存放 int 类型数据的数组arr的起始地址为0x101，寄存器rb中存放基地址0x100，偏移量Imm为0x1，通过R[rb] + Imm 可以得到数组的起始地址，由于数据类型是int，因此比例因子是4，假设要访问数组第2个数据，变址寄存器内存的就是2，那么对于数组内第二个元素arr[2]的寻址就是 0x1 + 0x100 + 4 * 2

类型	格式	操作数值	名称
立即数	$Imm	Imm	立即数寻址
寄存器	ra	R[ra]	寄存器寻址
存储器	Imm	M[Imm]	绝对寻址
存储器	(ra)	M[R[ra]]	间接寻址
存储器	Imm(rb)	M[Imm + R[ra]]	(基址+偏移量)寻址
存储器	(rb, ri)	M[R[rb] + R[rb]]	变址寻址
存储器	Imm(rb, ri)	M[Imm + R[rb] + R[rb]]	变址寻址
存储器	(, ri, s)	M[R[ri] * s]	比例变址寻址
存储器	Imm(, ri, s)	M[Imm + R[ri] * s]	比例变址寻址
存储器	(rb, ri, s)	M[R[rb] + R[ri] * s]	比例变址寻址
存储器	Imm(rb, ri, s)	M[Imm + R[rb] + R[ri] * s]	比例变址寻址

练习

假设下面的值存放在指明的内存地址和寄存器中：

地址值
0x100 0xFF
0x104 0xAB
0x108 0x13
0x10C 0x11

寄存器 值
%rax 0x100
%rcx 0x1
%rdx 0x3

给出操作数的值：

%rax —— 0x100 ，对应类型2，值为R[ra]，直接给出一个寄存器，其值就是寄存器里的值

0x104 —— 0xAB，对应类型3，值为M[Imm]，常数前不加$说明这是一个地址，取出该地址处的值

$0x108 —— 0x108，对应类型1，值为Imm，常数前面有$，说明以这个立即数作为操作数的值

(%rax) —— 0xFF，对应类型4，值为M[R[ra]]，把寄存器里的值当作地址，取出该地址的值(地址0x100)

4(%rax) —— 0xAB，对应类型5，值为M[Imm + R[ra]]，把寄存器里的值当作基址，立即数当作偏移量，算出地址(0x100 + 0x4 = 0x104)

9(%rax,%rdx) —— 0x11，对应类型7，值为M[Imm + R[rb] + R[rb]]，(0x100 + 0x3 + 0x9 = 0x10C)

0xFC(,%rcx,4) —— 0xFF，对应类型9，值为M[Imm + R[ri] * s]，(0xFC + 0x1 * 4 = 0x100)

(%rax,%rdx,4) —— 0x11，对应类型10，值为M[R[rb] + R[ri] * s]，(0x100 + 0x3 * 4 = 0x10C)

3. 数据传送指令

数据传送指令是最频繁使用的指令，其作用是将数据从一个位置复制到另一个位置

🔶 MOV

简单的数据传送指令
指令	效果	描述
MOV S, D	D ← S	传送
movb	D ← S	传送字节(Byte)
movw	D ← S	传送字(2Byte)
movl	D ← S	传送双字(4Byte)
movq	D ← S	传送四字(8Byte)
movabsq	R ← I	传送绝对的四字(8Byte)

D表示目的操作数，S表示源操作数，I表示立即数

这些mov指令的后面一般会跟上操作数的大小指示符，‘b’、‘w’、‘l’、‘q’分别对应1、2、4、8字节的数据，当这些操作数是寄存器操作数时，寄存器的大小必须要和大小指示符相对应

movb $0xF, (%ebx)  
错误，x86-64下的地址是64位的，(%ebx)表示以%ebx内的值作为地址，长度不够，内存引用的寄存器必须是64位

movl %rax (%rsp)  
错误，大小指示符l表示操作数位32位，%rax是64位寄存器，应该用%eax或将l改成q

movl %eax %rdx
错误，%rdx是64位的，不应该用来接受32位的值

对于数据传送指令的源操作数有如下规定：

只能是存储在寄存器或内存中的立即数

目的操作数有如下规定：

目的操作数必须指定一个位置，要么是一个寄存器，要么是一个内存地址
目的操作数和源操作数不能同时为内存，也就是说单条指令不能进行从内存到内存的数据传送

将一个内存位置的数据传到另一个内存地址需要两条指令，即先用一条指令将源值加载到寄存器中，第二条指令将该寄存器的值写入目的内存位置

movw (%rax) 4(%rsp)  // 这是一条错误的指令，其本意是以%rax内的值作为地址，将该地址处的值复制到地址%rsp内的值 + 4处

// 正确的写法应该是
movw (%rax) %cx     // 先将16位的数(大小指示符w)从源地址取出放到%cx(16位寄存器)
movw %cx 4(%rsp)    // 再将%cx的值传送到目的位置

下面给出源和目的类型的五种可能组合，第一个是源操作数，第二个是目的操作数

 movl $0x4050,%eax       立即数传送到寄存器中, 4 bytes

 movw %bp,%sp            寄存器的值传送到寄存器中, 2 bytes

 movb (%rdi,%rcx),%al    内存的值传送到寄存器中, 1 byte

 movb $-17,(%esp)        立即数传送到内存中, 1 byte

 movq %rax,-12(%rbp)     寄存器的值传送到内存中, 8 bytes

大多数情况下，MOV指令只会更新目的操作数指定的那些寄存器字节或内存地址，也就是说如果是movb指令（对应的目的寄存器应该是%al，8位），它只会更改%rax的低8位也就是%al部分

然而一个例外是movl指令以寄存器作为目标操作数，我们之前提到过，当指令以寄存器作为目标时，生成4字节的数字的指令会把高位4个字节置0。重新看上面的例题，或许会有更深的感悟

普通的movq指令只能以表示为32位补码数字的立即数作为源操作数，然后把这个值符号扩展到64位，movabsq指令能够以任意64位立即数作为源操作数，并且只能以寄存器作为目的

C语言中存在整型提升，它按照变量的数据类型的符号位进行提升的，比如下面的代码

int main()
{
    short a = 1;
    int b = 2 + a;  // 短整型a在计算时，要先整型提升为int类型

    return 0;
}

通过汇编代码查看这一提升是如何实现的

00000000004004ed <main>:
  4004ed:	55                   	push   %rbp
  4004ee:	48 89 e5             	mov    %rsp,%rbp
  4004f1:	66 c7 45 fe 01 00    	movw   $0x1,-0x2(%rbp)  // 将1这个立即数复制到内存地址(%rbp-2)处,这个内存地址就是a的地址
  4004f7:	0f bf 45 fe          	movswl -0x2(%rbp),%eax  // 将1(16位)传送给寄存器%eax(32位)，发生提升
  4004fb:	83 c0 02             	add    $0x2,%eax        // 1(32位) + 2(32位)
  4004fe:	89 45 f8             	mov    %eax,-0x8(%rbp)
  400501:	b8 00 00 00 00       	mov    $0x0,%eax
  400506:	5d                   	pop    %rbp
  400507:	c3                   	retq   
  400508:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40050f:	00

注意看4004f7处的汇编，movswl -0x2(%rbp), %eax，这是一条符号扩展数据传送指令

当我们要将较小的源值复制到较大的目的时使用的指令有两类MOVZ和MOVS

🔶 MOVZ

零扩展数据传送指令
指令	效果	描述
MOVZ S, R	R ← 零扩展(S)	以零扩展进行传送
movzbw	R ← 零扩展(S)	将做了零扩展的字节传送到字
movzbl	R ← 零扩展(S)	将做了零扩展的字节传送到双字
movzwl	R ← 零扩展(S)	将做了零扩展的字传送到双字
movzbq	R ← 零扩展(S)	将做了零扩展的字节传送到四字
movzwq	R ← 零扩展(S)	将做了零扩展的字传送到四字

零扩展数据传送指令以寄存器或内存中的数据作为源，寄存器作为目的(表中的R代表寄存器)。MOVZ指令将目的中剩余的字节填充位0，这意味着如果要实现%cl → %eax的零扩展传送，就会把%cl中的数据存放在%al中，同时将整个%eax的其余部分置0

🔶 MOVS

符号扩展数据传送指令
指令	效果	描述
MOVS S, R	D ← 符号扩展(S)	传送符号扩展的字节
movsbw	R ← 符号扩展(S)	将做了符号扩展的字节传送到字
movsbl	R ← 符号扩展(S)	将做了符号扩展的字节传送到双字
movswl	R ← 符号扩展(S)	将做了符号扩展的字传送到双字
movsbq	R ← 符号扩展(S)	将做了符号扩展的字节传送到四字
movswq	R ← 符号扩展(S)	将做了符号扩展的字传送到四字
movslq	R ← 符号扩展(S)	将做了符号扩展的双字传送到四字
cltq	%rax ← 符号扩展(%eax)	把%eax符号扩展到%rax

符号扩展数据传送指令和零扩展数据指令的区别是，它使用数据的符号位来进行填充

其中cltq比较特殊，它只以%eax或%rax作为对象，完成32位数据到64位数据的符号扩展

int main()
{
    short a = 1;
    int b = a;

    long c = b;    // 在刚刚的代码上多加一行，实现32位向64位扩展

    return 0;
}

得到的汇编为

00000000004004ed <main>:
  4004ed:	55                   	push   %rbp
  4004ee:	48 89 e5             	mov    %rsp,%rbp
  4004f1:	66 c7 45 fe 01 00    	movw   $0x1,-0x2(%rbp)
  4004f7:	0f bf 45 fe          	movswl -0x2(%rbp),%eax
  4004fb:	89 45 f8             	mov    %eax,-0x8(%rbp)
  4004fe:	8b 45 f8             	mov    -0x8(%rbp),%eax  // 把b存到%eax中
  400501:	48 98                	cltq                    // 使用cltq实现%eax的符号扩展
  400503:	48 89 45 f0          	mov    %rax,-0x10(%rbp) // 直接使用扩展后的%rax
  400507:	b8 00 00 00 00       	mov    $0x0,%eax
  40050c:	5d                   	pop    %rbp
  40050d:	c3                   	retq   
  40050e:	66 90                	xchg   %ax,%ax

通过Swap()来更好的理解数据传送

void swap(long *xp, long *yp)     #Register Value
{                                  %rdi xp
    long t0 = *xp;                 %rsi yp
    long t1 = *yp;                 %rax t0
    *xp = t1;                      %rdx t1
    *yp = t0;
}

%rdi和%rsi分别作为第一个参数和第二个参数，存放的是xp和yp这两个地址
movq (%rdi), %rax 将%rdi里的值作为地址(*xp)，取出地址里的值后传递给寄存器%rax(变量t0)， t0 = *xp
同上，t1 = *yp
将%rdx里的值(t1)，复制到%rdi的值对应的内存地址处，*xp = t1
同上，*yp = t0

🔶 XCHG

对于数据传送指令，一个很特殊的是xchg指令，其作用是交换两个操作数的内容，分三种情况

xchg reg，reg （寄存器 <-> 寄存器）
xchg reg，mem （寄存器 <-> 内存）
xchg mem，reg （内存 <-> 寄存器）

xchg除了不允许操作立即数之外，操作数规则遵循与MOV同样的规则，但由于常见的C程序不会用到xchg指令，我们写一个汇编+C语言的程序来查看底层

#include <stdio.h>

void xchg(int *a, int *b) 
{
    __asm__("xchg %0, %1\n\t"
            : "+r"(*a), "+r"(*b));
}

int main() 
{
    int x = 10;
    int y = 20;
    
    xchg(&x, &y);
    
    return 0;
}

__asm__ 关键字用于调用内联汇编程序，并且可在 C 或 C++ 语句合法时出现，其格式为

__asm__( 汇编语句模板: 输出部分: 输入部分: 破坏描述部分)

有关内联汇编的内容以后会出文章，现在我们得到的汇编为

00000000004004ed <xchg>:
  4004ed:	55                   	push   %rbp
  4004ee:	48 89 e5             	mov    %rsp,%rbp
  4004f1:	48 89 7d f8          	mov    %rdi,-0x8(%rbp)
  4004f5:	48 89 75 f0          	mov    %rsi,-0x10(%rbp)
  4004f9:	48 8b 45 f8          	mov    -0x8(%rbp),%rax  
  4004fd:	8b 10                	mov    (%rax),%edx      // %edx = 10
  4004ff:	48 8b 45 f0          	mov    -0x10(%rbp),%rax 
  400503:	8b 00                	mov    (%rax),%eax      // %eax = 20
  400505:	92                   	xchg   %eax,%edx        // 交换%eax,%edx的值
  400506:	48 8b 4d f8          	mov    -0x8(%rbp),%rcx
  40050a:	89 11                	mov    %edx,(%rcx)
  40050c:	48 8b 55 f0          	mov    -0x10(%rbp),%rdx
  400510:	89 02                	mov    %eax,(%rdx)
  400512:	5d                   	pop    %rbp
  400513:	c3                   	retq   

0000000000400514 <main>:
  400514:	55                   	push   %rbp
  400515:	48 89 e5             	mov    %rsp,%rbp
  400518:	48 83 ec 10          	sub    $0x10,%rsp
  40051c:	c7 45 fc 0a 00 00 00 	movl   $0xa,-0x4(%rbp)
  400523:	c7 45 f8 14 00 00 00 	movl   $0x14,-0x8(%rbp)
  40052a:	48 8d 55 f8          	lea    -0x8(%rbp),%rdx  // b 的地址
  40052e:	48 8d 45 fc          	lea    -0x4(%rbp),%rax  // a 的地址
  400532:	48 89 d6             	mov    %rdx,%rsi        // &b作为参数二
  400535:	48 89 c7             	mov    %rax,%rdi        // &a作为参数一
  400538:	e8 b0 ff ff ff       	callq  4004ed <xchg>    // 调用xchg函数 
  40053d:	b8 00 00 00 00       	mov    $0x0,%eax
  400542:	c9                   	leaveq 
  400543:	c3                   	retq   
  400544:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40054b:	00 00 00 
  40054e:	66 90                	xchg   %ax,%ax

xchg在一些特定的场合发挥着巨大作用，比如在某些多线程场景中，需要保证操作的原子性，需要实现互斥锁，互斥锁的底层就是xhcg指令完成，保证仅用一条指令就完成寄存器数据和内存数据的交换

4. 压入和弹出栈数据

这两个数据传送操作完成了数据在程序栈之中的压入和弹出，也就是push和pop操作。在程序中经常需要将变量或其他数据入栈和出栈，特别是在函数栈帧的调用之中

🔶 pushq和popq

指令

效果

描述

pushq S

R[%rsp] ← R[%rsp]− 8;

M[R[%rsp]] ← S

将四字入栈

popq D

D ← M[R[%rsp]];

R[%rsp] ← R[%rsp]+ 8

将四字出栈

pushq指令的功能是把数据压入到栈上，而popq指令则是弹出数据。它们都只有一个操作数——压入的数据源和弹出的数据目的

数据的出栈和入栈都是通过栈指针的增减来完成的，并且栈指针能够找到pushq指令要入栈的位置和popq指令要弹出数据的位置，因此pushq指令只需要即将入栈的数据作为源，而popq只需要将出栈的数据保存到寄存器或内存(目的)即可

将一个四字节值压入栈中，首先要将栈指针减8，然后将值写到新的栈顶地址。因此一条pushq %rbp指令相当于下面两条指令

subq $8,%rsp      减少栈指针，为数据在栈上开辟空间
movq %rbp,(%rsp)  将%rbp里的值存储在栈上

同样popq指令先要从栈中取出一个四字节的值，要先将这个值弹出，再将栈指针加8。因此，一条popq %rax指令相当于下面两条指令

movq (%rsp),%rax  从栈中弹出数据到%rax中
addq $8,%rsp      栈指针减8，将之前数据所占空间释放

压栈时，先将栈指针%rsp-8，[0x108 - 8 = 0x100]，然后将%rax的值0x123存储到%rsp[0x100]处
出栈时，先将%rsp[0x100]处的值0x123弹出，放到寄存器%rdx中，再将栈指针%rsp+8，[0x100 + 8 = 0x108]

七月不远.

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
程序的机器级表示part2——访问信息

简单介绍整数寄存器和传送mov汇编指令
复制链接

扫一扫

专栏目录