Dutor » 汇编

[转摘]代码优化概要

dutor — Mon, 20 Sep 2010 03:54:21 +0000

　　本文由陈皓译自Dr. Dobb’s Blogger的Walter Bright写的《Overlooked Essentials For Optimizing Code》.

　　我编写程序至今有35年了，我做了很多关于程序执行速度方面优化的工(一个示例)，我也看过其它人做的优化。我发现有两个最基本的优化技术总是被人所忽略。
　　注意，这两个技术并不是避免时机不成熟的优化。并不是把冒泡排序变成快速排序（算法优化）。也不是语言或是编译器的优化。也不是把 i*4写成i<<2的优化。

　　这两个技术是：

使用一个profiler。
查看程序执行时的汇编码。

　　使用这两个技术的人将会成功地写出运行快的代码，不会使用这两个技术的人则不行。下面让我为你细细道来。

使用一个 Profiler

　　我们知道，程序运行时的90%的时间是用在了10%的代码上。我发现这并不准确。一次又一次地，我发现，几乎所有的程序会在1%的代码上花了99%的运行时间。但是，是哪个1%？一个好的Profiler可以告诉你这个答案。就算我们需要使用100个小时在这1%的代码上进行优化，也比使用100个小时在其它99%的代码上优化产生的效益要高得多得多。

　　问题是什么？人们不用profiler？不是。我工作过的一个地方使用了一个华丽而奢侈的Profiler，但是购买这个Profiler后，它的包装3年还是那么的暂新。为什么人们不用？我真的不知道。有一次，我和我的同事去了一个负载过大的交易所，我同事坚持说他知道哪里是瓶颈，毕竟，他是一个很有经验的专家。最终，我把我的Profiler在他的项目上运行了一下，我们发现那个瓶颈完全在一个意想不到的地方。

　　就像是赛车一样。团队是赢在传感器和日志上，这些东西提供了所有的一切。你可以调整一下赛车手的裤子以让其在比赛过程中更舒服，但是这不会让你赢得比赛，也不会让你更有竞争力。如果你不知道你的速度上不去是因为引擎、排气装置、空体动力学、轮胎气压，或是赛车手，那么你将无法获胜。编程为什么会不同呢？只要没有测量，你就永远无法进步。

　　这个世界上有太多可以使用的Profiler了。随便找一个你就可以看到你的函数的调用层次，调用的次数，以前每条代码的时间分解表（甚至可以到汇编级）。我看过太多的程序员回避使用Profiler，而是把时间花在那些无用的，错误的方向上的“优化”，而被其竞争对手所羞辱。（译者陈皓注：使用Profiler时，重点需要关注：1）花时间多的函数以优化其算法，2）调用次数巨多的函数——如果一个函数每秒被调用300K次，你只需要优化出0.001毫秒，那也是相当大的优化。这就是作者所谓的1%的代码占用了99%的CPU时间）

查看汇编代码

几年前，我有一个同事，Mary Bailey，她在华盛顿大学教矫正代数（remedial algebra），有一次，她在黑板上写下：

x + 3 = 5

然后问他的学生“求解x”，然后学生们不知道答案。于是她写下：

__ + 3 = 5

　　然后，再问学生“填空”，所有的学生都可以回答了。未知数x就像是一个有魔法的字母让大家都在想“x意味着代数，而我没有学过代数，所以我就不知道这个怎么做”。

　　汇编程序就是编程世界的代数。如果某人问我“inline函数是否被编译器展开了？”或是问我“如果我写下i*4，编译器会把其优化为左移位操作吗？”。这个时候，我都会建议他们看看编译器的汇编码。这样的回答是不是很粗暴和无用？通常，在我这样回答了提问者后，提问都通常都会说，对不起，我不知道什么是汇编！甚至C++的专家都会这么回答。

　　汇编语言是最简单的编程语言了（就算是和C++相比也是这样的），如：

ADD ESI,x

就是（C风格的代码）

ESI += x;

而：

CALL foo

则是：

foo();

　　细节因为CPU的种类而不同，但这就是其如何工作的。有时候，我们甚至都不需要细节，只需要看看汇编码的长啥样，然后和源代码比一比，你就可以知道汇编代码很多很多了。

　　那么，这又如何帮助代码优化？举个例子，我几年前认识一个程序员认为他应该去发现一个新的更快的算法。他有一个benchmark来证明这个算法，并且其写了一篇非常漂亮的文章关于他的这个算法。但是，有人看了一下其原来算法以及新算法的汇编，发现了他的改进版本的算法允许其编译器把两个除法操作变成了一个。这和算法真的没有什么关系。我们知道除法操作是一个很昂贵的操作，并且其还在一个内嵌循环中，所以，他的改进版的算法当然要快一些。只需要在原来的算法上做一点点小的改动——使用一个除法操作，那么其原来的算法将会和新的一样快。而他的新发现什么也不是。

　　下一个例子，一个D用户张贴了一个 benchmark 来显示 dmd (Digital Mars D 编译器)在整型算法上的很糟糕，而ldc (LLVM D 编译器) 就好很多了。对于这样的结果，其相当的有意见。我迅速地看了一下汇编，发现两个编译器编译出来相当的一致，并没有什么明显的东西要对2：1这么大的不同而负责。但是我们看到有一个对long型整数的除法，这个除法调用了运行库。而这个库成为消耗时间的杀手，其它所有的加减法都没有速度上的影响。出乎意料地，benchmark 和算法代码生成一点关系也没有，完全就是long型整数的除法的问题。这暴露了在dmd的运行库中的long型除法的实现很差。修正后就可以提高速度。所以，这和编译器没有什么关系，但是如果不看汇编，你将无法发现这一切。

　　查看汇编代码经常会给你一些意想不到的东西让你知道为什么程序的性能是那样。一些意想不到的函数调用，预料不到的自傲，以及不应该存在的东西，等等其实所有的一切。但也不需要成为一个汇编代码的黑客才能干的事。

结论

　　如果你觉得需要程序有更好的执行速度，那么，最基本的方法就是使用一个profiler和愿意去查看一下其汇编代码以找到程序的瓶颈。只有找到了程序的瓶颈，此时才是真正在思考如何去改进的时候，比如思考一个更好的算法，使用更快的语言优化，等等。

　　常规的做法是制胜法宝是挑选一个最佳的算法而不是进行微优化。虽然这种做法是无可异议的，但是有两件事情是学校没有教给你而需要你重点注意的。第一个也是最重要的，如果你优化的算法没没有参与到你程序性能中的算法，那么你优化他只是在浪费时间和精力，并且还转移了你的注意力让你错过了应该要去优化的部分。第二点，算法的性能总和处理的数据密切相关的，就算是冒泡排序有那么多的笑柄，但是如果其处理的数据基本是排好序的，只有其中几个数据是未排序的，那么冒泡排序也是所有排序算法里性能最好的。所以，担心没有使用好的算法而不去测量，只会浪费时间，无论是你的还是计算机的。

