汇编005.txt

会变语言实现的一些程序

   |   xor cx,cx                                               |
   |  dec1:                                                    |
   |   xor edx,edx                                             |
   |   div ebx                                                 |
   |   push dx                                                 |
   |   inc cx                                                  |
   |   or eax,eax                                              |
   |   jnz dec1                                                |
   |  dec2:                                                    |
   |   pop ax                                                  |
   |   call toasc                                              |
   |   call echo                                               |
   |   loop dec2                                               |
   |   popad                                                   |
   |   ret                                                     |
   |todec endp                                                 | 
   |-----------------------------------------------------------|
   分析：将一个数用十进制数来表示，要它对它进行除以10的运算，得到商和余数。再将商除以10，如此循环直到商为0为止，在这个过程中得到的一系列的模(余数)就是十进制数系列。在主程序中，已经将f000:1234双字单元的内容放到EAX寄存器中，由于后来要用十六进制数，二进制数显示，所以EAX寄存器的内容不允许改变，因此在子过程的一开始，要将EAX的内容先入栈，所以子过程的一开始就用PUSHAD将8个32位通用寄存器的内容全部入栈。在标号dec1不断地进行除以10运算，将所得到的余数全部入栈，同时用cx进行计数。在标号dec2中，逐个弹出在标号dec1中得到的余数，然后分别将它们显示出来，这样就可以将该存储单元中的内容用十进数表示，下面解释每一条指令的功能：
   a1.pushad;将8个32位通用寄存器全部入栈
   a2.xor cx,cx;cx清0
   a3.mov ebx,10;10=>ebx
   a4.xor edx,edx;edx清0
   a5.div ebx;edx存放高32位，不过是0，EAX中存放低32位，即ffff:[1234]双字的内容；除法得到的商放在EAX,余数放在EDX  
   a6.push dx;将edx的低16位dx入栈
   a7.inc cx;cx+1=>cx
   a8.or eax,eax;对eax进行或操作，主要是用来判断eax是否为0，即判断商是否为0，从而判断是否应该结束标号为dec1的循环。
   a9.jnz dec1
   a10.pop ax;将放在堆栈中的余数逐个弹出到ax中
   a11.call toasc;显示ax的内容
   a12.call echo
   a13.loop dec2;将所有的余数显示完毕
   a14.popad;8个32位通用寄存器全部出栈
   a15.ret

   b.子过程tohex
    PUSH BP
    SP=>BP
    SP<=SP-CNT1
   |------------------------------------------------------------|
   |tohex proc near                                             |
   |  countb=8                                                  |
   |  enter countb,0                                            |
   |  movzx ebp,bp                                              |
   |  mov   ecx,countb                                          |
   |  mov   edx,eax                                             |
   |hex1:                                                       |
   |  mov al,dl                                                 |
   |  and al,0fh                                                |
   |  mov [ebp-countb+ecx-1],al                                 |
   |  ror edx,4                                                 |
   |  loop hex1                                                 |
   |  mov cx,countb                                             |
   |  xor ebx,ebx                                               |
   |hex2:                                                       |
   |  cmp byte ptr [ebp-countb+ebx],0                           |
   |  jnz hex3                                                  |
   |  inc ebx                                                   |
   |  loop hex2                                                 |
   |  dec ebx                                                   |
   |  mov cx,1                                                  |
   |hex3:                                                       | 
   |  mov al,[ebp-countb+ebx]                                   |
   |  inc ebx                                                   |
   |  call toasc                                                |
   |  call echo                                                 |
   |  loop hex3                                                 |
   |  leave                                                     |
   |  ret                                                       |
   |tohex endp                                                  |
   |------------------------------------------------------------|   
   分析：该子过程的功能是将f000:1234双字单元的内容以16进制数显示出来，首先来考虑一下将一个数以16进制数表示出来的算法，事实上在汇编语言中操作数一直都是以十六进制表示的。因此，在这个子过程中不可以像上一个子过程一样，通过不断的除法取模得到结果。事实上，我们只需要将32位操作，以每半个字节(四位)的内容显示出来就可以了，有了这一编程思想，就很容易看懂上面的子过程。当然你们会问，为什么要每次只显示半个字节而不显示一个字节呢？呵呵，十六进制的十六个数是从0000-1111，不就是半个字节了。所以要循环8次才可以显示出32位的EAX，所以这里用ror指令来不断循环移位，每次右移4位放到dl的低4位中。这8个半字节分别放在[ebp-1]至[ebp-8]的存储单元中。不过，存储的顺序是由低位到高位，如果就这样显示结果肯定显示反了。标号hex2,hex3的主要功能是用来判断f000:1234双字单元的内容是否为0，如果为0，只需要将最后结果显示一个0即可，否则就显示出8位内容。下面是每条指令的功能：
   b1.countb=8;伪指令定义一局部变量countb，其值为8
   b2.enter countb,0;建立堆栈框架指令
   b3.movzx ebp,bp;对bp进行零扩展
   b4.mov   ecx,countb;8=>ecx
   b5.mov   edx,eax;将eax=>edx
   b6.mov al,dl
   b7.and al,0fh;取低4位
   b8.mov [ebp-countb+ecx-1],al;将8个半字节的内容逐一送到[ebp-1]至[ebp-8]的内存单元中
   b9.ror edx,4;对edx进行循环右移，每次移动4位
   b10.loop hex1
   b11.mov cx,countb
   b12.xor ebx,ebx;ebx清0
   b13.cmp byte ptr [ebp-countb+ebx],0;下面的语句主要用来判断源操作数f000:1234的内容是否为0，如果是0，就在屏幕上只显示一个0
   b14.jnz hex3
   b15.inc ebx
   b16.loop hex2
   b17.dec ebx
   b18.mov cx,1
   b19.mov al,[ebp-countb+ebx];逐一显示[ebp-8]到[ebp-1]的内容。
   b20.inc ebx
   b21.call toasc
   b22.call echo
   b23.loop hex3
   b24.leave;释放堆栈框架
   b25.ret
     
   c.子过程tobin
   |---------------------------------------|
   |tobin proc near                        |
   |   push eax                            |
   |   push ecx                            |
   |   push edx                            |
   |   bsr edx,eax                         |
   |   jnz bin1                            |
   |   xor dx,dx                           |
   |bin1:                                  |
   |   mov cl,31                           |
   |   sub cl,dl                           |
   |   shl eax,cl                          |

   |   mov cx,dx                           |
   |   inc cx                                                   
   |   mov edx,eax                         |
   |bin2:                                                       

   |   rol edx,1                                                
   |   mov al,'0'                                               
   |   adc al,0                                                 
   |   call echo                                                
   |   loop bin2                                                
   |   pop  edx                            |
   |   pop  ecx                                                 
   |   pop  eax                                                 
   |   ret                                                      
   |tobin endp                                                  
   |---------------------------------------|
   分析：将一个数用二进制数显示出来，只需要用ROL指令就可以了。这里作者写的程序就是这个思路，在标号bin1中主要判断f000:1234单元的内容是否为0，如果为0，那么只需要在屏幕上显示一个0就可以了。否则的话，就用ROL指令对源操作数移位32位，从最高位31位到最低位逐一显示出来，程序设计思路很简单，没有什么复杂的算法，下面看每一条指令的含义：
   c1.push eax;eax入栈
   c2.push ecx;ecx入栈
   c3.push edx;edx入栈
   c4.bsr edx,eax;对eax进行扫描，并把第一个为1的位号送给edx
   c5.jnz bin1;如果eax不为0，就跳到c7去执行
   c6.xor dx,dx;如果eax为0，就将dx清0
   c7.mov cl,31;从c7到c12主要用来设置计数器cx,如果eax=0,那么就设置cx=1,如果eax不等于0,那么就设置ecx=32
   c8.sub cl,dl
   c9.shl eax,cl
   c10.mov cx,dx
   c11.inc cx
   c12.mov edx,eax
   c13.rol edx,1;从c13到c15主要用来显示二进制数据，顺序是从最高位31位到最低位0位
   c14.mov al,'0'
   c15.adc al,0
   c16.call echo
   c17.loop bin2
   c18.pop  edx;edx出栈
   c19.pop  ecx;ecx出栈
   c20.pop  eax;eax出栈
   c21.ret
   在后续的篇幅里将主要介绍保护式下的段页管理机制及及如何在保护模下编程。

