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

a^b ;          // XOR-Operation auf a und b
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

module test;

// 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.

OperatorSymbolRangfolge
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 [3:0]  a, b;
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

b = 4'b100x ;
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 [3:0]        mula ;
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

mula = -4'd4 ;
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

A = 4 ;
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

A = 4 ;
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

A = 3;
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)01x || (ODER)01x
0000 001x
101x 1111
x0xx xx1x
^ (XOR)01x ~^ (XNOR)01x
001x 010x
110x 101x
xxxx xxxx

Beispiel

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

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

A = 4'b1100 ;
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

A = 4'b1010 ;
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

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 ;