　　就好像赛车零件的订购速底是不会让你更靠进冠军（就算是你正确安装零件也不会），没有Profiler，你不会知道问题在哪里，不去看汇编，你可能知道问题所在，但你往往不知道为什么。

PIC18 EEPROM编程

dutor — Tue, 24 Nov 2009 14:25:04 +0000

　　本程序利用PIC18单片机实现了对EEPROM的读写。应用背景是”汽车里程表”，简单介绍下程序功能和流程。
　　单片机接受来自RA4管脚的计数脉冲信号，应用中这个脉冲信号通常由一个传感器来产生，计数脉冲被设定为上升沿触发。计数器溢出时，需要更新一个用于存储当前里程的RAM寄存器单元COUNT，可以理解为车轮转了一定圈数后，里程表的增加一定的里程数。
　　RB0管脚用来接收一个外部中断信号，接收到中断信号后，在中断服务程序中将COUNT的值即当前里程数保存至EEPROM的00H单元。这样可以配合外部电路实现当单片机掉电时自动保存里程表数值的功能，即汽车熄火时保存里程表，以减少对EEPROM的读写次数。
　　单片机启动时，首先应该到EEPROM的相应单元读取里程表的当前值，并在此基础上进行累加。
　　程序中为了调试方便，还将COUNT的数值同步地通过8个LED以二进制形式较直观地显示了出来。

list	P = 18F452
#include P18F452.INC
 
	TMR0B	EQU D'253'
	COUNT	EQU  0x10H
	ORG	0000H	  	;PIC上电时从0000h单元开始执行
	GOTO	MAIN	  	;跳转到主程序
 
	ORG	0008H
	GOTO	INT0_ISR	;中断向量入口
 
	ORG	0030H	  	;主程序定位
MAIN	
	CLRF	TRISD	  	;设定D口方向为输出
	CLRF	PORTD 		;设定C口方向为输出
	BSF	TRISA, 4 	; 使用RA4做为计数输入
	BSF	INTCON, GIE 	;开全局中断
	BCF	INTCON, INT0IF 	;清INT0中断标志
	BSF	INTCON, INT0IE 	; 开INT0中断
	BSF	TRISB, INT0 	; 设定RB0即INT0脚为接收(输入)状态
 
	MOVLW	68H
	MOVWF	T0CON 		; 设定计数器TMR0为8位计数，上升沿触发，分频比1:1
	MOVLW	0x00
	MOVWF	EEADR	 	; 装载EEPROM的地址00h
	CALL	READ_EE 	; 读入EEPROM中00h单元的原始数据，即计数初值，保存到WREG
	MOVWF	COUNT
	MOVWF	PORTD 		; 输出到PORTD(连接了8个LED)
 
LOOP	
 
	BCF	INTCON, T0IF 	; 清TMR0中断标志
	MOVLW	TMR0B 
	MOVWF	TMR0L 		; 装入计数初值 253
	BSF	T0CON, TMR0ON 	; 启动计数器
	TEST	
	BTFSS	INTCON, T0IF 	; 检测TMR0是否溢出
	GOTO	TEST
	INCF	COUNT, F 	; 计数加一
	MOVFF	COUNT, PORTD 	; 输出，显示
 
	GOTO	LOOP
 
WIRT_EE				; 写EEPROM
	BCF	EECON1, EEPGD
	BCF	EECON1, CFGS 	; 设定EECON1控制寄存器
	BSF	EECON1, WREN 	; EEPROM写使能
	BCF	INTCON, GIE 	; 写EEPROM时需要关闭一切中断
 
	MOVLW	0x55h 	; 
	MOVWF	EECON2
	MOVLW	0xAAh
	MOVWF	EECON2
	BSF	EECON1, WR 	; 经典的五指令序列，将EEDATA写入EEPROM
 
	BSF	INTCON, GIE 	; 开全局中断
	BCF	EECON1, WREN 	; 提前关闭写使能
	RETURN	
 
READ_EE				; 读EEPROM
	BCF	EECON1, EEPGD
	BCF	EECON1, CFGS
	BSF	EECON1, RD
	NOP	
	MOVF	EEDATA, W 	; 将读出的结果写入W并返回，
	RETURN	
 
 
INT0_ISR	
				; 外部中断int0服务程序，可以利用外部电路，
				; 实现掉电时将当前计数值写入EEPROM
	BTFSS	INTCON, INT0IF  ; 重新测试溢出位，防止干扰信号触发中断
	RETFIE	
	BCF	INTCON, INT0IF
	MOVLW	0x00h
	MOVWF	EEADR
	MOVFF	COUNT, EEDATA
	CALL	WIRT_EE
 
	RETFIE			; 中断返回
END

662e438d

PIC18 ADC模数转换

dutor — Wed, 18 Nov 2009 14:40:37 +0000

　　使用PIC18单片机的ADC转换模块对RA0口输入的模拟电压信号进行转换，然后通过PORTD端口输出，而这里与PORTD对应引脚相连接的是8个LED。

list P = 18F452 ;指明单片机型号为PIC18F452
#include P18F452.INC ;包含一个头文件，其中定义了一些端口及一些特殊寄存器的地址
 
	org	0000h  	;PIC上电时从0000h单元开始执行
	goto	main  	;跳转到主程序
	ORG	0008H  	;中断向量入口
	BTFSS	PIR1, ADIF 	; AD转换完成中断
	RETFIE
	GOTO	AD_ISR
 
	ORG	0030H  	;主程序定位
MAIN
	CLRF	TRISD  	;设定D口方向为输出
	CLRF 	PORTD 	;设定C口方向为输出
	BSF 	TRISA, 0 	; 使用AN0输入
	MOVLW	81H 	;FOSC/32, AN0, 开启
	MOVWF	ADCON0
	MOVLW	0EH 	;左对齐,AN0为模拟输入
	MOVWF	ADCON1 	;VDD & VSS为参考电压
	BCF 	INTCON, TMR0IF
	BCF 	PIR1, ADIF 	;清AD中断标志位
	BSF 	PIE1, ADIE 	;开AD中断
	BSF 	INTCON, PEIE 	;开外围中断
	BSF  	NTCON, GIE 	;开总中断
	MOVLW 	C7H 	;TMR0 8位，分频比为1:256
	MOVWF	T0CON
LOOP
	CALL	DELAY
	BSF  	DCON0, GO 	;开启 A/D转换
	GOTO	LOOP
 
DELAY
 
	BTFSS  	NTCON, TMR0IF 	; 等待延时，采样保持
	GOTO  	DELAY
	BCF  	NTCON, TMR0IF
	RETURN
 
