计算机系统原理，实验三：bomblab，汇编详解

实验验收准备的时候写的，放着也是浪费，就发出来吧。
写得还是比较详细的，下面只保留了函数部分

08048b50 <phase_1>:
8048b50: 83 ec 1c sub $0x1c,%esp
8048b53: c7 44 24 04 84 a1 04 movl $0x804a184,0x4(%esp)//参数左
8048b5a: 08
8048b5b: 8b 44 24 20 mov 0x20(%esp),%eax
8048b5f: 89 04 24 mov %eax,(%esp)//参数右
8048b62: e8 4d 04 00 00 call 8048fb4 <strings_not_equal>//不相等返回1，相等返回0
8048b67: 85 c0 test %eax,%eax
8048b69: 74 05 je 8048b70 <phase_1+0x20>
8048b6b: e8 56 05 00 00 call 80490c6 <explode_bomb>
8048b70: 83 c4 1c add $0x1c,%esp
8048b73: c3 ret

08048b74 <phase_2>:
8048b74: 56 push %esi
8048b75: 53 push %ebx
8048b76: 83 ec 34 sub $0x34,%esp
8048b79: 8d 44 24 18 lea 0x18(%esp),%eax//首元素地址
8048b7d: 89 44 24 04 mov %eax,0x4(%esp)//左参数
8048b81: 8b 44 24 40 mov 0x40(%esp),%eax
8048b85: 89 04 24 mov %eax,(%esp)//右参数
8048b88: e8 6e 06 00 00 call 80491fb <read_six_numbers>
8048b8d: 83 7c 24 18 00 cmpl $0x0,0x18(%esp) //第一个值要为0
8048b92: 75 07 jne 8048b9b <phase_2+0x27>
8048b94: 83 7c 24 1c 01 cmpl $0x1,0x1c(%esp) //第二个值要为1
8048b99: 74 05 je 8048ba0 <phase_2+0x2c>
8048b9b: e8 26 05 00 00 call 80490c6 <explode_bomb>

8048ba0: 8d 5c 24 20 lea 0x20(%esp),%ebx //a[3]地址
8048ba4: 8d 74 24 30 lea 0x30(%esp),%esi //数组末地址
8048ba8: 8b 43 f8 mov -0x8(%ebx),%eax
8048bab: 03 43 fc add -0x4(%ebx),%eax
8048bae: 39 03 cmp %eax,(%ebx)//a[i]=a[i-1]+a[i-2]
8048bb0: 74 05 je 8048bb7 <phase_2+0x43>
8048bb2: e8 0f 05 00 00 call 80490c6 <explode_bomb>
8048bb7: 83 c3 04 add $0x4,%ebx//i++
8048bba: 39 f3 cmp %esi,%ebx//循环判断
8048bbc: 75 ea jne 8048ba8 <phase_2+0x34>
8048bbe: 83 c4 34 add $0x34,%esp
8048bc1: 5b pop %ebx
8048bc2: 5e pop %esi
8048bc3: c3 ret

08048bc4 <phase_3>:
8048bc4: 83 ec 2c sub $0x2c,%esp
8048bc7: 8d 44 24 1c lea 0x1c(%esp),%eax
8048bcb: 89 44 24 0c mov %eax,0xc(%esp) //0x1c（%esp) 输入2
8048bcf: 8d 44 24 18 lea 0x18(%esp),%eax
8048bd3: 89 44 24 08 mov %eax,0x8(%esp) //0x18(%esp)输入1
8048bd7: c7 44 24 04 c3 a3 04 movl $0x804a3c3,0x4(%esp)
8048bde: 08
8048bdf: 8b 44 24 30 mov 0x30(%esp),%eax
8048be3: 89 04 24 mov %eax,(%esp)//eax 存放输入个数
8048be6: e8 85 fc ff ff call 8048870 __isoc99_sscanf@plt
8048beb: 83 f8 01 cmp $0x1,%eax
8048bee: 7f 05 jg 8048bf5 <phase_3+0x31> //输入个数大于1则跳过炸弹
8048bf0: e8 d1 04 00 00 call 80490c6 <explode_bomb>
8048bf5: 83 7c 24 18 07 cmpl $0x7,0x18(%esp)
8048bfa: 77 3c ja 8048c38 <phase_3+0x74>//第一个数大于7则引爆炸弹