虽然80386处理器要较以前的处理器的功能大大增强，但这些功能只能在保护模式下才能全部得到发挥。在实模式下最大寻址空间只有1M,但在保护模式最大寻址空间可达4G，可以访问到所有的物理内存。同时由于引入虚拟内存的概念，在程序设计中可使用的地址空间为64TB。80386处理器采用了可扩充的分段管理和可选的分页管理机制，这两个存储管理机制由MMU(Memory Management Unit)部件来实现。因此，如果在80386下进行实模式编程，这时的80386处理器相当于一功能更强大，运行速度更快的8086处理器。80386提供对虚拟存储器的支持，虚拟存储器的理论基础就是：速度非常快的内存储器和海量的外存储器，所以它是一种软硬件结合的技术，它能够提供比物理内存大得多的存储空间。
   80386下的段具有三个属性：段基址，段界限，段属性，通常描述段的称作段描述符(Segment Descriptor),而描述符通常放在一个线性表中，这种线性表又分为：GDT(Global Descriptor Table),LDT(Local Descriptor Table),IDT(Interrupt Descriptor Table)，通常用一个叫做选择子的东西去确定使用上述三个线性表中哪一个描述符。程序中使用的地址空间就是虚拟地址空间，上面已经说过80386下虚拟地址空间可达到64TB(后面将解释为什么可以达到64TB)，虚拟地址空间由一个选择子和段内偏移组成，这是因为通过段的选择子我们可以得到该段的描述符，而在描述符中又说明了段的基址，段的界限及段的属性，再加上段的偏移就可以得到虚拟地址空间。不过请注意，这里并没有将段基址乘以16再加上偏移地址，这是保护模式与实式模式的区别之一。很明显，任何数据都必须装入到物理内存才能够被存储器处理，所以二维的虚拟地址空间必须转换成一维的物理地址。同时，由于每个任务都有自已的虚拟地址空间，为了防止多个并行任务将虚拟地址空间映射同一物理地址空间采用线性地址空间隔离虚拟地址和物理地址，线性地址空间由一维的线性地址构成，线性地址空间与物理地址空间对等，线性地址为32位，可寻址空间为4GB(物理地址空间最大也可以达到4GB，址址为32位，所以说线性地址空间与物理地址空间对等)。下面是80386虚拟地址空间与物理址空间的转换示意图：
   
        |----------|              |------------|       |--------|        |------------------|       |--------|
        | 虚拟地址 |------>|分段管理部件|------>|线性地址|---|--->|可选的分页管理部件|---|-->|物理地址| 
        |----|-----|       |------------|       |--------|   |    |------------------|   |   |--------|
      |------|-------|                                       |                           |
      |              |                                       |---------------------------|   
 |----------|    |---------|   
 |  选择子  |    | 段内偏移|
 |----------|    |---------|

   地址映射过程中，通过分段管理部件将虚拟地址空间转换成线性地址，这一步是必然存在的。如果在程序中启用了分页管理机制，那么线性地址还要经过分页管理部件的处理才得到最后的物理地址。如果没有采用分页管理机制，那么得到的线性地址就是物理地址。分页管理部件的主要的工作机制在于将线性地址和物理地址划分成大小相同的块，通过在建立两者之间的页表来建立对应关系。分段管理机制使用大小可变的存储块，使用分段管理机制适合处理复杂系统的逻辑分段。分页管理机制使用固定大小的块，所以它适合管理物理存储器，分页管理机制能够更有效地使用虚拟地址空间。
   80386支持多任务，因此对各个任务进行保护是非常必要的，对任务的保护可分为：同一任务内的保护，不同任务之间的保护。
   a.同一任务内的保护，在同一任务内定义有四种特权级别(Previlege Level)，将这些特权级别分配给段中的代码和数据，把最高的特权级别分配给最重要的数据和最可信任的代码，将较低级别的特权分给一般的代码和不重要的数据。特权级别用0~3来表示，用数字0表示最高特权级别，用数字3表示最低特权级别，在比较特权级别时不使用大于或小于，而是使用外层或里层来比较，很明显特权级别为0表示最里层，特别级别为3表示最外层。任何一个存储段(程序直接进行访问的代码段和数据段)都有一个特权级别，在一个程序试图访问这个存储时，就会进行特权级别的比较，如果小于或等于(如果等于表明同级，小于则表明是内层)处该存储段的特权级别就可以对该存储段进行访问。任务在特定时刻下的特权级别称为CPL(Current Previlege Level)，看一简单的结构示意图:
                   
                   |---------|-------|   
                   |  CodeA  | DataA | 特权级别为0                              
                   |---------|-------|
                   |---------|-------|   
                   |  CodeB  | DataB | 特权级别为1                              
                   |---------|-------|
                   |---------|-------|   
                   |  CodeC  | DataC | 特权级别为2                              
                   |---------|-------|
                   |---------|-------|   
                   |  CodeD  | DataD | 特权级别为3                              
                   |---------|-------|

     CodeA可以访问DataA,CodeB,DataB,CodeC,DataC,CodeD,DataD
     CodeB可以访问Datab,CodeC,DataC,CodeD,DataD,但不可以访问CodeA,DataA
     CodeC可以访问DataC,CodeD,DataD,但不可以访问CodeA,DataA,CodeB,DataB
     CodeD处在最外层，只能访问同级的DataD,不可以访问CodeA,DataA,CodeB,DataB,CodeC,DataC
     通常应用程序放在最外层，但由于每个应用程序的虚拟地址空间不同，因此它们被隔离保护。这种特权级别的典型用法就是：将操作系统的核心放在0层，操作系统的其余部分放在1级，2级留给中间软件使用，3级放应用程序，这样的安排的好处在于：操作系统的核心因为放在0层，因此它可以访问任务中所有的存储段，而1级的部分操作系统可以访问除0级以外的所有存储段，应用程序只能访问自身的存储段。
   b.不同任务间的保护,通过把每个任务放在不同的虚拟地址空间来实现隔离保护，虚拟地址到物理地址之间的映射由每个任务中的映射函数来决定，随着任务切换，映射函数也跟着切换，这样可以保证任务A映射到物理内存中的区域与任务B映射到内存中的区域是不同的，尽管有可能它们的虚拟地址空间相同，但它们最终在物理内存中的位置是不同的，从而起到了保护作用。