AD_ISR ;AD转换完成时调用的中断服务程序，将转换结果输出
	ORG 	0200H
	MOVFF	ADRESH, PORTD 	;显示转换结果
	BCF 	PIR1, ADIF 	;清AD中断标志位
	RETFIE
END 	;程序结束

内存泄漏小陷阱

dutor — Wed, 18 Nov 2009 04:36:20 +0000

int
main()
{
	char * str = new char[32];
	str = "Hello, Piggy!";
	return 0;
}

这样是会内存泄漏的……而我一直都不知道……

.LC0:
	.string	"Hello, Piggy!"
	.text
.globl main
	.type	main, @function
main:
	andl	$-16, %esp
	subl	$32, %esp
	movl	$32, (%esp)
	call	_Znaj
	movl	%eax, 28(%esp)
	movl	$.LC0, 28(%esp) ;把str给覆盖了

不过想来也自然，因为这样是允许的，char *str = “Hello, Piggy!”;，“程序中的字符串被存放在常量存储区”不要把这句话当成耳旁风，谨记。

sizeof只是个运算符

dutor — Thu, 05 Nov 2009 04:35:05 +0000

　　有的东西，你自己觉得自己理解了知道了记住了，可能你真的记住了，但你真的理解了吗？Put a “Why” upon everything ever you touch.
　　sizeof仅仅是个运算符，但那又意味着什么呢？意味着它不是一个函数，意味着它是在编译期求值(我并不是说所有的运算符都编译期求值)的。对于这样一条语句：

1	size_t size = sizeof(int);

来说，仅仅对应着这样一条汇编指令：

1	movl $4, -4(%ebp)

　　这对于自定义类型class也是同样的。

PIC中断汇编

dutor — Tue, 03 Nov 2009 23:24:20 +0000

list P = 18F452
#include P18F452.INC
 
MOVLF macro R, K
    movlw 	K
    movwf 	R
endm
 
    ; 定义了几个寄存器
    R1  	EQU 20H
    R2  	EQU 21H
    R3  	EQU 22H
    R4 		EQU 23H
 
    ORG 	0008H  ;中断向量入口
    GOTO 	SELECT ;跳转到中段服务选择子程序
 
	org		0000h  ;PIC上电时从0000h单元开始执行
	goto	main  ;跳转到主程序
 
	org		0030h  ;主程序定位
main
	clrf	TRISD  ;设定D口方向为输出
    CLRF	TRISC ;设定C口方向为输出
    CLRF	PORTC ;C口置零
    BSF 	TRISB, INT0 ; 设定int0中断源对应引脚为输入
    CLRF 	PORTD
    CLRF	INTCON ;先将中断控制寄存器清零
    BSF 	INTCON, GIE ; 允许全局中断
    BSF  	INTCON, TMR0IE ; 允许TMR0定时器中断
    BSF		INTCON, INT0IE ; 允许int0中断
    MOVLF  	T0CON, 07H ; 设定定时器0的计数模式
 
    ; 给定时器装入初值，定时器为特殊的双缓冲结构，
    ; 注意初值的装入顺序为先高后低
    MOVLF 	TMR0H, 0C2H
    MOVLF  	TMR0L, 0F7H
    BSF  	T0CON, TMR0ON ; 打开定时器开始计数
 
LOOP ; PIC汇编的标号不需要冒号':'
   	;SLEEP  ; 进入Sleep模式
   	GOTO LOOP ; 转啊转
 
 
SELECT ; 中断服务选择程序,这里的测试顺序决定了中断优先级
   	BTFSC   INTCON, TMR0IF ; 测试定时器溢出位，为0则跳过一条指令
   	GOTO   	TMR0_ISR ; TMR0IF为1时，跳转到定时器服务程序
   	;NOP
   	BTFSS   INTCON, INT0IF ; 测试外部中断int0的标志位，为0则跳一步
   	RETFIE ; 中断返回，会涉及到出栈操作
   	GOTO   	INT0_ISR ; 跳转到int0服务程序
 
TMR0_ISR ; 定时器服务程序
   	BTFSS   INTCON, TMR0IF  ; 重新测试溢出位，防止干扰信号触发中断
   	RETFIE
   	BCF  	INTCON, TMR0IF  ; 清除溢出位
   	;BSF  	INTCON, GIE ; 
   	INCF   	PORTD, F ; D口加1
   	MOVLF 	TMR0H, 0C2H ; 计数器初值进行重装
   	MOVLF  	TMR0L, 0F7H
 
   	RETFIE ; 中断返回
 
 
INT0_ISR ; 外部中断int0服务程序
   	;CALL 	delay
   	BTFSS   INTCON, INT0IF  ; 重新测试溢出位，防止干扰信号触发中断
   	RETFIE
   	BCF   	INTCON, INT0IF ; 清除溢出位
   	; 下面的几行通过更改定时器的分频比来改变定时间隔，每次减半
   	MOVFF  	T0CON, R1
   	DECF   	R1, W
   	ANDWF   07H
   	MOVWF   T0CON
   	; D口加1
   	INCF   	PORTD
   	;MOVLF  R1, 0005H
   	;MOVF 	PORTD, W
   	;SUBWF 	R1, W
   	;BNZ 	NEXT
   	;BSF 	PORTC, 0002H
   	;CALL 	DELAY
   	;BCF 	PORTC, 0002H
NEXT
 
   	RETFIE ; 中断返回
 
SPEAKER
  	BSF  PORTC, 0002H
  	RETURN
DELAY  ; 软件延时
	movlw	0xFF
	movwf 	R1
L3
	movlw	0x1f
	movwf	R2
L2
	movlw	0x1f
	movwf	R3
L1
	decf	R3, F
	bnz		L1
	decf		R2, F
	bnz		L2
	decf		R1, F
	bnz		L3
	return
 
end

　　PIC的汇编实在诡异，有点被颠覆的感觉，原来汇编指令还可以这么来设计，原来汇编指令怎么设计都可以。最OOXX的一条指令就一个实现短转移的指令叫做BRA，意为BRAanch，看到这条指令的时候，我都诧异了，奶罩能做什么？哇塞！居然还能跳转！？奶罩居然可以无条件跳转？！Orz……另外PIC指令把单词缩写运用的淋漓尽致，譬如指令BTFSS，是一条位测试加条件跳转指令：BTFSS = Bit + Test + FileRegister + Skip + Set，用法：BTFSS R1, 0003h, 寄存器R1的第3位为1时跳过下一条指令。真是震撼！

　　最后附上PIC18的中断体系硬件结构图，出自陈育斌老师的手笔：

PIC18中断体系硬件结构示意图

一段小程序

dutor — Tue, 03 Nov 2009 04:40:13 +0000

一、
源程序，

