The ARM processor shows off its barrel shifter once again in its collection of bit shifting instructions.<\/p>\n
; logical shift right\r\n lsr Rd, Rn, #imm5 ; Rd = Rn >> imm5 (unsigned)\r\n lsr Rd, Rn, Rm ; Rd = Rn >> (Rm & 0xFF) (unsigned)\r\n\r\n ; arithmetic shift right\r\n asr Rd, Rn, #imm5 ; Rd = Rn >> imm5 (signed)\r\n asr Rd, Rn, Rm ; Rd = Rn >> (Rm & 0xFF) (signed)\r\n\r\n ; logical shift left\r\n lsl Rd, Rn, #imm5 ; Rd = Rn << imm5\r\n lsl Rd, Rn, Rm ; Rd = Rn << (Rm & 0xFF)\r\n\r\n ; rotate right\r\n ror Rd, Rn, #imm5 ; Rd = rotate_right(Rn, imm5)\r\n ror Rd, Rn, Rm ; Rd = rotate_right(Rn, Rm & 0xFF)\r\n\r\n ; rotate right extended\r\n rrx Rd, Rn ; temp = Rn\r\n ; Rd = (carry << 31) | (temp >> 1)\r\n ; carry = temp & 1\r\n\r\n ; all support the S suffix\r\n<\/pre>\nFor register-counted shifts, only the bottom byte of the shift amount is used. The “rotate right extended” instruction performs a 33-bit rotation, where the carry bit is the extra bit.<\/p>\n
If flags are updated, then the negative (N) and zero (Z) flags reflect the resulting value. The carry (C) flag contains the last bit shifted out. and the overflow (V) flag is unchanged. If the shift amount is zero, then carry is unchanged.<\/p>\n
There is no
RLX<\/code> instruction for rotating left through carry, but that’s okay, because you can emulate it:<\/p>\nadcs Rd, Rn, Rn ; Rd = Rn + Rn + carry, set carry on overflow\r\n<\/pre>\nAdding a number to itself is the same as shifting left one position. Adding with carry puts the former carry bit into bit 0 of the result. And setting flags on carry-out means that the previous bit 31 becomes the new carry bit. Voil\u00e0: Rotate left through carry.<\/p>\n
Note that for the shift instructions, the shift amount cannot itself be a shifted register. The barrel shifter is already being used by the primary opcode; it can’t be used to generate the shift amount, too.<\/p>\n
There are also some instructions specifically for manipulating bitfields.<\/p>\n
; bitfield clear: zero out #w bits starting at #lsb\r\n bfc Rd, #lsb, #w ; Rd[lsb+w-1:lsb] = 0\r\n\r\n ; bitfield insert: replace #w bits in starting at #lsb\r\n ; with least significant bits of source\r\n bfi Rd, Rn, #lsb, #w ; Rd[lsb+w-1:lsb] = Rn[w-1:0]\r\n\r\n ; unsigned bitfield extract\r\n ubfx Rd, Rn, #lsb, #w ; Rd = Rn[lsb+w-1:lsb], zero-extended\r\n\r\n ; signed bitfield extract\r\n sbfx Rd, Rn, #lsb, #w ; Rd = Rn[lsb+w-1:lsb], sign-extended\r\n<\/pre>\nSuppose you have a C structure like this:<\/p>\n
struct S\r\n{\r\n int x:10;\r\n int y:12;\r\n unsigned int z:10;\r\n};\r\n<\/pre>\nwhich might correspond to<\/p>\n
\n\n
\n 3
\n1<\/td>\n3
\n0<\/td>\n2
\n9<\/td>\n2
\n8<\/td>\n2
\n7<\/td>\n2
\n6<\/td>\n2
\n5<\/td>\n2
\n4<\/td>\n2
\n3<\/td>\n2
\n2<\/td>\n2
\n1<\/td>\n2
\n0<\/td>\n1
\n9<\/td>\n1
\n8<\/td>\n1
\n7<\/td>\n1
\n6<\/td>\n1
\n5<\/td>\n1
\n4<\/td>\n1
\n3<\/td>\n1
\n2<\/td>\n1
\n1<\/td>\n1
\n0<\/td>\n\n9<\/td>\n \n8<\/td>\n \n7<\/td>\n \n6<\/td>\n \n5<\/td>\n \n4<\/td>\n \n3<\/td>\n \n2<\/td>\n \n1<\/td>\n \n0<\/td>\n<\/tr>\n \n z<\/td>\n y<\/td>\n x<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Suppose the bitfield is held in register r0<\/var> and the variable v<\/var> is in the register r1<\/var>. The bitfield instructions would correspond to these C statements:<\/p>\n
bfc r0, #10, #12 ; s.y = 0\r\n\r\n bfi r0, r1, #10, #12 ; s.y = v\r\n\r\n ubfx r1, r0, #22, #10 ; v = s.z\r\n sbfx r1, r0, #10, #12 ; v = s.y\r\n<\/pre>\nThe “bitfield clear” instruction sets a range of bits to zero. The “bitfield insert” instruction copies the specific number of least significant bits of the source to a position in the destination. The bitfield extraction instructions copy the specific bits from the source to the least significant bits of the destination, and either zero-extends or sign-extends the result.<\/p>\n
The bitfield clear instruction can also be used for things other than bitfields, For example, you can write<\/p>\n
bfc r0, r0, #14, #18 ; r0 = r0 & 0x0003FFFF<\/pre>\nYou would be tempted to write something like<\/p>\n
and r0, r0, #0x0003FFFF ; not a valid instruction\r\n<\/pre>\nbut if you try, the assembler will get mad at you because the constant
0x0003FFFF<\/code> cannot be encoded. There are too many 1-bits for it to be encoded as a shifted 8-bit value, and there are too many 0-bits for it to be encoded as the inverse of a shifted 8-bit value.<\/p>\nThe signed bit field extraction instruction is useful for sign-extending a sub-word value in a single instruction:<\/p>\n
sbfx r0, r0, #0, #12 ; sign extend a 12-bit value\r\n\r\n ; alternative version would have been\r\n lsl r0, r0, #20 ; r0 = r0 << 20\r\n asr r0, r0, #20 ; r0 = r0 >> 20 (signed)\r\n<\/pre>\nThe bitfield instructions use a 32-bit encoding. While you could use them to sign-extend or zero-extend a byte or halfword, there are dedicated 16-bit instructions for those operations. We’ll look at those next time.<\/p>\n","protected":false},"excerpt":{"rendered":"
That barrel shifter again.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[2],"class_list":["post-105293","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-history"],"acf":[],"blog_post_summary":"
That barrel shifter again.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/105293","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=105293"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/105293\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=105293"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=105293"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=105293"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}