PrideLzh 一蓑烟雨任平生 2025-11-10T07:56:16.000Z https://blog.pridelzh.top/ pridelizihao Hexo a good app https://blog.pridelzh.top/posts/a-good-app.html 2025-11-10T07:56:16.000Z 2025-11-10T07:56:16.000Z 很久没有更新我的博客了，今天心有所感，新发一篇吧

我最近偶尔发现了一下非常好用的网站和app，二者搭配起来一定会有很好的效果，帮助我实现了图书自由

首先要介绍的是网站，zlibrary，一个免费的电子书下载网站，我之前一直不知道，最近才发现，里面的电子书种类非常丰富，而且下载速度非常快，而且支持多种格式，比如pdf，epub，mobi等，而且还可以下载电子书中的图片，非常方便，而且网站界面也非常简洁，非常容易使用，我强烈推荐大家去尝试一下

zlibrary

我先把网址放在这里了 https://z-lib.id/ ，大家可以去尝试一下

微信读书

然后是微信读书，微信读书是一款非常优秀的读书app，我之前一直不知道，最近才发现，里面的电子书种类也非常丰富，而且下载速度也非常快，而且支持多种格式，比如pdf，epub，mobi等，而且还可以下载电子书中的图片，非常方便，而且网站界面也非常简洁，非常容易使用，我强烈推荐大家去尝试一下

我们把而且结合，在手机上或者说平板或者说电脑上，就可以实现图书自由了，而且还可以随时随地阅读，非常方便，我强烈推荐大家去尝试一下

]]> <p>很久没有更新我的博客了，今天心有所感，新发一篇吧</p> <p>我最近偶尔发现了一下非常好用的网站和app，二者搭配起来一定会有很好的效果，帮助我实现了图书自由</p> <p>首先要介绍的是网站，zlibrary，一个免费的电子书下载网站，我之前一直不知道，最近才发现，里面 浅谈户晨风事件 https://blog.pridelzh.top/posts/qthcf.html 2025-09-24T15:15:25.000Z 2025-09-24T15:15:25.000Z 浅谈户晨风事件

最近对于户晨风事件，我有一些看法，在此与大家分享一下。

户晨风最近在各个平台已经被封杀了，原因可能是因为他总是强行将人打上标签，比如说，将手机操作系统，安卓和苹果加上人的身上，
新早了很多的新词语，比如说，安卓思维，苹果房子，苹果学校。

这样将人划分为不同的阶层固然是不对的，但是，我现在还没有想好怎么反驳这个观点，让我们先搁置吧

户晨风还说了三件套，即为用苹果手机，开特斯拉，逛山姆超市，这三件套，他称之为“三件套”，并以此作为标准，将人划分为不同的阶层。

但是我认为，这个貌似是有道理的。我一直认为，普通人应该在自己的能力范围内，其体验新的技术等等的，就比如说手机电脑等电子产品，从某种程度上来说，这是普通人最能够和富有的人同时享有的科技产品了，你可能住不起几百平米的大平层，开不起几百万的豪车，但是手机电脑这种东西，咬咬牙还是可以的，这绝对不是虚荣，而是对于自己的尊重。

而且，就我本人的使用体验来讲，苹果的产品往往可以长时间使用而不发生卡顿，其他的产品往往做不到，就比如我手上的一个MacBook air，这是一个十年的老物件，但是现在用来上网的话，还是十分流畅的，这个还是在4GB内存的前提下，如果说是Windows，大概率做不到，还有我同学的iPhone 13，四年前的物件了，先在还是可以正常使用，升级最新系统，但是我的华为P60，才用了三年，虽然正常使用还是比较流畅的，但是很久没有升级系统了，有时候就会卡顿，而且电池续航也不如以前了，甚至说在外面骚哥自行车五分钟都没有扫开来，这个确实有点离谱了。

如果以后有机会，我觉得自己可以尝试一下apple生态，毕竟，电子产品，还是苹果的比较稳定，也算是人生的一个体验，在这里立一个flag。

其他的，我们以后再聊。

]]> <h1 id="浅谈户晨风事件"><a href="#浅谈户晨风事件" class="headerlink" title="浅谈户晨风事件"></a>浅谈户晨风事件</h1><p>最近对于户晨风事件，我有一些看法，在此与大家分享一下。</p> <p>户晨风最近在各个平台已经被封杀 人的交友欲望和交友厌恶性 https://blog.pridelzh.top/posts/1e547de5.html 2025-09-12T02:00:00.000Z 2025-09-12T02:00:00.000Z 人的交友欲望和交友厌恶性

引言

人类是社会性动物，交友是人与生俱来的需求。然而，在实际的社交过程中，我们既会感受到强烈的交友欲望，也会产生对某些社交场合或人群的厌恶性。在当前社会背景下，这种复杂的心理现象更加值得我们深入探讨。

交友欲望的根源

社会认同感

人需要通过与他人建立联系来获得归属感和认同感。这种需求在心理学上被称为“社会认同”。当个体感到被群体接纳时，会产生积极的情感体验，从而增强自我价值感。

情感支持

朋友可以提供情感上的支持和安慰，帮助我们应对生活中的压力和挑战。这种支持不仅有助于心理健康，还能提升生活的幸福感。

信息交流

通过与他人交流，我们可以获取新的知识和信息，拓宽视野。这种信息交换的过程也是个人成长的重要途径。

交友厌恶性的成因

个性差异

每个人的性格、兴趣和价值观都有所不同。当遇到与自己格格不入的人时，可能会产生排斥感。这种差异可能导致沟通障碍，进而引发厌恶性情绪。

社交焦虑

一些人在社交场合中会感到紧张和不安，担心自己的表现不佳或被他人评判。这种社交焦虑可能导致他们避免参与社交活动，甚至对交友产生厌恶性反应。

负面经历

过去的负面社交经历，如被背叛、误解或伤害，可能让人对未来的社交关系产生不信任感，从而表现出厌恶性行为。

当前社会背景下的交友新趋势

数字化社交的兴起

随着互联网和社交媒体的发展，人们的交友方式发生了显著变化。线上社交平台为人们提供了更多结识新朋友的机会，但也带来了信息过载和虚假社交的问题。

“搭子”文化的流行

当前社会中，“搭子”文化逐渐兴起。这种基于共同兴趣或需求的浅社交关系，满足了年轻人对陪伴和社交的需求，同时也体现了他们对边界感和独立性的重视。

群体性孤独与社交恐惧

尽管社交工具不断升级，但部分年轻人却感到更加孤独。社交恐惧和对亲密关系的不信任，使得他们更倾向于选择临时性、短暂性的社交关系，以避免情感上的风险。

平衡交友欲望与厌恶性

自我认知

了解自己的性格特点和社交偏好，明确自己在交友中的需求和底线。这有助于我们在社交中保持真实，同时避免不必要的冲突。

选择性社交

不必强迫自己与所有人建立深厚的友谊。可以选择那些与自己价值观相近、能够相互尊重和支持的人进行深入交往。

积极应对

对于社交焦虑或负面经历带来的影响，可以通过心理咨询、自我调节等方式积极应对，逐步克服这些障碍。

结语

交友欲望和交友厌恶性是人类社交心理的两个重要方面。在当前社会背景下，理解它们的成因和影响，可以帮助我们更好地处理人际关系，建立健康、和谐的社交网络。在这个过程中，保持自我认知和选择性社交是非常关键的。

]]> <h1 id="人的交友欲望和交友厌恶性"><a href="#人的交友欲望和交友厌恶性" class="headerlink" title="人的交友欲望和交友厌恶性"></a>人的交友欲望和交友厌恶性</h1><h2 id="引言"><a href="#引言" class=" LSTM简介 https://blog.pridelzh.top/posts/lstm1.html 2025-09-06T10:47:00.000Z 2025-09-06T10:47:00.000Z Long ShortTerm 网络——一般就叫做LSTM——是一种RNN特殊的类型，可以学习长期依赖信息。当然，LSTM和基线RNN并没有特别大的结构不同，但是它们用了不同的函数来计算隐状态。

LSTM的“记忆”我们叫做细胞/cells，你可以直接把它们想做黑盒，这个黑盒的输入ht-1为前状态和当前输入xt。这些“细胞”会决定哪些之前的信息和状态需要保留/记住，而哪些要被抹去。实际的应用中发现，这种方式可以有效地保存很长时间之前的关联信息。

简而言之，LSTM可以自动保留有效信息，舍弃无效信息，这样的一个机制保证了它可以由长期记忆。

1.1 什么是LSTM网络

举个例子，当你想在网上购买生活用品时，一般都会查看一下此前已购买该商品用户的评价。

当你浏览评论时，你的大脑下意识地只会记住重要的关键词，比如“amazing”和“awsome”这样的词汇，而不太会关心“this”、“give”、“all”、“should”等字样。如果朋友第二天问你用户评价都说了什么，那你可能不会一字不漏地记住它，而是会说出但大脑里记得的主要观点，比如“下次肯定还会来买”，那其他一些无关紧要的内容自然会从记忆中逐渐消失。

而这基本上就像是 LSTM 或 GRU 所做的那样，它们可以学习只保留相关信息来进行预测，并忘记不相关的数据。简单说，因记忆能力有限，记住重要的，忘记无关紧要的。

所以说，LSTM 就是会有选择地记忆

LSTM由Hochreiter&Schmidhuber(1997)提出，并在近期被AlexGraves进行了改良和推广。在很多问题，LSTM都取得相当巨大的成功，并得到了广泛的使用。
LSTM通过刻意的设计来避免长期依赖问题。记住长期的信息在实践中是LSTM的默认行为，而非需要付出很大代价才能获得的能力！

所有RNN都具有一种重复神经网络模块的链式的形式。在标准的RNN中，这个重复的模块只有一个非常简单的结构，例如一个tanh层。

image.png

激活函数 Tanh 作用在于帮助调节流经网络的值，使得数值始终限制在 -1 和 1 之间。

image.png

LSTM的结构基本类似，但是重复的模块拥有不同的结构，即RNN是重复单一的神经网络层，LSTM包含四个交互层，三个Sigmoid 和一个tanh层，并以一种非常特殊的方式进行交互。

image.png

上图中，σ表示的Sigmoid 激活函数与 tanh 函数类似，不同之处在于 sigmoid 是把值压缩到01 之间而不是 -11 之间。这样的设置有助于更新或忘记信息：

  • 因为任何数乘以 0 都得 0，这部分信息就会剔除掉；
  • 同样的，任何数乘以 1 都得到它本身，这部分信息就会完美地保存下来

相当于要么是1则记住，要么是0则忘掉，所以还是这个原则：因记忆能力有限，记住重要的，忘记无关紧要的。

1.2 LSTM的核心思想

LSTM的关键就是细胞状态，水平线在图上方贯穿运行。

细胞状态类似于传送带。直接在整个链上运行，只有一些少量的线性交互。信息在上面流传保持不变会很容易。

image.png

LSTM有通过精心设计的称作为“门”的结构来去除或者增加信息到细胞状态的能力。门是一种让信息选择式通过的方法。他们包含一个sigmoid神经网络层和一个pointwise乘法的非线性操作。

如此，0代表“不许任何量通过”，1就指“允许任意量通过”！从而使得网络就能了解哪些数据是需要遗忘，哪些数据是需要保存。

image.png

LSTM拥有三种类型的门结构：遗忘门/忘记门、输入门和输出门，来保护和控制细胞状态。

增加一篇博客参考：https://www.cnblogs.com/xuruilong100/p/8506949.html#%E7%90%86%E8%A7%A3-lstm-%E7%BD%91%E7%BB%9C，可以看看

]]> <p>Long ShortTerm 网络——一般就叫做LSTM——是一种RNN特殊的类型，可以学习长期依赖信息。当然，LSTM和基线RNN并没有特别大的结构不同，但是它们用了不同的函数来计算隐状态。</p> <p>LSTM的“记忆”我们叫做细胞&#x2F;cells，你可以直接把 RNN神经网络 https://blog.pridelzh.top/posts/rnn.html 2025-09-06T08:59:00.000Z 2025-09-06T08:59:00.000Z RNN

1.1 单层网络到RNN结构

在学习LSTM之前，得先学习RNN，而在学习RNN之前，首先要了解一下最基本的单层网络，它的结构如下图所示：

image.png

输入是x，经过变换Wx+b和激活函数f，得到输出y。相信大家对这个已经非常熟悉了。

在实际应用中，我们还会遇到很多序列形的数据：

image.png

如：

  1. 自然语言处理问题。x1可以看做是第一个单词，x2可以看做是第二个单词，依次类推
  2. 语音处理。此时，x1、x2、x3……是每帧的声音信号。
  3. 时间序列问题。例如每天的股票价格等等

而其中，序列形的数据就不太好用原始的神经网络处理了。

RNN引入了隐状态h（hidden state）的概念，隐状态h可以对序列形的数据提取特征，接着再转换为输出。

先从h1的计算开始看

image.png

图示中记号的含义是：

  • a）圆圈或方块表示的是向量。
  • b）一个箭头就表示对该向量做一次变换。如上图中h0和x1分别有一个箭头连接，就表示对和各做了一次变换

h2的计算和h1的计算类似，但是有两点需要注意：

  1. 在计算时，每一步使用的参数U、W、b都是一样的，也就是说每个步骤的参数都是共享的，这是RNN的重要特点，一定要牢记；
  2. 而下文马上要看到的LSTM中的权值则不共享，因为它是在两个不同的向量中。而RNN的权值为何共享呢？很简单，因为RNN的权值是在同一个向量中，只是不同时刻而已

image.png

同样可以计算剩下来的

image.png

而RNN的输出方式就是，直接通过h进行计算

image.png

OK！大功告成！这就是最经典的RNN结构，是x1, x2, …..xn，输出为y1, y2, …yn，也就是说，输入和输出序列必须要是等长的

1.2 RNN的应用

类似于人脑的思考，我们的思考不会是完全的零基础，一定是建立在一定的基础上，每一次新的学习思考都是更进一步的

传统的神经网络并不能做到这点，看起来也像是一种巨大的弊端。例如，假设你希望对电影中的每个时间点的时间类型进行分类。传统的神经网络应该很难来处理这个问题：使用电影中先前的事件推断后续的事件。循环神经网络RNN解决了这个问题。

RNN就是这样包含循环的神经网络

image.png

本质上RNN就是同一神经网络的多次复制，每个神经网络模块会把消息传递给下一个

image.png

1.3 RNN的局限性：长期依赖问题

RNN的关键点之一就是他们可以用来连接先前的信息到当前的任务上，但是真的可以么？答案是，还有很多依赖因素。

在较短的循环进程中，RNN是很有效的

image.png

但是相关信息和当前预测位置之间的间隔肯定也有大的时候。

不幸的是，在这个间隔不断增大时，RNN会丧失学习到连接如此远的信息的能力。

image.png

RNN 会受到短时记忆的影响。如果一条序列足够长，那它们将很难将信息从较早的时间步传送到后面的时间步。

因此，如果你正在尝试处理一段文本进行预测，RNN 可能从一开始就会遗漏重要信息。在反向传播期间（反向传播是一个很重要的核心议题，本质是通过不断缩小误差去更新权值，从而不断去修正拟合的函数），RNN 会面临梯度消失的问题。

因为梯度是用于更新神经网络的权重值（新的权值 = 旧权值 - 学习率*梯度），梯度会随着时间的推移不断下降减少，而当梯度值变得非常小时，就不会继续学习。

换言之，在递归神经网络中，获得小梯度更新的层会停止学习—— 那些通常是较早的层。 由于这些层不学习，RNN会忘记它在较长序列中以前看到的内容，因此RNN只具有短时记忆。

而梯度爆炸则是因为计算的难度越来越复杂导致。

然而，幸运的是，有个RNN的变体——LSTM，可以在一定程度上解决梯度消失和梯度爆炸这两个问题，这个我们之后再讨论。

]]> <h1 id="RNN"><a href="#RNN" class="headerlink" title="RNN"></a>RNN</h1><h2 id="1-1-单层网络到RNN结构"><a href="#1-1-单层网络到RNN结构" class="headerlink" Windows10/11下的WSL2安装教程 https://blog.pridelzh.top/posts/dsbjda454.html 2025-09-01T13:03:00.000Z 2025-09-01T16:19:32.595Z 第一部分：用 wsl –install 安装 WSL 和 Linux

系统要求
Windows 10 版本 2004 及更高版本 (Build 19041 及以上) 或 Windows 11

确保 Windows 已更新到最新版本

安装步骤
以管理员身份打开 PowerShell 或 CMD

按 Win + X，选择 “Windows PowerShell (管理员)” 或 “命令提示符 (管理员)”

