Qual è la differenza tra Verilog! e ~?

Question

Quindi è finito che il bug che mi aveva tenuto acceso per giorni, era una sezione di codice che avrebbe dovuto valutare False valutando True. Il mio codice iniziale andato qualcosa di simile:

if(~x && ~y) begin 
    //do stuff 
end 

vale a dire se x non è uno e Y non è uno poi fare cose. Passando attraverso il debugger, mi sono reso conto anche se x era 1 l'espressione nell'istruzione if risultava ancora in TRUE e il codice successivo veniva eseguito.

Tuttavia, quando ho cambiato la dichiarazione:

if(x == 0 && y == 0) begin 
//do stuff 
end 

e anche provato:

if(!x && !y) begin 
//do stuff 
end 

il codice all'interno del se-dichiarazione non è stato valutato che è stato il comportamento previsto. Capisco che ~ è una negazione per bit e! una negazione logica, ma non dovrebbe (~ x & & ~ y) e (! x & &! y) valutare la stessa cosa? Temo che il codebase sia troppo grande, quindi non posso incollarlo qui, ma questa è stata l'unica modifica che ho apportato per far funzionare il codice come volevo. Grazie.

---

In risposta, ad uno dei commenti qui sotto, ho creato un test-case per verificare questo comportamento:

`scala cronologica 10ns/1ns

modulo test_negation();

integer x, y; 

initial begin 
    x = 1; y = 0; 

    if(~x && ~y) begin 
     $display("%s", "First case executed"); 
    end 

    if(!x && !y) begin 
     $display("%s", "Second case executed"); 
    end 

    if(x == 0 && y == 0) begin 
     $display("%s", "Third case executed"); 
    end 
end endmodule 

e stranamente, "Primo caso eseguito" viene stampato per confermare il comportamento originale ho osservato.

Answer 1

Il simbolo ! rappresenta la negazione booleana o logica. Per qualsiasi valore di x diverso da zero, !x viene valutato su zero o falso e quando x è zero, !x viene valutato su uno o su true.

Il simbolo ~ rappresenta la negazione bit a bit. Ogni bit del valore viene commutato, quindi per un x == 0xA5A5 a 16 bit, ~x valuterà a 0x5A5A.

Il condizionale if() prevede un'espressione che restituisce true o false, dove qualsiasi valore diverso da zero (positivo o negativo) è true e zero è false.

Il && è un AND logico. Richiede due espressioni, valutando una o una vera se e solo se entrambe le espressioni sono vere. Di nuovo, "vero" qui significa diverso da zero, positivo o negativo.

Dato tutto questo, possiamo vedere che l'unica volta che ~x e !x valutare allo stesso valore è quando x == -1, oppure, se non è firmato x, quando x == MAX_UNSIGNED.

Answer 2

~ è un operatore bit-saggio e restituisce l'inverso dell'argomento.

! è un operatore logico e restituisce un singolo bit.

Esempio:

reg [7:0] bit_wise, logic_op; 
initial begin 
    bit_wise = ~8'hA1; // bit_wise == 8'h6E 
    logic_op = !8'hA1; // logic_op == 8'b00 
    $display("bit_wise:%h logic_op:%h", bit_wise, logic_op); // bit_wise:5e logic_op:00 
end 

Per esempio:

if(~x && ~y) begin 
    //do stuff 
end 

è effettivamente la stessa:

if(x!='1 && y!='1) begin // '1 means the with of x all 1s and the with of y all 1s 
    //do stuff 
end 

Generalmente il migliore stile di codifica è quello di utilizzare gli operatori logici all'interno if . Utilizzare solo operatori bit-bit con manipolazioni di assegnazione dati.

Answer 3

Vedo. La variabile "x" nel codice precedente era un intero Verilog (integer x;). Tuttavia, una variabile numero intero è rappresentata da Verilog come numero intero a 32 bit. Quindi anche se x era "1" come avevo osservato, ~ x non produrrà "0" ma in "111111111111111111111111111111111110"! E quindi non sorprende che sia stato eseguito il primo caso. Colpa mia. Grazie per tutte le risposte.