int
main()
{
	unsigned a = 1;
	int b = 1;
	while(a + b >= 0) --b;
	return 0;
}

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
.L2:
	subl	$1, -8(%ebp)
	jmp	.L2

二、
源程序，

1
2
3

//...
	while(a + b > 0) --b;
//...

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	testl	%eax, %eax
	setne	%al
	testb	%al, %al
	jne	.L3

三、
源程序，

1
2
3

//...
	while(a + b > -2) --b;
//...

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	cmpl	$-1, %eax
	sete	%al
	testb	%al, %al
	jne	.L3

四、
源程序，

1
2
3

//...
	while(a + b >= -2) --b;
//...

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	cmpl	$-3, %eax
	seta	%al
	testb	%al, %al
	jne	.L3

五、
源代码，

1
2
3

//...
	while(a + b >= 1) --b;
//...

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	testl	%eax, %eax
	setne	%al
	testb	%al, %al
	jne	.L3

　　
　　这里面猫腻儿还真不少。

　　karmic到源里面没有以前到vim-full包了，取而代之到是vim包，但现在有很多问题，n”+yy和n”+p无法和系统”剪切板”里到内容关联了，不知道什么原因。

Update
　　一切都释然了，只要意识到，>也需要进行类型提升。那么后面到-1啦-2啦之类的，都是很大很大的数了，循环根本就进不去，更别提死循环了。这样看来四、五两段程序就没有必要列出来了。其实，我是被它们的汇编代码给迷惑住了。

最小的程序

dutor — Wed, 02 Sep 2009 14:25:11 +0000

void
nomain()
{
    asm("movl $42, %ebx \n\t"
            "movl $1, %eax \n\t"
            "int $0x80 \n\t");
}

　　程序中使用了EXIT系统调用，Linux中是通过0×80号中断实现的，寄存器ebx表示进程退出码，比如我们平时的main程序中的return的数值会返回系统库，由系统库将该数值传递给EXIT系统调用。这样父进程就能接受到子进程的退出码，例如在bash中环境变量$?就保存了上一个命令(即子进程)的退出码。寄存器eax用来保存系统调用的调用号，例如EXIT系统调用的调用号是1，write系统调用号为4。因此这个小程序的功能就是直接返回至父进程。

　　这里面没有用到C库，也没有main函数，为了把这个程序编译成可执行文件，需要指定程序的入口。编译指令：

$ gcc -c nomain.c 
$ ld -e nomain nomain.o -o nomain
$ ./nomain
$ echo $?
42
$ ls -l nomain
-rwxr-xr-x 1 ivan ivan 618 2009-09-02 22:11 nomain
$ strip nomain
$ ls -l nomain
-rwxr-xr-x 1 ivan ivan 356 2009-09-02 22:15 nomain

　　解释一下，ld是linux下的一个链接器，-e选项用来指定程序的入口。编译后可执行文件的大小为618字节(一个动态链接的HelloWorld需要9KB，静态链接将近600K)，strip命令可以”剥去”可执行文件中的调试信息，可进一步减小文件的大小，另外在链接时通过其他选项还可以将可执行文件中保存的编译器和系统版本信息也一并去掉……

　　此程序虽已经很小，没有调用任何C库，但还是脱离不了操作系统而独立运行。

Linux动态链接的实现方式

dutor — Tue, 25 Aug 2009 04:28:46 +0000

　　看了一个很牛B的帖子，关于动态链接的：
http://www.ibm.com/developerworks/cn/linux/l-dynlink/index.html。
　　对Linux中C程序的动态链接过程，在这里对几个关键点做一下注解。
　　反汇编后的汇编代码中，调用printf是通过call指令来实现的：

 804838c:       e8 47 ff ff ff          call   80482d8

 8048391:       b8 00 00 00 00          mov    $0x0,%eax

　　其中，0x80482d8是printf在plt中的地址(逻辑地址)。plt是结构这样的：

Disassembly of section .plt:

080482a8 <__gmon_start__@plt-0x10>:
 80482a8:       ff 35 60 95 04 08       pushl  0x8049560
 80482ae:       ff 25 64 95 04 08       jmp    *0x8049564
 80482b4:       00 00                   add    %al,(%eax)
080482b8 <__gmon_start__@plt>:
 80482b8:       ff 25 68 95 04 08       jmp    *0x8049568
 80482be:       68 00 00 00 00          push   $0x0
 80482c3:       e9 e0 ff ff ff          jmp    80482a8 <_init+0x30>
080482c8 <__libc_start_main@plt>:
 80482c8:       ff 25 6c 95 04 08       jmp    *0x804956c
 80482ce:       68 08 00 00 00          push   $0x8
 80482d3:       e9 d0 ff ff ff          jmp    80482a8 <_init+0x30>
080482d8 < printf @ plt>:
 80482d8:       ff 25 70 95 04 08       jmp    *0x8049570
 80482de:       68 10 00 00 00          push   $0x10
 80482e3:       e9 c0 ff ff ff          jmp    80482a8 <_init+0x30>

　　在call指令执行后执行

1	jmp *0x8049570

　　程序跳转到地址(addr1)0×8049570存储的地址(addr2)处，即*addr1 == addr2，若包含printf的库libc.so尚未加载，这时addr2的值就是0x080482de，即指令push $0×10。将0×10压入堆栈，用来定位printf在libc.so的位置。接下来的jmp指令将程序定位在0x80482a8，即<__gmon_start__@plt-0x10>处，将0×8049560压入堆栈。jmp *0×8049564指令是程序跳转到一个固定的加载程序处，即原帖中的function _dl_runtime_resolve：

Dump of assembler code for function _dl_runtime_resolve:
0x4000a960 <_dl_runtime_resolve>:       pushl  %eax
0x4000a961 <_dl_runtime_resolve+1>:     pushl  %ecx
0x4000a962 <_dl_runtime_resolve+2>:     pushl  %edx
0x4000a963 <_dl_runtime_resolve+3>:     movl   0x10(%esp,1),%edx
0x4000a967 <_dl_runtime_resolve+7>:     movl   0xc(%esp,1),%eax
0x4000a96b <_dl_runtime_resolve+11>:    call   0x4000a740 
0x4000a970 <_dl_runtime_resolve+16>:    popl   %edx
0x4000a971 <_dl_runtime_resolve+17>:    popl   %ecx
0x4000a972 <_dl_runtime_resolve+18>:    xchgl  %eax,(%esp,1)
0x4000a975 <_dl_runtime_resolve+21>:    ret    $0x8
0x4000a978 <_dl_runtime_resolve+24>:    nop
0x4000a979 <_dl_runtime_resolve+25>:    leal   0x0(%esi,1),%esi
End of assembler dump.

