- •Table of Contents
- •Foreword
- •Do Not Pass GO
- •Counting in Martian
- •Octal: How the Grinch Stole Eight and Nine
- •Hexadecimal: Solving the Digit Shortage
- •From Hex to Decimal and from Decimal to Hex
- •Arithmetic in Hex
- •Binary
- •Hexadecimal as Shorthand for Binary
- •Switches, Transistors, and Memory
- •The Shop Foreman and the Assembly Line
- •The Box That Follows a Plan
- •DOS and DOS files
- •Compilers and Assemblers
- •The Assembly Language Development Process
- •DEBUG and How to Use It
- •Chapter 5: NASM-IDE: A Place to Stand Give me a lever long enough, and a place to stand, and I will move the Earth.
- •NASM-IDE's Place to Stand
- •Using NASM-IDE's Tools
- •NASM-IDE's Editor in Detail
- •Other NASM-IDE Features
- •The Nature of Segments
- •16-Bit and 32-Bit Registers
- •The Three Major Assembly Programming Models
- •Reading and Changing Registers with DEBUG
- •Assembling and Executing Machine Instructions with DEBUG
- •Machine Instructions and Their Operands
- •Reading and Using an Assembly Language Reference
- •Rally Round the Flags, Boys!
- •Using Type Specifiers
- •The Bones of an Assembly Language Program
- •Assembling and Running EAT.ASM
- •One Program, Three Segments
- •Last In, First Out via the Stack
- •Using DOS Services through INT
- •Boxes within Boxes
- •Using BIOS Services
- •Building External Libraries of Procedures
- •Creating and Using Macros
- •Bits Is Bits (and Bytes Is Bits)
- •Shifting Bits
- •Flags, Tests, and Branches
- •Assembly Odds 'n Ends
- •The Notion of an Assembly Language String
- •REP STOSW, the Software Machine Gun
- •The Semiautomatic Weapon: STOSW without REP
- •Storing Data to Discontinuous Strings
- •Chapter 12: The Programmer's View of Linux Tools and Skills to Help You Write Assembly Code under a True 32-Bit OS
- •Prerequisites-Yukkh!
- •NASM for Linux
- •What's GNU?
- •The make Utility and Dependencies
- •Using the GNU Debugger
- •Your Work Strategy
- •Genuflecting to the C Culture
- •A Framework to Build On
- •The Perks of Protected Mode
- •Characters Out
- •Characters In
- •Be a Time Lord
- •Generating Random Numbers
- •Accessing Command-Line Arguments
- •Simple File I/O
- •Conclusion: Not the End, But Only the Beginning
- •Where to Now?
- •Stepping off Square One
- •Notes on the Instruction Set Reference
- •AAA Adjust AL after BCD Addition
- •ADC Arithmetic Addition with Carry
- •ADD Arithmetic Addition
- •AND Logical AND
- •BT Bit Test (386+)
- •CALL Call Procedure
- •CLC Clear Carry Flag (CF)
- •CLD Clear Direction Flag (DF)
- •CMP Arithmetic Comparison
- •DEC Decrement Operand
- •IMUL Signed Integer Multiplication
- •INC Increment Operand
- •INT Software Interrupt
- •IRET Return from Interrupt
- •J? Jump on Condition
- •JMP Unconditional Jump
- •LEA Load Effective Address
- •MOV Move (Copy) Right Operand into Left Operand
- •NOP No Operation
- •NOT Logical NOT (One's Complement)
- •OR Logical OR
- •POP Pop Top of Stack into Operand
- •POPA Pop All 16-Bit Registers (286+)
- •POPF Pop Top of Stack into Flags
- •POPFD Pop Top of Stack into EFlags (386+)
- •PUSH Push Operand onto Top of Stack
- •PUSHA Push All 16-Bit GP Registers (286+)
- •PUSHAD Push All 32-Bit GP Registers (386+)
- •PUSHF Push 16-Bit Flags onto Stack
- •PUSHFD Push 32-Bit EFlags onto Stack (386+)
- •RET Return from Procedure
- •ROL Rotate Left
- •ROR Rotate Right
- •SBB Arithmetic Subtraction with Borrow
- •SHL Shift Left
- •SHR Shift Right
- •STC Set Carry Flag (CF)
- •STD Set Direction Flag (DF)
- •STOS Store String
- •SUB Arithmetic Subtraction
- •XCHG Exchange Operands
- •XOR Exclusive Or
- •Appendix C: Web URLs for Assembly Programmers
- •Appendix D: Segment Register Assumptions
- •Appendix E: What's on the CD-ROM?
- •Index
- •List of Figures
- •List of Tables
SHL Shift Left
Flags affected:
O |
D |
I |
T |
S |
Z |
A |
P |
C |
OF: |
Overflow flag TF: |
Trap |
flag |
AF: |
Aux carry |
F |
F |
F |
F |
F |
F |
F |
F |
F |
DF: |
Direction flag SF: |
Sign |
flag |
PF: |
Parity flag |
** * * * * IF: Interrupt flag ZF: Zero flag CF: Carry flag
Legal forms:
SHL r8,1 |
|
SHL m8,1 |
|
SHL r16,1 |
|
SHL m16,1 |
386+ |
SHL r32,1 |
|
SHL m32,1 |
386+ |
SHL r8,CL |
|
SHL m8,CL |
|
SHL r16,CL |
|
SHL m16,CL |
386+ |
SHL r32,CL |
|
SHL m32,CL |
386+ |
SHL r8,i8 |
286+ |
SHL m8,i8 |
286+ |
SHL r16,i8 |
286+ |
SHL m16,i8 |
286+ |
SHL r32,i8 |
386+ |
SHL m32,i8 |
386+ |
Examples:
SHL AL,1
SHL WORD [BX+SI],CL
SHL BP,1
SHL EAX,9
SHL BP,CL
Notes:
SHL shifts the bits within the destination operand to the left, where left is toward the most significant bit (MSB). The number of bit positions shifted may be specified either as an 8-bit immediate value, or by the value in CL- not CX or ECX. (The 8086 and 8088 are limited to the immediate value 1.) Note that while CL may accept a value up to 255, it is meaningless to shift by any value larger than 16-or 32 in 32-bit mode-even though the shifts are actually performed on the 8086 and 8088. (The 286 and later limit the number of shift operations performed to the native word size except when running in Virtual 86 mode.) The leftmost bit of the operand is shifted into the Carry flag; the rightmost bit is cleared to 0. The Auxiliary carry flag (AF) becomes undefined after this instruction. OF is modified only by the shift-by-one forms of SHL; after shift-by-CL forms, OF becomes undefined.
SHL is a synonym for SAL (Shift Arithmetic Left). Except for the direction the shift operation takes, SHL is identical to SHR.
r8 |
= AL |
AH |
BL BH |
CL |
CH DL DH |
r16 |
= AX BX CX DX |
BP SP SI DI |
sr = CS |
DS SS ES |
FS GS |
r32 |
= EAX EBX ECX |
EDX EBP ESP ESI E |
|||
m8 |
= 8-bit |
memory data |
m16 |
= 16-bit memory data |
||||
m32 = 32-bit memory |
data |
i8 = 8-bit immediate data |
i16 |
= 16-bit |
immediate data |
i32 |
= |
32-bit |
immediate data |
d8 = 8-bit signed displacement |
d16 |
= |
16-bit |
signed displacement |
||
d32 |
= 32-bit |
unsigned displacement |
|
|
|
|
SHR Shift Right
Flags affected:
O |
D |
I |
T |
S |
Z |
A |
P |
C |
OF: |
Overflow flag TF: |
Trap |
flag |
AF: |
Aux carry |
F |
F |
F |
F |
F |
F |
F |
F |
F |
DF: |
Direction flag SF: |
Sign |
flag |
PF: |
Parity flag |
** * * * * IF: Interrupt flag ZF: Zero flag CF: Carry flag
Legal forms:
SHR r8,1 |
|
SHR m8,1 |
|
SHR r16,1 |
|
SHR m16,1 |
386+ |
SHR r32,1 |
|
SHR m32,1 |
386+ |
SHR r8,CL |
|
SHR m8,CL |
|
SHR r16,CL |
|
SHR m16,CL |
386+ |
SHR r32,CL |
|
SHR m32,CL |
386+ |
SHR r8,i8 |
286+ |
SHR m8,i8 |
286+ |
SHR r16,i8 |
286+ |
SHR m16,i8 |
286+ |
SHR r32,i8 |
386+ |
SHR m32,i8 |
386+ |
Examples:
SHR AL,1
SHR WORD [BX+SI],CL
SHR BP,1
SHR EAX,9
SHR BP,CL
Notes:
SHR shifts the bits within the destination operand to the right, where right is toward the least-significant bit (LSB). The number of bit positions shifted may be specified either as an 8-bit immediate value, or by the value in CL—not CX or ECX. (The 8086 and 8088 are limited to the immediate value 1.) Note that while CL may accept a value up to 255, it is meaningless to shift by any value larger than 16—or 32 in 32-bit mode—even though the shifts are actually performed on the 8086 and 8088. (The 286 and later limit the number of shift operations performed to the native word size except when running in Virtual 86 mode.) The rightmost bit of the operand is shifted into the Carry flag; the leftmost bit is cleared to 0. The Auxiliary carry flag (AF) becomes undefined after this instruction. OF is modified only by the shift-by-one forms of SHL; after shift-by-CL forms, OF becomes undefined.
SHR is a synonym for SAR (Shift Arithmetic Right). Except for the direction the shift operation takes, SHR is identical to SHL.
r8 |
= AL |
AH |
BL BH |
CL |
CH DL DH |
r16 |
= AX BX CX DX |
BP SP SI DI |
sr = CS |
DS SS ES |
FS GS |
r32 |
= EAX EBX ECX |
EDX EBP ESP ESI E |
|||
m8 |
= 8-bit |
memory data |
m16 |
= 16-bit memory data |
||||
m32 = 32-bit memory |
data |
i8 = 8-bit immediate data |
i16 |
= 16-bit |
immediate data |
i32 |
= |
32-bit |
immediate data |
d8 = 8-bit signed displacement |
d16 |
= |
16-bit |
signed displacement |
||
d32 |
= 32-bit |
unsigned displacement |
|
|
|
|