8048bfc: 8b 44 24 18 mov 0x18(%esp),%eax
8048c00: ff 24 85 00 a2 04 08 jmp *0x804a200(,%eax,4) // x/20wh 0x804a200,p/ *0x804a200@8

8048c07: b8 6b 02 00 00 mov $0x26b,%eax
8048c0c: eb 3b jmp 8048c49 <phase_3+0x85>
8048c0e: b8 cb 03 00 00 mov $0x3cb,%eax
8048c13: eb 34 jmp 8048c49 <phase_3+0x85>
8048c15: b8 9c 02 00 00 mov $0x29c,%eax
8048c1a: eb 2d jmp 8048c49 <phase_3+0x85>
8048c1c: b8 ee 01 00 00 mov $0x1ee,%eax
8048c21: eb 26 jmp 8048c49 <phase_3+0x85>
8048c23: b8 6c 02 00 00 mov $0x26c,%eax
8048c28: eb 1f jmp 8048c49 <phase_3+0x85>
8048c2a: b8 f2 02 00 00 mov $0x2f2,%eax
8048c2f: eb 18 jmp 8048c49 <phase_3+0x85>
8048c31: b8 cf 01 00 00 mov $0x1cf,%eax
8048c36: eb 11 jmp 8048c49 <phase_3+0x85>
8048c38: e8 89 04 00 00 call 80490c6 <explode_bomb>
8048c3d: b8 00 00 00 00 mov $0x0,%eax
8048c42: eb 05 jmp 8048c49 <phase_3+0x85>
8048c44: b8 d2 03 00 00 mov $0x3d2,%eax

8048c49: 3b 44 24 1c cmp 0x1c(%esp),%eax //对比输入的第二个数和条转表指定的数
8048c4d: 74 05 je 8048c54 <phase_3+0x90>
8048c4f: e8 72 04 00 00 call 80490c6 <explode_bomb>
8048c54: 83 c4 2c add $0x2c,%esp
8048c57: c3 ret

08048c58 :
8048c58: 83 ec 1c sub $0x1c,%esp
8048c5b: 89 5c 24 10 mov %ebx,0x10(%esp)
8048c5f: 89 74 24 14 mov %esi,0x14(%esp)
8048c63: 89 7c 24 18 mov %edi,0x18(%esp)
8048c67: 8b 74 24 20 mov 0x20(%esp),%esi//常数
8048c6b: 8b 5c 24 24 mov 0x24(%esp),%ebx//输入数
8048c6f: 85 f6 test %esi,%esi
8048c71: 7e 2b jle 8048c9e <func4+0x46>//常数小于等于0，返回1
8048c73: 83 fe 01 cmp $0x1,%esi
8048c76: 74 2b je 8048ca3 <func4+0x4b>//常数等于1，返回输入数

8048c78: 89 5c 24 04 mov %ebx,0x4(%esp)//输入数做右参数
8048c7c: 8d 46 ff lea -0x1(%esi),%eax
8048c7f: 89 04 24 mov %eax,(%esp)//常数减一做左参数
8048c82: e8 d1 ff ff ff call 8048c58
8048c87: 8d 3c 18 lea (%eax,%ebx,1),%edi //edi=func（i-1,cin2）+cin2
8048c8a: 89 5c 24 04 mov %ebx,0x4(%esp)
8048c8e: 83 ee 02 sub $0x2,%esi
8048c91: 89 34 24 mov %esi,(%esp)
8048c94: e8 bf ff ff ff call 8048c58 //func(i-2,cin2)
8048c99: 8d 1c 07 lea (%edi,%eax,1),%ebx //ebx=func(i-1,cin2)+cin2+func(i-2,cin2);

8048c9c: eb 05 jmp 8048ca3 <func4+0x4b>
8048c9e: bb 00 00 00 00 mov $0x0,%ebx
8048ca3: 89 d8 mov %ebx,%eax
8048ca5: 8b 5c 24 10 mov 0x10(%esp),%ebx
8048ca9: 8b 74 24 14 mov 0x14(%esp),%esi
8048cad: 8b 7c 24 18 mov 0x18(%esp),%edi
8048cb1: 83 c4 1c add $0x1c,%esp
8048cb4: c3 ret

