Expressions

Une expression est composée d'opérateurs et d'opérandes, et son but est d'obtenir un résultat de calcul selon la signification des opérateurs. Les expressions peuvent être utilisées partout où une valeur apparaît. Par exemple :

Exemple

a^b ;          // Opération XOR sur a et b
address[9:0] + 10'b1 ;  // accumulation d'adresses
flag1 && flag2 ;  // opération ET logique

Opérandes

Les opérandes peuvent être de n'importe quel type de données, mais certaines structures syntaxiques spécifiques nécessitent des opérandes d'un type spécifique.

Les opérandes peuvent être des constantes, des entiers, des nombres réels, des nets, des registres, time, des sélections de bits, des sélections de parties, des mémoires, des appels de fonction, etc.

Exemple

module test;

// nombre réel
real a, b, c;
c = a + b ;

// registre
reg  [3:0]       cprmu_1, cprmu_2 ;
always @(posedge clk) begin
        cprmu_2 = cprmu_1 ^ cprmu_2 ;
end
         
// fonction
reg  flag1 ;
flag = calculate_result(A, B);
 
// opérande illégal
reg [3:0]         res;
wire [3:0]        temp;
always@ (*)begin
    res    = cprmu_2 – cprmu_1 ;
    //temp = cprmu_2 – cprmu_1 ; //illégal, la cible d'affectation dans un bloc always ne peut pas être de type wire
end

endmodule

Opérateurs

Verilog fournit environ 9 types d'opérateurs : arithmétiques, relationnels, d'égalité, logiques, bit à bit, de réduction, de décalage, de concaténation et conditionnels.

La plupart des opérateurs sont similaires à ceux du C. Parmi les opérateurs de même type, à l'exception de l'opérateur conditionnel qui s'associe de droite à gauche, tous les autres opérateurs s'associent de gauche à droite. Les expressions entre parenthèses sont évaluées en premier. Par exemple, les deux formes de chaque groupe ci-dessous sont équivalentes.

//自右向左关联,两种写法等价
A+B-C ;
(A+B)-C ;

//自右向左关联,两种写法等价,结果为 B、D 或 F
A ? B : C ? D : F ;
A ? B : (C ? D : F) ;

//自右向左关联,两种写法不等价
(A ? B : C) ? D : F ;  //结果 D 或 F
A ? B : C ? D : F ; //结果为 B、D 或 F

Les différents opérateurs ont différents niveaux de priorité. Le tableau suivant liste les opérateurs par ordre de priorité décroissante. Lorsqu'il n'y a pas de parenthèses, Verilog évalue les expressions selon la priorité des opérateurs. Pour éviter la confusion causée par la priorité des opérateurs, il est recommandé d'utiliser des parenthèses pour séparer les expressions lorsque la priorité est incertaine.

OperatorSymbolePriorité
Opérations unaires+ - ! ~Maximale
Multiplication, division, modulo* / % 
Addition, soustraction+ - 
Décalage<<  >> 
Relationnel<  <=  >  >= 
Égalité==  !=  ===  !=== 
Réduction& ~& 
 ^ ~^ 
 | ~| 
Logique&& 
 || 
Conditional?:Le plus bas

Opérateurs arithmétiques

Les opérateurs arithmétiques comprennent les opérateurs unaires et les opérateurs binaires.

Les opérateurs binaires effectuent des opérations arithmétiques sur 2 opérandes, notamment la multiplication (*), la division (/), l'addition (+), la soustraction (-), l'exponentiation (**) et le modulo (%).

Exemple

reg [3:0]  a, b;
reg [4:0]  c ;
a = 4'b0010; // a a une valeur de 2
b = 4'b1001; // b a une valeur de 9
c = a+b;     // le résultat est c=b'b1011
c = b/a;     // le résultat est c=4, division entière

Si un bit quelconque d'un opérande est X, le résultat du calcul sera également tout X. Par exemple :

Exemple

b = 4'b100x ;
c = a+b ;       // le résultat est c=4'bxxxx

Lors de la déclaration de variables, la largeur de la variable doit être déclarée raisonnablement en fonction de l'opérateur qui agit sur elle, afin de ne pas provoquer de débordement du résultat. Dans l'exemple ci-dessus, les deux variables additionnées ont une largeur de 4 bits, donc la variable de registre de résultat doit avoir une largeur d'au moins 5 bits. Sinon, les bits de poids fort seront tronqués, entraînant une perte des bits de poids fort du résultat. Pour une multiplication non signée, la largeur de la variable de résultat doit être la somme des largeurs des deux opérandes.