　　此时的堆栈情况见原帖。以下三条指令，将0×10和0×8049560作为参数放入寄存器edx、eax并调用，用这两个参数定位并装入printf所在的库libc.so，并将printf的地址放入寄存器eax:

0x4000a963 <_dl_runtime_resolve+3>:     movl   0x10(%esp,1),%edx
0x4000a967 <_dl_runtime_resolve+7>:     movl   0xc(%esp,1),%eax
0x4000a96b <_dl_runtime_resolve+11>:    call   0x4000a740

　　指令xchgl %eax,(%esp,1)将printf的地址放入栈顶。最精彩的一条指令当属ret $0×8，它将栈顶元素即printf的地址弹出至程序计数器PC，作为下一条将执行的指令地址，同时，清除堆栈中的0×10和0×8049560。此时堆栈中的情形，就如同直接调用了printf函数，似乎什么都没发生过。

　　此外还做了一件重要的工作，就是把前面提到的addr2替换为printf的地址。从而当再次调用printf时jmp *addr1就直接将程序定位到printf，不需要再次加载库libc.so了。

　　不知道我说清楚了没有，感觉说的很乱，文字也很乱。:-)

if/else vs ?:

dutor — Tue, 18 Aug 2009 04:55:13 +0000

听到有人说，if/else比三目运算符? :容易调试，而且可读性高、效率也高( ⊙o⊙ )?！我迅速地搜索?:还有没有存在的理由，难道我一直都在写着晦涩、低效的? : !？为了一探究竟，我写下了这段代码：

#include 
int
main()
{
	int a = 1, b = 2, c;
	if(a < b)
		c = a;
	else
		c = b;
	c = a < b ? a : b;
	return 0;
}

g++ test.cpp -S 得到：

	call ___main
	movl $1,-4(%ebp) ; a
	movl $2,-8(%ebp) ; b
	movl -4(%ebp),%eax ;if/else开始
	cmpl -8(%ebp),%eax
	jge L2
	movl -4(%ebp),%eax
	movl %eax,-12(%ebp)
	jmp L3
	.p2align 4,,7
L2:
	movl -8(%ebp),%eax
	movl %eax,-12(%ebp) ; if/else结束
L3:
	movl -8(%ebp),%eax ; ? :开始
	cmpl -4(%ebp),%eax
	jle L4
	movl -4(%ebp),%eax
L4:
	movl %eax,-12(%ebp) ; ? :结束

if/else用了8条指令，?:用了5条，这个差距可不算小了啊！因为，程序里面是要有循环的，多数循环里面会有分支语句，且很多情况下是二分支。
呃……又学到一个单词，ternary：三元。:-)

分析一个奇怪的汇编程序

dutor — Mon, 06 Jul 2009 08:30:21 +0000

assume cs:code
 
code segment
	mov ax, 04c00h
	int 21h
start:
	mov ax, 0
s:
	nop
	nop
 
	mov di, offset s
	mov si, offset s2
	mov ax, cs:[si]
	mov cs:[di], ax
 
s0:
	jmp short s
s1:
	mov ax, 0
	int 21h
	mov ax, 0
 
s2:
	jmp short s1
	nop
 
code ends
end start

说这个程序奇怪，是因为用来结束程序并返回的两个语句:

	mov ax, 04c00h
	int 21h

没有放在程序结束处，而是放在的代码段的起始位置，更甚，由于程序是从start开始执行的，似乎永远不会执行到这两行，程序也永远不会结束。但是这个程序却能正常结束，而且是由我们的这两行代码来结束执行的。
其中的猫腻就在于短转移指令jmp short s1。jmp指令是用来更改寄存器CS:IP来实现程序的转移的，汇编语言中一般是以标号来指明跳转的目的地址的。对于长转移指令，例如jmp dword ptr ds:[0]，CPU确实是以目标地址的段基址和段内偏移来修改CS:IP的。但是对于短转移来说，却是利用当前IP与目标地址之间的的偏移量来确定的。上例中，执行jmp short s1时，IP指向下一条指令nop，与目标地址s1之间偏移量为10：

   CS:IP     机器码             汇编指令(编译器将标号进行了替换)
0B80:0018 B80000        MOV     AX,0000    ;s1
0B80:001B CD21          INT     21
0B80:001D B80000        MOV     AX,0000
0B80:0020 EBF6          JMP     0018           ; jmp short s1
0B80:0022 90              NOP

s1与s2之间的机器指令整好是10个字节，-10(向低地址方向转移)的补码是0xF6h，看汇编指令jmp short s1对应的机器指令EBF6，发现什么了吗？F6就指明了偏移量！
再回到正题，程序中将jmp short s1原封不动地复制到了s处，当程序执行到s处时，向前跳转10个字节，恰好是本文开始提到的那两条用来结束程序的指令！
其实，这个程序没有任何的实际意义，但却能加深我对汇编指令内部机理的理解。

I2C键盘扫描程序

dutor — Wed, 06 May 2009 14:22:26 +0000

;#################################################################
;              这是一个键盘扫描程序 
;将得到的健值（01H-10H）在右边两位数码管显示 (data= XX) 
;程序采用中断结构，硬件连接上将INT_KEY信号与P3.2(INT0) 连接；
;普通的I2C通讯程序可以直接利用，为读数据子程序需要加延时
;这是ZLG7290芯片在读数据时有延时，在RDBYT中添加一个20US延时
;#################################################################
SDA		BIT	P1.0
SCL		BIT	P1.1  
WSLA		EQU	070H
RSLA		EQU	071H
DISDA		EQU	20H		;源数据块首地址
DISCON		EQU	08H		;写入数据个数		
DATA_1		EQU	30H		;变量区首地址
;********************************************************
	ORG	8000H 
	LJMP	8100H  
;********************************************************
	ORG	8003H
	LJMP	INT_7290
;********************************************************
;            初始化部分					          
;********************************************************
	ORG	8100H 
START: MOV	SP,#60H
	CLR	P1.7   		;7290复位
	LCALL	DELAY	
	SETB	P1.7	
	SETB	EA 			;开INT0中断
	SETB	EX0
	SETB	IT0  		;触发极性为下降沿 	
;********************************************************
;           建立变量缓冲区	(30H-37H) 			          
;********************************************************
	MOV	DATA_1,  #13H	;变量缓冲区(显示 data =   )
	MOV	DATA_1+1,#13H	;注意：
	MOV	DATA_1+2,#13H 	;变量取值范围0-F
	MOV	DATA_1+3,#12H
	MOV	DATA_1+4,#10H
	MOV	DATA_1+5,#11H
	MOV	DATA_1+6,#10H
	MOV	DATA_1+7,#0DH
;********************************************************
;           通过查表建立显示缓冲区（20H-27H）				          
;********************************************************
	MOV	DPTR,#LEDSEG 	;开始对变量查表
	MOV	R7,#DISCON		;写入数据个数	
	MOV	R0,#DISDA  		;源数据块首地址
	MOV	R1,#DATA_1