执行一键安装命令

1
2
3
# 这会安装 WSL 2、Linux 内核，并默认安装 Ubuntu
wsl --install
如果你想安装特定的发行版（如 Kali Linux）：
1
2
3
4
5
# 首先查看可用的发行版列表
wsl --list --online

# 然后安装指定发行版，比如 Kali Linux
wsl --install -d Kali-linux

重启计算机

命令执行完成后，系统会提示你重启计算机

完成初始设置

重启后，会自动打开一个窗口

等待文件解压和安装完成

设置你的 用户名 和 密码（输入密码时不会显示字符）

第二部分：安装后的基本配置

更新系统软件包
在 Ubuntu/Kali 终端中运行：

1
2
3
4
5
6
7
8
# 更新软件包列表
sudo apt update

# 升级已安装的包
sudo apt upgrade -y

# 清理不必要的包
sudo apt autoremove -y

第三部分：安装 Neofetch 和 Fastfetch

在 Ubuntu WSL 中安装

1
2
3
4
5
6
7
8
9
10
# 安装 neofetch
sudo apt insl neofetch -y

# 安装 fastfetch (更快的替代品)
sudo apt install fastfetch -y

# 测试运行
neofetch
# 或
fastfetch

在 Kali Linux WSL 中安装

1
2
3
4
5
6
7
8
9
10
11
12
# Kali 推荐使用 fastfetch
sudo apt install fastfetch -y

# 测试运行
fastfetch

# 如果想安装原版 neofetch（需要从源码安装）
sudo apt install git make -y
git clone https://github.com/dylanaraps/neofetch.git
cd neofetch
sudo make install
neofetch

结果预览

]]> <h2 id="第一部分：用-wsl-–install-安装-WSL-和-Linux"><a href="#第一部分：用-wsl-–install-安装-WSL-和-Linux" class="headerlink" title="第一部分：用 wsl –install 安装 W Transformer简介 https://blog.pridelzh.top/posts/shx49469.html 2025-08-31T16:19:33.039Z 2025-08-31T16:19:32.595Z 1. Transformer 是什么？

简单来说，Transformer 是一种深度学习模型架构，最初由 Google 在 2017 年提出，主要用于处理序列数据（如文本）。它彻底改变了自然语言处理(NLP)领域，现在几乎所有先进的 AI 语言模型（如 GPT、BERT 等）都基于 Transformer 架构。

2. 为什么需要 Transformer？

在 Transformer 出现之前，处理序列数据主要使用 RNN（循环神经网络）和 LSTM（长短期记忆网络）。但这些模型存在两个主要问题：

  • 处理长序列困难：随着序列变长，早期信息容易被遗忘
  • 计算效率低：必须按顺序处理数据，无法并行计算
  • Transformer 通过全新的设计解决了这些问题。

3. Transformer 的核心思想

3.1 自注意力机制

这是 Transformer 最核心的创新。想象你在读一篇文章：

  • 传统方法：从左到右一个字一个字读
  • Transformer 方法：一眼看完整句话，自动找出哪些词之间关系更密切
  • 比如句子”这只猫坐在垫子上，因为它很柔软”：
  • “它”更可能与”垫子”相关，而不是”猫”
  • Transformer 能自动捕捉这种关系

3.2 位置编码

由于 Transformer 不是顺序处理数据，需要额外信息告诉模型词语的位置关系。这就像给每个词加上”座位号”。

4. Transformer 的基本结构

一个标准 Transformer 由两部分组成：编码器和解码器

4.1 编码器

  • 负责理解输入数据
  • 由多个相同的层堆叠而成
  • 每层包含自注意力机制和前馈神经网络

4.2 解码器

  • 负责生成输出
  • 也有多层结构
  • 比编码器多一个”编码器-解码器注意力”层

5. Transformer 为什么这么强大？

  • 并行处理：可以同时处理所有输入，训练速度大幅提升
  • 长距离依赖：能捕捉序列中任意两个元素间的关系
  • 可扩展性：通过堆叠更多层，模型能力可以不断增强

6. Transformer 在测试开发中的应用

作为测试开发人员，了解 Transformer 有助于：

  • 测试 AI 系统：理解模型工作原理，设计更有效的测试用例
  • 自动化测试：利用基于 Transformer 的模型生成测试数据或脚本
  • 异常检测：分析日志或监控数据中的异常模式

7. 通俗理解 Transformer

想象你在组织一场会议：

  • 传统 RNN：像一个人依次听取每位发言者的话，容易忘记前面内容
  • Transformer：像所有人同时发言，但有一种神奇能力能自动聚焦到相关的发言上，综合理解整个讨论

8. 常见 Transformer 模型

BERT：Google 开发的，擅长理解语言

  • 谷歌搜索（BERT 应用）场景：理解长尾搜索 query 测试要点：长 query 意图识别准确率多义词消歧能力测试搜索延迟性能监控

GPT 系列：OpenAI 开发的，擅长生成语言

  • GitHub Copilot（GPT-3 微调）
  • 测试相关：代码补全的边界测试安全测试：是否生成含漏洞的代码上下文记忆测试

T5：Google 开发的，统一了各种 NLP 任务

conclusion

对于测试开发人员，建议：

  • 先理解基本概念和工作原理
  • 学习如何使用现成的 Transformer 模型 API
  • 了解模型评估指标和测试方法
  • 逐步深入模型内部机制

Transformer 是当今 AI 领域最重要的突破之一，它通过自注意力机制实现了对序列数据的高效处理。作为测试开发人员，理解这一技术将帮助我们更好地测试和利用 AI 系统。

]]> <h1 id="1-Transformer-是什么？"><a href="#1-Transformer-是什么？" class="headerlink" title="1. Transformer 是什么？"></a><strong>1. Transformer 是什么？</st 10-子程序设计 https://blog.pridelzh.top/posts/45788787.html 2025-08-31T08:08:00.000Z 2025-08-31T08:08:00.000Z 一、子程序设计要点

  1. 两种传参方法

    1. 寄存器
    2. 堆栈

  2. 调用约定
    决定了到底怎么传参，在C语言写函数定义时，写以下关键词来显示指定调用约定，
    如void _fastcall cf330(unsigned m, char *buffer)指定了约定方式为_fastcall

  3. 安排局部变量

    1. 子程序需要一些局部变量，限于子程序部分
    2. 寄存器可以作为局部变量提高效率，但是寄存器的数量过少，一般不把局部变量安排在寄存器中
    3. 使用堆栈来安排局部变量，较为复杂，但是可以安排足够多的局部变量
      1. 用堆栈要控制esp指针位置
      2. 如果局部变量数量少，可以push一个寄存器进去，如果数量多，可以直接修改esp的值，然后用堆栈操作赋值

  4. 保护寄存器的约定

    1. 子程序可能会破坏某些寄存器内容。为此必须对有关寄存器的内容进行保护与恢复。
    2. 事前压入堆栈，事后从堆栈弹出。在利用堆栈进行寄存器的保护和恢复时，一定要注意堆栈的先进后出特性，一定要注意堆栈平衡
    3. 可能会降低效率。
    4. 需要主程序和子程序之间的“默契”和“约定”。子程序只保护主程序关心的那些寄存器，通常保护ebx、esi、edi和ebp。

  5. 描述子程序的说明

    1. 在给出子程序代码时，应该给出子程序的说明信息。
    2. 子程序说明信息一般包括：
      1. 子程序名（或者入口标号）；
      2. 子程序功能描述；
      3. 子程序的入口参数和出口参数；
      4. 所影响的寄存器等情况；
      5. 使用的算法和重要的性能指标；
      6. 其他调用注意事项和说明信息；
      7. 调用实例。

二、子程序举例说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
//子程序名（入口标号）：BTOHS
//功    能： 把32位二进制数转换为8位十六进制数的ASCII码串
//入口参数：（1）存放ASCII码串缓冲区的首地址（先压入堆栈）
//          （2）二进制数据（后压入堆栈）
//出口参数： 无
//其他说明：（1）缓冲区应该足够大（至少9个字节）
//          （2）ASCII串以字节0为结束标记
//          （3）影响寄存器EAX、ECX、EDX的值
_asm  
{
BTOHS:  ;子程序入口标号
    PUSH  EBP
    MOV   EBP, ESP
    PUSH  EDI//保护EDI
    MOV   EDI, [EBP+12]
    MOV   EDX, [EBP+8]
    MOV   ECX, 8
NEXT:
    ROL   EDX, 4
    MOV   AL, DL
    AND   AL, 0FH
    ADD   AL, '0'
    CMP   AL, '9'
    JBE   LAB580
    ADD   AL, 7
LAB580:
    MOV   [EDI], AL
    INC   EDI
    LOOP  NEXT
    MOV   BYTE PTR [EDI], 0
    POP   EDI
    POP   EBP
    RET
}


//子程序名（入口标号）：ISDIGIT
//功    能：判断字符是否为十进制数字符
//入口参数：AL=字符
//出口参数：如果为非数字符，AL=0；否则AL保持不变
_asm  
{
    ISDIGIT:
        CMP   AL, '0'           ;与字符'0'比较
        JL    ISDIG1            ;有效字符是'0'-'9'
        CMP   AL,'9'
        JA    ISDIG1
        RET
    ISDIG1:                     ;非数字符
        XOR   AL,AL             ; AL= 0
        RET
 }

//演示调用上述子程序as334和子程序as335
#inclue  <stdio.h>
int  main(  )
{
    char  buff1[16] = "328";
    char  buff2[16] = "1234024";
    unsigned  x1, x2;
    unsigned  sum;

    _asm  
    {
        LEA   ESI, buff1        ;转换一个字符串
        CALL  DSTOB
        MOV   x1, EAX
        LEA   ESI, buff2        ;转换另一个字符串
        CALL  DSTOB
        MOV   x2, EAX
        ;
        MOV   EDX, x1           ;求和
        ADD   EDX, x2
        MOV   sum, EDX
        ;           ;如这些代码位于前面，
        JMP   OK    ;需要通过该指令来跳过随后的子程序部分！
        }
        //
        //在这里安排子程序DSTOB和ISDIGIT的代码
        //
OK:
    printf("%d\n", sum);
    return  0;
}

三、子程序调用方法

（1）调用指令

  1. 分类

    段内直接调用
    段内间接调用
    段间直接调用
    段间间接调用

  2. 段内直接

名称call（段内直接调用指令）
格式CALL LABEL
动作把调用指令下一行指令地址压栈，然后转到LABEL处执行
注意除了保存返回地址，其他同无条件转JMP
  1. 段内间接
名称call（段内间接调用指令）
格式CALL OPDR
动作把调用指令下一行指令地址压栈，然后OPDR内容送到EIP，转到OPDR给出偏移地址处执行
合法值OPDR：保护方式下，32位通用寄存器、双字存储单元
注意除了保存返回地址，其他同无条件转JMP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include  <stdio.h>
int  subr_addr;                  //存放子程序入口地址
int  valu;                       //保存结果
int  main( )
{ 
_asm  
{
        LEA    EDX, SUBR2        //取得子程序二的入口地址
        MOV    subr_addr, EDX    //保存到存储单元
        LEA    EDX, SUBR1        //取得子程序一的入口地址
        XOR    EAX, EAX          //入口参数EAX=0
        CALL    EDX              //调用子程序一（段内间接，32位Reg）
        CALL    subr_addr        //调用子程序二（段内间接,双字存储单元）
        MOV   valu, EAX
    }
    printf("valu=%d\n",valu);    //显示为valu=28
    return  0;
}
  1. 函数指针
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
//源C程序
#include  <stdio.h>
int  max(int x, int y);            //声明函数原型
int  min(int x, int y);            //
int  main()
{   
int  (*pf)(int,int);           //定义指向函数的指针变量
    int  val1, val2;               //存放结果的变量

    pf = max;                      //使得pf指向函数max
    val1 = (*pf)(13,15);           //调用由pf指向的函数

    pf = min;                      //使得pf指向函数min
    val2 = (*pf)(23,25);           //调用由pf指向的函数

    printf("%d,%d\n",val1,val2);   //显示为15,23
    return  0;
}


//反编译(不优化)
//标号max_YAHHH、min_YAHHH分别是两个函数入口地址
push  ebp
    mov   ebp, esp           ;建立堆栈框架
    sub   esp, 12            ;安排3个局部变量pf、val1和val2

    ; pf = max;
    mov   DWORD PTR [ebp-4], OFFSET  max_YAHHH
                             
    ; val1 = (*pf)(13,15);
    push  15
    push  13
    call  DWORD PTR [ebp-4]  ;间接调用指针所指的函数max
    add   esp, 8 ;平衡堆栈
   
    ; val1= 返回结果
    mov   DWORD PTR [ebp-12], eax 
  
    ; pf = min;
    mov   DWORD PTR [ebp-4], OFFSET  min_YAHHH
   
    ; val2 = (*pf)(23,25);
    push  25
    push  23
    call   DWORD PTR  [ebp-4] ;间接调用指针所指的函数min
    add   esp, 8
    
    ; val2= 返回结果
    mov   DWORD PTR [ebp-8], eax
    mov   eax, DWORD PTR [ebp-8]     ; eax= val2
    push  eax
    mov   ecx, DWORD PTR [ebp-12]    ; ecx= val1
    push  ecx
    push  OFFSET  FORMTS             ;格式字符串
    call  _printf                    ;段内直接调用
    add   esp, 12                    ;平衡堆栈
                                     ;
    xor   eax, eax                   ;准备返回值
    mov   esp, ebp                   ;撤销局部变量
    pop   ebp                        ;撤销堆栈框架
    ret

可以看到

  1. 指针的本质就是地址
  2. 这里把函数入口和函数参数都放在堆栈，用堆栈传参。
  3. 注意传参时从ESP开始向高地址找参数，push参数的时候按从右到左的顺序
  4. 采用的是段内间接调用的方法

（2）返回指令

  1. 分类

    1. 按段内段间分
      1. 段内返回指令（对应段内调用）
      2. 段间返回指令（对应段间调用）（不介绍）
    2. 按返回时是否平衡堆栈
      1. 不带立即数的返回指令
      2. 带立即数的返回指令

  2. 段内返回不带立即数

名称RET（段内返回不带立即数指令）
格式RET
动作指令从堆栈弹出地址偏移，送到指令指针寄存器EIP，返回到call时压栈的返回地址处执行
  1. 段内返回带立即数
名称RET（段内返回带立即数指令）
格式RET count
动作指令从堆栈弹出地址偏移（当然这也会影响esp），送到指令指针寄存器EIP，还额外把count 加到ESP
注意用于平衡堆栈

四、示例

  • 以下是一个全汇编程序示例，它将十六进制数字符串转为数值（二进制），再转十进制输出查看，可以看一下函数调用的各种方法。
  • 此程序是按8086机资源写的，在64位机器上运行此程序，需要:
    1. 保存以下代码为.asm文件
    2. 用nasm编译成.com文件
    3. 用DOSbox模拟8086环境运行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
;说明：将十六进制数字符串转为数值（二进制），再转十进制输出查看
segment code;不分段，所有段共用一片内存空间
org 100H;从100H开始

MOV    AX, CS       ;使得数据段与代码段相同
   MOV    DS, AX       ;DS = CS

MOV AX, string;取到要转换的字符串首地址 
PUSH AX 
CALL Hex2Bin;转换
CALL PutWordDec;显示转换结果

MOV   AH, 4CH
    INT   21H   

;子程序名：Hex2Bin
;功    能：把十六进制字符串转数值
;入口参数：堆栈存字符串起始
;出口参数：ax
Hex2Bin:
PUSH BP
MOV BP, SP;建立堆栈框架
MOV SI, [BP+4];字长16位

MOV CX, -1;避免提前结束
XOR AX,AX;存结果

DEC SI;方便循环
TOBIN:
INC SI
MOV DL, '$';字符串结尾用$标记，DX在MUL的时候会被刷掉，这里要重新赋值
CMP [SI],DL
JE DONE

MOV BX,16;乘数16，BX在下面Hex2Bin_WORD的时候会被刷掉，要重新赋值
MUL BX;AX是被乘数，积的低16位仍在AX

PUSH WORD [SI];取一个16进制字符，转值存到BX（这里入栈后面要手动平衡）
CALL Hex2Bin_WORD
ADD SP,2;平衡堆栈

ADD AX,BX

;CALL PutWordDec
;CALL PutSpace
LOOP TOBIN
DONE:
POP BP;撤销堆栈框架
RET

;子程序名：Hex2Bin_WORD
;功    能：把一个十六进制字符转成二进制值
;入口参数：堆栈
;出口参数：BX
Hex2Bin_WORD:
PUSH BP
MOV BP, SP;建立堆栈框架

