Bitwise operatie

de bitverschuivingen worden soms als bitwise operaties beschouwd, omdat ze een waarde behandelen als een reeks bits in plaats van als een numerieke hoeveelheid. In deze bewerkingen worden de cijfers naar links of rechts verplaatst of verschoven. Registers in een computer processor hebben een vaste breedte, dus sommige bits zullen worden “verschoven” van het register aan de ene kant, terwijl hetzelfde aantal bits worden “verschoven” van de andere kant; de verschillen tussen bit shift operators liggen in hoe ze de waarden van de verschoven-in bits bepalen.

bitadressingedit

indien de breedte van het register (vaak 32 of zelfs 64) groter is dan het aantal bits (meestal 8) van de kleinste adresseerbare eenheid (atomair element), vaak byte genoemd, veroorzaken de shift-bewerkingen een adresseringsschema op de bits.Zonder rekening te houden met de grenseffecten aan beide uiteinden van het register, gedragen rekenkundige en logische shift operaties zich hetzelfde, en een shift met 8 bit posities transporteert het bit patroon met 1 byte positie op de volgende manier:

Rekenkundige shiftEdit

Links arithmetic shift

Rechts arithmetic shift

In een rekenkundige shift, de bits die zijn verschoven van een van de uiteinden worden verwijderd. In een linker rekenkundige shift worden nullen naar rechts verschoven; in een rechter rekenkundige shift wordt het teken bit (de MSB in twee ‘ s complement) verschoven naar links, waardoor het teken van de operand behouden blijft.

dit voorbeeld gebruikt een 8-bit register, geïnterpreteerd als een complement van twee:

 00010111 (decimal +23) LEFT-SHIFT= 00101110 (decimal +46)

 10010111 (decimal −105) RIGHT-SHIFT= 11001011 (decimal −53)

in het eerste geval werd het meest linkse cijfer verschoven voorbij het einde van het register, en een nieuwe 0 werd verschoven naar de meest rechtse positie. In het tweede geval werd de meest rechtse 1 naar buiten verschoven (misschien naar de draagvlag), en een nieuwe 1 werd gekopieerd naar de meest linkse positie, met behoud van het teken van het nummer. Meerdere diensten worden soms ingekort tot een enkele dienst met een aantal cijfers. Bijvoorbeeld::

 00010111 (decimal +23) LEFT-SHIFT-BY-TWO= 01011100 (decimal +92)

een linker rekenkundige verschuiving met n is gelijk aan vermenigvuldigen met 2n (mits de waarde niet overloopt), terwijl een rechter rekenkundige verschuiving met n van de complementwaarde van een twee gelijk is aan delen door 2n en afronden naar negatieve oneindigheid. Als het binaire getal wordt behandeld als iemands’ aanvulling, dan resulteert dezelfde rechts-shift operatie in deling door 2n en afronding naar nul.

logische verschuiving

Links logische verschuiving

Rechts logische verschuiving

In een logische verschuiving, nullen worden verschoven in voor het vervangen van de afgedankte bits. Daarom zijn de logische en rekenkundige linkse verschuivingen precies hetzelfde.

echter, omdat de logische rechtsverschuiving waarde 0 bits in het meest significante bit invoegt, in plaats van het tekenbit te kopiëren, is het ideaal voor niet-ondertekende binaire getallen, terwijl de rekenkundige rechtsverschuiving ideaal is voor de complement binaire getallen van signed two.

cirkelvormige ploegendienst

een andere vorm van ploegendienst is de cirkelvormige ploegendienst, bitwenteling of bitwenteling.

RotateEdit

Links circulaire verschuiven of draaien

Recht ronde verschuiven of draaien

In deze operatie, soms ook wel draaien voeren, de bits worden “gedraaid” als de linker-en rechterzijde van het register werden samengevoegd. De waarde die naar rechts wordt verschoven tijdens een links-shift is de waarde die naar links werd verschoven, en omgekeerd voor een rechts-shift operatie. Dit is nuttig als het nodig is om alle bestaande bits te behouden, en wordt vaak gebruikt in digitale cryptografie.

Draaien door carryEdit

Links draaien via dragen

Rechts roteren dragen

Draaien door carry is een variant van de draai werking, waar het beetje dat er is verschoven in de (op het einde) is de oude waarde van de carry-vlag, en het beetje dat er is verschoven (aan de andere kant) wordt de nieuwe waarde van de carry-vlag.

een enkele rotatie door carry kan een logische of rekenkundige verschuiving van één positie simuleren door vooraf de carry-vlag in te stellen. Bijvoorbeeld, als de carry flag 0 bevat, dan is x RIGHT-ROTATE-THROUGH-CARRY-BY-ONE een logische rechtsverschuiving, en als de carry flag een kopie van het tekenbit bevat, dan is x RIGHT-ROTATE-THROUGH-CARRY-BY-ONE een rekenkundige rechtsverschuiving. Om deze reden hebben sommige microcontrollers zoals low-end foto ‘ s gewoon roteren en roteren door carry, en doen geen moeite met rekenkundige of logische shift instructies.

roteren door carry is vooral handig bij het uitvoeren van verschuivingen op getallen die groter zijn dan de oorspronkelijke woordgrootte van de processor, omdat als een groot getal in twee registers wordt opgeslagen, de bit die van het ene uiteinde van het eerste register wordt verschoven aan het andere einde van de tweede moet binnenkomen. Met rotate-through-carry wordt dat bit tijdens de eerste shift” opgeslagen ” in de carry flag, klaar om in te schakelen tijdens de tweede shift zonder extra voorbereiding.

In talen op hoog niveau edit

C-familyEdit