LOOP1:	MOV	A,@R1
	MOVC	A,@A+DPTR 		;查表得对应的字形码
	MOV	@R0,A 			;送显示缓冲区
	INC	R1
	INC	R0
	DJNZ	R7,LOOP1  
;********************************************************
;	向7290B写入数据，以显示"data=  "
;********************************************************
LOOP:	MOV	R7,#DISCON
	MOV	R2,#10H
	MOV	R3,#WSLA
	MOV	R0,#DISDA 
	LCALL	WRNBYT			;调显示子程序
	LCALL	DELAY 			;使显示稳定 
	SJMP	LOOP 
;******************************************************************
LEDSEG:	DB	0FCH,60H,0DAH,0F2H,66H,0B6H,0BEH,0E4H	;0-7的字形码
		DB	0FEH,0F6H,0EEH,3EH,9CH,7AH,9EH,8EH		;8-F的字形码
		DB	0FAH,1EH,12H,00H						;a,t,= 和熄灭码
;******************************************************************
;	拆分程序（将A中的数据拆分为两个四位16进制数并查表）
;	( 结果在R4、R3中 ) 
;******************************************************************
CF:	PUSH	02H 		;将A中的数据拆分为两个四位16进制数并查表
	PUSH	DPH  	;	
PUSH	DPL
	MOV	DPTR,#LEDSEG
	MOV	R2,A
	ANL	A,#0FH
	MOVC	A,@A+DPTR
	MOV	R3,A
	MOV	A,R2
	SWAP	A
	ANL	A,#0FH
	MOVC	A,@A+DPTR
	MOV	R4,A
	POP	DPL
	POP	DPH
	POP	02H
	RET  
;*******************************************************************
;          中断服务程序 INT_7290:（INT0）
;*******************************************************************	
INT_7290:
	PUSH	00H
	PUSH	02H
	PUSH	03H
	PUSH	04H
	PUSH	07H
	PUSH	ACC
	PUSH	PSW
	MOV	R0,#28H	;状态数据区首址
	MOV	R7,#04H	;取状态数据个数
	MOV	R2,#00H ;内部数据首地址
	MOV	R3,#WSLA;取器件地址（写）
	MOV	R4,#RSLA;取器件地址（读）
 	LCALL	RDADD	;读出7290的00H-03H数据存于28H-2BH 
	NOP			;设定一个断点,以观察读出的4个数据
	MOV	A,29H	;取健值
	LCALL	CF		;拆分、查表
	MOV	20H,R3	;送显示缓冲区（最低两位数码管）
	MOV	21H,R4
	POP	PSW
	POP	ACC
	POP	07H
	POP	04H
	POP	03H
	POP	02H
	POP	00H
	RETI
;**********************************************************************
DELAY:	PUSH	00H
	PUSH	01H
	MOV	R0,#00H
DELAY1:	MOV	R1,#00H
	DJNZ	R1,$
	DJNZ	R0,DELAY1
	POP	01H
	POP	00H
	RET
;**********************************************************************
 
;相关的I2C子程序（WRNBYT、WRBYT、STOP、CACK、STA）参见8.1.4 。这里省略
;*******************************************************************
;【附录一】由汇编语言编制的I2C通讯子程序
;【提  示】下列程序是在系统时钟为12MHZ（或11.0592MHZ），即NOP指令为1微秒左右。
;（1）带有内部单元地址的多字节写操作子程序 WRNBYT
;*******************************************************************
;通用的I2C通讯子程序（多字节写操作）
;入口参数R7字节数,R0:源数据块首地址
;R0原数据块首地址；R2从器件内部子地址;R3:外围器件地址（写）
;相关子程序WRBYT、STOP、CACK、STA
;*******************************************************************	
WRNBYT:	PUSH	PSW		
		PUSH	ACC				
WRADD:	MOV		A,R3		;取外围器件地地址（包含r/w=0）	
		LCALL	STA		;发送起始信号S  
		LCALL	WRBYT		;发送外围地址
		LCALL	CACK		;检测外围器件的应答信号
		JB		F0,WRADD	;如果应
		MOV		A,R2
		LCALL	WRBYT		;发送内部寄存器首地址
		LCALL	CACK		;检测外围器件的应答信号
		JB		F0,WRADD	;如果应答不正确返回重来 	
WRDA:	MOV		A,@R0
		LCALL	WRBYT		;发送外围地址
		LCALL	CACK		;检测外围器件的应答信号
		JB		F0,WRADD	;如果应答不正确返回重来
		INC		R0
		DJNZ  	R7,WRDA
		LCALL	STOP 	
		POP		ACC
		POP		PSW
		RET 	       
;*******************************************************************
 
 
 
 
 
 
 
 
 
 
;（2）带有内部单元地址的多字节读操作子程序 RDADD 
;*******************************************************************
;通用的I2C通讯子程序（多字节读操作）
;入口参数R7字节数；
;R0目标数据块首地址；R2从器件内部子地址；
;R3器件地址（写）；R4器件地址（读）
;相关子程序WRBYT、STOP、CACK、STA、MNACK 
;*******************************************************************	
RDADD:  PUSH	PSW			;从PCF8563的02H单元读入7个参数
		PUSH	ACC			;存放于20H-26H单元	
RDADD1:	LCALL	STA 
		MOV		A,R3		;取器件地址（写）
		LCALL	WRBYT		;发送外围地址
		LCALL	CACK		;检测外围器件的应答信号
		JB		F0,RDADD1	;如果应答不正确返回重来
		MOV		A,R2		;取内部地址	
		LCALL	WRBYT		;发送外围地址
		LCALL	CACK		;检测外围器件的应答信号
		JB		F0,RDADD1	;如果应答不正确返回重来	
		LCALL	STA
		MOV		A,R4		;取器件地址（读）
		LCALL	WRBYT		;发送外围地址
		LCALL	CACK		;检测外围器件的应答信号
		JB		F0,RDADD1	;如果应答不正确返回重来
RDN:	LCALL	RDBYT 	
		MOV		@R0,A
		DJNZ	R7,ACK
		LCALL	MNACK
		LCALL	STOP	
		POP		ACC
		POP		PSW
		RET
ACK:	LCALL	MACK
		INC		R0
		SJMP	RDN 
 
 
 
 
 
 
 
;（3）I2C各个信号子程序
;**********************************************************************
;						启动信号子程序S 
;**********************************************************************
STA:	SETB	SDA		;启动信号S
		SETB	SCL
		NOP				;产生4.7US延时
		NOP
		NOP
		NOP
		NOP	
		CLR		SDA
		NOP				;产生4.7US延时
		NOP
		NOP
		NOP
		NOP 	
		CLR		SCL
		RET 
