汇编语言-子程序
汇编语言子程序设计实验心得总结 汇编语言程序设计实验心得体会汇总
汇编语言子程序设计实验心得总结汇编语言程序设计实验心得体会汇总心得体会是指一种读书、理论后所写的感受性文字。
那么我们写心得体会要注意的内容有什么呢？接下来我就给大家介绍一下如何才能写好一篇心得体会吧，我们一起来看一看吧。
汇编语言子程序设计实验心得总结汇编语言程序设计实验心得体会篇一做了两周的课程设计，有很多的心得体会，更多的是同学之间的合作精神，这道课程设计花了我们一到两周的时间，几人合作，老师的帮助才完成。
我第一次完成这么完美的杰作，心理有一份别样的滋味，在设计过程中，我付出了很多，也懂得了只有付出才有回报。
在这次设计中，我遇到了很多困难，但我没有向困难低头，通过查询资料，虚心向同学、老师请教，才一一得到理解决。
我发现平时学的太少了，在今后我要把老师在课堂讲的弄懂，弄透，在此根底上利用课余时间多看课外书籍，拓宽知识面。
在设计过程中，合作精神必不可少。
单凭一个人的力量是不能完成的，毕竟一个人学的很有限。
每个人掌握的不同。
我相信：态度决定一切，只有努力才有收获。
第二天我就着手画计数器图形，虽然有些人图形已画好，可我没有着急，毕竟别人花的时间比我多，为了使图形美观我不断运行、调试，直到自己满意为止。
接下来是星期五，说实话那天蛮难熬的，一天都泡在机房。
眼睛有点吃不消，可没有方法，将来我们就靠计算机吃饭，再苦再累也要坚持。
在已编好的程序上又加了一点精华，怎样使字符闪烁，这也是我们几个人互相讨论的结果。
第二周，通过周末到网上查的资料，和参考资料又参加计数器的灵魂算法。
接下来几天再将程序不断完善、加工，计数器程序初露头角。
小结：程序设计过程有如解决一实际问题，从解决实际问题的角度，我们可以这样来看：要理解这个问题的根本要求，即输入、输出、完成从输入到输出的要求是什么;从问题的要害入手，从前到后的解决问题的每个方面，即从输入开始入手，着重考虑如何从输入导出输出，在这个过程中，可确定所需的变量、数组、函数，确定处理过程--算法。
“汇编语言与微机原理”课程教学中汇编子程序实验设计
５ ８ ・
Ｃｏ ｍｐ ｕ ｔ ｅ ｒ Ｅｒ ａ Ｎｏ． ２ ２ ０１ ３
“ 汇 编语言与 微机原理’ ’ 课 程教学中 汇编子 程序实 验设计
赵 永标 。张 其林 ，詹 彬 ，康长 青
（ 湖北文理学院数学与计算机科学学院，湖北 襄阳 ４ ４ １ ０ ５ ３ ）
摘 要 ：“ 汇编语 言与微 机原理” 是 计算机科 学与技术 专业 的必修基 础课 程。在教 学中汇编语 言子程序 实验设计普遍存
关键词 ：汇编语言 ；子程序 ；宏 ；中断 ；实验设计 中图分类号 ： Ｇ６ ４ ２ 文献标志码 ： Ｂ 文章 编号 ： １ ０ ０ ６ — ８ ２ ２ ８ （ ２ ０ １ ３ ） ０ ２ — ５ ８ — ０ ２
Ｅｘ ｐ ｅ ｒ ｉ ｍｅ ｎ ｔ ａ ｌ ｄ ｅ ｓ ｉ ｇ ｎ ｏ ｆ ａ ｓ ｓ ｅ ｍｂ ｌ ｙ ｓ ｕ ｂ — ｒ ｏ ｕ ｔ ｉ ｎ ｅ ｓ ｉ ｎ “ ａ ｓ ｓ ｅ ｍｂ ｌ ｙ ｌ ａ ｎ ｇ ｕ ａ ｇ ｅ ａ ｎ ｄ ｍｉ ｃ ｒ ｏ ｃ ｏ ｍｐ ｕ ｔ ｅ ｒ ｐ ｒ ｉ ｎ ｃ ｉ ｐ ｌ ｅ ’ ’
Ｚ ｈ ａ ｏ Ｙ ｏ ｎ ｇ ｂ ｉ ａ ｏ ，Ｚ ｈ ａ ｎ ｇ Ｑｉ ｌ ｉ ｎ ，Ｚ ｈ ａ ｎ Ｂｉ ｎ ，Ｋａ ｎ ｇ Ｃ ｈ ａ ｎ ｇ ｑ ｉ ｎ ｇ
（ Ｓ ｃ ｈ ｏ ｏ ｌ ｏ ｆ Ｍ ａ ｔ ｈ ｅ ｍ ａ ｔ ｉ ｃ ｓ ａ ｎ ｄ Ｃ ｏ ｍ ｐ ｕ ｔ ｅ ｒ Ｓ ｃ ｉ ｅ ｎ ｃ ｅ ， Ｈ ｕ ｂ ｅ ｉ Ｕ ｎ ｉ ｖ ｅ ｒ ｓ ｉ ｔ ｙ ｆ ｏ Ａ ｒ ｔ ａ ｎ ｄ Ｓ ｃ ｉ ｅ ｎ ｃ ｅ ， Ｘ ｉ ａ ｎ ｇ ｙ ａ ｎ ｇ ， Ｈ ｕ ｂ ｅ ｉ ４ ４ １ ０ ５ ３ ，Ｃ ｈ ｉ ｎ ａ ）
汇编语言——子程序
6.2.2.2 RET指令 指令 【指令格式】RET 【功能】这是子程序返回指令，必须写在子程序的指令 序列之中。根据所在的子程序的类型不同，RET指令的功能 也分为两种情况： （1）如果RET所在子程序是NEAR类型，则从堆栈中出 栈一个字(当然，SP会加2)，送给IP。 （2）如果RET所在子程序是FAR类型，则先从堆栈中出 栈一个字送到IP，再出栈一个字送到CS，栈顶指SP的值加4。
cr
PROC NEAR MOV AH,2 MOV DL,13 INT 21H MOV DL,10 INT 21H RET
cr ENDP main:MOV AX,dseg MOV DS,AX LEA DX,buf MOV AH,10 INT 21H CALL cr MOV AH,1 INT 21H MOV BL,AL ;输入一个字符 ;用BL保存读入的字符 ;输入一个符号串
【解】程序段(a)中，先把AX赋值为102H，再把BX赋 值为304H，然后用ADD指令把两数相加，和为406H，结果 放在ADD指令的目的操作数AX中。 程序段(b)的前两行与(a)完全相同，AX取值102H，BX 取值304H，但在相加之前调用了子程序cr。从例6.3中cr的 具体实现方法可以知道，调用过程中寄存器AH的值被改为 2，因为INT 21H输出功能，使AL的值也被修改，变成0AH， 并且这个值一直保持到调用结束，于是“CALL cr”指令调 用子程序后，AX的值不再是调用前的102H，而变成了 20AH，当ADD指令进行两个寄存器相加时，结果是50EH， 并放到目的操作数AX中。
6.3 应用子程序进行编程
6.3.1 子程序实例
【例6.3】分析下列程序，描述它的功能。 dseg SEGMENT buf DB 80,81 DUP(0) dseg ENDS sseg SEGMENT STACK DW 64 DUP(0) sseg ENDS cseg SEGMENT ASSUME CS:cseg,DS:dseg,SS:sseg
汇编语言之子程序
汇编语言之子程序汇编语言是一种底层编程语言，是计算机指令的集合表示形式。
在汇编语言中，子程序是一段独立的、可重复使用的代码片段，可以在程序中被多次调用。
子程序可以帮助我们实现代码的模块化，提高代码的可读性和可维护性。
本文将介绍如何在汇编语言中使用子程序以及其工作原理。
一、子程序的定义和使用在汇编语言中，子程序由一系列指令组成，这些指令可以完成特定的功能。
子程序可以通过call指令被调用，执行完子程序后会返回到调用子程序的指令处，继续执行程序的下一条指令。
在使用子程序前，我们需要先定义子程序。
定义子程序的语法如下：```subroutine_name:; 子程序代码ret```其中，subroutine_name是子程序的名称，可以根据实际需求自定义。
ret指令用于返回到调用子程序的指令处，继续执行程序的下一条指令。
调用子程序的语法如下：```call subroutine_name```其中，subroutine_name是要调用的子程序的名称。
二、传递参数和返回值子程序可以接收参数，并且可以有返回值。
在调用子程序时，可以通过寄存器或栈来传递参数。
在子程序内部，可以通过相应的寄存器或栈地址来获取参数的值。
例如，我们定义一个计算两个数之和的子程序add：```add:mov ax, [bp+4] ; 获取第一个参数的值add ax, [bp+6] ; 获取第二个参数的值ret```在主程序中调用add子程序：```mov ax, 5 ; 第一个参数mov bx, 10 ; 第二个参数call add ; 调用add子程序; 此时ax寄存器中的值为15，即5+10的结果```在子程序add中，我们通过寻址方式获取传递的参数，并将计算结果存入ax寄存器中，供主程序使用。
三、保存和恢复寄存器在汇编语言中，调用子程序时需要保存和恢复寄存器的值，以保证程序的正确执行。
在调用子程序前，我们可以使用push指令将需要保存的寄存器值压栈，然后在子程序的开头使用相应的pop指令将值弹出并恢复。
汇编语言程序设计实例
汇编语言程序设计实例汇编语言是一种非常底层的编程语言，它允许程序员直接与计算机硬件进行交互。
汇编语言程序设计通常用于需要高性能或者对硬件有特定需求的场合。
以下是一些汇编语言程序设计的实例，以帮助理解其基本结构和应用。
实例一：数据传输在汇编语言中，数据传输是最基本的操作之一。
以下是一个简单的数据传输程序实例，它将一个立即数（即直接给出的数值）移动到寄存器中：```assemblymov ax, 1234h ; 将十六进制数1234h移动到ax寄存器```实例二：算术运算汇编语言支持基本的算术运算，如加法、减法、乘法和除法。
以下是一个进行加法运算的例子：```assemblymov ax, 5 ; 将数值5移动到ax寄存器add ax, 3 ; 将数值3加到ax寄存器中```实例三：条件跳转条件跳转是控制程序流程的重要手段。
以下是一个基于条件跳转的简单程序，它检查ax寄存器的值是否为0，并根据结果跳转到不同的代码段：```assemblymov ax, 0 ; 将数值0移动到ax寄存器jz zero ; 如果ax为0，则跳转到标签zero; 继续执行其他代码...zero:; 如果ax为0，执行这里的代码```实例四：循环结构循环结构在汇编语言中实现起来较为复杂，但可以通过重复使用跳转指令来模拟。
以下是一个简单的循环结构实例，它将ax寄存器的值减1，直到值为0：```assemblystart_loop:dec ax ; 将ax寄存器的值减1jnz start_loop ; 如果ax不为0，跳回start_loop```实例五：字符串处理汇编语言程序设计中，字符串处理是一个常见的任务。
以下是一个将字符串从源地址复制到目标地址的程序：```assemblymov si, source ; 将源字符串的地址移动到si寄存器mov di, dest ; 将目标地址移动到di寄存器mov cx, length ; 将字符串的长度移动到cx寄存器copy_loop:movsb ; 从si复制一个字节到diloop copy_loop ; 减少cx的值并重复循环直到cx为0```实例六：子程序调用在汇编语言中，子程序是一种将代码封装成模块化单元的方法。
1200子程序调用指令
1200子程序调用指令以1200子程序调用指令为标题，写一篇文章在计算机编程中，子程序是一段独立的代码，可以被主程序调用。
通过使用子程序，我们可以将复杂的任务分解成一系列较小的任务，使程序更加可读、易于维护。
而1200子程序调用指令是一种特定的指令，用于在汇编语言中调用子程序。
本文将介绍1200子程序调用指令的使用方法和注意事项。
我们需要了解如何定义和使用子程序。
在汇编语言中，子程序通常以一段标签标识，并且可以接受参数和返回结果。
在定义子程序时，我们需要使用一些特定的指令来保存寄存器的值，并在子程序结束后恢复这些值。
这样可以确保在子程序调用完成后，程序的状态与调用前保持一致。
在使用1200子程序调用指令之前，我们需要将子程序的地址存储在一个特定的寄存器中。
在调用子程序时，我们可以使用1200子程序调用指令来跳转到存储在寄存器中的地址，并将控制权交给子程序。
子程序执行完成后，会返回到调用指令的下一条指令继续执行。
在进行子程序调用时，我们需要注意一些事项。
首先，在调用子程序之前，我们需要将参数传递给子程序。
这可以通过将参数存储在寄存器或内存中来实现。
在子程序内部，我们可以使用这些参数进行计算或其他操作。
在子程序返回时，我们可以将结果存储在寄存器或内存中，供主程序使用。
我们需要注意子程序调用的返回地址。
在1200子程序调用指令中，返回地址是自动保存在栈中的。
这意味着在子程序内部，我们可以自由地使用栈来保存其他临时数据，而不会破坏返回地址。
在子程序返回时，通过使用返回指令，将栈中保存的返回地址弹出，程序会跳转到返回地址所指向的位置。
我们还需要注意子程序的参数传递和返回结果的存储。
在使用1200子程序调用指令时，通常使用寄存器来传递参数和存储返回结果。
这是因为寄存器的访问速度比内存更快，可以提高程序的执行效率。
但是需要注意的是，在调用子程序之前，我们需要保存寄存器中的值，并在子程序返回后恢复这些值，以防止数据丢失或错误。
浅谈汇编语言中子程序的设计
ｒ 。＋ ”＋ ＋
“＋ ＋ ” ＋ ＋ ‘＋ ＋ “＋ “＋ 。
。＋ ’＋ ＋ ’
‘ ’ ＋
“＋ ’＋ ’
“＋
＋
浅谈汇编 中子 语言
■＋ ． ． ． ．＋ ” ＋ ． ＋ 一 ＋ ． ． ＋ 一 ＋ ． ． ＋ － ＋ 一 ＋ ＋ 一 ＋ ” ＋ 一 ＋ ・ ・ 一 ＋ ＋ 一 ＋ ・ ・
一
是 否按 “ 进 先 出” 后 的原 则 组 织 的 。 （） ２堆栈保 护。子程 序是利用调用 Ｃ Ｉ ＡＬ 指令 和返 回 Ｒ Ｔ 指令来 实现正确 的调用 和返 回 的。因 Ｅ
为Ｃ Ａｕ 命令执 行 时压 入堆栈 的断 点地 址就 是供 子程序返 回主程序 时的地址 ， 编程 时一定 要注 意子
程 序 的类 型 属 性 ， 是 段 内 调 用 还 是 段 间 调 用 。段 即 内调 用 和 返 回为 Ｎ Ａ 属 性 ， 问 调 用 和 返 回 为 Ｅ Ｒ 段 Ｆ Ｒ 属性 。８ ８ ／ ０ ８的 汇编 程 序用 子 程序 定 义 Ａ ０ ６８ ８ Ｐ （ 的 类 型 属 性 来 确 定 Ｃ Ｌ和 Ｒ Ｔ 指令 的 属 Ｒ） Ｃ ＡＬ Ｅ 性 。如 果 所 定 义 的 子 程 序 是 Ｆ ＡＲ 属 性 ， 么 对 它 那 的调用和返 回一定都是 Ｆ Ｒ Ａ 属性 ； 如果所定义的子 程 序 是 ＮＥ Ｒ Ａ 属性 ， 么 对 它 的 调 用 和 返 回 也 一 定 那 是 ＮＥ Ｒ Ａ 属 性 。这 样 用 户 只 是 在 定 义 子 程 序 时 考 虑它的属性 ， Ｃ Ｉ 而 ＡＬ 和 Ｒ Ｔ指 令 的 属 性 就 可 以 Ｅ 由 汇 编 程 序 来 确 定 了 。另 外 ， 入 子 程 序 后 再 使 用 进 堆 栈 时 也 必 须 保 证 压 人 和 弹 出 字 节 数 一 致 ， 果 在 如 这 里 堆 栈 存 取 出错 ， 然 会 导 致 返 回地 址 的 错 误 。 必 ２ 参 数传 递 ． 主程序在调用子程序 时 ， 经常要 向子程 序传递 些参数或控 制信息 ， 子程序执行后 ， 也常需要把运 行的结果返 回调用程序 。这种信息传递称 为参数传 递， 其常用 的方 法有 寄存 器传 递 、 内存 固定单 元传 递 、 栈传递 。 堆 （ ） 存 器 传 递 。 由 主 程 序 将 要 传 递 的参 数 装 １寄 入事先 约定 的寄存 器 中， 转入子 程序后 再取 出进行 处 理 ， 种 方 法 受 Ｃ Ｕ 内 部 寄 存 器 数 量 限 制 ， 此 这 Ｐ 因 只适 于传 递 少 量 参 数 的 场 合 ， 一 些 常 见 的 软 件 延 如 时子程序 ， 均是利用某寄存器传递循环计数 器初值 。 （ ） 过 内存 固 定 单 元 的 传 递 。此 方 法 适 于 大 ２通 量传递参数时使用 ， 它是在 内存 中开辟特 定 的一片 区域用于传递参数 。主程序和子程序都按事先约定 在指定 的存储单元 中进行数据 交换 ， 这种 方法要 占
汇编子程序设计阶乘
汇编子程序设计阶乘汇编语言是一种底层的程序语言，用于编写机器指令的程序。
子程序设计是汇编语言的一个重要概念，用于将程序模块化以便重复使用。
阶乘是一个经典的数学问题，定义为对于正整数n，阶乘的值表示为n!，等于从1到n的所有正整数相乘的结果。
例如，5!=5×4×3×2×1=120。
在汇编语言中，实现阶乘可以通过递归或迭代的方式完成。
下面我们将详细讨论这两种方法。
一、递归方式实现阶乘：递归方式是一种将问题分解为更小规模的子问题的编程技术。
在实现阶乘时，可以通过递归方式计算出n-1的阶乘，然后将结果与n相乘得到n。
以下是使用递归方式实现阶乘的汇编代码示例：```assemblysection .dataresult db 1section .textglobal _start_start:mov eax, 5call factorialmov [result], eax;此处可添加输出结果的代码mov eax, 1int 0x80factorial:push ebpmov ebp, espmov eax, [ebp+8] ; 读取传入的参数n cmp eax, 1jle end_factorialdec eaxpush eaxcall factorialpop eaximul eax, [ebp+8] ; 计算阶乘结果end_factorial:mov esp, ebppop ebpret```以上代码中，_start是程序的入口点。
我们传入参数5给阶乘的子程序，然后将结果存储在result变量中。
请注意，在第一个call指令后，我们将使用eax寄存器存储结果。
factorial是计算阶乘的子程序。
我们通过比较n是否小于等于1来确定是否终止递归。
如果n大于1，则我们将n减1，并将其压入栈中作为下一次递归的参数。
然后，我们通过调用相同的子程序计算n-1的阶乘结果。
汇编语言实验报告_6
青岛理工大学课程实验报告
课程名称汇编语言程序设计班级实验日期
2013.11.3
姓名学号实验成绩
实验
名称
子程序
实验目的及要求1.掌握子程序设计相关指令和伪指令的使用方法
2.掌握子程序设计方法, 特别是参数传递方法
3.掌握主程序和子程序之间的调用关系和调用方法
4.熟悉循环和子程序结合应用解答问题的思路
实验环境1.命令行方式
2.MASM.EXE LINK.EXE DEBUG.EXE
实验内容1.设DATA1开始的内存单元中, 存放着一串带符号字数据, 要求采用冒泡排序算法（Bubble Sort）按照从小到大的顺序排序并将排好序的数据存在DATA1开始的单元。
然后在显示器输出排好序的数据, 中间用’,’隔开。
2.输出数据使用子程序方式。
算法描述及实验步骤步骤:
（1）设置数据段地址
（2）设置堆栈段地址
（3）设置堆栈指针
（4）调用9号功能, 输出一个提示性字符串。
（5）循环进入子程序, 输出原始数据。
（6）在子程序内循环输出每一位的十进制数字。
（7）主程序进行内外循环, 进行冒泡排序。
（8）再一次调用子程序输出排序后的结果。
调试过程及实验结果调试过程:
（2）（1）在输出时, 调用DOS 9号功能, 并不是只要语句MOV AH,09H
（3）它是存在入口条件的, 入口条件：DS:DX＝输出字符缓冲区首地址。
所以前面必须加上MOV DX,OFFSET NOTE1。
（4）汇编语言是不会再输出汉字的。
（5）子程序结束时一定要有RET
（6）冒泡排序也遇到一些困难。
调试结果:。
汇编子程序的一般结构组成。
汇编子程序的一般结构组成。
汇编子程序是一段独立的程序代码，可以被其他程序调用。
它的一般结构由以下几个部分组成：
1. 子程序头部：包括子程序的名称、输入参数和输出参数的说
明等。
2. 参数传递：子程序的输入参数和输出参数通过栈或寄存器传递。
3. 保存寄存器：在进入子程序之前，需要保存一些寄存器的值，以免在执行子程序时被覆盖。
4. 执行程序：这是子程序的核心部分，实现子程序的功能。
5. 恢复寄存器：在退出子程序之前，需要还原保存的寄存器的值。
6. 返回值：如果子程序有返回值，需要将其保存在寄存器或栈中，并通过ret指令返回给调用程序。
以上是汇编子程序的一般结构组成，不同的子程序可能会有差异。
编写子程序需要熟悉汇编语言的基础知识和调试技巧，能够理解程序的逻辑思路、掌握数据结构和算法，才能编写出高效、稳定的子程序。
- 1 -。
汇编语言-子程序调用
汇编语⾔-⼦程序调⽤汇编语⾔-⼦程序调⽤ret与ref指令retret == pop IPret指令⽤栈中的数据，修改IP的内容，从⽽实现近转移；功能介绍retf指令⽤栈中的数据，修改CS和IP的内容，从⽽实现远转移CPU执⾏ret指令时，进⾏下⾯两步操作：（1）(IP) = ((ss) * 16 + (sp))（2）(sp) = (sp) + 2相当于进⾏：pop IPretfretf == pop IP + POP CS功能介绍CPU执⾏retf指令时，进⾏下⾯两步操作：（1）(IP) = ((ss) * 16 + (sp))（2）(sp) = (sp) + 2（3）(CS) = ((ss) * 16 + (sp))（4）(sp) = (sp) + 2相当于进⾏：pop IPpop CScall指令call 标号功能介绍(把当前IP压栈后, 转到标号处执⾏指令)a. (SP) = (SP) - 2((SS) * 16 + SP) = (IP)b. (IP) = (IP) + 16位位移相当于:push IPjmp near ptr 标号16位位移 = “标号”处的地址 - call指令后的第⼀个字节的地址;16位位移的范围 -32768—-32767, ⽤补码表⽰;16位位移由编译程序在编译时算出;call far ptr 标号功能介绍(把当前CS，IP压栈后, 转到标号处执⾏指令)a. (SP) = (SP) - 2((SS) * 16 + SP) = (CS)b. (SP) = (SP) - 2((SS) * 16 + SP) = (IP)c. (CS) = 标号所在段的段地址(IP) = 标号在段中的偏移地址相当于:push CSpush IPjmp par ptr 标号call 16位寄存器功能介绍(sp) = (sp) – 2((ss) * 16 + (sp)) = (IP)(IP) = (16位寄存器)相当于：push IPjmp 16位寄存器call word ptr 内存单元地址功能介绍push IPjmp word ptr 内存单元地址实例展⽰mov sp, 10hmov ax, 0123hmov ds:[0], axcall word ptr ds:[0]执⾏后，(IP)=0123H，(sp)=0EHcall dword ptr 内存单元地址功能介绍push CSpush IPjmp dword ptr 内存单元地址实例展⽰mov sp, 10hmov ax, 0123hmov ds:[0], axmov word ptr ds:[2], 0call dword ptr ds:[0]执⾏后，(CS)=0，(IP)=0123H，(sp)=0CH((IP)= ds:[0], (CS) = ds:[2])⼦程序调⽤通过上⾯介绍的两个指令，我们可以完成⼦程序的调⽤。
汇编语言writestring
汇编语言writestring"writestring" 是汇编语言中的一个子程序，用于输出字符串到屏幕上。
下面是一个示例代码：```。
writestring PROC。
push ax。
push dx。
mov ah, 09h ;设定功能号为 09h。
mov dx, offset message ;将要输出的字符串的地址存入 dx。
int 21h ;调用 21h 中断。
pop dx。
pop ax。
ret。
writestring ENDP。
message db "Hello, world!", 0 ;要输出的字符串。
```。
在上面的示例代码中，`writestring` 子程序使用 `int 21h` 中断来进行输出。
`int 21h` 是 DOS 中断，它可以实现各种 DOS 服务，例如打印字符、读取键盘输入、打开文件等。
具体来说，`writestring` 子程序使用 `mov ah, 09h` 指令将功能号设为 09h，这表明我们要进行字符串输出。
然后，使用 `mov dx, offset message` 将要输出的字符串的地址存入 dx 寄存器中。
最后，使用 `int 21h` 命令来调用 DOS 中断，从而实现字符串输出。
最后两行使用 `pop` 指令来恢复堆栈，以及使用`ret` 指令来返回子程序调用点。
在最下面的一行，我们定义了要输出的字符串 `message`。
其中，`db` 表示定义字节类型数据，字符串末尾需要添加0。
使用上述代码，我们可以通过在主程序中调用 `writestring` 子程序来实现字符串输出：```。
main:。
mov ds, ax。
call writestring ; 调用子程序。
mov ah, 4ch ; 设定功能号为 4ch，指代程序结束。
mov al, 0 ; 返回值为 0 。
int 21h ; 调用 DOS 中断。
汇编语言的16位除法子程序
;-------------------------------------
R23DIVR45:
MOV DPTR, #0
D_LOOP:
CLR C
MOV A, R3
SUBB A, R5
MOV B, A
MOV A, R2
SUBB A, R4 ;R2R3-R4R5
JC DIV_E ;有借位转移
INC DPTR
MOV R3, B
MOV R2, A
SJMP D_LOOP
DIV_E:
RET ;不够减就结束
下列程序，对数值范围的要求很宽松，被除数、除数和商，都可以是16位数，这比网上常见的16位除8位的除法程序，适用面要广得多。
注意，除数为０的问题，应该在主程序中进行检测。
;-------------------------------------
;16位/16位的子程序
;被除数：R2R3、除数：R4R5；商：DPTR、余数：R2R3。
汇编语言的16位除法子程序
应邀写个汇编语言的除法子程序。
编写除法子程序，有两种算法，移位相减的方法和循环相减的方法。
移位相减的方法是仿照人们做除法的竖式编写，执行速度较快，但是计算的原理，一般人不好理解，难以让大家推广到更多的字节。故此下面采用循环相减的思路来编写程序。
设计思路：所谓除法，就是要求出在被除数中，含有多少个除数。那么就用被除数连续的减去除数，直到不够减为止，够减的次数，就是商，不够减的数值，就是余数。
;-------------------------------------
;பைடு நூலகம்
对于R2R3中的余数，还应该有个“四舍五入”的程序。
汇编语言第5章王爽版(子程序调用指令)
例5-1：分别用三种参数传递方法编写求1＋2的和的程序。要求将结果送到内存单元，并显示。
DATA SEGMENT SUM DB 0 DATA ENDS STACK SEGMENT DB 100 DUP(?) STACK ENDS CODE SEGMENT ASSUME DS:DATA,SS:STACK,CS:CODE START: MOV AX,DATA MOV DS,AX MOV AL, 1 MOV BL, 2 CALL subprog mov ah,4cH int 21h CODE ENDS END START
5.2 子程序的定义、调用和返回（续）
子程序返回指令(RET)
RET [n] 功能：弹出CALL指令压入堆栈的返回地址 段内返回——偏移地址IP出栈 IP←SS:[SP]， SP＋2 段间返回——偏移地址IP和段地址CS出栈 IP←SS:[SP]，SP←SP＋2 CS←SS:[SP]，SP←SP＋2
子程序的概念
子程序的现场保护与参数传递**
子程序的嵌套与递归调用
子程序的定义、调用和返回 **
子程序设计 *
宏汇编程序设计
教学基本内容
第5章 结构化程序设计
子程序：在程序设计中，我们会发现一些多次无规律重复的程序段或语句序列。解决此类问题一个行之有效的方法就是将它们设计成可供反复调用的独立的子程序结构，以便在需要时调用。在汇编语言中，子程序又称过程。 过程（子程序）：是指功能相对独立的一段程序。 主程序和子程序间的关系：调用子程序的程序称为主调程序或主程序，被调用的程序称为子程序。
Spr PROC PUSH BP MOV BP, SP MOV AX, [BP+6] MOV BX, [BP+4] ADD AL, BL OR AL, 30H MOV DL,AL MOV AH,2 INT 21H MOV SUM, AL POP BP RET Spr ENDP
汇编延时1s的延时子程序
汇编延时1s的延时子程序一、延时子程序的概念延时子程序是指在程序中设置一个时间延迟，使得程序在执行到该子程序时暂停一段时间后再继续执行下一条指令。
在汇编语言中，常用的延时子程序有软件延时和硬件延时两种。
二、软件延时的实现方法1. 循环计数法循环计数法是一种简单而常用的软件延时方法。
其原理是利用CPU进行循环计数，当计数器达到设定值后，即完成了指定的时间延迟。
2. 空循环法空循环法是在循环体内不执行任何有意义的操作，只进行空转等待的方法。
其原理是利用CPU进行忙等待，当指定的时间到达后再继续执行下一条指令。
三、硬件延时的实现方法硬件延时是通过外部电路或芯片来实现的。
常用的硬件延时器有555定时器和8254可编程定时器等。
四、汇编语言实现1s延时子程序以下以循环计数法为例，介绍如何使用汇编语言实现1s延时子程序。
1. 程序思路：（1）将需要等待的时间转换为机器周期；（2）循环计数，当计数器达到指定值时，跳出循环。
2. 程序代码：delay:mov cx, 0FFFFh ;将计数器初始化为最大值mov dx, 0FFFFhdelay1:loop delay1 ;循环计数dec dx ;减少dx的值jnz delay1 ;如果dx不为0，则继续循环dec cx ;减少cx的值jnz delay1 ;如果cx不为0，则继续循环ret ;延时结束，返回3. 程序说明：（1）mov cx, 0FFFFh：将CX寄存器初始化为最大值，即65535；（2）mov dx, 0FFFFh：将DX寄存器初始化为最大值，即65535；（3）loop delay1：循环计数，每次减少CX的值，当CX的值为0时跳出循环；（4）dec dx：每次减少DX的值；（5）jnz delay1：如果DX的值不为0，则跳转到delay1标号处继续执行循环；（6）dec cx：每次减少CX的值；（7）jnz delay1：如果CX的值不为0，则跳转到delay1标号处继续执行循环；（8）ret：延时结束，返回。
汇编子程序设计实验心得(精选5篇)
汇编子程序设计实验心得(精选5篇)汇编子程序设计实验心得【篇1】经过了一周左右密集的学习，仔细地回顾和评估了自己学习的过程，我切实地发现28定律在编程学习中同样发挥着作用。
在很长一段时间以前的学习中，我总是试图把一本书从头读到尾，或者是找一个视频课，想要从头到尾跟着做，但结果不是做不完放弃，就是看完之后感觉到还是什么都不会。
这一周我发现了编程学习中那百分之二十产生效益的地方在哪，因此将改善学习方法，提升效率。
简要地说，编程学习的那百分之二十飞速提升效率的地方就在代码上。
这听起来很荒谬，编程不就是写代码吗?但在实际的学习中，我确实时常犯下这个错误，就是绝大多数的精力并没有放在代码上。
我思考了一下改善学习的流程：在资料充分的情况下，理当先拿到源代码，然后查看源代码的输入和输出。
搞清楚这一段源代码的效果是什么.然后接下来对源代码写注释，逐行搞清楚源代码中每一句的意思，并且借此补充知识，不需要记忆，就是通过注释写明就好了。
搞清楚原理，然后写作出来。
尝试清楚明确地讲明白这段代码背后的概念是什么，原理是什么。
做完这三步之后马上循环写下一个项目，以项目到项目的方式来进展，试图把前面写过的项目追加到后面的项目中去，去连接学过的内容，并且就此复习。
同样不需要记忆，只要查看原来写过的东西就好了了。
接下来的学习中将彻底实践此方法论，并且在下一个阶段评估学习的效率。
汇编子程序设计实验心得【篇2】经过五天的Java实训，感触很深，收获也很大，对自己的缺点也有了很多的认识，回首本学期JAVA学习，重点还是在学习概念等一些常识性的东西，关于类型、变量、接口、输入输出流、分析异常、抛出异常，后期主要是小程序运用，Gui界面设计和事件。
在我学习的语言中，我自己认为Java是一门比较强大的面向对象的编程语言，不仅仅是因为它的跨平台型还有它的较强的实用性，强悍的嵌入性。
本次实训主要是针对我们对项目流程不熟悉和对整体项目的把握不清楚，学习数据库的设计和表的建设以及表与表之间的联系，还有一些代码的编写，这些都是我们所不熟悉的也是我们最薄弱的部分。
51单片机汇编中断程序调用子程序
51单片机汇编中断程序调用子程序（原创实用版）目录1.51 单片机汇编中断程序概述2.中断程序的调用方式3.子程序的定义与调用4.中断程序调用子程序的实例分析5.总结正文一、51 单片机汇编中断程序概述在 51 单片机汇编语言编程中，中断是一种常见的编程方式，可以实现在特定条件下程序的跳转和执行。
通过中断程序，可以实现对硬件设备的实时控制，提高程序的执行效率。
二、中断程序的调用方式中断程序的调用方式主要有两种：1.通过外部中断引脚（如 P1.0、P2.0 等）触发中断。
这种方式下，当外部中断引脚的状态发生改变时，单片机会立即跳转到中断程序的入口地址执行。
2.通过软件中断实现中断程序的调用。
这种方式下，程序员可以通过设置特定的寄存器值来触发中断，使程序跳转到中断程序的入口地址执行。
三、子程序的定义与调用子程序，也称为子例程，是程序中一段可独立执行的代码段。
子程序可以通过以下方式定义和调用：1.使用“SUB”伪指令定义子程序。
在需要调用子程序的地方，编写“CALL 子程序名”，即可实现子程序的调用。
2.使用“PROG”伪指令定义子程序。
在需要调用子程序的地方，直接编写子程序名，即可实现子程序的调用。
四、中断程序调用子程序的实例分析假设我们有一个 51 单片机汇编语言程序，当外部中断引脚 P1.0 触发时，需要执行一个子程序以完成特定功能。
程序如下：```ORG 00HMOV P1, #00HMOV R4, #0FFHSTART: NOPINT0: MOV R3, #0FFHCALL INT_SUBROUTINESJMP STARTINT_SUBROUTINE: MOV R5, R3// 子程序执行的内容MOV R3, R5SJMP RETURNRETURN: MOV R4, R3SJMP RETURN_SUBROUTINERETURN_SUBROUTINE: MOV R3, #00HSJMP START```在上述程序中，当 P1.0 引脚触发中断时，程序会跳转到“INT0”标签所在的位置，执行子程序“INT_SUBROUTINE”。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
随着指令的丰富、子程序的引入，汇编语言的表达也越来越灵 活。为了方便地组织数据，引入了结构伪操作STRUC。 STRUC可以把不同类型的数据放在同一个结构里，方便处理。 a). 结构类型说明格式为： structure_name STRUC … ;DB、DW、DD等伪操作 structure_name ENDS 注意：ENDS之前为结构名，注意与段结束相区别。 例如：下列语句说明了一个名STUDENT的结构类型： STUDENT STRUC ID DW ? SCORE DB 0 NAME DB „ABCDEFGH‟ STUDENT ENDS 但是，定义一个结构类型的时候不进行任何存储器分配，只有 在定义结构变量时才进行存储分配。
b). 结构变量的定义 格式是： [变量名] 结构名 < [字段值表]> 例：Lisi STUDENT <103 , 88 , „LI‟> ;三个字段重新赋值 Wangwu STUDENT <104 ,, „WANG‟> ;字段SCORE仍用缺省 值 Zhangsan STUDENT <> ;三个字段均用缺省初值 Team STUDENT 50 DUP (<>) ;定义50个结构变量，初值不变 在定义结构变量时，如果某个字段有多值，就不能给该字段重 新赋初值（定义时存在“DUP”, “ , , , ”等）。 c). 访问方式 访问方式：结构变量名.结构字段名 该变量的地址实质少年宫是结构变量地址的偏移பைடு நூலகம்相应字段偏 移值之和。 例：Zhangsan.ID ;访问张三的学号，实际上是直接寻址 还可以把结构变量地址的偏移先存入某个基址或变址寄存器， 然后利用“[寄存器名]”来代替结构变量名。 例如：MOV BX , OFFSET Zhangsan MOV AL , [BX].SCORE
POP DS POP BP RET STRLEN ENDP
主程序调用这个子程序的代码片段如下： MOV AX , SEG STR PUSH AX MOV AX , OFFSET STR PUSH AX CALL STRLEN MOV LEN , AX
当然，除了上面提及的3种方式外， 如果过程和调用程序在同一文件（同 一程序块中，则过程可直接访问模块 中的变量。
本章学习要点： （1）子程序的编写格式 （2）子程序调用时的参数传递方法 （3）嵌套及递归子程序 一、过程定义语句(process) 利用过程定义伪指令语句，可把程序片段说明为具有 近类型或远类型的过程，并且能给过程取一个名字。 过程定于语句的格式如下： 过程名 PROC [NEAR | FAR] … 过程名 ENDP 过程的类型在过程定义开始语句PROC中指定； 过程可以被指定位近(NEAR)类型，也可以被指定为 远类型。如果不指定，则通常默认为近类型； 定义一个过程的开始语句PROC和结束语句ENDP前 使用的过程名称必须一致，从而保持配对。
MADD PROC PUSH AX ;为什么会把AX,CX,SI压入栈？ PUSH CX PUSH SI MOV CX , 2 XOR SI , SI ;CF也会被清0 MADD1：MOV AX , WORD PTR DATA1[SI] ADC AX , WORD PTR DATA2[SI] MOV WORD PTR DATA3[SI] , AX INC SI INC SI POP SI LOOP MADD1 POP CX MOV AL , 0 POP AX ADC AL , 0 RET MOV BYTE PTR [DATA3 + 4] , AL MADD ENDP
例：写一个大写字母转换为小写字母的子程序 ;子程序名：UPTOLW ;功能：大写字母转换为小写字母 ;入口参数：AL=字符的ASCII码 ;出口参数：AL=字符的ASCII码 ;说明：如字符为大写字母，则转换为小写，其它字符不变。 UPTOLW PROC PUSHF ;保护各标志 CMP AL , „A‟ JB UPTOLW1 CMP AL , „Z‟ JA UPTOLW1 ADD AL , 20H UPTOLW1：POPF ;恢复各标志 RET UPTOLW ENDP
例：通过结构类型，在主程序和子程序中传输信息。
三、嵌套与递归子程序 一个子程序可以作为调用程序去调用另外一个子程序，这种情 况称为子程序的嵌套。 嵌套的层数称为嵌套深度。
深度为2的嵌套
如果一个子程序直接调用它自身，这种调用称为（直接）递归 调用。 具有递归调用的子程序就称为递归子程序。 递归是嵌套的特殊情况。
CODE SEGMENT MAIN PROC FAR ASSUME CS:CODE , DS:DSEG, SS:STACK START: PUSH DS SUB AX , AX PUSH AX MOV AX , DSEG MOV DS , AX MOV CX , 10 CALL COUNT ;调用COUNT子程序进行统计 ;可在此处添加显示输出 RET MAIN ENDP 注意：红色部分在这里构成一种固定搭配，把主程序看成DOS 调用的远过程，RET与前2个PUSH配对，相当于: MOV AH , 4CH INT 21H
四、综合示例 有10个学生的成绩分别为76、69……80。编制一个子程序分 别统计60~69分，70~79分，80~89分，90~99分及100分的人 数，分别存放到S6，S7，S8，S9，S10单元中。 DSEG SEGMENT REC DW 76, 69,63,83,92,73,65,100,99,80 S6 DW 0 S7 DW 0 S8 DW 0 S9 DW 0 S10 DW 0 DSEG ENDS STACK SEGMENT DW 64 DUP (?) STACK ENDS
例：用程序调用的方法，完成一个把16位二进制数转换为4位 十六进制ASCII码的转换程序。 子程序说明：入口参数：DX=欲转换的二进制数； DS:BX=存放转换所得ASCII码串的缓冲区首地址，转换后的 ASCII码串按照高位到低位的次序存放在指定的缓冲区中。 HTASCS PROC RET MOV CX , 4 HTASCS ENDP HTASCS1: ROL DX , 1 HTOASC PROC NEAR ROL DX , 1 AND AL , 0FH ROL DX , 1 ADD AL , 30H ROL DX , 1 CMP AL , 39H MOV AL , DL JBE HTOASC1 CALL HTOASC ADD AL , 7 MOV [BX] , AL HTOASC1: RET INC BX HTOASC ENDP LOOP HTASCS1
像普通标号一样，过程名具有段值、偏移和类型这三个属性。 过程名的段值和偏移是对应过程入口（过程定义开始伪指令语 句后的指令语句）的段值和偏移。 例：下面程序片段运行后，AL=?,BL=?。 XOR AL , AL CALL SUBS MOV BL , AL CALL SUBS RCR AL , 1 HLT ;停机，halt SUBS PROC NEAR NOT AL JS NEXT STC ;CF=1, SeT Cf = 1 NEXT : RET SUBS ENDP
递归子程序的设计要点： （1）递推性：逐级调用； （2）回归性：逐层回归； （3）有穷性：终止条件； 这3点为所有语言递归程序设计具有的共性。 汇编语言设计递归程序时的个性在于： （1）参数和中间结果一般存于堆栈中，但有时也可以存于寄 存器中； （2）递归的深度受堆栈空间的限制。
例：子程序FACT采用递归算法实现阶乘。 ;子程序名：FACT ;功能：计算n! ;入口参数： （AX）= n ;出口参数： （AX）= n! ;说明： （1）采用递归算法实现阶乘； ; （2）n 不能超过8 FACT(n) = n * FACT(n - 1) = n * [ (n - 1) * FACT(n- 2)]… 当n=0时，FACT(0) = 1. 要点: (1)递推：只要n不为0，即推进到FACT(n-1); (2)有穷：n=0时有确切解，即FACT(0)=1 (3)回归：逐层返回——FACT(n-1)的解和n（保存的中间参数）
FACT PROC PUSH DX ;保存中间参数（最外层为原有参数） MOV DX , AX CMP AX , 0 ;判断n是否为0？ JZ DONE ;如是，则终止推进。（有穷） DEC AX ;否则，继续推进 CALL FACT ;推进 MUL DX ;中间结果后逐层返回: n * FACT(n-1) POP DX ;得到中间参数（最外层为原有参数） RET DONE: MOV AX , 1 ;给出确定结果 0! = 1 POP DX ;得到中间参数 RET FACT ENDP
二、主程序与子程序间的参数传递 主程序在调用子程序时，往往要向子程序传递一些参数；同样 地，子程序运行后夜经常要把一些结果传会给主程序。主程序 和子程序之间的这种信息传递称为参数传递。 有多种参数传递的方法： （1）寄存器传递法 （2）约定内存单元传递法 （3）堆栈传递法 （4）其它方法 1.利用寄存器传递参数 利用寄存器传递参数就是把参数放在约定的寄存器中。这种方 法适用于传递参数较少的情况。
STRLEN PROC PUSH BP MOV BP , SP PUSH DS PUSH SI MOV DS , [BP + 6] MOV SI , [BP + 4] MOV AL , 0 STRLEN1 : CMP AL , [SI] JZ STRLEN2 INC SI JMP STRLEN1 STRLEN2： MOV AX , SI SUB AX , [BP + 4] POP SI
2.利用约定存储单元传递参数 在传递参数较多的情况下，可利用约定的内存变量来传递参数。 例：写一个实现32位数相加的子程序 ;子程序名：MADD ;功能：32位数相加 ;入口参数：DATA1和DATA2缓冲区中分别存放要相加的数 ;出口参数：DATA3缓冲区存放结果 ;说明： ;（1）32位数据的存放次序采用“高高低低”原则 ;（2）可能产生的进位放在DATA3开始的第5字节中