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
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
// 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.
| Operator | Symbole | Priorité |
|---|---|---|
| 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 [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
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 [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
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
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
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
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) | 0 | 1 | x | || (OU) | 0 | 1 | x | |
|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 | 1 | x | |
| 1 | 0 | 1 | x | 1 | 1 | 1 | 1 | |
| x | 0 | x | x | x | x | 1 | x |
| ^ (OU exclusif) | 0 | 1 | x | ~^ (NON-OU exclusif) | 0 | 1 | x | |
|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 1 | x | 0 | 1 | 0 | x | |
| 1 | 1 | 0 | x | 1 | 0 | 1 | x | |
| x | x | x | x | x | x | x | x |
Exemple
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
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
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
(addr[9:8] == 2'b01) ? hsel_p2 :
(addr[9:8] == 2'b10) ? hsel_p3 :
(addr[9:8] == 2'b11) ? hsel_p4 ;