View source for X86 Assembly/Shift and Rotate

{{x86 Assembly Page}}


== Logical Shift Instructions ==

In a '''logical shift''' instruction (also referred to as '''unsigned shift'''), the bits that slide off the end disappear (except for the last, which goes into the carry flag), and the spaces are always filled with zeros. Logical shifts are best used with unsigned numbers.

{{x86-inst-2|shr|cnt|dest}}

Logical shift <code>dest</code> to the right by <code>cnt</code> bits.

{{x86-inst-2|shl|cnt|dest}}

Logical shift <code>dest</code> to the left by <code>cnt</code> bits.

Examples ([[X86 Assembly/GAS Syntax|GAS Syntax]]):

<syntaxhighlight lang="asm">
movw   $ff00,%ax        # ax=1111.1111.0000.0000 (0xff00, unsigned 65280, signed -256) 
shrw   $3,%ax           # ax=0001.1111.1110.0000 (0x1fe0, signed and unsigned 8160)
                        # (logical shifting unsigned numbers right by 3
                        #   is like integer division by 8)
shlw   $1,%ax           # ax=0011.1111.1100.0000 (0x3fc0, signed and unsigned 16320) 
                        # (logical shifting unsigned numbers left by 1
                        #   is like multiplication by 2)
</syntaxhighlight>

== Arithmetic Shift Instructions ==

In an '''arithmetic shift''' (also referred to as '''signed shift'''), like a logical shift, the bits that slide off the end disappear (except for the last, which goes into the carry flag). But in an arithmetic shift, the spaces are filled in such a way to preserve the sign of the number being slid. For this reason, arithmetic shifts are better suited for signed numbers in two's complement format.

{{x86-inst-2|sar|cnt|dest}}

Arithmetic shift <code>dest</code> to the right by <code>cnt</code> bits. Spaces are filled with sign bit (to maintain sign of original value), which is the original highest bit.

{{x86-inst-2|sal|cnt|dest}}

Arithmetic shift <code>dest</code> to the left by <code>cnt</code> bits. The bottom bits do not affect the sign, so the bottom bits are filled with zeros.  This instruction is synonymous with SHL.

Examples ([[X86 Assembly/GAS Syntax|GAS Syntax]]):

<syntaxhighlight lang="asm">
movw   $ff00,%ax        # ax=1111.1111.0000.0000 (0xff00, unsigned 65280, signed -256)
salw   $2,%ax           # ax=1111.1100.0000.0000 (0xfc00, unsigned 64512, signed -1024)
                        # (arithmetic shifting left by 2 is like multiplication by 4 for
                        #   negative numbers, but has an impact on positives with most
                        #   significant bit set (i.e. set bits shifted out))
sarw   $5,%ax           # ax=1111.1111.1110.0000 (0xffe0, unsigned 65504, signed -32)
                        # (arithmetic shifting right by 5 is like integer division by 32
                        #   for negative numbers)
</syntaxhighlight>

== Extended Shift Instructions ==

The names of the ''double precision'' shift operations are somewhat misleading, hence they are listed as ''extended'' shift instructions on this page.

They are available for use with 16- and 32-bit data entities (registers/memory locations). The <code>src</code> operand is always a register, the <code>dest</code> operand can be a register or memory location, the <code>cnt</code> operand is an immediate byte value or the CL register. In 64-bit mode it is possible to address 64-bit data as well.

{{x86-inst-3|shld|src|dest|cnt}}

The operation performed by <code>shld</code> is to shift the most significant <code>cnt</code> bits out of <code>dest</code>, but instead of filling up the least significant bits with zeros, they are filled with the most significant <code>cnt</code> bits of <code>src</code>.

{{x86-inst-3|shrd|src|dest|cnt}}

Likewise, the <code>shrd</code> operation shifts the least significant <code>cnt</code> bits out of <code>dest</code>, and fills up the most significant <code>cnt</code> bits with the least significant bits of the <code>src</code> operand.

Intel's nomenclature is misleading, in that the shift does not operate on double the basic operand size (i.e. specifying 32-bit operands doesn't make it a 64-bit shift): the <code>src</code> operand always remains unchanged.

Also, Intel's manual<ref>[http://download.intel.com/products/processor/manual/325383.pdf Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 2] ([[w:PDF|PDF]], 6.2 MB)</ref> states that the results are undefined when <code>cnt</code> is greater than the operand size, but at least for 32- and 64-bit data sizes it has been observed that shift operations are performed by (<code>cnt [[w:Modulo_operator|mod]] n</code>), with n being the data size.

Examples ([[X86 Assembly/GAS Syntax|GAS Syntax]]):