08048cb5 <phase_4>:
8048cb5: 83 ec 2c sub $0x2c,%esp
8048cb8: 8d 44 24 18 lea 0x18(%esp),%eax
8048cbc: 89 44 24 0c mov %eax,0xc(%esp)//0x18(%esp)第二个输入数
8048cc0: 8d 44 24 1c lea 0x1c(%esp),%eax
8048cc4: 89 44 24 08 mov %eax,0x8(%esp)// 0x1c(%esp)第一个输入数
8048cc8: c7 44 24 04 c3 a3 04 movl $0x804a3c3,0x4(%esp)
8048ccf: 08
8048cd0: 8b 44 24 30 mov 0x30(%esp),%eax
8048cd4: 89 04 24 mov %eax,(%esp)//返回输入个数
8048cd7: e8 94 fb ff ff call 8048870 __isoc99_sscanf@plt
8048cdc: 83 f8 02 cmp $0x2,%eax//输入个数要为2
8048cdf: 75 0e jne 8048cef <phase_4+0x3a>
8048ce1: 8b 44 24 18 mov 0x18(%esp),%eax
8048ce5: 83 f8 01 cmp $0x1,%eax
8048ce8: 7e 05 jle 8048cef <phase_4+0x3a>//第二个输入数小于等于1则引爆炸弹
8048cea: 83 f8 04 cmp $0x4,%eax
8048ced: 7e 05 jle 8048cf4 <phase_4+0x3f>//第二个输入数小于等于4则跳过炸弹
8048cef: e8 d2 03 00 00 call 80490c6 <explode_bomb>

8048cf4: 8b 44 24 18 mov 0x18(%esp),%eax//第二个输入数做右参数
8048cf8: 89 44 24 04 mov %eax,0x4(%esp)
8048cfc: c7 04 24 09 00 00 00 movl $0x9,(%esp)//9作为左参数
8048d03: e8 50 ff ff ff call 8048c58
8048d08: 3b 44 24 1c cmp 0x1c(%esp),%eax//比较函数结果和第一个输入数
8048d0c: 74 05 je 8048d13 <phase_4+0x5e>
8048d0e: e8 b3 03 00 00 call 80490c6 <explode_bomb>
8048d13: 83 c4 2c add $0x2c,%esp
8048d16: c3 ret

08048d17 <phase_5>:
8048d17: 53 push %ebx
8048d18: 83 ec 18 sub $0x18,%esp
8048d1b: 8b 5c 24 20 mov 0x20(%esp),%ebx
8048d1f: 89 1c 24 mov %ebx,(%esp)
8048d22: e8 74 02 00 00 call 8048f9b <string_length>//返回字符串长度
8048d27: 83 f8 06 cmp $0x6,%eax
8048d2a: 74 05 je 8048d31 <phase_5+0x1a>//字符串长度要为6跳炸弹
8048d2c: e8 95 03 00 00 call 80490c6 <explode_bomb>

8048d31: ba 00 00 00 00 mov $0x0,%edx
8048d36: b8 00 00 00 00 mov $0x0,%eax
8048d3b: 0f be 0c 03 movsbl (%ebx,%eax,1),%ecx//顺序处理a[eax]，放入%ecx，作为一个标记
8048d3f: 83 e1 0f and $0xf,%ecx
8048d42: 03 14 8d 20 a2 04 08 add 0x804a220(,%ecx,4),%edx//根据%ecx中的标记位在数组中查值累加
//p/x *0x804a220@15 x/20wd 0x804a220
8048d49: 83 c0 01 add $0x1,%eax//循环标记
8048d4c: 83 f8 06 cmp $0x6,%eax
8048d4f: 75 ea jne 8048d3b <phase_5+0x24>

8048d51: 83 fa 28 cmp $0x28,%edx//对比累加值是否为0x28
8048d54: 74 05 je 8048d5b <phase_5+0x44>
8048d56: e8 6b 03 00 00 call 80490c6 <explode_bomb>
8048d5b: 83 c4 18 add $0x18,%esp
8048d5e: 5b pop %ebx
8048d5f: 90 nop
8048d60: c3 ret