MOV BX,[BP+4]                
MOV BH,0
CMP BL,'A'
JB NUM
SUB BL,'A'-10
JMP OK
NUM:
SUB BL,'0'
OK:
POP BP;撤销堆栈框架
RET

;子程序名：PutWordDec
;功    能：把一个字的值转十进制输出
;入口参数：AX
;出口参数：无
PutWordDec:
PUSH BP
MOV BP, SP;建立堆栈框架
PUSHA;保护所有reg(关键是AX/BX/CX/DX)

MOV CX, -1
MOV BX,10
LoopPWD1:
XOR DX, DX
DIV BX
PUSH DX
CMP AX, 0
LOOPNE LoopPWD1

NOT CX
LoopPWD2:
POP DX
ADD DL, '0'
CALL PutChar
LOOP LoopPWD2

POPA;恢复所有reg
POP BP;撤销堆栈框架
RET

;子程序名：PutChar
;功    能：显示输出一个字符
;入口参数：DL = 显示输出字符ASCII码
;出口参数：无
PutChar:
    PUSH AX;简单的函数，可以不建立堆栈框架
    MOV   AH,2
    INT   21H       ;调用2号系统功能显示输出
    POP AX
    RET

;子程序名：PutSpace
;功    能：显示输出一个空格
;入口参数：无
;出口参数：无
PutSpace:
    PUSH AX;简单的函数，可以不建立堆栈框架
    PUSH DX
    MOV   DL,20H
    MOV   AH,2
    INT   21H       ;调用2号系统功能显示输出
    POP DX
    POP AX
    RET
;---------------------------------------------
string db "1234", '$';在这里写要转换的十六进制数
]]> <h1 id="一、子程序设计要点"><a href="#一、子程序设计要点" class="headerlink" title="一、子程序设计要点"></a>一、子程序设计要点</h1><ol> <li><p>两种传参方法</p> <ol> <li>寄存器</li> <li> 9-循环程序设计 https://blog.pridelzh.top/posts/456456.html 2025-08-31T08:07:00.000Z 2025-08-31T08:07:00.000Z 一、循环程序设计

（1）循环程序设计示例

  1. 两种循环结构

1747123181507.webp

  1. 简单循环示例
  • 简单循环程序
1
2
3
4
5
6
7
8
9
10
//统计无符号整数n作为十进制数时的位数
int  cf320(unsigned  int  n)
{
    int  len = 0;
    do  {
        len++;
        n = n/10;
    } while (n != 0);
    return  len ; 
}
  • 反汇编之后
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//堆栈传参数，eax传返回值
push  ebp
    mov   ebp, esp
    push  ecx                    ;在堆栈，安排局部变量len
    mov   DWORD PTR  [ebp-4], 0  ; len=0;
LN3cf320:                         ; do  {
                                  ;    len++;
    mov   eax, DWORD PTR [ebp-4]
    add   eax, 1
    mov   DWORD PTR [ebp-4], eax
                                  ; n = n/10;
    mov   eax, DWORD PTR [ebp+8]
    xor   edx, edx               ;因n是无符号数，用XOR指令清0
    mov   ecx, 10
    div   ecx
    mov   DWORD PTR [ebp+8], eax
    cmp   DWORD PTR [ebp+8], 0
    jne   SHORT LN3cf320
                                  ; return  len ;
    mov   eax, DWORD PTR [ebp-4]  ;准备返回值
                                  ;}
    mov   esp, ebp                ;撤销局部变量len
    pop   ebp                     ;撤销堆栈框架
    ret

  • 简单分析

    1. 堆栈示例
      1747123486750.webp
    2. 32位数除法，先把被除数扩展到64位，这里是无符号数，所以直接0扩展就行。使用64位无符号数除法div OPDR，被除数放在edx:eax中，除数OPDR这里是ecx，商存在eax，余数在edx
    3. 没优化，改一个数的值要三步：从堆栈取到寄存器，改寄存器值，存回堆栈。几乎所有数据计算之后都要先在堆栈更新，要用时再从堆栈取

  • 反汇编之后

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
push  ebp
    mov   ebp, esp
                                  ;ECX作为len
    xor   ecx, ecx                ;len=0;
    push  esi                     ;在使用ESI之前，保护之
LL3cf320:                         ;do  {
                                  ;     len++;
                                  ;     n = n/10;
    mov   eax, DWORD PTR [ebp+8]
    push  10                      ;准备借助堆栈送到ESI
    xor   edx, edx                ;使得EDX=0
    pop   esi                     ;使得ESI=10
    div   esi
    inc   ecx
    mov   DWORD PTR [ebp+8], eax
    test  eax, eax                ;测试n是否为0？
    jne   SHORT LL3cf320
                                  ; return len ;
    mov   eax, ecx                ;准备返回值
    pop   esi                     ;恢复ESI
                                  ;}
    pop   ebp
    ret
  • 简单分析
    1. 堆栈分析
      1747123804595.webp
    2. 仍使用64位无符号数除法div OPDR，但除数OPDR用了源变址寄存器esi，可能因为本质是指针寄存器，所以这里利用堆栈给它赋值，esi=0x0A
    3. 优化
      1. 每轮循环一开始就把n取到寄存器，循环结束时才存回，减少堆栈操作。
      2. 使用test指令判断等于0

（2）循环指令

  1. 循环指令的说明

    1. 类似于条件转移指令，段内转移，相对转移方式。
    2. 通过在指令指针寄存器EIP上加一个地址差的方式实现转移。
    3. 只用一个字节（8位）表示地址差，转移范围仅在-128至+127之间。
    4. 在保护方式（32位代码段）下，以ECX作为循环计数器。在实方式下，以CX作为循环计数器。
    5. 不影响各标志。

  2. 计数循环指令LOOP

名称LOOP（计数循环指令）
格式LOOP LABEL
动作令使寄存器ECX的值减1，如果结果不等于0，则转移到标号LABEL处，否则顺序执行LOOP指令后的指令
注意用于循环次数已知的循环，如for循环
计数器必须用ecx先设置计数器ECX初值，即循环次数。
由于首先进行ECX减1操作，再判结果是否为0，所以最多可循环 2 32 2^{32} 232遍。
1
2
3
4
5
6
7
;统计寄存器EAX中位是1的个数

  XOR   EDX, EDX        ;清EDX
      MOV   ECX, 32         ;设置循环计数
LAB1: SHR   EAX, 1          ;右移1位（最低位进入进位标志CF）
      ADC   DL, 0           ;统计（实际是加CF）
      LOOP    LAB1         ;循环
  1. **等于/全零循环指令LOOPE/LOOPZ
名称LOOPE/LOOPZ（等于/全零循环指令）
格式LOOPE（LOOPZ） LABEL
动作指令使寄存器ECX的值减1，如果结果不等于0，并且零标志ZF等于1（表示相等），则转移到标号LABEL处，否则顺序执行。
注意适用于循环比较直到找到相等字符的情况
同一条指令，有两个助记符
指令本身实施的ECX减1操作不影响标志
可以在循环开始前把ecx设为-1，相当于最大循环FFFFFFFFH-1次，退出循环后用not ecx把ecx按位取反，即可得LOOPE执行次数
1
2
3
4
5
6
7
8
9
10
//在一个字符数组中查找第一个非空格字符，假设字符数组buff的长度为100：

    LEA   EDX, buff           ;指向字符数组首
    MOV   ECX, 100            ;
    MOV   AL, 20H             ;空格字符
    DEC   EDX                 ;为了简化循环，先减1
LAB2:
    INC   EDX                 ;调整到指向当前字符
    CMP   AL, [EDX]           ;比较
    LOOPE    LAB2
  1. 不等于/非零循环指令LOOPNE/LOOPNZ
名称LOOPNE/LOOPNZ（等于/全零循环指令）
格式LOOPNE（LOOPNZ） LABEL
动作指令使寄存器ECX的值减1，如果结果不等于0，并且零标志ZF等于0（表示不相等），则转移到标号LABEL处，否则顺序执行。
注意适用于循环比较直到找到不相等字符的情况
同一条指令，有两个助记符
指令本身实施的ECX减1操作不影响标志
可以在循环开始前把ecx设为-1，相当于最大循环FFFFFFFFH-1次，退出循环后用not ecx把ecx按位取反，即可得LOOPNE执行次数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//演示LOOPNE指令的使用：嵌入汇编代码形式，测量由用户输入的字符串之长度

#include  <stdio.h>
int  main( )
{   char  string[100];           //用于存放字符串
    int  len;                    //用于存放字符串长度
    printf("Input string:");     //由用户输入一个字符串
    scanf("%s",string);
    
    _asm  
    {
        LEA   EDI, str        //使得EDI指向字符串
        XOR   ECX, ECX        //假设字符串“无限长”
        XOR   AL, AL          //使AL=0（字符串结束标记）
        DEC   EDI             //为了简化循环，先减1
 LAB3:  INC   EDI             //指向待判断字符
        CMP   AL, [EDI]       //是否为结束标记
        LOOPNE   LAB3       //如果不是结束标记，继续循环
        NOT   ECX             //据ECX，推得字符串长度
        MOV   len, ECX
    }
    printf("len=%d\n",len);      //显示为len=12
    return 0;
}

（3）计数器转移指令

  • 上面的第一条LOOP指令，提供了一种指定循环次数的方法，但它有一个问题：由于是先将ecx减一再判断，当设定循环次数为0时，实际上会循环FFFFFFFFH次。为了解决这个问题，IA32专门提供了一条用ECX是否为0作为判断条件的条件转移指令JECXZ/JCXZ
名称JECXZ/JCXZ（计数器转移指令）
格式JECXZ（JCXZ） LABEL
动作指令实现当寄存器ECX（CX）的值等于0时转移到标号LABEL处，否则顺序执行。
注意通常在上面几条循环指令之前使用，这样当循环次数为0时，就可以跳过循环体
JECXZ对应判断ECX值；JCXZ对应判断CX值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
//计算由用户输入的若干成绩的平均值
//演示堆栈传递参数调用子程序和JECXZ指令的使用：
//注意JECXZ和LOOP配合

#include  <stdio.h>
#define  COUNT  5                  //假设成绩项数
int  main()
{
    int  score[COUNT];             //用于存放由用户输入的成绩
    int  i, average;
    for  (i=0; i < COUNT; i++)
    {                             //由用户从键盘输入成绩
        printf("score[%d]=", i);
        scanf("%d", &score[i]);
    }
    //调用子程序计算成绩平均值
    _asm  {
        LEA    EAX, score
        PUSH   COUNT         //把数组长度压入堆栈
        PUSH   EAX            //把数组起始地址压入堆栈
        CALL    AVER           //调用子程序
        ADD    ESP, 8           //平衡堆栈
        MOV    average, EAX
    }
    printf("average=%d\n",average);
    return 0;


 _asm  {
    AVER:     //子程序入口
        PUSH  EBP
        MOV   EBP, ESP
        MOV   ECX, [EBP+12]      //取得数组长度
        MOV   EDX, [EBP+8]       //取得数组起始地址
        XOR   EAX, EAX           //将EAX作为和sum
        XOR   EBX, EBX           //将EBX作为下标i
        JECXZ   OVER            //如数组长度为0，不循环累加
    NEXT:
        ADD   EAX, [EDX+EBX*4]   //累加
        INC   EBX                //调整下标i
        LOOP   NEXT 
       
        CDQ                        //被除数符号扩展到64位，准备做除法

        IDIV  DWORD PTR [EBP+12]
    OVER:
        POP   EBP                  //撤销堆栈框架
        RET                        //返回
    }
}

说明：

  1. 堆栈示意
    1747124190761.webp

  2. 32位有符号数除法，先用CDQ把EAX符号扩展到EDX:EAX

二、综合示例

  1. 把二进制数转换为十进制数的ASCII码串

    1. 方法：

      1. 把一个整数除以10，所得的余数就是个位数。
      2. 把所得的商再除以10，所得的余数就是十位数。
      3. 继续把所得的商除以10，所得的余数就是百位数。
      4. 依次类推，就可以得到一个整数的各位十进制数字了。

    32位二进制数能表示的最大十进制数只有10位，循环地除上10次，就可以得到各位十进制数，注意这样得到的结果最前面有若干个0

    1. 把一位十进制数转换为对应的ASCII码，只要加上数字符‘0’的ASCII码。

    2. 存放顺序：
      由于先得到个位数，然后得到十位数，再得到百位数，所以在把所得的各位十进制数的ASCII码存放到字符串中去时，要从字符串的尾部开始。
      1747124475280.webp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int  main( )
{
    unsigned  uintx = 56789123;  //无符号整型变量
    char  buffer[11];            //用于存放ASCII码串的缓冲区
    _asm  
    {
    LEA   ESI, buffer          ;获存放字符串的缓冲区首地址
    MOV   EAX, uintx           ;取得待转换的数据
    MOV   ECX, 10              ;循环次数（十进制数的位数）
    MOV   EBX, 10              ;十进制的基数是10
NEXT:
    XOR   EDX, EDX             ;形成64位的被除数（无符号数除）
    DIV   EBX                  ;除以10，EAX含商，EDX含余数
    ADD   DL, '0'              ;把析出十进制位转成对应的ASCII码
    MOV   [ESI+ECX-1], DL     ;保存到缓冲区
    LOOP   NEXT              ;计数循环
    ;
    MOV   BYTE PTR [ESI+10],0  ;设置字符串结束标志
}
    printf("%s\n", buffer);      //输出字符串
    return 0;
}
  1. 改进上面的程序
    （1）设二进制数是有符号的。如果负数，则所得字符串的第一个字符应该是负号。
    （2）不需要前端可能出现的字符‘0’
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
int  main( )
{
    int   intx = -57312;
char  buffer[16];               //足够长
//printf(“%d\n”,intx);

    _asm  
    {
    LEA   ESI, buffer           ;置指针初值
    MOV   EAX, intx             ;取得待转换的数据
    CMP   EAX, 0                ;判断待转换数据是否为负数
    JGE   LAB1                  ;非负数，转
    MOV   BYTE  PTR  [ESI], '-' ;先保存一个负号
    INC   ESI                   ;调整指针
    NEG   EAX                   ;取相反数，得正数
LAB1:
    MOV   ECX, 10               ;最多循环10次
    MOV   EBX, 10               ;每次除以10
    MOV   EDI, 0                ;置有效位数的计数器初值
NEXT1:
    XOR   EDX, EDX
    DIV   EBX                   ;获得1位十进制数
    ;
    PUSH   EDX                ;把所得1位十进制数压入堆栈
    INC   EDI                   ;有效位数增加1
    ;
    OR    EAX, EAX              ;测试结果（商）
    LOOPNE    NEXT1          ;如结果不为0，考虑继续循环
    MOV   ECX, EDI              ;置下一个循环的计数
NEXT2:
    POP   EDX                  ;从堆栈弹出余数
    ADD   DL, '0'               ;转成对应的ASCII码
    MOV   [ESI], DL             ;依次存放到缓冲区
    INC   ESI
    LOOP    NEXT2             ;循环处理下一位
    ;
    MOV   BYTE  PTR  [ESI], 0   ;设置字符串结束标志
}
    printf("%s\n", buffer);      //输出字符串
    return 0;
}
]]> <h1 id="一、循环程序设计"><a href="#一、循环程序设计" class="headerlink" title="一、循环程序设计"></a>一、循环程序设计</h1><h2 id="（1）循环程序设计示例"><a href="#（1）循环程序设计示例" class 8-分支程序设计 https://blog.pridelzh.top/posts/784783.html 2025-08-31T08:06:00.000Z 2025-08-31T08:06:00.000Z 一、分支程序设计

（1）分支程序设计示例

1. 两种分支结构

  • if结构（图a）；if-else结构（图b）
  • 需要注意一下用汇编写if-else结构的时候，if分支结束后要用无条件转跳过else分支，后面详细说明

2. 简单分支示例

  • 有简单分支程序
1
2
3
4
5
6
7
//大写字母转小写
int cf315(int ch)
{
if(ch>='A' && ch<='Z')
ch+=0x20;
return ch;
}
  • 现在把它反汇编（关闭优化）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//子过程cf315
