[Back to FAQ SWAG index]  [Back to Main SWAG index]  [Original]

The non-general use registers, What are they for?

*GENERAL REGISTERS *register*               definition                *
*                  *   AX   *  accumulator                   (16 bit) *
*                  *   AH   *  accumulator high-order byte   ( 8 bit) *
*                  *   AL   *  accumulator low order byte    ( 8 bit) *
*                  *   BX   *  base                          (16 bit) *
*                  *   BH   *  base high-order byte          ( 8 bit) *
*                  *   BL   *  base low-order byte           ( 8 bit) *
*                  *   CX   *  count                         (16 bit) *
*                  *   CH   *  count high order byte         ( 8 bit) *
*                  *   CL   *  count low order byte          ( 8 bit) *
*                  *   DX   *  data                          (16 bit) *
*                  *   DH   *  date high order byte          ( 8 bit) *
*                  *   DL   *  data low order byte           ( 8 bit) *
*SEGMENT REGISTERS *register*               definition                *
*                  *   CS   *  code  segment (16 bit)                 *
*                  *   DS   *  data  segment (16 bit)                 *
*                  *   SS   *  stack segment (16 bit)                 *
*                  *   ES   *  extra segment (16 bit)                 *
*INDEX REGISTERS   *register*               definition                *
*                  *   DI   *  destination index (16 bit)             *
*                  *   SI   *  source      index (16 bit)             *
*POINTERS          *register*               definition                *
*                  *   SP   *  stack       pointer (16 bit)           *
*                  *   BP   *  base        pointer (16 bit)           *
*                  *   IP   *  instruction pointer (16 bit)           *
*FLAGS               AF, CF, DF, IF, OF, PF, SF, TF, ZF               *
     Once again here is the list of registers [and flags] on you 80xxx
     processor. As was said before registers AX-DX are general use;
     however they do have some other special uses. In part II we saw
     that CX is known as the counting register because in is can be
     automatically inc/dec durring a loop. It can also be used to
     repeat a single type of machine instruction. [scambling for Doc]
     The "prefix" and the instructions are as follows:
     Prefix = REP
     Instructions = Movs,Lods,Stos,Ins, or outs
     We already know that Mov is used to move a value to a register or
     a register value some address, but what's a (lod,sto,ins,out)?
     That's were are other registers come into play.
     In order to do operation like in pascal, you must use to special
     pointers to get information that is far away from the current
     code being executed. These pointers can be thought of as [es:di],
     and [ds:si]. I like to label them as

     [es:di] -> put
     [ds:si] -> get
     These two are used to get or put the value that they point to.
     Notice that DS is called the data segment register, and it is
     used to "get" values from where DS points. To get back to pascal,
     lets use some examples.
     var x : array[1..22] of byte;
     fillchar(X,32,#0); {I may have this in reverse}
     This procedure takes the address of X and fills is with 32 zero
       push es
       push di
       mov ax,seg X
       mov es,ax
       mov di,offset X
       mov cx,32d  {number of times to repeat}
       mov ax,0    {the "char" we want to move}
       REP         {tells the processor to repeat the next repeatable}
                   {instruction CX times                             }
           stosB   {store whats in AX to [es:di] and increment di}
       pop di
       pop es
     There's alot of extra stuff there and you may want to know why.
     The non-general use registers are used by pascal and they
     _must_ remain the same value in order for pascal to run correctly.
     That's why we push and pop
     what's push & pop? If you know, skip the next paragraph.
     Push and pop "Push" and "pop" values onto the stack. The stack is
     part of the operation system and it is used by most calling programs.
     Misuse of the stack can cause you program to crash the computer.
     Think of the stack as like a deck of cards. IF you put a Jack, then
     and Ace, and then a King in a pile you have just pushed Jack,Ace, and
     King. Know when you pick up the cards you "pop" King,Ace,Jack. This
     is known as a "last in first out" way of storage, and any storage
     using the scheme can be called a stack. A stack must always take
     the last value first and it can't jump around. What you put into
     the stack always comes out in reverse order. That's why when I
     push ES and DI, I must Pop Di then ES. The stack is a quick way
     of storing and retrieving values.
     Next, whats that "Seg" and "offset"?
     These are Key words that tell the compiler to substitute at that
     position the absolute address of the Variable refrenced. It's kinda
     like pascal's Addr(variable) procedure. In order for you to access
     variables that aren't part of a procedure call, its best to use
     this method. Remeber that ES:DI must point to the variable you
     are wanting to change in the code about - so you must tell the
     compiler - "I want you to give the location of this variable, and
     not the variables value" using the segment and offset key words.
     Why didn't you move the segment of array X dirrectly to DS?
     Answer, you can't. You can move the value of a register to a
     segment register, but you can't move immediate values.
        mov DS,938d
        mov DS,seg X
        mov CS,832d
        mov ES,21h
        mov ax,938d
        mov ds,ax
        mov ax,seg X
        mov ds,ax
     or also legal
        push 938d
        pop  DS
        push seg X
        pop  DS

Tpas -> asmb
part III      [2 of 2]

This section may have a bit too much information for now. If you don't
quite get all of it, don't worry! Most of this section will be repeated
and explain in greater detail in the next upcomming sections.

var x : array[1..22] of byte;
 push es
 push di
 mov ax,seg X
 mov es,ax
 mov di,offset X
 mov cx,32d  {number of times to repeat}
 mov ax,0    {the "char" we want to move}
 REP         {tells the processor to repeat the next repeatable}
             {instruction CX times                             }
    stosB   {store whats in AX to [es:di] and increment di}
 pop di
 pop es
  Starting from the top, we know that we should push the original
  values of registers that aren't general use [non AX-DX]. Next,
  we know that we are telling the compiler to give us the address
  that X is located at and not to give us the value of X. Segment
  registers can only be assinged values by a Register or a Pop.
  That bring us to CX gets the number of times we want to REPeat,
  and AX get the value we want to move to X. We are know at the
  meaty instruction and that is STOSB. STOSB does a lot at once.
  First,  it moves the byte located in AL to [es:di].
  Second, it increments DI so it points to the next byte of X.
  Third,  CX is decremented
  fourth, if CX in not Zero then the process is repeated
  When you have a simple loop like
  " for I := 1 to 32 do x[i] := 0; ";
  then, the above is a _really_quick_ way to do the same thing.
  Unlike in Part II, this loop is not as general, and cant as
  easily be used to do many things durring a loop. The REP only
  works for certain instruction and can only repeat that instruction
  CX times.
  "OK, now what's LOD,INS,OUT ?"
  First off, the STOS can be use two other ways. There is a STOSW
  that moves a word at a time [AX] and advances DI two bytes. The
  other one is STOS and truthfully, I haven't and don't know how
  to use it yet.
  LODS is kinda the oposite of STOS. IF stosB, it moves the byte at
  DS:SI into AL, and if stosW, it moves the word at DS:SI into AX.
  !Unless you know your hardware ports, skip INS and OUT for now.!
  ]INS is not part of the 8088 and 8086 processor and won't execute.
  ]IT takes a byte or word [insB, insW] from the port listed in DX
  ]and moves it the addess located in [ES:ID].
  ]OUT takes a byte or word and moves it to a port. It can be done
  ]as follows
  ]OUT 13h,AL  {moves byte in AL to port 13h}
  ]OUT 13h,AX  {moves word in AX to port 13h}
  ]OUT DX,al   {move byte in al to port listed DX}
  ]out DX,ax   {move word in ax to port listed DX}
  ]outs, outsB,outsW are not part of the 8088 and 8086 instruction
  ]outsB moves byte [ds:si] to port listed in DX and advances SI
  ]outsW moves word [ds:si] to port listed in DX and advances SI
  ]I've not used OUTS & don't yet know how.
  That brings us back to the rest of the special use registers,
  And they are
     CS   *  code  segment (16 bit)                 *
     SS   *  stack segment (16 bit)                 *.
  My best advice is DON'T TOUCH! Your processor uses pointers
  just like you so it knows what to execute next and where the
  top of the stack is. CS:IP points the next instuction to execute
  and SS:SP points to the top of the stack.
  CS:IP are changed by jumps and calls.
  SS:SP are changed by pushes and pops
  I screwed up a little bit in order so I need to rectify this
  I need to define immediate values, effective addresses, and so forth.
  mov ax,983d
  An immediate value is a byte or word that is part of the instruction.
  In the example above, 938d is the immediate value that is going to
  be moved into ax.
  "mov ax,bx" has no immediate values. The value is stored in BX and
  the word associated is not part of the instruction.
  mov ax,[0000]
  An effective address can be a word value that is part of the instuction
  but is a location and an immediate value. When this is compiled
  0000 is not moved into ax, the word pointed to by cs:[0000] is moved
  into ax. Why CS? If you don't overide the segment the compiler used
  defaults. Unfortunatly I don't readily know which are which, but
  seeing that you might be a beginner, this won't be a problem that
  has to be delt with know. In other word ignore for now.
  mov ax,[bx]
  This has [bx] as the effective address. The value in BX is thought
  of as an address and the word pointed to by BX is moved into ax.
  There are several addressing modes and I will try to explain them as
  I get to them and as they are needed.
  _I HIGHLY suggest that we start out with assembler procedure and
  functions in Pascal and leave it at that_! I think that asm should
  be used only for critical procedures that are too slow in pascal
  or are things not supported by native pascal. This way you code can
  be effiecient and still easily understandable.
  Next section Part IV - assembler functions and procedures in pascal.

