Ausdrücke
Ein Ausdruck besteht aus Operatoren und Operanden, und sein Zweck ist es, entsprechend der Bedeutung der Operatoren ein Berechnungsergebnis zu erhalten. Ausdrücke können überall dort verwendet werden, wo ein Wert auftritt. Zum Beispiel:
Beispiel
address[9:0] + 10'b1 ; // Adressakkumulation
flag1 && flag2 ; // logische UND-Operation
Operanden
Operanden können jeden Datentyp haben, aber einige spezielle Syntaxstrukturen erfordern Operanden eines bestimmten Typs.
Operanden können Konstanten, ganze Zahlen, reelle Zahlen, Netze, Register, Zeit, Bit-Auswahlen, Teilauswahlen, Speicher, Funktionsaufrufe usw. sein.
Beispiel
// reelle Zahl
real a, b, c;
c = a + b ;
// Register
reg [3:0] cprmu_1, cprmu_2 ;
always @(posedge clk) begin
cprmu_2 = cprmu_1 ^ cprmu_2 ;
end
// Funktion
reg flag1 ;
flag = calculate_result(A, B);
// ungültiger Operand
reg [3:0] res;
wire [3:0] temp;
always@ (*)begin
res = cprmu_2 – cprmu_1 ;
//temp = cprmu_2 – cprmu_1 ; //unzulässig, das Zuweisungsziel in einem always-Block kann nicht vom Typ wire sein
end
endmodule
Operatoren
Verilog bietet etwa 9 Arten von Operatoren: arithmetische, relationale, Gleichheits-, logische, bitweise, Reduktions-, Schiebe-, Verkettungs- und Bedingungsoperatoren.
Die meisten Operatoren ähneln denen in C. Bei Operatoren desselben Typs sind, mit Ausnahme des Bedingungsoperators, der rechtsassoziativ ist, alle anderen Operatoren linksassoziativ. Ausdrücke in Klammern werden zuerst ausgewertet. Beispielsweise sind die beiden Formen in jeder Gruppe unten äquivalent.
//自右向左关联,两种写法等价 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
Verschiedene Operatoren haben unterschiedliche Vorrangstufen. Die folgende Tabelle listet die Operatoren in der Reihenfolge von hohem zu niedrigem Vorrang auf. Wenn keine Klammern vorhanden sind, wertet Verilog Ausdrücke gemäß der Operatorrangfolge aus. Um Verwirrung durch die Operatorrangfolge zu vermeiden, wird empfohlen, Klammern zu verwenden, um Ausdrücke zu trennen, wenn der Vorrang unklar ist.
| Operator | Symbol | Rangfolge |
|---|---|---|
| Unäre Operationen | + - ! ~ | Höchste |
| Multiplikation, Division, Modulo | * / % | |
| Addition, Subtraktion | + - | |
| Verschiebung | << >> | |
| Relational | < <= > >= | |
| Gleichheit | == != === !=== | |
| Reduktion | & ~& | |
| ^ ~^ | ||
| | ~| | ||
| Logisch | && | |
| || | ||
| Conditional | ?: | Am niedrigsten |
Arithmetische Operatoren
Arithmetische Operatoren umfassen unäre Operatoren und binäre Operatoren.
Binäre Operatoren führen arithmetische Operationen mit 2 Operanden aus, darunter Multiplikation (*), Division (/), Addition (+), Subtraktion (-), Potenzierung (**) und Modulo (%).
Beispiel
reg [4:0] c ;
a = 4'b0010; // a hat den Wert 2
b = 4'b1001; // b hat den Wert 9
c = a+b; // Ergebnis ist c=b'b1011
c = b/a; // Ergebnis ist c=4, ganzzahlige Division
Wenn ein Bit eines Operanden X ist, ist das Berechnungsergebnis ebenfalls ausschließlich X. Zum Beispiel:
Beispiel
c = a+b ; // Ergebnis ist c=4'bxxxx
Beim Deklarieren von Variablen sollte die Breite der Variable entsprechend dem darauf wirkenden Operator sinnvoll deklariert werden, damit das Ergebnis nicht überläuft. Im obigen Beispiel sind die beiden addierten Variablen 4 Bit breit, daher sollte die Ergebnisregistervariable mindestens 5 Bit breit sein. Andernfalls werden die höherwertigen Bits abgeschnitten, was zu einem Verlust der höherwertigen Bits des Ergebnisses führt. Bei der vorzeichenlosen Multiplikation sollte die Breite der Ergebnisvariable die Summe der Breiten der beiden Operanden sein.
Beispiel
reg [1:0] mulb;
reg [5:0] res ;
mula = 4'he ;
mulb = 2'h3 ;
res = mula * mulb ; // Ergebnis ist res=6'h2a, im Daten-Ergebnis gehen keine Bits verloren
+ und - können auch als unäre Operatoren verwendet werden, um das Vorzeichen eines Operanden anzugeben. Solche Operatoren haben die höchste Priorität.
-4 //表示负4 +3 //表示正3
Um eine negative Zahl darzustellen, können Sie direkt ein Minuszeichen vor eine Dezimalzahl setzen-, oder Sie können eine Breite angeben. Da negative Zahlen im Zweierkomplement dargestellt werden, veranlasst das Darstellen einer negativen Zahl ohne Angabe einer Breite den Compiler, während der Konvertierung automatisch eine Breite zuzuweisen, was zu unerwarteten Ergebnissen führt. Zum Beispiel:
Beispiel
mulb = 2 ;
res = mula * mulb ; // Berechnungsergebnis ist res=-6'd8, d. h. res=6'h38, normal
res = mula * (-'d4) ; // (4 hoch 32 - 4) * 2, abnormales Ergebnis
Relationale Operatoren
Vergleichsoperatoren sind größer als (>), kleiner als (<), größer oder gleich (>=), kleiner oder gleich (<=).
Das normale Ergebnis von Vergleichsoperatoren hat 2 Möglichkeiten: wahr (1) oder falsch (0).
Wenn irgendein Bit eines Operanden x oder z ist, ist das Ergebnis des Vergleichsausdrucks x.
Beispiel
B = 3 ;
X = 3'b1xx ;
A > B // true
A <= B // false
A >= Z // X, unsicher
Gleichheitsoperatoren
Zu den Gleichheitsoperatoren gehören logische Gleichheit (==), logische Ungleichheit (!=), Case-Gleichheit (===) und Case-Ungleichheit (!==).
Das normale Ergebnis von Gleichheitsoperatoren hat 2 Möglichkeiten: wahr (1) oder falsch (0).
Logische Gleichheits-/Ungleichheitsoperatoren können x oder z nicht vergleichen; wenn ein Operand x oder z enthält, ist das Ergebnis ein unbekannter Wert.
Beim Case-Gleichheitsvergleich kann das zurückgegebene Ergebnis ebenfalls 1 sein, wenn der bitweise Vergleich denselben x- oder z-Wert ergibt; das heißt, die Case-Gleichheit kann x oder z vergleichen. Daher enthält das Ergebnis der Case-Gleichheit niemals x. Beispiele sind wie folgt:
Beispiel
B = 8'h04 ;
C = 4'bxxxx ;
D = 4'hx ;
A == B // true
A == (B + 1) // false
A == C // X, unsicher
A === C // falsch, gibt 0 zurück
C === D // wahr, gibt 1 zurück
Logische Operatoren
Es gibt hauptsächlich 3 logische Operatoren: && (logisches UND), || (logisches ODER), ! (logisches NICHT).
Das Ergebnis eines logischen Operators ist ein 1-Bit-Wert, wobei 0 für falsch, 1 für wahr und x für unbekannt steht.
Wenn ein Operand ungleich null ist, entspricht er der Logik 1; wenn ein Operand gleich 0 ist, entspricht er der Logik 0. Wenn eines seiner Bits x oder z ist, entspricht er x.
Wenn ein Operand x enthält, ist das Ergebnis eines logischen Operators nicht unbedingt x.
Die Operanden logischer Operatoren können Variablen oder Ausdrücke sein. Zum Beispiel:
Beispiel
B = 0;
C = 2'b1x ;
A && B // false
A || B // true
! A // false
! B // true
A && C // X, ungewiss
A || C // true, weil A true ist
(A==2) && (! B) // true; hier ist der erste Operand ein Ausdruck
Bitweise Operatoren
Bitweise Operatoren umfassen: bitweises NOT (~), AND (&), OR (|), XOR (^), XNOR (~^).
Bitweise Operatoren führen bitweise Operationen an jedem Bit der 2 Operanden aus.
Wenn die zwei Operanden ungleiche Breiten haben, wird der kürzere Operand links mit Nullen erweitert.
Der NOT-Operator hat nur einen Operanden und invertiert jedes Bit des Operanden.
Die folgende Abbildung zeigt die Logikregeln für bitweise Operatoren.
| & (UND) | 0 | 1 | x | || (ODER) | 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 |
| ^ (XOR) | 0 | 1 | x | ~^ (XNOR) | 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 |
Beispiel
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
Reduktionsoperatoren
Reduktionsoperatoren umfassen: Reduktions-UND (&), Reduktions-NAND (~&), Reduktions-ODER (|), Reduktions-NOR (~|), Reduktions-XOR (^), Reduktions-XNOR (~^).
Ein Reduktionsoperator hat nur einen Operanden. Er operiert auf jedem Bit des Vektoroperanden und erzeugt schließlich ein 1-Bit-Ergebnis.
Logische Operatoren, bitweise Operatoren und Reduktionsoperatoren verwenden dieselben Symbole, daher sind sie manchmal leicht zu verwechseln. Der Schlüssel zur Unterscheidung dieser Operatoren liegt darin, die Anzahl der Operanden und die Regeln zur Berechnung des Ergebnisses zu klären.
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
Schiebeoperatoren
Zu den Schiebeoperatoren gehören Linksverschiebung (<<), Rechtsverschiebung (>>), arithmetische Linksverschiebung (<<<) und arithmetische Rechtsverschiebung (>>>).
Schiebeoperatoren sind binäre Operatoren. Die beiden Operanden repräsentieren jeweils das zu verschiebende Vektorsignal (links vom Operator) und die Anzahl der zu verschiebenden Bits (rechts vom Operator).
Beim arithmetischen Linksshift und beim logischen Linksshift werden die niederwertigen Bits rechts mit 0 aufgefüllt.
Beim logischen Rechtsshift werden die hohen Bits links mit 0 aufgefüllt; beim arithmetischen Rechtsshift werden die hohen Bits links mit dem Vorzeichenbit aufgefüllt, um die Korrektheit des Werts nach der Skalierung sicherzustellen.
Beispiel
B = 4'b0010 ;
A = A >> 2 ; // Ergebnis ist 4'b0011
A = A << 1; // Ergebnis ist 4'b1000
A = A <<< 1 ; // Ergebnis ist 4'b1000
C = B + (A>>>2); // Ergebnis ist 2 + (-4/4) = 1, 4'b0001
Verkettungsoperator
Der Verkettungsoperator verwendet geschweifte Klammern{,}, um mehrere Operanden (Vektoren) zu einem neuen Operanden (Vektor) zu verketten, wobei die Signale durch Kommas getrennt werden.
Die Operanden des Verkettungsoperators müssen eine Bitbreite angeben; auch Konstanten müssen eine Bitbreite angeben. Zum Beispiel:
Beispiel
B = 1'b1 ;
Y1 = {B, A[3:2], A[0], 4'h3 }; //Das Ergebnis ist Y1='b1100_0011
Y2 = {4{B}, 3'd4}; //Das Ergebnis ist Y2=7'b111_1100
Y3 = {32{1'b0}}; //Das Ergebnis ist Y3=32h0, wird häufig als eine zur Bitbreite passende Initialwertzuweisung während der Registerinitialisierung verwendet
Bedingter Operator
Ein bedingter Ausdruck hat 3 Operanden und ist wie folgt aufgebaut:
condition_expression ? true_expression : false_expression
Während der Auswertung, wenn condition_expression wahr ist (logischer Wert 1), ist das Operationsergebnis true_expression; wenn condition_expression falsch ist (logischer Wert 0), ist das Auswertungsergebnis false_expression.
assign hsel = (addr[9:8] == 2'b0) ? hsel_p1 : hsel_p2 ; //当信号 addr 高 2bit 为 0 时,hsel 赋值为 hsel_p1; 否则,将 hsel_p2 赋值给 hsel。
Tatsächlich ähnelt ein bedingter Ausdruck einem 2-Wege- (oder Mehrwege-)Selektor, und seine Beschreibung kann vollständig durch if-else-Anweisungen ersetzt werden.
Natürlich können bedingte Operatoren auch verschachtelt werden, um eine Mehrfachauswahl-Logik zu implementieren. Zum Beispiel:
Beispiel
(addr[9:8] == 2'b01) ? hsel_p2 :
(addr[9:8] == 2'b10) ? hsel_p3 :
(addr[9:8] == 2'b11) ? hsel_p4 ;