tests/simple/operators.v

   1 module optest(clk, mode, u1, s1, u2, s2, y);
   2
   3 input clk;
   4 input [6:0] mode;
   5
   6 input [3:0] u1, u2;
   7 input signed [3:0] s1, s2;
   8
   9 output reg [7:0] y;
  10
  11 always @(posedge clk) begin
  12         y <= 8'h42;
  13         case (mode)
  14                  0: y <= u1 << u2;
  15                  1: y <= u1 << s2;
  16                  2: y <= s1 << u2;
  17                  3: y <= s1 << s2;
  18
  19                  4: y <= u1 >> u2;
  20                  5: y <= u1 >> s2;
  21                  6: y <= s1 >> u2;
  22                  7: y <= s1 >> s2;
  23
  24                  8: y <= u1 <<< u2;
  25                  9: y <= u1 <<< s2;
  26                 10: y <= s1 <<< u2;
  27                 11: y <= s1 <<< s2;
  28
  29                 12: y <= u1 >>> u2;
  30                 13: y <= u1 >>> s2;
  31                 14: y <= s1 >>> u2;
  32                 15: y <= s1 >>> s2;
  33
  34                 16: y <= u1 < u2;
  35                 17: y <= u1 < s2;
  36                 18: y <= s1 < u2;
  37                 19: y <= s1 < s2;
  38
  39                 20: y <= u1 <= u2;
  40                 21: y <= u1 <= s2;
  41                 22: y <= s1 <= u2;
  42                 23: y <= s1 <= s2;
  43
  44                 24: y <= u1 == u2;
  45                 25: y <= u1 == s2;
  46                 26: y <= s1 == u2;
  47                 27: y <= s1 == s2;
  48
  49                 28: y <= u1 != u2;
  50                 29: y <= u1 != s2;
  51                 30: y <= s1 != u2;
  52                 31: y <= s1 != s2;
  53
  54                 32: y <= u1 >= u2;
  55                 33: y <= u1 >= s2;
  56                 34: y <= s1 >= u2;
  57                 35: y <= s1 >= s2;
  58
  59                 36: y <= u1 > u2;
  60                 37: y <= u1 > s2;
  61                 38: y <= s1 > u2;
  62                 39: y <= s1 > s2;
  63
  64                 40: y <= u1 + u2;
  65                 41: y <= u1 + s2;
  66                 42: y <= s1 + u2;
  67                 43: y <= s1 + s2;
  68
  69                 44: y <= u1 - u2;
  70                 45: y <= u1 - s2;
  71                 46: y <= s1 - u2;
  72                 47: y <= s1 - s2;
  73
  74                 48: y <= u1 * u2;
  75                 49: y <= u1 * s2;
  76                 50: y <= s1 * u2;
  77                 51: y <= s1 * s2;
  78
  79                 52: y <= u1 / u2;
  80                 53: y <= u1 / s2;
  81                 54: y <= s1 / u2;
  82                 55: y <= s1 / s2;
  83
  84                 56: y <= u1 % u2;
  85                 57: y <= u1 % s2;
  86                 58: y <= s1 % u2;
  87                 59: y <= s1 % s2;
  88
  89                 60: y <= 4'd2 ** u1;
  90                 61: y <= 4'd2 ** s1;
  91                 62: y <= 4'sd2 ** u1;
  92                 63: y <= 4'sd2 ** s1;
  93
  94                 64: y <= +u1;
  95                 65: y <= -u1;
  96                 66: y <= ~u1;
  97                 67: y <= !u1;
  98
  99                 68: y <= +s1;
 100                 69: y <= -s1;
 101                 70: y <= ~s1;
 102                 71: y <= !s1;
 103
 104                 72: y <= { &u1, ~&u1, |u1, ~|u1, ^u1, ~^u1, ^~u1 };
 105                 73: y <= { &s1, ~&s1, |s1, ~|s1, ^s1, ~^s1, ^~s1 };
 106                 74: y <= { &u1[1:0], ~&u1[1:0], |u1[1:0], ~|u1[1:0], ^u1[1:0], ~^u1[1:0], ^~u1[1:0] };
 107                 75: y <= { &s1[1:0], ~&s1[1:0], |s1[1:0], ~|s1[1:0], ^s1[1:0], ~^s1[1:0], ^~s1[1:0] };
 108
 109                 76: y <= { u1[1:0] && u2[1:0], u1[1:0] && u2[1:0], !u1[1:0] };
 110                 77: y <= {4{u1[1:0]}};
 111                 78: y <= {u1, u2} ^ {s1, s2};
 112                 79: y <= {u1, u2} & {s1, s2};
 113
 114                 80: y <= u1[0] ? u1 : u2;
 115                 81: y <= u1[0] ? u1 : s2;
 116                 82: y <= u1[0] ? s1 : u2;
 117                 83: y <= u1[0] ? s1 : s2;
 118         endcase
 119 end
 120
 121 endmodule