;**********************************************************************
;						停止信号子程序P 
;**********************************************************************
STOP:	CLR		SDA 	;停止信号P
		SETB	SCL
		NOP				;产生4.7US延时
		NOP
		NOP
		NOP
		NOP	
		SETB	SDA
		NOP				;产生4.7US延时
		NOP
		NOP
		NOP
		NOP	
		CLR		SCL
		CLR		SDA
		RET 
;**********************************************************************
;						应答信号子程序   MACK
;**********************************************************************
MACK:	CLR		SDA	;发送应答信号ACK
		SETB	SCL
		NOP			;产生4.7US延时
		NOP
		NOP
		NOP
		NOP
		CLR		SCL
		SETB	SDA
		RET
;**********************************************************************
;						非应答法信号子程序MNACK
;**********************************************************************
MNACK:	SETB	SDA		;发送非应答信号NACK
		SETB	SCL
		NOP				;产生4.7US延时
		NOP
		NOP
		NOP
		NOP
		CLR		SCL
		CLR		SDA
		RET
;**********************************************************************
;						应答检测子程序CACK
;**********************************************************************
CACK:	SETB	SDA		;应答位检测子程序
		SETB	SCL 
		CLR		F0
		MOV		C,SDA	;采样SDA
		JNC		CEND	;应答正确时转CEND
		SETB	F0		;应答错误时F0置一
CEND:	CLR		SCL
		RET
;**********************************************************************
;						发送一个字节子程序WRBYT
;**********************************************************************
WRBYT:	PUSH	06H
MOV		R6,#08H		;发送一个字节子程序 
WLP:	RLC		A 			;(入口参数A)
		MOV		SDA,C
		SETB	SCL
		NOP					;产生4.7US延时
		NOP
		NOP
		NOP
		NOP
		CLR		SCL
		DJNZ	R6,WLP
		POP		06H
		RET
;**********************************************************************
;						接收一个字节子程序RDBYT 
;**********************************************************************
RDBYT: 	PUSH	06H
		MOV		R6,#08H	;接收一个字节子程序
RLP:	SETB	SDA
		SETB	SCL
;  *******************************************
	NOP			;!!!!!产生大于15微秒的延时!!!!!!
	NOP 		;注意这是专门为ZLG7290
	NOP 		;添加的20微秒延时部分
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
;  ********************************************	
	MOV		C,SDA
	MOV		A,R2
	RLC		A
	MOV		R2,A
	CLR		SCL
	DJNZ	R6,RLP 		;(出口参数R2)
	POP		06H
	RET  
;**********************************************************************
 
		END

51单片机A/D转换器

dutor — Wed, 06 May 2009 14:18:19 +0000

 
	dat 	bit p3.2	;定义端口号
	clk	bit p3.3	
	cs	bit p3.4
 
	org	8000h		;程序定位及跳转指令的设置
	ljmp	8100h
	org	8100h
 
start:
	mov	sp, #60h	;定义堆栈底位置
stable:
	mov	r3, #00h	;循环体执行次数:256
	mov	r6, #00h	;寄存器清零
	mov	r7, #00h	;寄存器清零
loop:
				;取平均值主要是为了减小
				;高速模数转换干扰产生的误差
	lcall	tlc549_adc	;调用模数转换子程序
	add	a, r6		;向R7-R6累加a的值256次
	mov	r6, a
	mov 	a, #00h
	addc	a, r7
	mov	r7, a	
	lcall	delay
	djnz	r3, loop
	mov	a, r7		;将R7中的平均值送到a
	cpl	a		;a取反
	mov	p1, a		;输出a的值
	sjmp	stable
 
tlc549_adc:			;模数转换的驱动子程序
	push	07h
	clr	a		;清零
	clr	clk		;清零
	mov	r7, #08h	;由于是串行输入，每字节需要8次读入
	clr	cs		;片选信号置低位，选中模数转换器
loop1:
	setb	clk		;开始读取数据
	mov	c, dat
	rlc	a		;诸位读取，送到a
	clr	clk
	djnz	r7, loop1
	setb	cs
	setb	clk
	pop	07h
ret
 
delay:				;微小的延时，用来同步和协调单片机
				;与模数转换器的工作步调
	push	00h
	mov	r0, #00h
	djnz	r0, $
	pop	00h
ret
 
 
end

单片机蜂鸣器

dutor — Wed, 29 Apr 2009 14:16:25 +0000

功能描述

功能很简单，程序更简单：

简单的蜂鸣器实验程序：本程序通过在P1.1输出一个音频范围的方波，驱动实验板上的蜂鸣器发出蜂鸣声，其中包含有一个定时模块，作用是使输出的方波频率在人耳朵听觉能力之内的20KHZ以下，如果没有这个延时程序的话，输出的频率将大大超出人耳朵的听觉能力，我们将不能听到声音。更改定时常数，可以改变输出频率，也就可以调整蜂鸣器的音调。

 	org 	8000h		;定位
	ljmp 	start
	org 	8100h
start:
	mov 	sp, #60h
	mov	tmod, #10h	;置T1为方式1
	mov	tl1, #010h
	mov	th1, #010h	;设初值，定时为50ms
	setb	tr1		;启动定时器T1
loop:	jnb	tf1, $
 
	clr	tf1
	mov	tl1, #033h
	mov	th1, #0feh
	jb	p1.0, loop
	cpl	p1.1
down:
	sjmp	loop
	END

[warning]This is original article, you could copy it freely with my site links!
此日志为dutor原创，您可以自由转载，添加原文链接我将万分感激！[/warning]

单片机简易电子琴

dutor — Wed, 29 Apr 2009 14:12:53 +0000

功能描述

由p1口外接按键开关，p3.3接蜂鸣器组成。

 	org 	8000h		;定位
	ljmp 	start
	org 	8100h
start:
	mov 	sp, #60h
	mov	tmod, #10h	;置T1为方式1
;	mov	tl1, #010h
;	mov	th1, #010h	;设初值，定时为50ms
	setb	tr1		;启动定时器T1
 
loop1:	
	mov	p1, #0ffh
	mov	a, p1
	mov	r5, a
	cpl 	a
	jz	loop1
	cjne	a, #01h, loop2
	sjmp	do
loop2:
	cjne	a, #02h, loop3
	sjmp	ra
loop3:
	cjne	a, #04h, loop4
	sjmp	mi
loop4:
	cjne	a, #08h, loop5
	sjmp	fa
loop5:
	cjne	a, #10h, loop6
	sjmp	so
loop6:
	cjne	a, #20h, loop7
	sjmp	la
loop7:
	cjne	a, #40h, loop8
	sjmp	xi
loop8:
	cjne	a, #80h, loop1
	sjmp	hdo
	sjmp	loop1
 
