Opérateurs de décalage

Fait partie de la section Fondamentaux du Journey Verilog de Coddy — leçon 26 sur 90.

Les opérateurs de décalage déplacent les bits vers la gauche ou la droite au sein d'un vecteur.

Opérateurs de décalage disponibles

Opérateur	Opération	Description
`<<`	Décalage logique à gauche	Décale les bits vers la gauche, remplit avec des zéros
`>>`	Décalage logique à droite	Décale les bits vers la droite, remplit avec des zéros
`<<<`	Décalage arithmétique à gauche	Identique au décalage logique à gauche
`>>>`	Décalage arithmétique à droite	Décale vers la droite, préserve le bit de signe

Comment ils fonctionnent

Décalage à gauche (<strong><<</strong>) :

8'b00001010 << 2 = 8'b00101000

Les bits se déplacent vers la gauche. Des zéros remplissent le côté droit.

Décalage à droite (<strong>>></strong>) :

8'b00001010 >> 2 = 8'b00000010

Les bits se déplacent vers la droite. Des zéros remplissent le côté gauche.

Exemple de code

module shift_demo;
  reg [7:0] original, left_shift, right_shift;
  
  initial begin
    original = 8'b00001010;
    
    left_shift  = original << 2;   // 00001010 → 00101000
    right_shift = original >> 2;   // 00001010 → 00000010
    
    $display("original   = %b", original);
    $display("<< 2       = %b", left_shift);
    $display(">> 2       = %b", right_shift);
    $finish;
  end
endmodule

Sortie :

original   = 00001010
<< 2       = 00101000
>> 2       = 00000010

Décalage arithmétique à droite (`>>>`)

Pour les nombres signés, le décalage arithmétique à droite conserve le bit de signe :

reg signed [7:0] a;
a = -5;                // 11111011
a >>> 2 = 11111110     // Toujours négatif

Le décalage logique (>>) remplirait avec des zéros et perdrait le signe.

Utilisations courantes

Multiplier par une puissance de 2 (décalage à gauche) :

x << 1    // Multiplier par 2
x << 2    // Multiplier par 4
x << 3    // Multiplier par 8

Diviser par une puissance de 2 (décalage à droite) :

x >> 1    // Diviser par 2
x >> 2    // Diviser par 4
x >> 3    // Diviser par 8

Extraire un champ :

// Récupérer les bits 5-2 d'une valeur de 8 bits
field = (data >> 2) & 4'b1111;

Défi

Écrivez les expressions de décalage correctes pour chaque tâche.

Ce qu'il faut faire :

Décalez a vers la gauche de 3 bits et stockez le résultat dans left_result
Décalez a vers la droite de 1 bit et stockez le résultat dans right_result
Décalez b vers la droite de 2 bits (arithmétique) et stockez le résultat dans arith_result

Aide-mémoire

Les opérateurs de décalage déplacent les bits vers la gauche ou la droite au sein d'un vecteur :

Opérateur	Description
`<<`	Décalage logique à gauche (remplit avec des zéros)
`>>`	Décalage logique à droite (remplit avec des zéros)
`<<<`	Décalage arithmétique à gauche (identique au logique)
`>>>`	Décalage arithmétique à droite (préserve le bit de signe)

8'b00001010 << 2  // = 8'b00101000
8'b00001010 >> 2  // = 8'b00000010

reg signed [7:0] a;
a = -5;           // 11111011
a >>> 2           // = 11111110 (signe préservé)

Utilisations courantes :

x << n    // Multiplier par 2^n
x >> n    // Diviser par 2^n

// Extraire les bits 5-2 d'une valeur de 8 bits
field = (data >> 2) & 4'b1111;

Essayez vous-même

module shift_challenge;
  reg [7:0] a;
  reg signed [7:0] b;
  reg [7:0] left_result, right_result;
  reg signed [7:0] arith_result;
  
  initial begin
    a = 8'b00010001;
    b = -8'sd16;       // 11110000 en binaire
    
    left_result  = ______;   // Décaler a vers la gauche de 3 bits
    right_result = ______;   // Décaler a vers la droite de 1 bit
    arith_result = ______;   // Décaler b vers la droite de 2 bits (arithmétique)
    
    $display("a = %b", a);
    $display("a << 3 = %b", left_result);
    $display("a >> 1 = %b", right_result);
    $display("b = %b", b);
    $display("b >>> 2 = %b", arith_result);
    $finish;
  end
endmodule