//入口参数：堆栈传递ch
//出口参数：eax
_asm
{
CF315:
push ebp
mov ebp,esp

cmp DWORD PTR[ebp+8],65
jl SHORT lab1//<A跳转
cmp DWORD PTR[ebp+8],90
jg SHORT lab1//>Z跳转

mov eax,DWORD PTR[ebp+8]//是大写字母，转小写
add eax,32
mov DWORD PTR[ebp+8],eax

lab1://用eax返回结果
mov eax,DWORD PTR[ebp+8]
pop ebp
ret

}
  • 现在再打开优化反汇编一次
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
_asm
{
CF315:
push ebp
mov ebp,esp

mov eax,DWORD PTR[ebp+8]//ch取到eax中
lea ecx,DWORD PTR[eax-65]//ecx=eax-65
cmp ecx,25
ja lab1//看作无符号数，如果ecx>25，意味着ch不是大写字母
add ecx,32

lab1://用eax返回结果
pop ebp
ret
}
  • 观察到的优化手段：
    1. 巧妙地把两个分支减少到一个
    2. 充分利用寄存器，减少从内存取值

3. 双分支示例

  • 有双分支程序
1
2
3
4
5
6
7
8
9
10
//把十进制数m转十六进制字符的ASCII码
int cf316(int m)
{
m = m & 0x0f;//确保m的值在0~15
if(m<10)
m+=0x30;//如：1->'1'
else
m+=0x37;//如：10->'A'
return m;
}
  • 现在把它反汇编（关闭优化）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
_asm
{
CF316:
push ebp
mov ebp,esp

mov eax,DWORD PTR[ebp+8]//m = m & 0x15;
and eax,15
mov DWORD PTR[ebp+8],eax

cmp DWORD PTR[ebp+8],10
jge SHORT lab1//m>=10转lab1

mov ecx,DWORD PTR[ebp+8]//m<10,m+=0x30
add ecx,48
mov DWORD PTR[ebp+8],ecx
jmp lab2//绕过else分支，注意！！！
lab1:
mov ecx,DWORD PTR[ebp+8]//m>=10,m+=0x37
add ecx,55
mov DWORD PTR[ebp+8],ecx
lab2://统一的返回位置
mov eax,DWORD PTR[ebp+8]
pop ebp
ret
}
  • 现在打开优化再反汇编一次
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
_asm
{
push ebp
mov ebp,esp

mov eax,DWORD PTR[ebp+8]
and eax,15

cmp eax,10
jge SHORT lab1

add eax,48
pop ebp
ret

lab1:
add eax,55
pop ebp
ret
}

观察：

  1. 如果不开优化，参数或局部变量都存在堆栈，要修改必须要进行：取到Reg，修改，写回堆栈三步
  2. 汇编程序是自上往下顺序执行的，（不像C语言中if-else可以选择分支执行；while、for可以循环执行一段代码），它只能用jcc指令修改下一条程序代码的位置，就好像不能用if、else、while、for，只能用goto的C程序。因此像if-else结构，必须在if分支最后jmp跳过else，否则会顺序把else也执行一次。
  3. 优化手段：
    1. 用寄存器减少从内存取值
    2. 避免了jmp指令，两个分支不再合并而是各自返回。减少跳转次数
  • 优化源程序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int cf317(int m)
{
m=m&0x0f;
m+=0x30;
if(m>'9')
m+=7;
return m;
}

//开优化反汇编
_asm
{
push ebp
mov ebp,esp

mov eax,DWORD PTR[ebp+8]
and eax,15

add eax,48
cmp eax,57
jle lab1
add eax,7
lab1:
pop ebp
ret
}
  • 小结：
    1. 靠编译器自动优化，再好也是依赖于源C程序的，要想真正提高程序效率，还得从源程序上改进
    2. 优化策略：
      1. 减少内存的存取数据，多用寄存器
      2. 减少跳转数量
      3. 避免时钟数多的指令（右移代替除法）
      4. 减少循环次数
      5. 用内联函数减少call和ret

（2）无条件和条件转移指令

1. 基本概念

  • 段内转移（近转移）：转移时只重置指令指针寄存器EIP，不重置代码段寄存器CS，
  • 段间转移（远转移）：转移时重置指令指针寄存器EIP和代码段寄存器CS
  • 转移类型判断
转移属于段内还是段间
条件转移段内
循环指令段内
无条件转移段内或段间
过程调用和返回段内或段间
软中断指令段间
中断返回指令段间
  • 直接转移：转移指令中直接给出转移目的地址
  • 间接转移：转移指令中给出包含转移目的地址的寄存器或存储单元

2. 无条件转移指令

  1. 无条件段内直接转移
    1. 无条件段内直接转移指令的机器码格式
      image.png
    2. 操作码OP：转移指令的机器码
    3. 地址差rel：转移目标地址偏移（标号LABEL所指定指令的地址偏移）与紧随JMP指令的下一条指令的地址偏移之间的差值。
      1. rel会被汇编器自动计算，并自动选取为8/16/32位来表示。如果只用了8位，就称为短（short）转移。
      2. 如果程序不能自动计算地址偏差了多少，用32位来表示rel
      3. 如果编程时可以判断地址偏差不超过8位范围，可以用SHORT指令强制汇编器用8位表示rel
      4. 由于rel是有符号数，转移方向可以向前也可以向后
    4. 执行无条件段内转移指令时，把指令中的地址差rel加到指令指针寄存器EIP上，使EIP之内容为转移目标地址偏移，从而实现转移。
名称jmp（无条件段内直接转移指令）
格式jmp label
动作下一条指令转移到 label 处执行
  1. 无条件段内间接转移
名称jmp（无条件段内间接转移指令）
格式jmp OPDR
动作指令使控制无条件地转移到由操作数OPRD的内容给定的目标地址处
合法值OPDR：32位寄存器、32位存储单元
注意OPRD内容直接被装入指令指针寄存器EIP，从而实现转移

3. 条件转移指令

  1. 之前的文章已经写过，见jcc相关部分：
  2. 条件转移指令通过判断状态标志确定转移是否发生，但是本身不影响标志状态
  3. 也是通过label标记确定转移位置，在机器码层面的实现和无条件段内直接转移一样

（3）多分支的实现

  • 多分枝类似C中的switch-case
  • 源程序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//示例函数cf319
int  cf319(int x, int operation)
{
int  y;
//多路分支
switch (operation) {
case 1:
y = 3 * x;
break;
case 2:
y = 5 * x + 6;
break;
case 4:
case 5:
y = x * x;
break;
case 8:
y = x * x + 4 * x;
break;
default://0 3 6 7 9 10 ...
y = x;
}
if (y > 1000)
y = 1000;
return  y;
}
  • 进行反汇编
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
//返汇编（速度最大化）
push  ebp
    mov   ebp, esp
                                   ; switch ( operation ) {
    mov   eax, DWORD PTR [ebp+12]  ;取得参数operation（case值）
    dec   eax                      ;从0开始计算，所以先减去1
    cmp   eax, 7                   ;从0开始计算，最多就是7
    ja    SHORT LN2cf319           ;超过，则转default
    ;
    jmp   DWORD  PTR  LN12cf319[ eax*4 ]     ;实施多路分支
    ;
LN6cf319:                            ; case 1:
                                     ; y = 3*x;
    mov   eax, DWORD PTR [ebp+8]
    lea   eax, DWORD PTR [eax+eax*2]
    jmp   SHORT  LN7cf319            ; break;
    ;
LN5cf319:                            ; case 2:
                                     ; y = 5*x+6;
    mov   eax, DWORD PTR [ebp+8]
    lea   eax, DWORD PTR [eax+eax*4+6]
    jmp   SHORT  LN7cf319            ; break;
    
LN4cf319:                            ; case 4:
                                     ; y = x*x ;
    mov   eax, DWORD PTR [ebp+8]
    imul  eax, eax
    jmp   SHORT LN7cf319             ;  break;
    ;
LN3cf319:                            ; case 8:
                                     ; y = x*x+4*x;
    mov   ecx, DWORD PTR [ebp+8]
    lea   eax, DWORD PTR [ecx+4]
    imul  eax, ecx
    jmp   SHORT LN7cf319             ; break;

LN2cf319:                            ; default:
                                     ; y = x ;
    mov   eax, DWORD PTR [ebp+8]
                                     ; }
LN7cf319:                            ; if ( y > 1000 )
    cmp   eax, 1000
    jle   SHORT  LN1cf319
                                     ; y = 1000;
    mov   eax, 1000
LN1cf319:                            ; return  y;
    pop   ebp                        ;撤销堆栈框架
    ret
    ;

LN12cf319:                           ;多向分支目标地址表
    DD    LN6cf319                   ; case 1(DD代表双字，每4个字节存放一个入口地址)
    DD    LN5cf319                   ; case 2
    DD    LN2cf319                   ; default
    DD    LN4cf319                   ; case 4
    DD    LN4cf319                   ; case 5
    DD    LN2cf319                   ; default
    DD    LN2cf319                   ; default
    DD    LN3cf319                   ; case 8

分析

  1. 最后LN12cf319部分，开启了多向分支目标地址表，DD代表地址表中每一项占4个字节，因此LN12cf319+4*0就是LN6cf319；LN12cf319+4*1就是LN5cf319，依次类推
  2. jmp DWORD PTR LN12cf319[ eax*4 ]这句，跳转到地址LN12cf319+eax*4执行，这是实现switch-case的关键。注意eax要改到0起始
  3. 空位置default必须留出，否则转换过来的时候会出错
  4. 可以看到地址表是按地址排列的，适用于多分枝且没有大空洞的情况。如果各个case间有大间距，会导致地址表中default项过多，最好预处理一下，或者改用if-else逻辑
]]> <h1 id="一、分支程序设计"><a href="#一、分支程序设计" class="headerlink" title="一、分支程序设计"></a>一、分支程序设计</h1><h3 id="（1）分支程序设计示例"><a href="#（1）分支程序设计示例" class 7-算术逻辑运算指令 https://blog.pridelzh.top/posts/78465153.html 2025-08-31T08:05:00.000Z 2025-08-31T08:05:00.000Z 一、乘除运算指令
  • 乘除运算指令区分有符号数与无符号数
  • 对状态标志的影响，和加减指令相比不是很自然。

（1）无符号数乘法指令

名称MUL（无符号乘法指令）
格式MUL OPRD
动作乘数是OPRD，被乘数位于AL、AX或EAX中（由OPRD的尺寸决定，乘数和被乘数的尺寸一致），相乘后乘积尺寸翻倍：16位乘积送到AX；32位乘积送DX:AX；64位乘积送EDX:EAX
合法值OPRD：通用寄存器、存储单元；
注意OPRD不能是立即数
乘数和被乘数的尺寸一致
1
2
3
MUL   BL                 //8位乘    乘积在AX
MUL   ECX                //32位乘   乘积在DX:AX
MUL   DX                 //16位乘   乘积在EDX:EAX

（1）有符号数乘法指令

  1. 单操作数形式：
名称IMUL（单操作数乘法指令）
格式IMUL OPRD
动作乘数是OPRD，被乘数位于AL、AX或EAX中（由OPRD的尺寸决定，乘数和被乘数的尺寸一致），乘法运算时把二者看作有符号数，相乘后乘积尺寸翻倍：16位乘积送到AX；32位乘积送DX:AX；64位乘积送EDX:EAX
合法值OPRD：通用寄存器、存储单元；
注意OPRD不能是立即数
乘数和被乘数的尺寸一致
1
2
IMUL   CL
IMUL   DWORD PTR [EBP+12]     //双字存储单元
  1. 双操作数形式：
名称IMUL（双操作数乘法指令）
格式IMUL DEST，SRC
动作DEST和SRC相乘后送到DEST，乘法运算时把二者看作有符号数
合法值DEST：16位或者32位通用寄存器
SRC：通用寄存器、存储单元、立即数
注意DEST不能是8位寄存器
SRC是通用寄存器、存储单元时，尺寸需要和目的操作数一致
SRC是立即数时，尺寸不能超过目的操作数
  1. 三操作数形式：和MUL相比
名称IMUL（三操作数乘法指令）
格式IMUL DEST，SRC1，SRC2
动作SRC1 和SRC2相乘后送到DEST，乘法运算时把二者看作有符号数
合法值SRC1：寄存器、存储单元
SRC2：立即数
注意SRC1和SRC2都看作有符号数
SRC1尺寸需要和目的操作数一致
SRC2尺寸不能超过目的操作数
1
2
3
4
5
6
IMUL   BX
IMUL   EBX, ECX
IMUL   AX，CX，3
IMUL   EDX，DWORD PTR [ESI]，5
IMUL   AX，7
IMUL   AX，AX，7

（3）无符号数除法指令

名称DIV（无符号数除法指令）
格式DIV OPRD
动作除数是OPRD
被除数位于AX、DX:AX或EDX:EAX中（被除数的尺寸是OPRD两倍）
商在AL、AX或者EAX中（尺寸与oprd相同）
余数在AH、DX或者EDX中（尺寸与oprd相同）
合法值OPRD：寄存器、存储单元
注意必须防止除溢出，除数不能为0，商不能太大超出存放位置尺寸
OPDR不能是立即数
1
2
3
DIV   BL                //除数8位
DIV   ESI               //除数32位
DIV   CX                //除数16位

（4）有符号数除法指令

名称IDIV（有符号数除法指令）
格式IDIV OPRD
动作除数是OPRD
被除数位于AX、DX:AX或EDX:EAX中（尺寸为OPRD两倍）
商在AL、AX或者EAX中（尺寸同OPRD）
余数在AH、DX或者EDX中（尺寸同OPRD）
合法值OPRD：寄存器、存储单元
注意必须防止除溢出，除数不能为0，商绝对值不能太大超出存放位置尺寸
如果不能整除，余数的符号与被除数一致，而且余数的绝对值小于除数的绝对值。
OPDR不能是立即数

（5）符号扩展指令

  1. 字节转换为字
名称CBW（字节转换为字指令）
格式CBW
动作指令把AL中的符号扩展到AH
注意若AL的最高有效位为0，则AH=0；若AL的最高有效位为1，则AH=0FFH，也即AH的8位全都为1
1
2
3
4
MOV   AX, 3487H        //AX=3487H
CBW                    //AX=FF87H
MOV   AX, 8734H
CBW                    //AX=0034H
  1. 字转换为双字
名称CWD（字转换为双字指令）
格式CWD
动作指令把AX中的符号扩展到DX
注意若AX的最高有效位为0，则DX=0；若AX最高有效位为1，则DX=0FFFFH，也即DX的16位全都为1
1
2
3
4
MOV   AX, 3487H        //AX=3487H
CWD                    //DX=0000H, AX=3487H
MOV   AX, 8734H
CWD                    //DX=FFFFH, AX=8734H
名称CWDE（字转换为双字指令）
格式CWDE
动作指令把AX中的符号扩展到EAX高16位
注意AX的最高有效位为0，则EAX的高16位都为0；若AX的最高有效位为1，则EAX的高16位都为1。
1
2
3
4
MOV   AX, 3487H        //AX=3487H
CWDE                   //EAX=00003487H
MOV   AX, 8734H
CWDE                   //EAX=FFFF8734H
  1. 双字转换为四字
名称CDQ（双字转换为四字指令）
格式CDQ
动作指令把EAX中的符号扩展到EDX
注意若EAX的最高有效位为0，则DX=0；若AX最高有效位为1，则DX=0FFFFFFFFH，也即EDX的16位全都为1
1
2
MOV   EAX, 12563487H   ;EAX=12563487H
CDQ                    ;EDX=00000000H, EAX=12563487H

综合示例：演示除法指令和符号扩展指令的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include  <stdio.h>
int  main()
{   
int  quotient, remainder;    //为了输出结果，安排两个变量
    _asm 
    {
        MOV   AX, -601
        MOV   BL, 10
        IDIV   BL                   //除数是BL，被除数是AX,余数在AH,商在AL
        MOV   BL, AH              //先临时保存余数
        ;
        CBW                        //商在AL，符号扩展到AX
        CWDE                       //AX符号扩展到EAX
        MOV   quotient, EAX
        ;
        MOV   AL, BL                //余数送到AL
        CBW                        //AL符号扩展到AX
        CWDE                       //AX符号扩展到EAX
        MOV   remainder, EAX
    }
    printf("quotient= %d\n", quotient);     //显示为-200
    printf("remainder= %d\n", remainder);   //显示为-1
    return  0;
}
  1. 符号扩展传送指令
名称MOVSX（符号扩展传送指令指令）
格式MOVSX DEST，SRC
动作把源操作数符号扩展后送至目的操作数DEST
合法值SRC：通用寄存器、存储单元
DEST：通用寄存器
注意目的操作数的尺寸必须大于源操作数的尺寸。源操作数的尺寸可以是8位或者16位；目的操作数的尺寸可以是16位或者32位
1
2
3
4
5
MOV    AL, 85H               //AL=85H
MOVSX  EDX, AL               //EDX=FFFFFF85H
MOVSX  CX, AL                //CX=FF85H
MOV    AL, 75H               //AL=75H
MOVSX  EAX, AL               //EAX=00000075H
  1. 零扩展传送指令