tpas -> asmb
part IV - assembler functions and procedures in pascal.
     [1 of 2]
     Now that we know just a little bit, let learn through example.
     Translation from tpas to asm is not an exact science. There
     are several way to do about the same structure as pascal and
     it is this reason that ASM procedures can be so efficient. You
     can completetly eliminate the legnthy and general machine code
     that pascal produces when things like overflow,range checking,
     and so forth, are not as important as speeding things up.
     For the first example, we are going to write a procedure in
     Tpascal that clears the screen in mode $13. We will assume
     that we are already in mode $13.
     mov ax,13h
     int 10h    {bios call}
     procedure ClearScrn13;
     var i,j : word;
       for I := 0 to 199 do
           For J := 0 to 319 do
                 mem[$a000:(i*320) + j] := 0;
     First off, I assume you know that in ram at $a000:0000 is
     were the vga screen memory is stored. I can be thought of
     as an array of 64,000 bytes, and you must do the Row_Major
     math to access it by Row and Column.
     For every row there are 320 bytes, in order to access [2,2]
     of a [320,200] array we must pass up 320 bytes in the first row
     and and 1 more byte to get to [2,2].
     In this case, who cares about rows and colums. We know the
     size of the 1 dimesional array so when can just loop 64000 times.
     This keeps us from having to do any math - which will slow every-
     thing down.
     procedure clearScrn13asm;
       push es  {remeber to store the values of non-general}
       push di
       mov ax,0a000h
       mov es,ax      {es := $a000}
       xor di,di      {di := 0}
       mov cx,32000d   {cx := 64000 div 2;}
       xor ax,ax      {ax := 0;}
       rep stosW
       pop di
       pop es
     I know, you saying "what the f..?". Remember first we point our
     "put" pointer [es:di] to where we are going to store stuff. So what
     is "xor di,di"? "Xor" or is "exclusive or". It means either A or B
     but not A and B. The truth table is as follows
     true  xor false = true
     false xor true  = true
     false xor false = false
     true  xor true  = false
     in bits
     1 xor 0 = 1
     0 xor 1 = 1
     0 xor 0 = 0
     1 xor 1 = 0
     So any number xor'd it self is zero. For example, 48 decimal is 30
     hexidecimal. In binary 30 is 00110000. Now if you xor each
     individual bit by using the table above you get
     0 0 1 1 0 0 0 0   |
 xor 0 0 1 1 0 0 0 0   |
 -------------------   v
   = 0 0 0 0 0 0 0 0
     For each column use the table. From left to right 0 xor 0 is 0,
     0 xor 0 is 0, 1 xor 1 is 0 and so forth.
     "Why not mov di,0 ? or mov ax,0 ?"
     Code size. Mov di,0 will produce 3 bytes of code and "xor di,di"
     should produce 1 byte of code. For more information, get the
     opcode list from "ftp.intel.com". It list all possible and valid
     "Why is is mov cx,32000 and not mov cx,64000?"
     Well If you look at the repeated instruction, is will move
     a word at a time, and a word is two bytes. So moving 32000
     words is the same as moving 64000 bytes but just much
     Remeber the "REP stosW" will automatically mov ax to es:di
     and increment di and decrement cx until repeated 32000 times.
     Know lets use an example that won't let us use the repeat prefix.
     Lets mov a virtual screen to the physical screen.
     type V_scrn : array[0..319,0..199] of byte;
     var V_P : ^V_scrn;
     procedure Paste_scrn( P : V_P );
     var i,j : word;
       for I := 0 to 199 do
           For J := 0 to 319 do
                 mem[$a000:(i*320) + j] := V^[j,i];; {or ist ^V[j,i]?}
