programmers resources
  http://www.intel-assembler.it/  (c)2017 intel-assembler.it   info@intel-assembler.it
 
Search :  
Lingua Italiana    English Language   
Index
 
just an empty assembly space
just an arrow Intel Platform
just an arrow Article & Guides
just an arrow Download Software


23/01/2009 Featured Article: How to remove Buzus Virus (permalink)




:::3348711:::
Bottone Scambio Directory Pubblicitaonline.it
Home Page | Articles & Guides | Download | Intel Platform | Contacts

Google
 


Bookmark and Share
Download 
Tell a friend



Intel Assembly Instruction Set

Asm instructions explained with many details

(by unknown)

Each entry in this list includes information on which flags in the 8088's flag register are changed, and how they're changed. Since there are 9 flags in the flags register, the flags display is very compact.
The timing charts show timings for the 8088. Since the 80x8x processors execute instructions in fewer clock cycles than the 8088, these charts represent the worst case.


This article is online from 3089 days and has been seen 9081 times




-------- Assembly Language ---------------------------------------------------
  
-------- Assembly Instruction Set --------------------------------------------
 Overview                Overview of the Instruction Format                   
 AAA                     ASCII Adjust after Addition                          
 AAD                     ASCII Adjust before Division                         
 AAM                     ASCII Adjust after Multiply                          
 AAS                     ASCII Adjust after Subtraction                       
 ADC                     Add with Carry                                       
 ADD                     Addition                                             
 AND                     Logical AND                                          
 CALL                    Call Procedure                                       
 CBW                     Convert Byte to Word                                 
 CLC                     Clear Carry Flag                                     
 CLD                     Clear Direction Flag                                 
 CLI                     Clear Interrupt-Enable Flag                          
 CMC                     Complement Carry Flag                                
 CMP                     Compare                                              
 CMPS                    Compare String (Byte or Word)                        
 CMPSB                   Compare String Byte                                  
 CMPSW                   Compare String Word                                  
 CWD                     Convert Word to Doubleword                           
 DAA                     Decimal Adjust after Addition                        
 DAS                     Decimal Adjust after Subtraction                     
 DEC                     Decrement                                            
 DIV                     Divide, Unsigned                                     
 ESC                     Escape                                               
 HLT                     Halt                                                 
 IDIV                    Integer Divide, Signed                               
 IMUL                    Integer Multiply, Signed                             
 IN                      Input Byte or Word                                   
 INC                     Increment                                            
 INT                     Interrupt                                            
 INTO                    Interrupt on Overflow                                
 IRET                    Interrupt Return                                     
 JA                      Jump If Above                                        
 JAE                     Jump If Above or Equal                               
 JB                      Jump If Below                                        
 JBE                     Jump If Below or Equal                               
 JC                      Jump If Carry                                        
 JCXZ                    Jump if CX Register Zero                             
 JE                      Jump If Equal                                        
 JG                      Jump If Greater                                      
 JGE                     Jump If Greater or Equal                             
 JL                      Jump If Less                                         
 JLE                     Jump If Less or Equal                                
 JMP                     Jump Unconditionally                                 
 JNA                     Jump If Not Above                                    
 JNAE                    Jump If Not Above or Equal                           
 JNB                     Jump If Not Below                                    
 JNBE                    Jump If Not Below or Equal                           
 JNC                     Jump If No Carry                                     
 JNE                     Jump If Not Equal                                    
 JNG                     Jump If Not Greater                                  
 JNGE                    Jump If Not Greater or Equal                         
 JNL                     Jump If Not Less                                     
 JNLE                    Jump If NOt Less or Equal                            
 JNO                     Jump If No Overflow                                  
 JNP                     Jump If No Parity                                    
 JNS                     Jump If No Sign                                      
 JNZ                     Jump If Not Zero                                     
 JO                      Jump If Overflow                                     
 JP                      Jump If Parity                                       
 JPE                     Jump If Parity Even                                  
 JPO                     Jump If Parity Odd                                   
 JS                      Jump If Sign                                         
 JZ                      Jump If Zero                                         
 LAHF                    Load Register AH from                                
 LDS                     Load Pointer Using DS                                
 LEA                     Load Effective Address                               
 LES                     Load Pointer Using ES                                
 LOCK                    Lock the Bus                                         
 LODS                    Load String (Byte or Word)                           
 LODSB                   Load String Byte                                     
 LODSW                   Load String Word                                     
 LOOP                    Loop on Count                                        
 LOOPE                   Loop While Equal                                     
 LOOPNE                  Loop While Not Equal                                 
 LOOPNZ                  Loop While Not Zero                                  
 LOOPZ                   Loop While Zero                                      
 MOV                     Move (Byte or Word)                                  
 MOVS                    Move String (Byte or Word)                           
 MOVSB                   Move String Byte                                     
 MOVSW                   Move String Word                                     
 MUL                     Multiply, Unsigned                                   
 NEG                     Negate                                               
 NOP                     No Operation                                         
 NOT                     Logical NOT                                          
 OR                      Logical OR                                           
 OUT                     Output to Port                                       
 POP                     Pop a Word from the Stack                            
 POPF                    Pop Flags from the Stack                             
 PUSH                    Push Word onto Stack                                 
 PUSHF                   Push Flags onto Stack                                
 RCL                     Rotate through Carry Left                            
 RCR                     Rotate through Carry Right                           
 REP                     Repeat                                               
 REPE                    Repeat While Equal                                   
 REPNE                   Repeat While Not Equal                               
 REPNZ                   Repeat While Not Zero                                
 REPZ                    Repeat While Zero                                    
 RET                     Return from Procedure                                
 ROL                     Rotate Left                                          
 ROR                     Rotate Right                                         
 SAHF                    Store Register AH into                               
 SAL                     Shift Arithmetic Left                                
 SAR                     Shift Arithmetic Right                               
 SBB                     Subtract with Borrow                                 
 SCAS                    Scan String (Byte or Word)                           
 SCASB                   Scan String Byte                                     
 SCASW                   Scan String Word                                     
 SHL                     Shift Logical Left                                   
 SHR                     Shift Logical Right                                  
 STC                     Set Carry Flag                                       
 STD                     Set Direction Flag                                   
 STI                     Set Interrupt Enable Flag                            
 STOS                    Store String (Byte or Word)                          
 STOSB                   Store String Byte                                    
 STOSW                   Store String Word                                    
 SUB                     Subtract                                             
 TEST                    Test                                                 
 WAIT                    Wait                                                 
 XCHG                    Exchange Registers                                   
 XLAT                    Translate                                            
 XOR                     Exclusive OR                                         