名称MOVZX（零扩展传送指令指令）
格式MOVZX DEST，SRC
动作指令把源操作数SRC零扩展后送至目的操作数DEST
合法值SRC：通用寄存器、存储单元
DEST：通用寄存器
注意目的操作数的尺寸必须大于源操作数的尺寸。源操作数的尺寸可以是8位或者16位；目的操作数的尺寸可以是16位或者32位
1
2
3
MOV    DX, 8885H             ;DX=8885H
MOVZX  ECX, DL               ;ECX=00000085H
MOVZX  EAX, DX               ;EAX=00008885H

综合示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//参数是有符号字符型，返回值是int
int  cf310(char x, char y)
{
    return  ( x + 22 ) / y ;
}

//转汇编如下
push   ebp
mov    ebp, esp
movsx  eax, BYTE PTR [ebp+8]   //把参数x符号扩展后送到eax
add    eax, 22
movsx  ecx, BYTE PTR [ebp+12]  //把参数y符号扩展后送到ecx
cdq                            //符号扩展，形成64位的被除数
idiv   ecx
pop    ebp
ret
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//参数是无符号字符型，返回值是unsigned int
unsigned int  cf311(unsigned char x, unsigned char y)
{
    return  (unsigned)( x + 22 ) / y ;
}

//转汇编如下
push   ebp
mov    ebp, esp
movzx  eax, BYTE PTR [ebp+8]   //把参数x零扩展后送到eax
add    eax, 22
movzx  ecx, BYTE PTR [ebp+12]  //把参数x零扩展后送到ecx
xor    edx, edx                //零扩展，形成64位的被除数
div    ecx
pop    ebp
ret

二、逻辑运算指令

  • C语言中有一组按位逻辑运算符
    1. 按位取反运算符 ~
    2. 按位与运算符 &
    3. 按位或运算符 |
    4. 按位异或运算符 ^
  • 处理器提供一组逻辑运算指令
    1. 否指令 NOT
    2. 与指令 AND
    3. 或指令 OR
    4. 异或指令 XOR
  • 关于逻辑运算指令的通用说明
    1. 只有通用寄存器或存储单元可作为目的操作数，用于存放运算结果。
    2. 如只有一个操作数，则该操作数既是源又是目的。
    3. 如有两个操作数，那么最多只能有一个是存储单元，源操作数可以是立即数。
    4. 存储单元可采用各种存储器操作数寻址方式。
    5. 操作数可以是字节、字或者双字。如果有两个操作数，尺寸必须一致。

（1）否运算指令

名称NOT（否运算指令）
格式NOT OPRD
动作把操作数OPRD按位取反，然后送回OPRD
合法值OPRD：通用寄存器、存储单元
1
2
3
NOT   CL
NOT   EAX
NOT   BX

（2）与运算指令

名称AND（与运算指令）
格式AND DEST，SRC
动作指令对两个操作数进行按位的逻辑与运算，结果送到目的操作数DEST
合法值SRC：通用寄存器、存储单元、立即数
OPRD：通用寄存器、存储单元
注意两个操作数最多只能有一个是存储单元
1
2
3
AND   ECX，ESI
MOV   AX，3437H          //AX=3437H
AND   AX，0F0FH          //AX=0407H

（3）或运算指令

名称OR（或运算指令）
格式OR DEST，SRC
动作指令对两个操作数进行按位的逻辑或运算，结果送到目的操作数DEST
合法值SRC：通用寄存器、存储单元、立即数
OPRD：通用寄存器、存储单元
注意两个操作数最多只能有一个是存储单元
1
2
3
4
OR    CL，CH
OR    EBX，EAX
MOV   AL，41H         ;AL=01000001B，后缀B表示二进制
OR    AL，20H         ;AL=01100001B

（4）异或运算指令

名称XOR（异或运算指令）
格式XOR DEST，SRC
动作指令对两个操作数进行按位异或的逻辑“异或”运算，结果送到目的操作数DEST
合法值SRC：通用寄存器、存储单元、立即数
OPRD：通用寄存器、存储单元
注意两个操作数最多只能有一个是存储单元
1
2
3
4
MOV   AL，34H         ;AL=00110100B，符号B表示二进制
MOV   BL，0FH         ;BL=00001111B
XOR   AL，BL          ;AL=00111011B
XOR   ECX，ECX        ;ECX=0，CF=0

（5）测试指令

名称TEST（测试指令）
格式TEST DEST，SRC
动作类似指令AND，把两个操作数进行按位“与”，但结果不送到目的操作数DEST，仅仅影响状态标志
合法值SRC：通用寄存器、存储单元、立即数
OPRD：通用寄存器、存储单元
注意两个操作数最多只能有一个是存储单元
标志ZF、PF和SF反映运算结果，标志CF和OF被清0
1
2
3
4
5
6
TEST  AL, BL
TEST  EDX, ECX

//检查AL中的位6和位2是否有一位为1
TEST   AL，01000100B       //符号B表示二进制
//随后，判断标志位ZF，若ZF=0，则这两位上都是0

三、移位指令

关于移位的几个要素：

  1. 移动方式
    • 一般移位指令
    • 循环移位指令
    • 双精度移位指令
  2. 移动方向
    • 左移
    • 右移
  3. 移动位数
    • 1位
    • m位

（1）一般移位指令

名称算术左移SAL SAL OPRD，count
逻辑左移SHL SHL OPRD，count
算术右移SAR SAR OPRD，count
逻辑右移SHR SHR OPRD，count
动作算术左移SAL：动作一样，左移count位。每左移一位，移出的最高位进入CF，最低位补0
逻辑左移SHL：同算术左移SAL
算术右移SAR：右移count位。每右移一位，移出的最低位进入CF，符号（最高）位不变
逻辑右移SAR：右移count位。每右移一位，移出的最低位进入CF，符号（最高）位补0
合法值count：8位立即数、存储单元、寄存器CL
OPRD：通用寄存器、存储单元（字节、字、双字）
注意通过截取count的低5位，实际的移位数被限于0到31之间

1747106285619.webp

SAL、SHL示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
MOV   EBX, 7400EF9CH    //EBX=7400EF9CH
ADD   EBX, 0            //EBX=7400EF9CH，CF=0,SF=0,ZF=0,PF=1
SHL   EBX, 1            //EBX=E801DF38H，CF=0,SF=1,ZF=0,PF=0
MOV   CL, 3             //CL=3
SHL   EBX, CL           //EBX=400EF9C0H，CF=1,SF=0,ZF=0,PF=1
SHL   EBX, 16           //EBX=F9C00000H，CF=0,SF=1,ZF=0,PF=1
SHL   EBX, 12           //EBX=00000000H，CF=0,SF=0,ZF=1,PF=1

//实现把寄存器AL中的内容（设为无符号数）乘以10
//算术（逻辑）左移1位，相当于乘以2
XOR   AH, AH            //AH=0
SHL   AX, 1             //2*X
MOV   BX, AX            //暂存2*X
SHL   AX, 2             //8*X
ADD   AX, BX            //8*X+2*X

SAR示例

1
2
3
4
5
6
//算术右移1位，相当于有符号数除以2
MOV   DX, 82C3H         //DX=82C3H
SAR   DX, 1             //DX=C161H,CF=1,SF=1,ZF=0,PF=0
MOV   CL, 3             //CL=3
SAR   DX, CL            //DX=F82CH,CF=0,SF=1,ZF=0,PF=0
SAR   DX, 4             //DX=FF82H,CF=1,SF=1,ZF=0,PF=1

SHR示例

1
2
3
4
5
MOV   DX, 82C3H         //DX=82C3H
SHR   DX, 1     //DX=4161H,CF=1,SF=0,ZF=0,PF=0
MOV   CL, 3             //CL=3
SHR   DX, CL            //DX=082CH,CF=0,SF=0,ZF=0,PF=0
SHR   DX, 12            //DX=0000H,CF=1,SF=0,ZF=1,PF=1

（2）循环移位指令

名称左循环移位指令 ROL ROL OPRD，count
右循环移位指令 ROR ROR OPRD，count
带进位左循环移位指令 RCL RCL OPRD，count
带进位右循环移位指令 RCR RCR OPRD，count
动作见下图
合法值count：8位立即数、存储单元、寄存器CL
OPRD：通用寄存器、存储单元（字节、字、双字）
注意通过截取count的低5位，实际的移位数被限于0到31之间

1747106441546.webp

循环移位指令的示例

1
2
3
4
5
6
7
8
9
MOV   DX, 82C3H           ;DX=82C3H
ROL   DX, 1               ;DX=0587H, CF=1
MOV   CL, 3               ;CL=3
ROL   DX, CL              ;DX=2C38H, CF=0
MOV   EBX, 8A2035F7H      ;EBX=8A2035F7H
ROR   EBX, 4              ;EBX=78A2035FH, CF=0
STC                       ;CF=1（设置进位标志）
RCL   EBX, 1              ;EBX=F14406BFH, CF=0
RCR   EBX, CL             ;EBX=DE2880D7H, CF=1

（3）双精度移位指令

  • 把一个操作数的部分内容移位方式复制到另一个操作数
名称双精度左移SHLD SHLD OPRD1，OPRD2，count
双精度右移SHRD SHRD OPRD1，OPRD2，count
动作双精度左移SHLD ：OPDR1左移count位，低端空出的位用OPDR2高端的count位填补，但OPDR2不变。OPDR1中最后移出的放在CF
双精度右移SHRD ：OPDR1右移count位，高端空出的位用OPDR2低端的count位填补，但OPDR2不变。OPDR1中最后移出的放在CF
合法值OPDR1：通用寄存器、存储单元（字、双字）
OPRD：通用寄存器（字、双字）
注意两个操作数尺寸必须一致
count表示移位的位数，可以是一个8位立即数，也可以是寄存器CL。寄存器CL表示移位数由CL的值决定。通过截取count的低5位，移位数被限于0到31之间

示例

1
2
3
4
5
6
7
8
9
10
MOV   AX, 8321H
MOV   DX, 5678H
SHLD  AX, DX, 1            //AX=0642H，DX=5678H，CF=1，OF=1
SHLD  AX, DX, 2            //AX=1909H，DX=5678H，CF=0，OF=0

MOV   EAX, 01234867H
MOV   EDX, 5ABCDEF9H
SHRD  EAX, EDX, 4          //EAX=90123486H，CF=0，OF=1
MOV   CL, 8
SHRD  EAX, EDX, CL         //EAX=F9901234H，CF=1，OF=0
]]> <h1 id="一、乘除运算指令"><a href="#一、乘除运算指令" class="headerlink" title="一、乘除运算指令"></a>一、乘除运算指令</h1><ul> <li>乘除运算指令区分有符号数与无符号数</li> <li>对状态标志的影响，和加减指 6-堆栈的作用 https://blog.pridelzh.top/posts/4564778.html 2025-08-31T08:04:00.000Z 2025-08-31T08:04:00.000Z 一、过程调用和返回指令

（1）过程

  1. 过程：汇编语言中的子程序称为过程（procedure），对应C语言中的函数。
  2. 调用子程序（过程、函数）在本质上是控制转移，它与无条件转移的区别是调用子程序要考虑返回

（2）过程调用指令

名称CALL（过程调用指令）
格式CALL LABEL
动作先把返回地址偏移（EIP内容）压入堆栈，然后给EIP赋值为目标LABEL的地址偏移，实现转移
注意返回地址：紧随过程调用指令的下一条指令的地址（有效地址）
目标地址：子程序开始处的地址（有效地址）
与无条件转移指令相比，过程调用指令CALL只是多了第一步（保存返回地址）

1747103763953.webp

（3）过程返回指令

名称RET（过程返回指令）
格式RET
动作从堆栈弹出地址偏移，并送到指令指针寄存器EIP
注意通常，这个返回地址就是在执行对应的调用指令时所压入堆栈的返回地址
过程返回指令的使用应该与过程调用指令相对应
示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
dp32
·演示子程序的调用和返回，说明call和RET指令的作用
·调试时关注ESP的值，进出子程序时有压栈和出栈
·这里都是用寄存器传递参数的，影响堆栈的只有进/出子程序时保存/弹出原EIP位置
·特别注意，这里把子程序的汇编安排在return语句之后，这样能避免不经调用直接进入子程序。如果有编译器不支持这样写，需要用goto跳过
*/
#include <stdio.h>
char string[] = "abcde";

int main()
{
_asm
{
LEA ESI,string//指针寄存器ESI指向string首
MOV AX,[ESI]//从ESI取两个字节放入AX ('a''b')
CALL TUPPER//把这两个字节的字符小写转大写
MOV [ESI],AX

MOV AX,[ESI+2]
CALL TUPPER//把这两个字节的字符小写转大写（这里进栈了返回地址偏移，ret时自动平衡)
MOV [ESI+2],AX

MOV AL, [ESI+4]
CALL UPPER//把最后一个字节的字符小写转大写
MOV [ESI+4],AL
}

printf("%s\n", string);
system("pause");

return 0;

_asm
{
//UPPER函数用于把AL中的字符小写转大写
UPPER:
CMP AL, 'a'
JB UPPER2
CMP AL, 'z'
JA UPPER2
SUB AL, 20H//确认是小写字符后，转为大写
UPPER2 :
RET

//TUPPER函数用于把AX中的两个字符小写转大写
TUPPER :
CALL UPPER
XCHG AH, AL
CALL UPPER
XCHG AH, AL
RET
}
}

二、参数传递

（1）参数传递

  1. 参数传递：主程序在调用子程序时，往往要向子程序传递一些参数；同样，子程序运行后也经常要把一些结果返回给主程序。主程序与子程序之间的这种信息传递被称为参数传递
  2. 入口参数：由主程序传给子程序的参数称为子程序的入口参数
    出口参数：由子程序传给主程序的参数称为子程序的出口参数
  3. 一般而言，子程序既有入口参数，又有出口参数。但有的子程序只有入口参数，而没有出口参数；少数子程序只有出口参数，而没有入口参数。

（2）参数传递方式

  1. 有多种传递参数的方法∶寄存器传递法、堆栈传递法、约定内存单元传递法和CALL后续区传递法等。有时可能同时采用多种方法，根据具体情况而事先约定好
  2. 常用的两种方法：
方法说明特点
寄存器传递参数把参数放在约定的寄存器中，在主程序中将参数放入寄存器，在子程序中取出实现简单和调用方便，但只适用于传递参数较少的情形
堆栈传递参数主程序在调用子程序之前，把需要传递的参数依次压入堆栈，然后子程序从堆栈中取入口参数不占用寄存器，也无需额外的存储单元。但较为复杂
示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*
dp33
·演示利用堆栈传递子程序参数，子程序参数x,y,返回2x+5y+100
·注意平衡堆栈：esp和ebp的值在子程序调用前后是一致的
·如果反汇编C语言形式的这个函数，不要加_fastcall前缀，否则会用寄存器传参，不会生成这样的代码
*/

#include <stdio.h>

int main()
{
int sum = 0;

_asm
{
push 456//参数y进栈，esp+=4
push 23//参数x进栈，esp+=4
call cf34//这里进栈了返回地址偏移（ret自动平衡）
add esp,8//手动平衡堆栈（x,y）

mov sum,eax
}

printf("sum=%d\n", sum);
system("pause");
return 0;

_asm
{
cf34:
push ebp//子程序返回时ebp要复原，这里先保存一下，esp+=4
mov ebp,esp//ebp指向栈顶（esp）——建立堆栈框架
mov eax,DWORD PTR[ebp+12]//之前入栈了3个值，这里地址往回找4*3=12，取出第一个参数y
mov ecx,DWORD PTR[ebp+8]//取第二个参数x

//计算2x+5y+100,存入eax
lea eax,DWORD PTR[eax+eax*4+100]
lea eax, DWORD PTR[eax+ecx*2]
pop ebp//回复ebp的值，平衡堆栈——撤销堆栈框架
ret
}
}

堆栈传递参数的堆栈变化示意

1747104101750.webp

三、局部变量

  1. 局部变量是高级语言中的概念。所谓局部变量指对其的访问仅限于某个局部范围。在C语言中，局部的范围可能是函数，或者是复合语句。局部变量还有动态和静态之分。
  2. 堆栈可以用于安排动态局部变量

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/*
dp36
·演示利用堆栈安排动态局部变量
·等价的C程序：
int cf36(int x,int y)//返回xy中较大的
{
int z;
z=x;
if(x<y)
z=y;
return z;
}
*/

#include <stdio.h>