part IV - assembler functions and procedures in pascal.
      [2 of 2]
procedure Paste_scrnASM( P : V_P );
        push es
        push di
        push ds
        push si
        {: Setup or Get and Put pointers :}
        mov ax,word ptr P[2]  {ds:si -> V_screen }
        mov ds,ax
        mov si,word ptr P
        mov ax,0a000h         {es:di -> screen}
        mov es,ax
        xor di,di
        mov cx,32000d         { for I := 1 to 32000 do begin }
        lodsW                 {  ax  := -> get } { inc si }
        stosW                 {  put := ax     } { inc di }
        loop @looper          { end;           } { dec CX }
        pop si
        pop ds
        pop di
        pop es
     OK lets start with "P[2]" a Pointer type is 4 bytes in legnth.
     The first 2 bytes are the offset that it points to and the
     second 2 bytes are the segment that it point to.
     The "[]" symbols also mean indexing - much like an 1 dimensional
     array in pascal. Seeing that the Segment is 2 bytes passed the
     begining of the pointer, we tell th copmiler that we are talking
     about the word 2 bytes passed the begining of the 4 byte pointer.
     "word ptr?"
     If we didn't tell the copmiler that we want that this is a word
     and it an effective address and not a varialbe, we'd have a
     problem. We can't use the Offset and Seg key words; becuase, we
     we want the value of the of the pointer and not its location.
     Pascal takes all the parameters of the procedure and
     pushes them on the stack write before a call to the procedure.
     In a procedure when you use one of those variables you are actually
     using a values that is on the stack. When you use the "VAR" keyword
     is pushes the address of the variable on the stack, and therefore
     any changes made to that variable are actually chaning the value
     of the original variable. Otherwise, is just pushes the value of
     the variable on the stack and any changes to that value are made
     only in the stack and are thrown away after completion.
     Procedure test(VAR X : byte; Y,Z : byte);
     a:= 1;
     b:= 2;
     c:= 3;
     When you call test(a,b,c);
     It pushed all the paramters starting backwards with C
     SP ->   [ addr(A) ]   a
             [    2    ]   b
             [    3    ]   c
     to move C's value into AX you could say
        mov ax,word ptr Z
     to move B's value into AX you could say
        mov ax,word ptr Y
     to move A's value into AX you could say
        mov ax,word ptr X[2]
        mov ds,ax
        mov si,word ptr X     {[ds:si] -> A}
        lodsB                 {ax := [ds:si] }
     because the value of A is not on the stack, but A's address is.
     !Back to the code!
     Next es:di points to the vga memory in ram.
       mov cx,32000d         { for I := 1 to 32000 do begin }
        lodsW                 {  ax  := -> get } { inc si }
        stosW                 {  put := ax     } { inc di }
        loop @looper          { end;           } { dec CX }
     sets up our loop counter CX
     lodsW gets from out virtual screen the first word and increments si 2
     bytes [word size in bytes]
     AX holds the word
     stosW takes the word in AX and puts it to the screen and increments
     di 2 bytes.
     Loop decrements CX and compares it to zero, if its not equal to zero
     it jumps to @Looper [this changes the values of CS:IP].
     You get all that done with just a tinty bit of speedy code.
     I didn't get to functions this time, but in part V I'll get to functions
     and how to acccess pascal variables like a string.
     As always, I'll be glad to answer any questions. Just one warning,_all
     the code in these section have _NOT_ been compiled and are sure to have
     errors. If you find these errors then maybe these lessons are too simple
     for you and you may be ready to start learning from an intermediate to
     advanced asm book. However, I'll try to be as unassuming as possible,
     but if I loose you on some concept, just mail me.

[Back to FAQ SWAG index]  [Back to Main SWAG index]  [Original]