Операции сдвига

Операции сдвига и вращения являются одними из базовых операций, которые позволяютманипулировать битами в регистре. Для подобных операций в ассемблере ARM64 можно использовать инструкцию MOV в форме:

mov Xd, Xs, [Оператор_сдвига] количество_разрядов

В качестве третьего параметра инструкции передается один из следующих операторов сдвига:

• LSL: логический сдвиг влево

• LSR: логический сдвиг вправо

• ASR: арифметический сдвиг вправо

• ROR: вращение вправо

Этим операторам передается непосредственный операнд, который указывает, на сколько бит надо сдвинуть значение. Рассмотрим каждую из этих операций.

Логический сдвиг влево

Логический сдвиг влево сдвигает влево битовое представление числа на определенное количество разрядов. Сдвинутые слева разряды отбрасывюатся, а справа число дополняется нулями. Например:

mov X1, #13
mov X0, X1, LSL #2    // сдвигаем число из X1 (число 13) на 2 разряда влево 

Здесь сдвигаем число из X1 на 2 разрядо влево и результат помещаем в X0. Рассмотрим сдвиг в двоичной форме. Число 13 в двоичной форме представляет число 0b1101 или 0b00001101. Логический сдвиг на два разряда влево будет означать, что 2 старших бита будут отброшены, а справа будут добавлены 2 нулевых бита:

0b00001101
<<
2
0b00110100

То есть в результате получится число 0b00110100 или 52 в десятичной системе, которое будет помещено в регистр X0.

Фактически сдвиг влево на 1 разряд эквивалентен умножению на 2, соответственно сдвиг на 2 разряда влево - умножению на 4 (13 * 4 = 52).

Логический сдвиг вправо

При логическом сдвиге вправо сдвинутые справа разряды отбрасываются, а слева число дополняется нулями. указанное количество разрядов слева отбрасываются, а справа число дополняется нулями:

mov X1, #13
mov X0, X1, LSR #2    // сдвигаем число из X1 (число 13) на два разряда вправо 

Здесь сдвигаем число из X1 на 2 разрядо вправо и результат помещаем в X0, что означает, что 2 младших бита в X1 будут отброшены, а слева будут добавлены 2 нулевых бита:

0b00001101
>>
2
0b00000011

То есть в результате получится число 0b00000011 или 3 в десятичной системе, которое будет помещено в регистр X0.

Фактически сдвиг вправо на 1 разряд эквивалентен делению на 2 (дробная часть отбрасывается), соответственно сдвиг на 2 разряда вправо эквивалентно делению на 4 (13 / 4 = 3).

Арифметический сдвиг вправо

Арифметический сдвиг вправо во многом аналогичен логическому - справа также отбрасывается указанное число разрядов, однако слево число дополняется знакомым (старшим) битом. Так, у положительных этот бит равен 0, а у отрицательных равен 1:

mov X1, -13        // 0b11111111111111111111111111110011
mov X0, X1, ASR #2    // сдвигаем число из X1 (число -13) на два разряда вправо 

Здесь сдвигаем число -13 (в двоичной системе 0b11111111111111111111111111110011) из X1 на 2 разрядо вправо и результат помещаем в X0, что означает, что 2 младших бита в X1 будут отброшены, а слева будут добавлены 2 бита, равных 1 (так как число отрицательное):

0b1111111111110011
>>
2
=
0b1111111111111100

То есть число будет равно -3 (если бы число рассматривалось как положительное, то оно было бы равно 252).

Вращение вправо

Оператор ROR выполняет вращение на определенное количество бит вправо, при котором отброшенные справа биты добавляются слева. Например:

mov X1, 13          // 0b00001101
mov X0, X1, ROR #2  // вращение числа из X1 (число 13) на два разряда вправо 

Здесь мы имеем следующую операцию:

0b00001101
⇒
2
=
0b01000011

Специальные инструкции сдвига

Операции сдвига настолько распространены, что для них имеются псевдонимы:

LSL X0, X1, #1    // эквивалентно MOV X0, X1, LSL #1
LSR X0, X1, #1    // эквивалентно MOV X0, X1, LSR #1
ASR X0, X1, #1    // эквивалентно MOV X0, X1, ASR #1
ROR X0, X1, #1    // эквивалентно MOV X0, X1, ROR #1

В качестве первого операнда передается регистр, куда надо поместить данные. Второй операнд представляет сдвигаемые данные, а третий операнд - на сколько разрядов надо сдвинуть данные.