int main()
{
int max = 0;
int x, y;
printf("输入两个整数：");
scanf("%d %d", &x, &y);

_asm
{
mov eax,y
push eax
mov eax,x
push eax

call cf36//这里进栈了返回地址偏移
add esp,8//平衡堆栈

mov max,eax
}
printf("max = %d\n", max);
system("pause");
return 0;

_asm
{
cf36:
push ebp
mov ebp,esp//建立堆栈框架
push ecx//在堆栈安排局部变量z
mov eax,DWORD PTR[ebp+8]//eax取得参数x
mov DWORD PTR[ebp-4],eax//z=x

mov ecx, DWORD PTR[ebp+8]//ecx取得参数x
cmp ecx, DWORD PTR[ebp+12]//比较x和y
jge SHORT LN1cf36//x>y则跳转，SHORT表示转移目的地就在附近
mov edx, DWORD PTR[ebp+12]//x<=y,则edx取得y,赋值给z
mov DWORD PTR[ebp-4],edx

LN1cf36:
mov eax,DWORD PTR[ebp-4]//eax取得z的值
mov esp,ebp//撤销局部变量z
pop ebp//撤销堆栈框架
ret 
}
}

堆栈示意，安排局部变量并且由堆栈传递参数
1747104248056.webp

]]> <h1 id="一、过程调用和返回指令"><a href="#一、过程调用和返回指令" class="headerlink" title="一、过程调用和返回指令"></a>一、过程调用和返回指令</h1><p>（1）过程</p> <ol> <li><code>过程</code> 5-控制转移与堆栈 https://blog.pridelzh.top/posts/45646.html 2025-08-31T08:03:00.000Z 2025-08-31T08:03:00.000Z 一、指令指针寄存器和简单控制转移

（1）指令指针寄存器

  1. 指令指针寄存器EIP:

    • IA-32系列CPU有一个32位的指令指针寄存器EIP，它始终指向当前处理的指令。
    • 它是早先8086CPU指令指针寄存器IP的扩展
    • 由CS和EIP确定所取指令的存储单元地址。段寄存器CS给出当前段代码段的段号，指令指 针寄存器EIP给出偏移。即CS:EIP
    • 如果代码段起始地址为0，则EIP给出的偏移直接决定所取指令的存储单元地址
    • 实方式下，段的最大范围是64k，EIP中高16位必须为0，只有低16位的IP起作用

  2. 顺序执行指令的过程
    CPU执行代码（程序）就是一条接一条地执行机器指令。可以把CPU执行指令的过程看做一条处理指令的流水线，通过以下两个步骤实现的指令的顺序执行。

    1. 从存储器取指令
    2. 根据指令长度，自动调整指令指针寄存器EIP的值，使其指向下一条指令
      这些工作是CPU自动完成的，只需要把我们编写的汇编程序存入代码段，就可以自动顺序执行了。

  3. 控制转移指令
    控制转移指令，它通过直接改变EIP寄存器的内容，实现指令执行过程中的跳转

    1. 转移：非自动顺序调整EIP内容
    2. 控制转移指令：专门用于改变EIP内容的指令
    3. 各种控制转移指令用于根据不同的情形改变EIP内容，从而实现转移，包括：
      1. 条件转移指令
      2. 无条件转移指令
      3. 循环指令
      4. 函数调用及返回指令

（2）常用条件转移指令

  1. 格式：Jcc LABEL
  2. 操作：jcc代表各种条件转移指令的缩写（助记符），当条件满足时，转到标号LABEL处执行；否则顺序执行
  3. 注意：就好像小于和不大于等于是一码事，同一条指令也可能有多个助记符，见下表
    image.png

（3）比较指令和数值大小比较

  1. 比较指令
名称CMP（比较指令）
格式CMP DEST,SRC
动作根据DEST-SRC的差影响标志寄存器中各状态标志，但不结果作为结果的差值送目的寄存器
合法值SRC：通用寄存器、存储单元、立即数
DEST：通用寄存器、存储单元
注意DEST 和 SRC 必须尺寸一致
除了不把差值结果送DEST外，其他和SUB指令完全一致
1
2
3
4
CMP   EDX, -2             ;把EDX与-2比较
CMP   ESI, EBX            ;把ESI与EBX比较
CMP   AL, [ESI]           ;AL与由ESI所指的字节存储单元值作比较
CMP   [EBX+EDI*4+5], DX   ;由EBX+EDI*4+5所指字存储单元值与DX作比较
  1. 比较数值的大小
    1. 一般使用比较指令CMP。
    2. 根据零标志ZF判断是否相等（JN/JE）
      • 如果都是无符号数，可根据进位CF判断大小（JNB/JAE/JC）
      • 如果都是有符号数，同时根据符号标志SF和溢出标志OF判断（JL/JNGE）
    3. IA-32同时提供两套以数值大小为条件的条件转移指令，分别使用无符号数之间比较和有符号数之间比较。二者判断标志不同
      • 有符号数间称：大于（G），等于（E）,小于（L）
      • 无符号数间称：高于（A），等于（E）,低于（B）

示例：

1
2
3
4
5
6
7
8
9
10
11
12
//假设ECX和EDX存储两个数，现在要把较大的存在ECX中，较小的存在EDX中
//如果这两个数是有符号数
cmp ecx,edx
jge OK//有符号数比较转移：ecx>=edx转到OK
xchg ecx,edx//ecx<edx，交换
OK:

//如果这两个数是无符号数
cmp ecx,edx
jae OK//无符号数比较转移：ecx>=edx转到OK
xchg ecx,edx//ecx<edx，交换
OK:

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//用汇编实现下面C函数转的功能：
int myCmpare(int x,int y)
{
int z=1;
if(x>=13 && y<=28)
z=2;
return z;
}

//转汇编,假设ecx传递x,edx传递y，eax作变量z：
mov eax,1
cmp ecx,13//x和13比较
jl SHORT lab1//SHORT参数代表转移目的地就在附近
cmp edx,28//y和28比较
jg SHORT lab1
mov eax,2
lab1:
ret//函数结束，返回到调用者

（4）简单无条件转移指令

名称CMP（比较指令）
格式JMP LABEL
动作指令控制无条件转移到LABEL处
注意是段内转移，没有任何前提一定发生转移，类似C中的goto
通常用在if-else分支用，if分支结束后跳过else分支

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//原始C代码（_fastcall表示用寄存器传参数）
int  _fastcall  cf215(int x, int y)
{
    int  z;
    if  ( x > 10 )            //语句A
        z = 3*x+4*y+7;
    else
        z = 2*x+7*y-12;
    if ( y <= 20 )           //语句B
        z = 4*z+3;
    return  z;               //语句C
}

//反编译
 cmp   ecx, 10                          //x与10比较
    jle   SHORT  LN3cf215                  //当小于等于10时转
    lea   eax, DWORD PTR [ecx+ecx*2]       //计算表达式3*x+4*y+7
    lea   eax, DWORD PTR [eax+edx*4+7]
    jmp   SHORT  LN2cf215                  //无条件转（if-else语句结束）
LN3cf215:
    lea   eax, DWORD PTR [edx*8]           //计算表达式7*y+2*x-12
    sub   eax, edx
    lea   eax, DWORD PTR [eax+ecx*2-12]
LN2cf215:
    cmp   edx, 20                          //y与20比较
    jg    SHORT  LN1cf215                  //当大于20时转
    lea   eax, DWORD PTR [eax*4+3]         //计算4*z+3LN1cf215:
    ret

二、堆栈和堆栈操作

（1）堆栈

  1. 程序的运行和堆栈有密切关系

    • cpu运行期间需要堆栈保存某些关键信息
    • 程序自身用堆栈保存一些临时数据

  2. 堆栈

    • 堆栈：一段内存区域，对他的访问限于一端进行。存储于堆栈段，段寄存器为SS
    • 栈底：堆栈中地址较大的一端
    • 栈顶：堆栈中地址较小的一端

  3. 堆栈的操作

    • 后进先出原则，所有存取在栈顶进行（存入数据的地址越来越小，堆栈生长方向为从高地址到低地址）
    • 进栈/压栈操作：存入数据
    • 出栈/弹出操作：取出数据

  4. 堆栈相关寄存器

寄存器存储内容
SS（堆栈段寄存器）当前堆栈段号，指示堆栈所在内存区域的位置
ESP（堆栈指针寄存器）栈顶的偏移，SS:ESP永远指向栈顶，CPU自动控制
EBP（堆栈数据寄存器）栈内数据的偏移，SS:EBP指向栈中一个数据 （习惯指向函数帧栈底），手动控制

  1. 堆栈平衡

    1. 堆栈平衡：在函数调用前后esp和ebp的值应当相同
    2. 为何要做堆栈平衡：esp和ebp寄存器在子函数调用时是非常重要的（见下方说明），其值在调用过程中会发生改变。一个程序中可能有很多函数，有时还会有嵌套调用的情况，但CPU只有esp和ebp两个寄存器，怎么处理大量的函数呢？intel的策略是同一时刻只处理该时刻执行的函数，也就是说esp和ebp的值在不断刷新。如果一个函数执行后没有恢复esp和ebp指针，就会影响它前后及嵌套的函数，使它们操作堆栈时地址错乱。

  2. 堆栈的用途

    1. 保护寄存器、保护现场
    2. 保存返回地址
    3. 传递参数
    4. 安排局部变量或临时变量
    5. 反转一组数据

一张很清晰的图片
image.png

（2）堆栈操作指令

  1. 进栈指令
名称PUSH（进栈指令）
格式PUSH SRC
动作把源操作数SRC压入堆栈，并调整esp指向栈顶
合法值SRC：32/16位通用Reg或段Reg；双字/字存储单元；立即数
注意双字入栈：ESP-4，然后把双字送到ESP所指的数据单元
字入栈：ESP-2，然后把字送到ESP所指的数据单元
至少进栈一个字
示例：
1
2
3
4
PUSH   EAX                //把EAX的内容压入堆栈
PUSH   DWORD PTR [ECX]    //把ECX指示的双字存储单元的内容压入堆栈
PUSH   BX                 //把BX的内容压入堆栈
PUSH   WORD PTR [EDX]     //把EDX指示的字存储单元的内容压入堆栈

image.png

  1. 出栈指令
名称POP（出栈指令）
格式POP DEST
动作从栈顶弹出一个双字/字到DEST，并调整esp指向栈顶
合法值DEST：32/16位通用Reg或段Reg；双字/字存储单元。但是不能是立即数或代码段寄存器CS
注意双字出栈：先从ESP所指存储单元弹出一个双字数据送DEST，然后ESP+=4
字出栈：先从ESP所指存储单元弹出一个字数据送DEST，然后ESP+=2
至少出栈一个字
DEST不能是立即数或代码段寄存器CS
示例：
1
2
3
4
POP   ESI                  //从堆栈弹出一个双字到ESI
POP   DWORD PTR [EBX+4]    //从堆栈弹出一个双字到EBX+4所指示存储单元
POP   DI                   //从堆栈弹出一个字到DI
POP   WORD PTR [EDX+8]     //从堆栈弹出一个字到EDX+8所指示的存储单元
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include  <stdio.h>
int  main( )  
{
int  varsp1, varsp2, varsp3, varsp4, varsp5;  //用于存放ESP值
int  varr1, varr2;                            //用于存放EBX值
_asm
{
    MOV   EAX, 12345678H     //初值
    MOV   varsp1, ESP        //保存演示之初的ESP（假设为0013FA74H）
    
    PUSH  EAX                //把EAX压入堆栈
    MOV  varsp2, ESP         //保存当前ESP（0013FA70H）
    
    PUSH  AX                 //把AX压入堆栈
    MOV   varsp3, ESP        //保存当前ESP（0013FA6EH）
    
    POP   EBX                //从堆栈弹出双字到EBX
    MOV   varsp4, ESP        //保存当前ESP（0013FA72H）
    MOV   varr1, EBX
    
    POP   BX                 //从堆栈弹出字到BX
    MOV   varsp5, ESP        //保存当前ESP（0013FA74H）
    MOV   varr2, EBX
}
    printf("ESP1=%08XH\n",varsp1);    //显示为ESP1=0013FA74H
    printf("ESP2=%08XH\n",varsp2);    //显示为ESP2=0013FA70H
    printf("ESP3=%08XH\n",varsp3);    //显示为ESP3=0013FA6EH
    printf("ESP4=%08XH\n",varsp4);    //显示为ESP4=0013FA72H
    printf("ESP5=%08XH\n",varsp5);    //显示为ESP5=0013FA74H
    printf("EBX1=%08XH\n",varr1);     //显示为EBX1=56785678H
    printf("EBX2=%08XH\n",varr2);     //显示为EBX2=56781234H
    return  0;
}
  1. 通用寄存器全进出栈指令
  • 有时需要把多个通用Reg压入栈，以保护值。为了提高效率，从80186开始提供了通用寄存器全进出栈指令

（1）16位通用Reg

名称PUSHA（16位通用寄存器全进栈指令）
格式PUSHA
动作将8个16位通用寄存器的内容压入堆栈，压入顺序：AX、CX、DX、BX、SP、BP、SI、DI
名称POPA（16位通用寄存器全出栈指令）
格式POPA
动作从堆栈弹出内容，以PUSHA相反的顺序送通用寄存器

（2）32位通用Reg

名称PUSHAD（32位通用寄存器全进栈指令）
格式PUSHAD
动作将8个16位通用寄存器的内容压入堆栈，压入顺序：EAX、ECX、EDX、EBX、ESP、EBP、ESI、EDI
名称POPAD（32位通用寄存器全出栈指令）
格式POPAD
动作从堆栈弹出内容，以PUSHA相反的顺序送通用寄存器

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//演示PUSHAD指令的执行效果，还演示另一种访问堆栈区域存储单元的方法
#include  <stdio.h>
int   buff[8];       //全局数组，存放从堆栈中取出的各寄存器之值
int  main( )
{
    _asm 
    {    
     PUSH  EBP            //先保存EBP！！
    ;
    MOV   EAX, 0         //给各通用寄存器赋一个特定的值
    MOV   EBX, 1
    MOV   ECX, 2
    MOV   EDX, 3
    ;                    //决不能随意改变ESP！！
    MOV   EBP, 5
    MOV   ESI, 6
    MOV   EDI, 7
    ;
    PUSHAD               //把8个通用寄存器之值全部推到堆栈
    ;
MOV   EBP, ESP       //使得EBP也指向堆栈顶
    LEA   EBX, buff      //把数组buff首元素的有效地址送到EBX
    MOV   ECX, 0         //设置计数器（下标）初值
NEXT:
    MOV   EAX, [EBP+ECX*4]    //依次从堆栈中取
    MOV   [EBX+ECX*4], EAX    //依次保存到数组buff
    INC   ECX                 //计数器加1
    CMP   ECX, 8              //是否满8
    JNZ   NEXT                //没有满8个，继续处理下一个
    ;
    POPAD                     //恢复8个通用寄存器
    POP   EBP      
    }
    //依次显示数组buff各元素之值，从中观察PUAHAD指令压栈的效果
    int  i;
    for  (i=0; i<8; i++)
        printf("buff[%d]=%u\n", i, buff[i]);
    return  0;
}

image.png

]]> <h2 id="一、指令指针寄存器和简单控制转移"><a href="#一、指令指针寄存器和简单控制转移" class="headerlink" title="一、指令指针寄存器和简单控制转移"></a>一、指令指针寄存器和简单控制转移</h2><h3 id="（1）指令指针寄存 4-段寄存器&寻址方式 https://blog.pridelzh.top/posts/78454568.html 2025-08-31T08:01:00.000Z 2025-08-31T08:01:00.000Z 一、段寄存器及使用

1、存储器分段

（1）物理地址相关

  • 内存(逻辑存储器)：CPU能通过CPU总线直接寻址访问的存储器

  • 物理地址：内存(逻辑存储器)每一个字节单元有一个唯一的地址，称为物理地址。

    1. 这个物理地址就是各存储器在CPU总线上的地址，利用它CPU可以直接访问到对应的存储空间
    2. CPU的地址线数量决定可产生的最大物理地址，n根地址线—>最大地址2^n-1，32位CPU通常有32根地址线，因此32位CPU的电脑最大只能装4G的内存条

  • 物理地址空间：所有可形成的物理地址的集合

    1. 物理地址空间大小不等于实际安装物理内存大小
    2. Intel8086有20根地址线，物理地址的范围是0到FFFFF
      Intel80386有32根地址线，物理地址的范围是0到FFFFFFFF

（2）存储器分段

  • 为了有效地管理存储器，常常把

    1. 线性的物理地址空间划分为若干逻辑段
    2. 存储空间被划分为若干存储段

    可以认为逻辑段和存储段是对应的。

  • 通常，运行的程序把不同的数据存储于存储器中的不同存储段，包括

    1. 代码：要执行的指令序列（存储于代码段）
    2. 数据：要处理加工的内容（存储数据段）
    3. 堆栈：按先进后出规则存取的区域（存储于堆栈段）