in C-familietalen zijn de logische ploegenoperatoren ” << “voor de linkerdienst en” >> ” voor de rechterdienst. Het aantal plaatsen om te verschuiven wordt gegeven als het tweede argument aan de operator. Bijvoorbeeld:,

x = y << 2;

wijst x het resultaat toe van een verschuiving van y naar links met twee bits, wat gelijk staat aan een vermenigvuldiging met vier.

verschuivingen kunnen resulteren in implementatiegedefinieerd gedrag of ongedefinieerd gedrag, dus voorzichtigheid is geboden bij het gebruik ervan. Het resultaat van het verschuiven met een bit telling groter dan of gelijk aan de grootte van het woord is ongedefinieerd gedrag in C en c++. Rechts-shifting een negatieve waarde is implementatie-gedefinieerd en niet aanbevolen door goede codering praktijk; het resultaat van links-shifting een ondertekende waarde is niet gedefinieerd als het resultaat niet kan worden weergegeven in het type resultaat.

in C# is de Right-shift een rekenkundige shift wanneer de eerste operand een int of long is. Als de eerste operand van het type uint of ulong is, is de right-shift een logische shift.

circulaire shiftsEdit

de C-familie van talen ontbreekt een roterende operator, maar één kan worden gesynthetiseerd uit de shift operators. Zorg moet worden genomen om ervoor te zorgen dat de verklaring is goed gevormd om ongedefinieerd gedrag en timing aanvallen in software met beveiligingsvereisten te voorkomen. Bijvoorbeeld, een naïeve implementatie die links een 32-bit ongesigneerde waarde x roteert met n posities is gewoon:

uint32_t x = ..., n = ...;uint32_t y = (x << n) | (x >> (32 - n));

een verschuiving met 0 bits resulteert echter in ongedefinieerd gedrag in de rechter expressie (x >> (32 - n)) omdat 32 - 0 32 is en 32 buiten het bereik valt. Een tweede poging kan resulteren in:

uint32_t x = ..., n = ...;uint32_t y = n ? (x << n) | (x >> (32 - n)) : x;

waar de shift hoeveelheid wordt getest om ervoor te zorgen dat het geen ongedefinieerd gedrag introduceert. Echter, de branch voegt een extra code pad en biedt een kans voor timing analyse en aanval, die vaak niet acceptabel is in hoge integriteit software. Daarnaast compileert de code meerdere machine-instructies, wat vaak minder efficiënt is dan de oorspronkelijke instructie van de processor.

om ongedefinieerd gedrag en branches onder GCC en Clang te vermijden, wordt het volgende aanbevolen. Het patroon wordt herkend door veel compilers, en de compiler zal een enkele rotatie instructie uitzenden:

uint32_t x = ..., n = ...;uint32_t y = (x << n) | (x >> (-n & 31));

er zijn ook compiler-specifieke intrinsiek implementeren van circulaire verschuivingen, zoals _rotl8, _rotl16, _rotr8, _rotr16 in Microsoft Visual C++. Clang biedt een aantal roteren intrinsiek voor Microsoft-Compatibiliteit die de problemen hierboven lijdt. GCC biedt geen rotatie intrinsiek. Intel biedt ook x86 Intrinsics.

JavaEdit

in Java zijn alle integer types ondertekend, zodat de” << “en” >> ” operators rekenkundige verschuivingen uitvoeren. Java voegt de operator ” >>> “toe om logische rechtsverschuivingen uit te voeren, maar aangezien de logische en rekenkundige linksverschuiving identiek zijn voor een getekend geheel getal, is er geen” <<< ” operator in Java.

meer details van Java shift-operators:

• de operatoren << (linker shift), >> (ondertekende rechter shift) en >>> (niet-ondertekende rechter shift) worden de operatoren genoemd.
• het type van de shift-expressie is het gepromote type van de linker operand. Bijvoorbeeld, aByte >>> 2 is gelijk aan ((int) aByte) >>> 2.
• als het gepromote type van de linker operand int is, worden alleen de vijf laagste-orde bits van de rechter operand gebruikt als de shift afstand. Het is alsof de rechter operand wordt onderworpen aan een bitsgewijze logische en operator & met de maskerwaarde 0x1f (0b11111). De werkelijk gebruikte Schakelafstand ligt daarom altijd tussen 0 en 31, inclusief.
• als het gepromote type van de linker operand lang is, dan worden alleen de zes laagste-orde bits van de rechter operand gebruikt als de shift afstand. Het is alsof de rechter operand wordt onderworpen aan een bitsgewijze logische en operator & met de maskerwaarde 0x3f (0b111111). De werkelijk gebruikte Schakelafstand ligt daarom altijd tussen 0 en 63.
• de waarde van n >>> s is n naar rechts verschoven s-bitposities met nuluitbreiding.
• bij bitbewerkingen en shiftbewerkingen wordt het type byte impliciet geconverteerd naar int. Als de byte waarde negatief is, is het hoogste bit één, dan worden degenen gebruikt om de extra bytes in de int op te vullen. Dus byte b1 = -5; int I = b1 | 0x0200; zal resulteren in i = = -5.

JavaScriptEdit

JavaScript gebruikt bitwise-bewerkingen om elk van twee of meer eenheden op 1 of 0 te evalueren.

PascalEdit

in Pascal, evenals in alle dialecten (zoals Object Pascal en Standaard Pascal), zijn de logische linker en rechter Shift operators respectievelijk “shl” en “shr“. Zelfs voor getekende gehele getallen gedraagt shr zich als een logische shift en kopieert het teken bit niet. Het aantal plaatsen om te verschuiven wordt gegeven als het tweede argument. Bijvoorbeeld, de volgende toewijst X het resultaat van het verschuiven van y naar links met twee bits:

x := y shl 2;