do:
	mov	r7, #0f9h
	mov	r6, #21h
	sjmp	loop
ra:
	mov	r7, #0f9h
	mov	r6, #0e0h
	sjmp	loop
mi:
	mov	r7, #0fah
	mov	r6, #08bh
	sjmp	loop
fa:
	mov	r7, #0fah
	mov	r6, #0d7h
	sjmp	loop
so:
	mov	r7, #0fbh
	mov	r6, #67h
	sjmp	loop
la:
	mov	r7, #0fbh
	mov	r6, #0e8h
	sjmp	loop
xi:
	mov	r7, #0fch
	mov	r6, #5bh
	sjmp	loop
hdo:
	mov	r7, #0fch
	mov	r6, #8eh
	sjmp	loop
 
loop:
	lcall 	music
	sjmp	loop1
music:
	mov	tl1, r6
	mov	th1, r7
 
loop9:
	jnb	tf1, $
	clr	tf1
	mov	tl1, r6
	mov	th1, r7
	cpl	p3.3
	mov	a, p1
	cpl	a
	jnz	loop9
	setb	p3.3
down:
	ret
	END

[warning]This is original article, you could copy it freely with my site links!
此日志为dutor原创，您可以自由转载，添加原文链接我将万分感激！[/warning]

单片机中断实验

dutor — Wed, 29 Apr 2009 14:05:40 +0000

功能描述

正常情况下(p3.2为高电平), p3.3的电平以一定的频率连续翻转，当p3.2为低电平时，触发int0外部中断，进入中断服务程序，另p3.3保持低电平，并将p1端口加1。p3.2外接一个按键开关时，中断服务程序有防抖动的功能，这时通过一定的延时(通常为10ms–20ms)来实现的。

程序

 	org 	8000h		;定位
	ljmp 	start
	org 	8003h		;中断向量
	ljmp	int_0
	org 	8100h
start:
	mov 	sp, #60h
	setb	ex0		;开int0中断
	setb 	ea		;开总中断
	mov	tcon, #00h	;低电平触发
	mov	r3, #00h
	mov	a, r3
	cpl	a
loop3:				;死循环
	mov	p1, a
	cpl	p3.3		;翻转
	lcall	DELAY		;延时
	sjmp	loop3
 
int_0:				;中断服务子程序
	push	psw
	lcall	DELAY		;防抖动
	setb	p3.3
	inc	r3
	mov	a, r3
	cpl	a
	mov	p1, a
	jnb	p3.2, $		;查询，防止多次中断
	lcall	DELAY		;还是防抖动
	pop	psw
	reti
 
DELAY:  PUSH 06H
	PUSH 07H
	MOV R7, #70H
LABEL1:
	MOV R6, #70H
LABEL2:
	DJNZ R6, $
	DJNZ R7, LABEL1
	POP 07H
	POP 06H
	RET
	END

[warning]This is original article, you could copy it freely with my site links!
此日志为dutor原创，您可以自由转载，添加原文链接我将万分感激！[/warning]

中断方式定时器

dutor — Wed, 29 Apr 2009 13:54:20 +0000

89C51单片机，每计时一秒将P1端口翻转一次，晶振频率12MHz，中断方式实现。这里另外一个查询方式的实现

 	org 	8000h		;定位
	ljmp 	start
	org 	801bh		;中断向量
	ljmp	int_t1
	org 	8100h
start:
	mov 	sp, #60h
	mov	tmod, #10h	;置T1为方式1
	mov	tl1, 0fch
	mov	th1, #4bh	;设初值，定时为50ms
	mov	r1, #20		;中断次数，以使定时为1ms
	setb	tr1		;启动定时器T1
	clr	a		;累加器清零
	setb	et1		;T1中断允许
	setb	ea		;开总外部中断标志
	sjmp	$		;等待中断
 
 
int_t1:				;中断服务子程序
	push	psw		;保存程序状态字
	mov 	tl1, #0fch	;重装计数器
	mov	th1, #4bh
	djnz	r1, exit	;1s时间未到，返回主程序，等待下一次中断
	mov	r1, #20		;1s时间到，重装r1
	cpl	a		;a取反
	mov	p1, a		;输出a
exit:	pop	psw		;程序状态字出栈
	reti
 
DELAY:  PUSH 06H
	PUSH 07H
	MOV R7, #70H
LABEL1:
	MOV R6, #70H
LABEL2:
	DJNZ R6, $
	DJNZ R7, LABEL1
	POP 07H
	POP 06H
	RET
	END

[warning]This is original article, you could copy it freely with my site links!
此日志为dutor原创，您可以自由转载，添加原文链接我将万分感激！[/warning]

查询式定时器

dutor — Wed, 29 Apr 2009 13:33:29 +0000

89C51单片机，每计时一秒将P1端口翻转一次，晶振频率12MHz，这里另外一个中断方式的实现

 	org 	8000h		;定位
	ljmp 	start
	org 	8100h
start:
	mov 	sp, #60h
	mov	r1, #20	
	clr	a
	mov	tmod, #10h	;置T1为方式1
loop:	mov	tl1, 0fch
	mov	th1, #4bh	;设初值，定时为50ms
	setb	tr1		;启动定时器T1
	jnb	tf1, $		;查询TF1是否溢出
 
	clr	tf1		;清除溢出标志
	djnz	r1, loop	;1s时间未到，重装计数器
	mov	r1, #20		;1s时间到，重装r1
	cpl	a		;a取反
	mov	p1, a		;输出a
	ljmp	loop
 
	END

[warning]This is original article, you could copy it freely with my site links!
此日志为dutor原创，您可以自由转载，添加原文链接我将万分感激！[/warning]

Evolving Scenic Lantern C51

dutor — Thu, 23 Apr 2009 04:19:34 +0000

        ORG 8000H                    ; position the localtion of the beginning of the commands
        LJMP START                  ; jump to the user's commands 
        ORG 8100H                    ; position the localtion of the program
START:	MOV R0, #08H       ; times of right or left shifts
	MOV A, #0FEH               ; set LED which is lighten
	JNB P3.2, LOOP_L           ; watch the switch which controls the shift direction
LOOP_R:	RR A                    ; branch 1: right shift
	MOV P1, A
	LCALL DELAY                 ; delay so that we can notice the flickering
	DJNZ R0, LOOP_R
	SJMP START
LOOP_L:	RL A                     ; branch 1: right shift
	MOV P1, A
	LCALL DELAY
	DJNZ R0, LOOP_L
	SJMP START	 
 
DELAY:  PUSH 06H                   ; subProgram impliments delaying
	PUSH 07H
	MOV R7, #0FFH
LABEL1:
	MOV R6, #0FFH
LABEL2:
	DJNZ R6, $
	DJNZ R7, LABEL1
	POP 07H
	POP 06H
	RET
	END