2、逻辑地址

（1）逻辑地址

  • 分段后，程序中使用的某个存储单元总是属于某个段，所以可以 某某段 某某单元方式表示存储单元
  • 逻辑地址：程序中用于表示存储单元的地址
    1. 由于采用分段存储管理方式，程序中使用的逻辑地址是二维的，第一维给出某某段，第二维给出段内的某某单元。
    2. 二维的逻辑地址可以表示为：段号∶段内地址
    3. (段内)偏移：存储单元的物理地址与所在段起始地址的差值。这个差值恰好是段内地址，因此二维的逻辑地址又可以表示为：段号∶偏移
    4. 实方式下，段号是段值
      保护方式下，段号是段选择子
    5. 有效地址/偏移地址：逻辑地址中的偏移称作有效地址或偏移地址，汇编程序中，不同的数据往往固定存放在不同的段，有唯一对应的段寄存器，因而这个地址用的最多。比如指示代码的EIP、指示堆栈位置的ESP、EBP等都是存储的有效地址

（2）逻辑地址转为物理地址

  • 物理地址 = 段起始地址 + 偏移

  • 获得物理地址的过程：

    1. 由段号得到段起始地址
    2. 加上偏移

  • 对于IA32

    1. 保护方式下：物理地址32位，段起始地址32位，偏移32位
    2. 实方式下：物理地址20位，段起始地址20位，偏移16位
    3. 可以参考：我理解的逻辑地址、线性地址、物理地址和虚拟地址(补充完整了)

    对于8086：

    1. 只有实方式：物理地址20位，段起始地址20位，偏移16位
    2. 可以参考：逻辑地址、线性地址和物理地址之间的转换

  • 如果整个程序只有一个段，则二维逻辑地址退化为一维。段起始地址完全相同，偏移决定一切。如果用VS2010来编写嵌入汇编程序，那么就是这种情况，只考虑偏移即可

（3）三种地址小结

地址说明
物理地址各存储器在CPU总线上的地址，是实际上可以直接访问到存储器的地址
逻辑地址段号∶偏移 方式描述的地址，需要进行一些计算才能转换为物理地址
有效地址就是逻辑地址中的偏移量

3、段寄存器

  • 作用：段寄存器存放着当前使用的逻辑地址中的段号（段值/段选择子），用于获得段起始地址。
  • 段寄存器是16位的，在实方式下存储16位段值；在保护方式下存储16位段选择子
  • 1747644039768.webp
  • 若代码段、堆栈段、数据段在同一个存储段，则CS、DS、SS给出相同的段起始地址
  • 若段寄存器给出的段起始地址为0，则偏移相当于物理地址

二、寻址方式

  • 寻址方式：表示指令中操作数所在的方法
  • CPU常用的三种寻址方式：立即寻址、寄存器寻址、存储器寻址，此外还有固定寻址和I/O端口寻址
  • 以上三种方式都是对于偏移地址的不同描述，对于段基址：
    1. 基址寄存器是EBP或ESP时，默认的段寄存器是SS
    2. 否则，默认的段寄存器是DS

1、立即寻址

  • 立即寻址方式：操作数本身就包含在指令中，直接作为指令的一部分给出，这样的操作数称为立即数

  • 注意：

    1. 只有源操作数可以使用立即寻址方式
    2. 如果立即数由多个字节构成，么在作为指令的一部分存储时，也采用“高高低低”规则。

  • 由于立即寻址方式的操作数是立即数，包含在指令中，所以执行指令时，不需要再到存储器中去取该操作数了。

    1. 立即寻址，会自动配合目的操作数尺寸，不需要dword ptr等参数

  • 示例：

1
2
3
4
5
6
7
8
9
//以下源操作数使用立即寻址方式
MOV   EAX, 12345678H      //给EAX寄存器赋初值
ADD   BX, 1234H           //给BX寄存器加上值1234H
SUB   CL, 2               //从CL寄存器减去值2

//以下源操作数值一致，但是尺寸不同
MOV   EDX, 1              //源操作数是32位
MOV   DX, 1               //源操作数是16位
MOV   DL, 1               //源操作数是8位

2、寄存器寻址

  • 寄存器寻址方式：操作数存在CPU内部寄存器，指令指定寄存器

  • 适用范围：

    1. 8个32位寄存器：EAX,EBX,ECX,EDX,ESI,EDI,EBP,ESP
    2. 8个16位寄存器：AX,BX,CX,DX,BP,SI,DI,SP
    3. 8个8位寄存器：AH,AL,BH,BL,CH,CL,DH,DL

  • 操作数在寄存器中，不需要访问存储器取得操作数，这样指令执行速度较快

  • 示例：

1
2
3
4
MOV   EBP, ESP        //把ESP之值送到EBP
ADD   EAX, EDX        //把EAX之值与EDX之值相加，结果送到EAX
SUB   DI, BX          //把DI之值减去BX之值，结果送到DI
XCHG  AH, DH          //交换AH与DH之值

3、32位的存储器寻址方式

  • 存储器寻址方式：给出存储单元偏移的寻址方式（在某个段内，给出存储单元的偏移即可找到它）
  • 存储器操作数：在指令中[xxx]意味着从xxx地址取数据，称这个[xxx]为存储器操作数。
  • 有效地址：要访问的存储单元的段内偏移。在32位的存储器寻址方式下，存储单元有效地址可达32位
  • 采用32位的存储器寻址方式，能够给出32位的偏移
  • 有多种存储器寻址方式
    1. 直接寻址
    2. 寄存器间接
    3. 寄存器相对
    4. 基址加变址
    5. 通用方法
  • 说明：
    1. 存储器操作数尺寸是字节/字/双字
    2. 默认指令中的寄存器操作数的尺寸决定了存储器操作数的尺寸；但也可以显式指定存储器操作数尺寸
修饰符功能
WORD PTR指定尺寸为“字”
BYTE PTR指定尺寸为“字节”
DWORD PTR指定尺寸为“双字”

（1）直接寻址方式

  • 直接寻址方式：操作数在存储器中，指令直接包含操作数所在的存储单元的有效地址。
  • 示例：
1
2
3
MOV   ECX, [95480H]       //源操作数采用直接寻址
MOV   [9547CH], DX        //目的操作数采用直接寻址
ADD   BL, [95478H]        //源操作数采用直接寻址

  • 即寻址和直接寻址的区别：

    1. 直接寻址中十六进制数表示地址，要到此地址取出操作数；立即寻址中表示操作数
    2. 直接寻址的地址要写在方括号[]中

  • 注意：

    1. 直接寻址时，[]给出的是被取出数据的最低地址
    2. 按 “高高低低” 规则取出数据
      1747644493685.webp

（2）寄存器间接寻址方式

  • 寄存器间接寻址：操作数在存储器中，由八个32位通用寄存器之一给出操作数所在存储单元有效地址。

  • 寄存器间接寻址和寄存器寻址的区别：

    1. 寄存器间接的Reg名称出现在方括号[]中
    2. 寄存器间的Reg中存储的是操作数所在地址；寄存器寻址的Reg存储的是操作数

  • 注意：

    1. 操作数地址必须来自八个32位通用寄存器之一

  • 示例：

1
2
3
MOV   EAX, [ESI]    //源操作数寄存器间接寻址，ESI给出有效地址
MOV   [EDI], CL     //目的操作数寄存器间接寻址，EDI给出有效地址
SUB   DX, [EBX]     //源操作数寄存器间接寻址，EBX给出有效地址

（3）通用方式

  • 存储单元的有效地址可以由三部分内容相加构成

    1. 一个32位基地址寄存器
    2. 一个可乘上比例因子1/2/4/8的32位变址寄存器
    3. 一个8/16/32位位移量

    PS：可省去任意两部分
    1747644625918.webp

  • 注意：

    1. 变址寄存器乘上的比例因子取值只能是1/2/4/8之一
    2. 三部分中可以任意省略。省略后的寻址方式又有不同名称，但都属于通用方式，前面提到的直接寻址方式和寄存器间接寻址方式也是属于通用方式

  • 示意图：

  • 1747644764536.webp

  • 示例：

    1. 寄存器相对寻址方式：[寄存器名+偏移]
    1
    2
    3
    MOV   EAX, [EBX+12H]      ;源操作数有效地址是EBX值加上12H
    MOV   [ESI-4], AL         ;目的操作数有效地址是ESI值减去4
    ADD   DX, [ECX+5328H]     ;源操作数有效地址是ECX值加上5328H
    1. 基址+变址寻址：[寄存器名+寄存器名]
1
2
3
MOV   EAX, [EBX+ESI]      ;源操作数有效地址是EBX值加上ESI值
SUB   [ECX+EDI], AL       ;目的操作数有效地址是ECX值加上EDI值
XCHG  [EBX+ESI], DX       ;目的操作数有效地址是EBX值加上ESI值
3. `基址+带放大因子的变址寻址`：`[寄存器名+寄存器名*放大因子+偏移]`
1
2
3
4
5
MOV   EAX, [ECX+EBX*4]      ;EBX作为变址寄存器，放大因子是4
MOV   [EAX+ECX*2], DL       ;ECX作为变址寄存器，放大因子是2
ADD   EAX, [EBX+ESI*8]      ;ESI作为变址寄存器，放大因子是8
SUB   ECX, [EDX+EAX-4]      ;EAX作为变址寄存器，放大因子是1
MOV   EBX, [EDI+EAX*4+300H] ;EAX作为变址寄存器，放大因子是4

（4）补充

  • 用 [address] 这样的方法从内存取值

    1. address是地址尾，也就是取出值的最低字节地址
    2. 存入寄存器时，低地址对应寄存器低位；高地址对应高位（“高高低低”规则）
    3. 初始化好的全局变量，占用内存空间是连续的

  • 使用尺寸修饰符的示例：

  • 1747644937172.webp

  • 关于存储器寻址的说明

    1. 缺省段寄存器
      （1）如果基址寄存器不是EBP/ESP，缺省引用的段寄存器为DS
      （2）如果基址寄存器是EBP/ESP，缺省引用的段寄存器为SS
      （3）如果EBP作为变址寄存器（ESP不能做变址寄存器），缺省引用的段寄存器为DS
    2. 有效地址
      （1）无论存储器寻址方式具体是哪种，如果基址寄存器、变址 寄存器、比例因子、位移量这些算出来超过32位，只有低32位有效

三、取有效地址指令LEA

名称LEA（取有效地址指令）
格式LEA REG,OPRD
动作把操作数OPRD的有效地址传送到REG
合法值OPRD：存储器操作数；
REG：16/32位通用寄存器
注意此指令不影响标志寄存器
此指令是取地址，和mov有本质区别
  • 示例1：基本操作
1
2
3
4
5
MOV   EDI, 51234H                 //EDI=00051234H
MOV   EAX, 6                      //EAX=00000006H
LEA   ESI, [EDI+EAX]              //ESI=0005123AH
LEA   ECX, [EAX*4]                //ECX=00000018H
LEA   EBX, [EDI+EAX*4+300H]       //EBX=0005154CH
  • 示例2：指针的实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include  <stdio.h>
char  chx, chy;                //全局字符变量
int  main( )
{
    char  *p1, *p2;            //两字符型指针变量
    //嵌入汇编代码之一
    _asm {
        LEA   EAX, chx         //取变量chx的存储单元有效地址
        MOV   p1, EAX          //送到指针变量p1, p1 = &chx
        LEA   EAX, chy         //取变量chy的存储单元有效地址
        MOV   p2, EAX          //送到指针变量p2, p2 = &chy
   } 
    
 printf("Input:");           //提示
    scanf("%c", p1);            //键盘输入一个字符
    
    //嵌入汇编代码之二
    _asm {
        MOV   ESI, p1           //取回变量chx的有效地址
        MOV   EDI, p2           //取回变量chy的有效地址
        MOV   AL, [ESI]         //取变量chx之值
        MOV   [EDI], AL         //送到变量chy中
    }
    printf("ASCII:%02XH\n", *p2);  //显示之
    return  0;
}
  • 示例三：取一个double数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
int     iarr[5] = {55, 87, -23, 89, 126};   
double  darr[5] = {9.8, 2.77, 3.1415926, 1.414, 1.73278};
                                            
int  main()
{   int     ival;           //整型变量
    double  dval;           //双精度浮点
    //嵌入汇编
    _asm  {
        LEA   EBX, iarr         //把整型数组首元素的有效地址送EBX
        MOV   ECX, 3
        MOV   EDX, [EBX+ECX*4]  //取出iarr的第4个元素
        MOV   ival, EDX
        ;
        LEA   ESI, darr         //把浮点数组首元素的有效地址送ESI
        LEA   EDI, dval         //把变量dval的有效地址送EDI
        MOV   ECX, 2
        MOV   EAX, [ESI+ECX*8]    //取darr的第3个元素的低双字
        MOV   EDX, [ESI+ECX*8+4]  //取darr的第3个元素的高双字
        MOV   [EDI], EAX          //保存低双字
        MOV   [EDI+4], EDX        //保存高双字
    }
    printf("iVAL=%d\n",ival);     //显示为iVAL=89
    printf("dVAL=%.8f\n",dval);   //显示为dVAL=3.14159260
    return  0;
}
  • 示例四：妙用LEA和存储器取值，进行多项式计算
1
2
3
4
5
6
7
8
9
10
11
12
//待翻译的c函数
int  _fastcall  cf212(int x, int y)    //由寄存器传参数
{
    return ( 3 * x + 7 * y + 200 );
}

//翻译成汇编后的核心代码（ECX传递x，EDX传递y）
lea   eax, DWORD PTR [ecx+ecx*2]    //eax=3*x
lea   ecx, DWORD PTR [edx*8]        //ecx=8*y
sub   ecx, edx                      //ecx=7*y
lea   eax, DWORD PTR [eax+ecx+200]  //eax=3*x+7*y+200
ret
]]> <h1 id="一、段寄存器及使用"><a href="#一、段寄存器及使用" class="headerlink" title="一、段寄存器及使用"></a>一、段寄存器及使用</h1><h2 id="1、存储器分段"><a href="#1、存储器分段" class="he 3-简单传送，加减指令&标志寄存器 https://blog.pridelzh.top/posts/98989.html 2025-08-31T08:00:00.000Z 2025-08-31T08:00:00.000Z 一、简单传送指令

1747051478856.webp

  • 示例
1
2
3
4
5
6
7
8
9
10
MOVEAX, 12345678H//EAX =12345678H
MOVEBX, EAX//EBX =12345678H
MOVESI, 256//ESI =00000100H 
MOVECX, -1//ECX =FFFFFFFFH
MOVBX, ‘b’//EBX =12340062H
MOVAH, AL//EAX =12347878H
MOVCX, AX//ECX =FFFF7878H
MOVAX, SI//EAX =12340100H
MOVSI, BX//ESI =00000062H
MOVAL, BH//EAX =12340100H

1747051629241.webp

  • 示例
1
2
3
4
5
6
7
XCHG    AL, AH          //8位交换
XCHG    SI, BX          //16位交换
XCHG    EAX, EBX        //32位交换

XCHG    AL, [EBX]       //AL与由EBX指定的字节存储单元交换
XCHG    [ESI], BX       //BX与由ESI指定的字存储单元交换
XCHG    EDX, [EDI]      //EDX与由EDI指定的双字存储单元交换

二、加减指令

1747051822803.webp

  • 示例
1
2
3
4
5
6
ADD ECX,200//使ECX加上200
ADD EBX,ECX//使EBX加上ECX的值
ADD SI,10//使SI加上10
ADD DH,DL//使DH加上DL的值
ADD AL,5//使AL加上5
ADD EAX,[EBX]//使EAX加上EBX的值指定的存储单元的值

1747051907692.webp

1747057025764.webp
示例：

1
2
3
4
5
6
SUB    EDX,1000       //使EDX减去1000
SUB    ESI,EBX        //使ESI减去EBX值
SUB    DI,20          //使DI减去20
SUB    DH,CL          //使DH减去CL值
SUB    AL,7           //使AL减去7
SUB    ECX,[EDI]      //使ECX减去由EDI指定的双字存储单元值

1747057112278.webp
示例：

1
2
3
INC    ESI //使寄存器ESI值加1
INC    DI   //使寄存器DI值加1
INC    CL   //使寄存器CL值加1

1747057173044.webp
示例：

1
2
3
DEC   EDI     //使寄存器EDI值减1
DEC   SI      //使寄存器SI值减1
DEC   AL      //使寄存器AL值减1

1747057279293.webp
示例：