------------------------------------------------------------------------------
Overview         Overview of the Instruction Format

    Each entry in this list includes information on which flags in the
    8088's flag register are changed, and how they're changed.  Since
    there are 9 flags in the flags register, the flags display is very
    compact:
                        Flags: O D I T S Z A P C
                               0       * * ? * 0

           ?      Undefined after the operation.
           *      Changed to reflect the results of the instruction.
           0      Always cleared
           1      Always set
  --------------------------------------------------------------------------
    The timing charts show timings for the 8088.  Since the 80x8x
    processors execute instructions in fewer clock cycles than the 8088,
    these charts represent the worst case.
------------------------------------------------------------------------------
       Operands       This field gives the list of possible operands and
                      addressing modes for each instruction.

       Clocks         Number of clock cycles required to execute the
                      instruction on an 8088.  Effective Address
                      calculations (EA) take additional time, as outlined
                      in the EA table.

       Transfers      The number of memory references.  4 clock cycles are
                      required for each memory reference.

       Bytes          Number of bytes in the instruction.
  --------------------------------------------------------------------------
       Note:          The additional clock cycles required to reinitialize
                      the instruction que and fetch the next instruction
                      after a control transfer instruction (such as JMP or
                      CALL) is already included in the timing tables.  Two
                      clock times are listed for conditional transfer
                      instructions (such as JZ); the shortest time is for
                      the case when there is no transfer.
---------------------------------------
 See also:  AAD  AAS  AAM  ADC  DAA  Flags
------------------------------------------------------------------------------
AAA              ASCII Adjust after Addition         Flags: O D I T S Z A P C
                                                            ?       ? ? * ? *
AAA
          Logic:    If (AL & 0Fh) > 9 or (AF = 1) then
                        AL  <-  AL + 6
                        AH  <-  AH + 1
                        AF  <-  1;  CF  <-  1
                    else
                        AF  <-  0;  CF  <-  0
                    AL  <-  AL & 0Fh

    Converts the number in the lower 4 bits (nibble) of AL to an unpacked
    BCD number (high-order nibble of AL is zeroed).
  --------------------------------------------------------------------------
   Operands                  Clocks   Transfers  Bytes   Example
   no operands                 4          -        1     AAA
  --------------------------------------------------------------------------
    If the lower 4 bits of the number in AL is greater than 9, or the
    auxiliary carry flag is set, this instruction converts AL to its
    unpacked BCD form by adding 6 (subtracting 10) to AL; adding 1 to AH;
    and setting the auxiliary flag and carry flags. This instruction will
    always leave 0 in the upper nibble of AL.

       Note:          Unpacked BCD stores one digit per byte; AH contains
                      the most-significant digit and AL the least-
                      significant digit.
---------------------------------------
 See also:  AAA  AAS  AAM  DIV  IDIV  Flags
------------------------------------------------------------------------------

(*** download for full text ***)



Top
Download 
Tell a friend
Bookmark and Share



Similar Articles

8086/80186/80286/80386/80486 Instruction Set
A very nice reference about Intel instruction set
(by unknown)

Hamarsoft's 86BUGS list
Undocumented/buggy instructions of x86 processors
(by Harald Feldmann)

Intel MMX Instruction Set +Cyrix extensions
A reference manual for MMX instructions
(by thenet)

Motorola Instruction set table
MC68030 processor instruction description
(by Bjorn Ove Arthun)

Notes on Intel Pentium Processor
CMPXCHG8B CPUID MOV RDMSR RDTSC RSM WRMSR
(by Microsoft)

The Complete Pentium Instruction Set Table
(32 Bit Addressing Mode Only)
(by Sang Cho)

 Tags: instruction set


webmaster jes
writers rguru, tech-g, aiguru, drAx

site optimized for IE/Firefox/Chrome with 1024x768 resolution

Valid HTML 4.01 Transitional


ALL TRADEMARKS ® ARE PROPERTY OF LEGITTIMATE OWNERS.
© ALL RIGHTS RESERVED.

hosting&web - www.accademia3.it

grossocactus
find rguru on
http://www.twitter.com/sicurezza3/
... send an email ...
Your name

Destination email

Message

captcha! Code