Exemple

reg [3:0]        mula ;
reg [1:0]        mulb;
reg [5:0]        res ;
mula = 4'he   ;
mulb = 2'h3   ;
res  = mula * mulb ; // le résultat est res=6'h2a, aucun bit perdu dans le résultat des données

+ et - peuvent également être utilisés comme opérateurs unaires pour indiquer le signe d'un opérande. Ces opérateurs ont la priorité la plus élevée.

-4  //表示负4
+3  //表示正3

Pour représenter un nombre négatif, vous pouvez ajouter directement un signe moins devant un nombre décimal-, ou vous pouvez spécifier une largeur. Comme les nombres négatifs sont représentés en complément à deux, représenter un nombre négatif sans spécifier de largeur amènera le compilateur à attribuer automatiquement une largeur lors de la conversion, ce qui conduit à des résultats inattendus. Par exemple :

Exemple

mula = -4'd4 ;
mulb = 2 ;
res = mula * mulb ;      // le résultat du calcul est res=-6'd8, c'est-à-dire res=6'h38, normal
res = mula * (-'d4) ;    // (4 à la puissance 32 - 4) * 2, résultat anormal

Opérateurs relationnels

Les opérateurs relationnels sont supérieur à (>), inférieur à (<), supérieur ou égal à (>=), inférieur ou égal à (<=).

Le résultat normal des opérateurs relationnels a 2 possibilités : vrai (1) ou faux (0).

Si un bit quelconque d'un opérande est x ou z, le résultat de l'expression relationnelle est x.

Exemple

A = 4 ;
B = 3 ;
X = 3'b1xx ;
   
A > B     // vrai
A <= B    // false
A >= Z    // X, incertain

Opérateurs d'égalité

Les opérateurs d'égalité comprennent l'égalité logique (==), l'inégalité logique (!=), l'égalité de cas (===) et l'inégalité de cas (!==).

Le résultat normal des opérateurs d'égalité a 2 possibilités : vrai (1) ou faux (0).

Les opérateurs d'égalité/d'inégalité logique ne peuvent pas comparer x ou z ; lorsqu'un opérande contient un x ou un z, le résultat est une valeur inconnue.

Dans la comparaison d'égalité de cas, si la comparaison bit à bit a le même x ou z, le résultat renvoyé peut aussi être 1 ; c'est-à-dire que l'égalité de cas peut comparer x ou z. Par conséquent, le résultat de l'égalité de cas ne contient jamais x. Exemples comme suit :

Exemple

A = 4 ;
B = 8'h04 ;
C = 4'bxxxx ;
D = 4'hx ;
A == B        // vrai
A == (B + 1)  // false
A == C        // X, incertain
A === C       // faux, renvoie 0
C === D       // vrai, renvoie 1

Opérateurs logiques

Il existe principalement 3 opérateurs logiques : && (ET logique), || (OU logique), ! (NON logique).

Le résultat d'un opérateur logique est une valeur de 1 bit, où 0 représente faux, 1 représente vrai et x représente inconnu.

Si un opérande est non nul, il équivaut à la logique 1 ; si un opérande est égal à 0, il équivaut à la logique 0. Si l'un de ses bits est x ou z, il équivaut à x.

Si un opérande contient x, le résultat d'un opérateur logique n'est pas nécessairement x.

Les opérandes des opérateurs logiques peuvent être des variables ou des expressions. Par exemple :

Exemple

A = 3;
B = 0;
C = 2'b1x ;
   
A && B    // false
A || B    // true
! A       // false
! B       // true
A && C    // X, incertain
A || C    // true, car A est vrai
(A==2) && (! B)  // true ; ici, le premier opérande est une expression

Opérateurs bit à bit

Les opérateurs bit à bit incluent : NOT bit à bit (~), AND (&), OR (|), XOR (^), XNOR (~^).

Les opérateurs bit à bit effectuent des opérations bit à bit sur chaque bit des 2 opérandes.

Si les deux opérandes ont des largeurs inégales, l'opérande le plus court est étendu avec des zéros à gauche.

L'opérateur NOT n'a qu'un seul opérande, et il inverse chaque bit de l'opérande.

La figure suivante donne les règles logiques pour les opérateurs bit à bit.

& (ET)01x || (OU)01x
0000 001x
101x 1111
x0xx xx1x
^ (OU exclusif)01x ~^ (NON-OU exclusif)01x
001x 010x
110x 101x
xxxx xxxx

Exemple

A = 4'b0101 ;
B = 4'b1001 ;
C = 4'bx010 ;
   
~A        //4'b1010
A & B     //4'b0001
A | B     //4'b1101
A^B       //4'b1100
A ~^ B    //4'b0011
B | C     //4'b1011
B&C       //4'bx000

Opérateurs de réduction

Les opérateurs de réduction incluent : ET de réduction (&), NON-ET de réduction (~&), OU de réduction (|), NON-OU de réduction (~|), OU exclusif de réduction (^), NON-OU exclusif de réduction (~^).

Un opérateur de réduction n'a qu'un seul opérande. Il opère sur chaque bit de l'opérande vectoriel et produit finalement un résultat de 1 bit.

Les opérateurs logiques, les opérateurs bit à bit et les opérateurs de réduction utilisent les mêmes symboles, il est donc parfois facile de les confondre. La clé pour distinguer ces opérateurs est de clarifier le nombre d'opérandes et les règles de calcul du résultat.

A = 4'b1010 ;
&A ;      //结果为 1 & 0 & 1 & 0 = 1'b0,可用来判断变量A是否全1
~|A ;     //结果为 ~(1 | 0 | 1 | 0) = 1'b0, 可用来判断变量A是否为全0
^A ;      //结果为 1 ^ 0 ^ 1 ^ 0 = 1'b0

Opérateurs de décalage

Les opérateurs de décalage incluent le décalage à gauche (<<), le décalage à droite (>>), le décalage arithmétique à gauche (<<<), le décalage arithmétique à droite (>>>).

Les opérateurs de décalage sont des opérateurs binaires. Les deux opérandes représentent respectivement le signal vectoriel à décaler (à gauche de l'opérateur) et le nombre de bits à décaler (à droite de l'opérateur).

Pour le décalage à gauche arithmétique et le décalage à gauche logique, les bits de poids faible à droite sont remplis avec 0.

Pour le décalage à droite logique, les bits de poids fort à gauche sont remplis avec 0 ; pour le décalage à droite arithmétique, les bits de poids fort à gauche sont remplis avec le bit de signe afin de garantir l'exactitude de la valeur après mise à l'échelle.

Exemple

A = 4'b1100 ;
B = 4'b0010 ;
A = A >> 2 ;        //Le résultat est 4'b0011
A = A << 1;         //Le résultat est 4'b1000
A = A <<< 1 ;       //Le résultat est 4'b1000
C = B + (A>>>2);    //Le résultat est 2 + (-4/4) = 1, 4'b0001

Opérateur de concaténation

L'opérateur de concaténation utilise des accolades{,}pour représenter, et sert à concaténer plusieurs opérandes (vecteurs) en un nouvel opérande (vecteur), avec les signaux séparés par des virgules.

Les opérandes de l'opérateur de concaténation doivent spécifier la largeur de bits ; les constantes doivent aussi spécifier la largeur de bits. Par exemple :

Exemple

A = 4'b1010 ;
B = 1'b1 ;
Y1 = {B, A[3:2], A[0], 4'h3 };  //Le résultat est Y1='b1100_0011
Y2 = {4{B}, 3'd4};  //Le résultat est Y2=7'b111_1100
Y3 = {32{1'b0}};  //Le résultat est Y3=32h0, couramment utilisé comme affectation de valeur initiale correspondant à la largeur de bits lors de l'initialisation d'un registre

Opérateur conditionnel

Une expression conditionnelle a 3 opérandes, avec la structure décrite comme suit :

condition_expression ? true_expression : false_expression

Lors de l'évaluation, si condition_expression est vraie (valeur logique 1), le résultat de l'opération est true_expression ; si condition_expression est fausse (valeur logique 0), le résultat de l'évaluation est false_expression.

assign hsel    = (addr[9:8] == 2'b0) ? hsel_p1 : hsel_p2 ;
//当信号 addr 高 2bit 为 0 时,hsel 赋值为 hsel_p1; 否则,将 hsel_p2 赋值给 hsel。

En fait, une expression conditionnelle est similaire à un sélecteur à 2 voies (ou à plusieurs voies), et sa description peut être complètement remplacée par des instructions if-else.

Bien sûr, les opérateurs conditionnels peuvent également être imbriqués pour implémenter une logique de sélection multiple. Par exemple :

Exemple

assign   hsel = (addr[9:8] == 2'b00) ? hsel_p1 :
                (addr[9:8] == 2'b01) ? hsel_p2 :
                (addr[9:8] == 2'b10) ? hsel_p3 :
                (addr[9:8] == 2'b11) ? hsel_p4 ;