1
2
3
4
MOV   AL,3       //AL=03H
NEG   AL         //AL=FDH（-3）
MOV   EDX,-5     //EDX=FFFFFFFBH
NEG   EDX        //EDX=00000005H

1747057360282.webp
示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*
dp26
利用带符号加法ADC，处理可能产生的进位
*/

#include<stdio.h>

int main()
{
unsigned char v1 = 188, v2 = 172, v3 = 233;//3个字节变量
unsigned int sum = 0;

_asm
{
XOR EDX,EDX//EDX清零，DX用于存放累加和
ADD DL,v1//加第一个字节
ADC DH,0//高8位相加

ADD DL, v2//加第二个字节
ADC DH, 0//高8位相加（意在处理进位）

ADD DL, v3//加第三个字节
ADC DH, 0//高8位相加（意在处理进位）

MOV sum,EDX
}
// 通过ADC带位加法，使得可以保证处理进位，将仅为成功加到高位中

printf("sum=%u\n", sum);
system("pause");
return 0;
}

1747057421118.webp
示例：

1
2
3
4
MOV AX,620H
SUB AL,21H//AX=06FFH, CF=1
SBB AH,2//AX=03FFH，CF=0(注意这里CF的影响)
SBB AH,2//AX=01FFH，CF=0

三、标志寄存器及使用

1. 标志寄存器

  • 一个32位寄存器
  • 用于反映处理器的状态和运算结果的某些特征
  • 可以暂时认为主要是：状态标志 & 控制标志
  • 低16位对应8086的FLAGS寄存器
    1747057567052.webp
    1747057610001.webp

2. 状态标志

（1）CF进借位标志
1747057727585.webp
1747057749584.webp

（2）ZF零标志
1747057808999.webp
1747057827002.webp

（3）SF符号标志
1747057877487.webp
1747057899713.webp

（4）OF溢出标志
1747057931478.webp
1747057961047.webp

]]> <h1 id="一、简单传送指令"><a href="#一、简单传送指令" class="headerlink" title="一、简单传送指令"></a>一、简单传送指令</h1><p><img src="https://raw.gitcode.com/Pridelzh/blo 云支教之旅 https://blog.pridelzh.top/posts/78862.html 2025-08-29T09:25:34.797Z 2025-08-30T00:01:05.897Z

“一代人有一代人的使命，一代人有一代人的担当。”
——题记

盛夏的阳光炽烈而温柔，映照着城市的屋檐，也照进了屏幕两端的世界。这个暑假，我选择了一条不同寻常的道路——踏入“云支教”的实践旅程。借助互联网的桥梁，我与一位来自邻近城市的中学生相遇，在“云端”牵起了一段关于学习、成长与责任的缘分。

我仍清晰记得第一次连线时的情景。少年拘谨地坐在摄像头前，声音轻得像风拂过水面。我微笑着打破僵局，告诉他我们是一同学习的伙伴，而不是居高临下的讲解者。从那天起，我们制定了详尽的暑期学习计划，规划了语数英的复习安排，划定了每周的“云课堂”时段。课堂上，我引导他巩固基础知识，帮助他找到学习的薄弱环节，并带着他一步步拆解难题。渐渐地，我看到他的眼神里闪烁出自信的光芒，那是一束正在被点燃的希望。

除了课堂，我们还有一项特别的“云运动”计划。虽然身处不同的城市，但我们约定每周三下午共同完成一次“线上运动挑战”。我们会各自记录跑步的里程，分享自己的锻炼成果；有时候还会比拼平板支撑、俯卧撑次数，哪怕隔着屏幕，汗水依然是彼此的见证。一次次的挑战，让少年不再沉溺于手机和游戏，而是学会了用汗水收获力量。

更让我印象深刻的，是我们共同完成的“家乡风物探索”活动。我请他用手机拍摄自己家乡的风景和人文故事，再由我来帮他梳理资料，一起在“云端”制作出一份关于家乡文化的小小展示文案。他第一次认真去走访村头的古祠堂、河畔的老榕树、集市上的传统小吃摊；他第一次用镜头记录自己熟悉却从未留意的事物。当他骄傲地在屏幕前向我展示这些作品时，我仿佛也在和他一同重新认识这片土地。这种探索，不只是看风景，而是理解生活、理解家乡、理解文化本身。

就在这样一段段看似平凡的互动中，我逐渐意识到，所谓“支教”，并不是“我给予，你接受”的单向流动，而是一场双向奔赴的成长之旅。少年的自信在慢慢发芽，而我在教与学之间也愈加明白自己的责任感与使命感。

这种实践经历，让我对“新时代文明实践”有了更加具体、真切的感受。文明实践并不是书本上的抽象概念，也不仅仅是高悬在标语上的口号。它深深嵌入到社会的肌理里，融入到一场场具体的活动中，渗透进一个个普通人的生活里。正如习近平总书记所强调的，新时代文明实践中心要成为“传播党的创新理论、弘扬时代新风、推动文化自信的重要阵地”。而我们所做的云支教，正是把这种理念落到实处，让文明之花在看似平凡的日常里悄然绽放。

国家提出建设新时代文明实践中心，是为了打通思想宣传、文化服务、社会治理的“最后一公里”。而“云支教”就是一条跨越空间的数字纽带，让教育资源与文化交流突破时空限制，实现更大范围的共享。尤其在“双减”政策落地的背景下，教育公平成为社会关注的焦点。云支教的形式，使更多中学生能够获得优质的学习资源与精神陪伴，让“每一个孩子都能在同一片星空下闪耀”不再是遥不可及的梦想。

与此同时，《志愿服务条例》也为我们提供了制度保障，明确指出志愿服务是促进社会进步、提升社会文明程度的重要力量。这让我更加坚信，云支教不仅是一次志愿行动，更是文明传递的生动实践。技术让世界的距离缩短，而志愿精神让心与心的距离拉近。数字文明与志愿服务交织在一起，正在为新时代社会治理注入新的温度与力量。

我渐渐发现，文明实践的意义不仅在于“给予”，更在于“激发”。通过陪伴和引导，我看到少年慢慢养成自主学习的习惯，学会利用身边的资源，探索自己家乡的独特魅力。这种改变，不是单纯的成绩提升，而是一种对生活的热爱与对未来的渴望。这正是新时代文明实践的核心所在：让更多人有能力、有勇气去追求更加美好的生活。

站在更高的维度回望，云支教不仅关乎一个中学生的成长，更是社会文明程度提升的缩影。教育资源的共享、文化认同的建立、青少年精神世界的丰富，这些细微而深远的变化，最终会汇聚成推动社会前行的磅礴力量。

而在这股力量中，我们青年一代责无旁贷。青年是国家的未来与希望，我们不仅是文明果实的享用者，更是文明火炬的传递者。每一次云端的耐心讲解、每一段远隔千里的情感连接，都是对社会文明的默默贡献。正如习近平总书记所言：“青年兴则国家兴，青年强则国家强。”我们的志愿服务，不只是帮助别人，更是在塑造自己的精神品质，锤炼责任与担当。

或许，云支教本身无法改变社会的宏观格局，但它能点亮力所能及的角落。无数青年志愿者的一束束星光，终将汇聚成照亮时代前行的文明之河。当这样的星光愈加璀璨，新时代文明的航程，便会在我们这一代人的书写下，延伸得更加辽阔而壮丽。

“长风破浪会有时，直挂云帆济沧海。”云课堂暂告一段落，但文明的实践永远不会结束。那一端少年的眼神依旧闪亮，而我的心中也燃起更炽烈的信念：让青春与文明同行，让责任与梦想并肩，用我们一代人的脚步，去丈量新时代文明实践的广阔大地。

]]> <blockquote> <p>“一代人有一代人的使命，一代人有一代人的担当。”<br>——题记</p> </blockquote> <p>盛夏的阳光炽烈而温柔，映照着城市的屋檐，也照进了屏幕两端的世界。这个暑假，我选择了一条不同寻常的道路——踏入“云支教”的实践旅程。借助互联网 2-IA32处理器及寄存器 https://blog.pridelzh.top/posts/78454566788.html 2025-05-23T08:42:39.000Z 2025-05-23T08:42:39.000Z 一、IA32处理器简介
  1. IA32系列处理器

1747050199903.webp

  1. 保护地址方式&实地址方式
  • IA32系列CPU有3种工作方式：保护方式（包含一种子工作方式：虚拟8086方式）、实地址方式、系统管理方式

（1）保护方式

  1. 保护方式是IA32系列处理器的常态工作方式，可以发挥全部性能和特点 ,windows、Linux都运行于保护方式
  2. 全部32根地址线有效，可寻址4GB物理地址空间
  3. 支持存储器分段管理 & 可选的存储器分页管理机制
  4. 支持虚拟存储器的实现，用于指定存储单元的是面向虚拟存储器的虚拟地址
  5. 提供完善的保护机制
  6. 支持操作系统实现多任务管理
  7. 支持虚拟8086方式

（2）实地址方式

  1. 实地址方式是最初的工作方式：
    1. 开机/重新设置系统后，IA32工作于实地址方式
    2. 很久以前8086/8088等只支持实地址方式
  2. 实地址方式下只能访问最低1MB物理地址空间（00000H-FFFFFH）
  3. 实地址方式下只支持存储器分段管理，且每个段大小限于64KB，段内有效地址范围0000H-FFFFH。不支持分页
  4. 储管理机制。可以认为实地址方式下用于指定要访问存储单元的线性地址就是真实地址
  5. 实地址方式无法发挥IA32处理器 全部性能
  6. 指令集、执行环境和保护方式相同
  7. 实地址方式常被称为实方式

（3）工作方式的切换
1747050901961.webp

二、通用寄存器及使用

  • 寄存器是处理器内的特殊存储单元
  • 处理器内有多种不同用途的寄存器
  • 寄存器分别有各自的名称，以便表示和访问
  1. 通用寄存器简介
    1. IA32系列CPU有8个32位通用寄存器
    2. 通用寄存器用于存储数据、参与算数逻辑运算、给出存储单元地址
    3. 名称：
    • 32位：EAX,EBX,ECX,EDX,ESI,EDI,EBP,ESP
    • 16位：AX,BX,CX,DX,BP,SI,DI,SP
    • 8位：AH,AL,BH,BL,CH,CL,DH,D
      1747051079008.webp
    1. 通用寄存器的高16位不可以单独使用，因为没有名字；但是可以单独用低16位、还可再拆开高低8位单独使用
    2. 通用寄存器的低16位叫：AX,BX,CX,DX,BP,SI,DI,SP，对应8086中的8个通用寄存器
    3. 各寄存器作用简要说明
    • EAX,EBX,ECX,EDX主要用于算术逻辑运算之中，如ADD/SUB/XOR/OR等
    • ESI,EDI,EBP,ESP主要用作保存内存地址的指针。

1747051190119.webp

]]> <h1 id="一、IA32处理器简介"><a href="#一、IA32处理器简介" class="headerlink" title="一、IA32处理器简介"></a>一、IA32处理器简介</h1><ol> <li>IA32系列处理器</li> </ol> <p><img 1-基础知识 https://blog.pridelzh.top/posts/7845654.html 2025-05-23T08:38:58.000Z 2025-05-23T08:38:58.000Z 一、CPU简介

  1. 目标代码
    ==目标代码/目标程序：由机器指令组成的程序==

    • CPU只能执行机器指令
    • 高级语言编写的程序，最后都要转换成机器指令组成的程序，即目标代码，这样才能执行
    • 目标代码是二进制编码的
  • 程序编译过程
    • 1747049018950.webp

  1. CPU基本功能
    CPU的基本功能包括：==执行机器指令、暂存少量数据、访问寄存器==

    执行机器指令
    机器指令：CPU能直接识别并执行的指令
    指令集：一款CPU能执行的全部指令的集合
    指令的分类：
    （1）数据传送指令
    （2）转移指令
    （3）处理器控制指令
    （4）其他指令
    暂存少量数据
    大部分指令是对数据进行运算和处理。运算数据和运算结构存在
    （1）寄存器（CPU中）
    （2）存储器中（内存）
    利用CPU内寄存器存取运算数据和结果效率最高。汇编器会充分利用CPU中仅有的寄存器，编写汇编时也要注意
    访问存储器
    存储器：CPU可以直接访问的计算机系统的物理内存
    由机器指令组成的目标程序存储于存储器中，部分待处理数据也是
    存储器（内存）由一系列存储单元线性组成，最基本的存储单元为一个字节。为了标识和存取每一个单元，给每个单元一个编号（即地址）

二、汇编语言的概念

  1. 机器指令
  • 由CPU直接识别并执行的指令称为机器指令，采用二进制编码
  • 一般由操作码和操作数两部分构成
    （1）操作码指出要进行的 操作/运算…
    （2）操作数指出参与操作的 对象/结果存放位置/数据…
  • 通常用十六进制形式写出机器指令
  • 1747049313452.webp

  1. 汇编指令格式

    1. 用指令助记符、地址符号等表示的指令称为汇编格式指令
    2. 格式：[标号:] 指令助记符 [操作数表]，其中助记符是必须的，操作数随指令而定，标号可有可无

  2. 汇编语言的优缺点

    1. 优：效率高
    2. 缺：繁琐、难调试

三、数据的表示和存储

  1. 数值数据的表示

    • 数的二进制表示
    • 有符号数的补码表示
    • 符号扩展（扩展符号位）
    • 数值数据表示范围
    • BCD码（常用8421）
    • 十六进制表示(4位二进制转换1位十六进制，通常后加H)

  2. 非数值数据表示

    • ASCII码
    • 变形国标码

  3. 基本数据类型

    • 计算机存取的以二进制位表示的信息位数一般是8的倍数，有专门名称
      1747049719596.webp

  4. 数据的存储

  • 使用小端存储：数据的低位保存在内存的低地址中，而数据的高位保存在内存的高地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致。
]]> <h1 id="一、CPU简介"><a href="#一、CPU简介" class="headerlink" title="一、CPU简介"></a>一、CPU简介</h1><ol> <li><p>目标代码<br> &#x3D;&#x3D;目标代码&#x2F;目标程序：由机器指令 0-基础概念 https://blog.pridelzh.top/posts/78687865.html 2025-05-23T08:36:49.000Z 2025-05-23T08:36:49.000Z 这里有汇编语言的基础概念

1747048719342.webp
1747048749989.webp
1747048777898.webp

]]> <h1 id="这里有汇编语言的基础概念"><a href="#这里有汇编语言的基础概念" class="headerlink" title="这里有汇编语言的基础概念"></a>这里有汇编语言的基础概念</h1><p><img src="https://raw.gitcode. 6-LALR预测分析表 https://blog.pridelzh.top/posts/51.html 2025-05-16T13:28:41.000Z 2025-05-16T13:28:41.000Z

  • 研究LALR的原因

    • 规范LR分析表的状态数偏多

  • LALR特点

    • LALR和SLR的分析表有同样多的状态，比规范LR分析表要小得多
    • LALR的能力介于SLR和规范LR之间
    • LALR的能力在很多情况下已经够用

  • LALR分析表构造方法

    • 通过合并规范LR(1)项目集来得到
    • 合并核心项

    • image.png

    写出自动机，发现有共同点
    image.png

    image.png

    合并之后的
    image.png

    image.png

    分析表
    image.png

    该报错的依旧是报错
    image.png

    是否会引起冲突

    对于 LR(1) 文法, 合并得到的 LALR(1) 分析表是否会引入冲突？

    ·     不会引入移入/归约冲突

    假设合并后出现冲突，[A → α·, a] 与 [B → β · aγ, b]

    则在 LR(1) 自动机中, 存在某状态同时包含 [A → α·, a] 与 [B → β · aγ, c] (c随便是什么)

    ·     可能会引入归约/归约冲突

    image.png

    总结

    语法分析: 

    自顶向下:  LL(1)

    自底向上:  LR(0),  SLR(1), LALR(1), LR(1)

    LL(1), LR(0), SLR(1), LALR(1), LR(1)文法之间的关系

    https://blog.csdn.net/zuzhiang/article/details/79047743

    LR(0) < SLR(1) < LALR(1) < LR(1)

    即某个文法，如果是LR(0)文法，

    那其一定是SLR(1)文法，

    反过不成立。

    什么是LR(0)文法?

    LR(0)自动机, LR(0)分析表

    LL(1) 和他们没关系

    所有的二义性文法都不是上述文法.

    ]]>     <ul> <li><p>研究LALR的原因</p> <ul> <li>规范LR分析表的状态数偏多</li> </ul> </li> <li><p>LALR特点</p> <ul> <li>LALR和SLR的分析表有同样多的状态，比规范LR分析表要小得多</li> <li>LALR的