08048d61 <phase_6>:
8048d61: 56 push %esi
8048d62: 53 push %ebx
8048d63: 83 ec 44 sub $0x44,%esp
8048d66: 8d 44 24 10 lea 0x10(%esp),%eax
8048d6a: 89 44 24 04 mov %eax,0x4(%esp)
8048d6e: 8b 44 24 50 mov 0x50(%esp),%eax
8048d72: 89 04 24 mov %eax,(%esp)
8048d75: e8 81 04 00 00 call 80491fb <read_six_numbers>//以上是读取6个数字

8048d7a: be 00 00 00 00 mov $0x0,%esi//双重循环判断是否有重复元素
8048d7f: 8b 44 b4 10 mov 0x10(%esp,%esi,4),%eax

8048d83: 83 e8 01 sub $0x1,%eax//外层循环判断ary[esi]是否小于等于6
8048d86: 83 f8 05 cmp $0x5,%eax
8048d89: 76 05 jbe 8048d90 <phase_6+0x2f>
8048d8b: e8 36 03 00 00 call 80490c6 <explode_bomb>
8048d90: 83 c6 01 add $0x1,%esi//esi++
8048d93: 83 fe 06 cmp $0x6,%esi
8048d96: 74 1b je 8048db3 <phase_6+0x52>
8048d98: 89 f3 mov %esi,%ebx//内层循环

8048d9a: 8b 44 9c 10 mov 0x10(%esp,%ebx,4),%eax //eax=ary[esi]
8048d9e: 39 44 b4 0c cmp %eax,0xc(%esp,%esi,4) //和ary[ebx++]比较
8048da2: 75 05 jne 8048da9 <phase_6+0x48>
8048da4: e8 1d 03 00 00 call 80490c6 <explode_bomb>
8048da9: 83 c3 01 add $0x1,%ebx
8048dac: 83 fb 05 cmp $0x5,%ebx
8048daf: 7e e9 jle 8048d9a <phase_6+0x39>
8048db1: eb cc jmp 8048d7f <phase_6+0x1e> //循环结束

8048db3: 8d 44 24 10 lea 0x10(%esp),%eax
8048db7: 8d 5c 24 28 lea 0x28(%esp),%ebx//首尾地址复制
8048dbb: b9 07 00 00 00 mov $0x7,%ecx

8048dc0: 89 ca mov %ecx,%edx
8048dc2: 2b 10 sub (%eax),%edx//a[i]=7-a[i];
8048dc4: 89 10 mov %edx,(%eax)
8048dc6: 83 c0 04 add $0x4,%eax//地址加4
8048dc9: 39 d8 cmp %ebx,%eax//判断是否为数组尾地址
8048dcb: 75 f3 jne 8048dc0 <phase_6+0x5f> //处理数组里面的数值 a[i]=7-a[i];

8048dcd: bb 00 00 00 00 mov $0x0,%ebx
8048dd2: eb 16 jmp 8048dea <phase_6+0x89>

8048dd4: 8b 52 08 mov 0x8(%edx),%edx//a[i]>1
8048dd7: 83 c0 01 add $0x1,%eax
8048dda: 39 c8 cmp %ecx,%eax//比较a[i]
8048ddc: 75 f6 jne 8048dd4 <phase_6+0x73>//不相等就再跳
8048dde: 89 54 b4 28 mov %edx,0x28(%esp,%esi,4)//若是相等，把当前地址放到数组的终止地址？！！！
//这里可以演示
8048de2: 83 c3 01 add $0x1,%ebx
8048de5: 83 fb 06 cmp $0x6,%ebx
8048de8: 74 17 je 8048e01 <phase_6+0xa0>

8048dea: 89 de mov %ebx,%esi
8048dec: 8b 4c 9c 10 mov 0x10(%esp,%ebx,4),%ecx//取a[ebx]
8048df0: b8 01 00 00 00 mov $0x1,%eax
8048df5: ba 3c c1 04 08 mov $0x804c13c,%edx
8048dfa: 83 f9 01 cmp $0x1,%ecx
8048dfd: 7f d5 jg 8048dd4 <phase_6+0x73>
8048dff: eb dd jmp 8048dde <phase_6+0x7d>//以上是根据输入的值，把不同的地址接在原数组后面