<syntaxhighlight lang="asm">
xorw   %ax,%ax          # ax=0000.0000.0000.0000 (0x0000)
notw   %ax              # ax=1111.1111.1111.1111 (0xffff)
movw   $0x5500,%bx      # bx=0101.0101.0000.0000
shrdw  $4,%ax,%bx       # bx=1111.0101.0101.0000 (0xf550), ax is still 0xffff
shldw  $8,%bx,%ax       # ax=1111.1111.1111.0101 (0xfff5), bx is still 0xf550
</syntaxhighlight>

Other examples ('''decimal numbers are used instead of binary number to explain the concept''')
<syntaxhighlight lang="asm">
# ax = 1234 5678
# bx = 8765 4321
shrd   $3, %ax, %bx     # ax = 1234 5678 bx = 6788 7654 
</syntaxhighlight>

<syntaxhighlight lang="asm">
# ax = 1234 5678
# bx = 8765 4321
shld   $3, %ax, %bx     # bx = 5432 1123 ax = 1234 5678
</syntaxhighlight>

== Rotate Instructions ==
=== Rotate Right ===
In a rotate instruction, the bits that slide off the end of the register are fed back into the spaces.
{{x86-inst-2|ror|offset|variable}}
Rotate <var><code>variable</code></var> to the right by <var><code>offset</code></var> bits.
Here is a graphical representation how this looks like:
             ╭─────────────────╮
 %al old     │ 0 0 1 0'0 1 1 1 │
 ror 1, %al  ╰─╮╲ ╲ ╲ ╲ ╲ ╲ ╲╰─╯
 %al new       1 0 0 1'0 0 1 1
The number of bits to rotate <var><code>offset</code></var> is masked to the lower 5&nbsp;bits (or 6&nbsp;bits in 64-bit mode).
This is equivalent to a <math>\text{offset}\!\!\!\!\mod 32</math> operation, i.&#8239;e. the remainder of integer division (note: <math>2^5 = 32</math>).
This means, you can never do one or more “complete” rotations.

==== Operands ====
* <var><code>Variable</code></var> has to be a register or memory location.
* <var><code>Offset</code></var> can be either
** an immediate value (where the value <code>1</code> has a dedicated opcode),
** or the <syntaxhighlight lang="asm" inline>cl</syntaxhighlight> register (that is the lowest byte of <syntaxhighlight lang="asm" inline>ecx</syntaxhighlight>).

==== Modified Flags ====
<syntaxhighlight lang="asm" inline>ror</syntaxhighlight> only alters flags if the masked <var><code>offset</code></var> is ''non''-zero.
The <var>{{abbr|CF|carry flag}}</var> becomes the most recently rotated bit, so in the case of <syntaxhighlight lang="asm" inline>ror</syntaxhighlight> the <var>result</var>’s {{abbr|MSB|most-significant bit}} (the “sign”).

Furthermore, if the masked <var><code>offset</code></var> = 1, <var>{{abbr|OF|overflow flag}}</var> ≔ <var>result</var>[{{abbr|MSB|most-signifcant bit}}] ⊻ <var>result</var>[{{abbr|MSB|most-significant bit}}−1], so the OF tells us, whether “the sign” has changed.

=== Rotate Left ===
{{x86-inst-2|rol|offset|variable}}

Rotate <var><code>variable</code></var> to the left by <var><code>offset</code></var> bits.

Operands and modified flags are pretty much the same as for [[#Rotate Right|<syntaxhighlight lang="asm" inline>ror</syntaxhighlight>]].
However, in the case that the masked <var><code>offset</code></var> = 1, the {{abbr|OF|overflow flag}} is defined differently, although it has effectively same meaning.
For <syntaxhighlight lang="asm" inline>rol 1, x</syntaxhighlight> the <var>{{abbr|OF|overflow flag}}</var> ≔ <var>result</var>[MSB] ⊻ <var>result</var>[{{abbr|LSB|least-signifcant bit}}].

Note that the {{abbr|CF|carry flag}} contains the {{abbr|LSB|least-signifcant bit}} in the case of <syntaxhighlight lang="asm" inline>rol</syntaxhighlight>.

== Rotate With Carry Instructions ==

Like with shifts, the rotate can use the carry bit as the "extra" bit that it shifts through.

{{x86-inst-2|rcr|cnt|dest}}

Rotate <code>dest</code> to the right by <code>cnt</code> bits with carry.

{{x86-inst-2|rcl|cnt|dest}}

Rotate <code>dest</code> to the left by <code>cnt</code> bits with carry.

== Number of arguments ==
Unless stated, these instructions can take either one or two arguments. If only one is supplied, it is assumed to be a register or memory location and the number of bits to shift/rotate is one (this may be dependent on the assembler in use, however).
<code> shrl $1, %eax </code> is equivalent to <code> shrl %eax</code>  (GAS syntax).

== Notes ==
{{reflist|colwidth=30em}}