求一个无符号整数的10进制位数

mathe

gcc里面可以将跳转的目标直接放置在数组里面,然后用goto语句跳转过去: http://nathanxu.blog.51cto.com/50836/56661

无心人

? 怎么看不到回复 呵呵， 再来一次 我刚转了mathe提供的那个链接

无心人

昨天想了一晚上 连做梦也是在紧张的（不是编程序）抗洪抢险（好多人，大院子，污水，很多，淘水） 似乎可以把代码段的相对偏移保存到数组 此时的跳转表，只要获得起始地址 加上相对偏移 就能跳转了 这么做，可保证跳转正确，且不需刻意保持代码的字节数 缺点是，需要仔细计算代码的字节数 有错误就会产生错误的跳转甚至是跳转到指令的中间 造成非法指令

无心人

举个例子

2. int jmpTable[] = {0, 7, 14}
4. int JmpTest(void)
5. {
6. __asm
7. {
8. mov eax, 1
9. mov edx, offset jmp1
10. mov ecx, [jmpTable + 4]
11. add edx, ecx
12. jmp edx
13. jmp1:
14. mov ecx, 2
15. jmp exit1
16. jmp2:
17. mov ecx, 3
18. jmp exit1
19. jmp3:
20. mov ecx, 4
21. jmp exit1
22. exit1:
23. mov eax, ecx
24. }
25. }
27. void main()
28. {
29. int a=JmpTest();
30. printf("a=%d",a);
32. }

复制代码

无心人

宝宝的这个题目如果用嵌入汇编，则这么做， 当然可能存在化简， 否则，不如他外部汇编指令少

2. //0 9B 0
3. //1-2 6B 9
4. //3 9B 15
5. //4-5 6B 24
6. //6 9B 30
7. //7-8 6B 39
8. //9 12B 45
9. //10-12 6B 57
10. //13 12B 63
11. //14-15 6B 75
12. //16 12B 81
13. //17-18 6B 93
14. //19 12B 99
15. //20-22 6B 111
16. //23 12B 117
17. //24-25 6B 129
18. //26 12B 135
19. //27-28 6B 147
20. //29 12B 151
21. //30-31 6B 163

复制代码

2. jmpTable[32] = { 0, 9, 9, 15, 24, 24, 30, 39, 39, 45, 57, 57, 57, 63, 75, 75, 81, 93, 93, 99, 111, 111, 111, 117, 129, 129, 135, 147, 147, 151, 163, 163 }

复制代码

2. mov ecx, n
3. bsr eax, ecx
4. mov edx, offset jmpBegin
5. add edx, [jmpTable + eax * 4]
6. jmp edx
7. jmpBegin:
8. //0 9B
9. cmp ecx, 1
10. sbb eax, eax
11. add eax, 1
12. ret
13. //1-2 6B
14. mov eax, 1
15. ret
16. //3 9B
17. cmp ecx, 10 //比较的数值小于256，是3B，否则是6B
18. sbb eax, eax
19. add eax, 2 //加的数值小于256， 是3B，否则是6B
20. ret
21. //4-5 6B
22. mov eax, 2 //5B
23. ret //1B
24. //6 9B
25. cmp ecx, 100
26. sbb eax, eax
27. add eax, 3
28. ret
29. //7-8 6B
30. mov eax, 3
31. ret
32. //9 12B
33. cmp ecx, 1000
34. sbb eax, eax
35. add eax, 4
36. ret
37. //10-12 6B
38. mov eax, 4
39. ret
40. //13 12B
41. cmp ecx, 10000
42. sbb eax, eax
43. add eax, 5
44. ret
45. //14-15 6B
46. mov eax, 5
47. ret
48. //16 12B
49. cmp ecx, 100000
50. sbb eax, eax
51. add eax, 6
52. ret
53. //17-18 6B
54. mov eax, 6
55. ret
56. //19 12B
57. cmp ecx, 1000000
58. sbb eax, eax
59. add eax, 7
60. //20-22 6B
61. mov eax, 7
62. ret
63. //23 12B
64. cmp ecx, 10000000
65. sbb eax, eax
66. add eax, 8
67. ret
68. //24-25 6B
69. mov eax, 8
70. ret
71. //26 12B
72. cmp ecx, 100000000
73. sbb eax, eax
74. add eax, 9
75. ret
76. //27-28 6B
77. mov eax, 9
78. ret
79. //29 12B
80. cmp ecx, 1000000000
81. sbb eax, eax
82. add eax, 10
83. ret
84. //30-31 6B
85. mov eax, 10
86. ret

复制代码

无心人

最大执行指令是9条

无心人

有谁能验证下55#的算法的正确性 另外，谁能改进它

无心人

19#可以精简为下面的代码 另外，中间10个指令组可以随意排序

2. mov edx, n
3. xor eax, eax
4. cmp edx, 1 //1
5. sbb eax, 0
6. cmp edx, 10 //2
7. sbb eax, 0
8. cmp edx, 100 //3
9. sbb eax, 0
10. cmp edx, 1000 //4
11. sbb eax, 0
12. cmp edx, 10000 //5
13. sbb eax, 0
14. cmp edx, 100000 //6
15. sbb eax, 0
16. cmp edx, 1000000 //7
17. sbb eax, 0
18. cmp edx, 10000000 //8
19. sbb eax, 0
20. cmp edx, 100000000 //9
21. sbb eax, 0
22. cmp edx, 1000000000 //10
23. sbb eax, 0
24. add eax, 10

复制代码

无心人

还是太啰嗦了 到底是对x86汇编不精通啊 呵呵 还可以精简，如下

2. mov edx, n
3. mov eax, 10
4. cmp edx, 1000000000 //10
5. sbb eax, 0
6. cmp edx, 100000000 //9
7. sbb eax, 0
8. cmp edx, 10000000 //8
9. sbb eax, 0
10. cmp edx, 1000000 //7
11. sbb eax, 0
12. cmp edx, 100000 //6
13. sbb eax, 0
14. cmp edx, 10000 //5
15. sbb eax, 0
16. cmp edx, 1000 //4
17. sbb eax, 0
18. cmp edx, 100 //3
19. sbb eax, 0
20. cmp edx, 10 //2
21. sbb eax, 0
22. cmp edx, 1 //1
23. sbb eax, 0

复制代码

gxqcn

先mov eax, 10后，倒序比较更便于理解（当然对CPU无所谓了）。