8048e01: 8b 5c 24 28 mov 0x28(%esp),%ebx//链表地址首地址
8048e05: 8b 44 24 2c mov 0x2c(%esp),%eax//第二位地址
8048e09: 89 43 08 mov %eax,0x8(%ebx)//把第二位地址，放在首地址对应内存后面八位
8048e0c: 8b 54 24 30 mov 0x30(%esp),%edx//取第三位地址
8048e10: 89 50 08 mov %edx,0x8(%eax)//把第三位地址放到第二位地址对应内存后面八位
8048e13: 8b 44 24 34 mov 0x34(%esp),%eax
8048e17: 89 42 08 mov %eax,0x8(%edx)
8048e1a: 8b 54 24 38 mov 0x38(%esp),%edx
8048e1e: 89 50 08 mov %edx,0x8(%eax)
8048e21: 8b 44 24 3c mov 0x3c(%esp),%eax
8048e25: 89 42 08 mov %eax,0x8(%edx)
8048e28: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)//以上同理构建链表，因为寄存器中存放的是地址

8048e2f: be 05 00 00 00 mov $0x5,%esi//前面是保存数据
8048e34: 8b 43 08 mov 0x8(%ebx),%eax//跟在首节点后面的第二位地址
8048e37: 8b 10 mov (%eax),%edx//取第二位地址的值
8048e39: 39 13 cmp %edx,(%ebx)//比较首地址数值和第二位地址的数值

8048e3b: 7d 05 jge 8048e42 <phase_6+0xe1>//递减排列才能跳过炸弹
8048e3d: e8 84 02 00 00 call 80490c6 <explode_bomb>
8048e42: 8b 5b 08 mov 0x8(%ebx),%ebx//地址移动，循环处理
8048e45: 83 ee 01 sub $0x1,%esi
8048e48: 75 ea jne 8048e34 <phase_6+0xd3>
8048e4a: 83 c4 44 add $0x44,%esp
8048e4d: 5b pop %ebx
8048e4e: 5e pop %esi
8048e4f: c3 ret

08048e50 :
8048e50: 53 push %ebx
8048e51: 83 ec 18 sub $0x18,%esp
8048e54: 8b 54 24 20 mov 0x20(%esp),%edx
8048e58: 8b 4c 24 24 mov 0x24(%esp),%ecx
8048e5c: 85 d2 test %edx,%edx
8048e5e: 74 37 je 8048e97 <fun7+0x47>
8048e60: 8b 1a mov (%edx),%ebx
8048e62: 39 cb cmp %ecx,%ebx
8048e64: 7e 13 jle 8048e79 <fun7+0x29>
8048e66: 89 4c 24 04 mov %ecx,0x4(%esp)
8048e6a: 8b 42 04 mov 0x4(%edx),%eax
8048e6d: 89 04 24 mov %eax,(%esp)
8048e70: e8 db ff ff ff call 8048e50
8048e75: 01 c0 add %eax,%eax
8048e77: eb 23 jmp 8048e9c <fun7+0x4c>
8048e79: b8 00 00 00 00 mov $0x0,%eax
8048e7e: 39 cb cmp %ecx,%ebx
8048e80: 74 1a je 8048e9c <fun7+0x4c>
8048e82: 89 4c 24 04 mov %ecx,0x4(%esp)
8048e86: 8b 42 08 mov 0x8(%edx),%eax
8048e89: 89 04 24 mov %eax,(%esp)
8048e8c: e8 bf ff ff ff call 8048e50
8048e91: 8d 44 00 01 lea 0x1(%eax,%eax,1),%eax
8048e95: eb 05 jmp 8048e9c <fun7+0x4c>
8048e97: b8 ff ff ff ff mov $0xffffffff,%eax
8048e9c: 83 c4 18 add $0x18,%esp
8048e9f: 5b pop %ebx
8048ea0: c3 ret