dlx/bv_test-bench.vhdl

    1 --------------------------------------------------------------------------
    2 --
    3 --  Copyright (C) 1993, Peter J. Ashenden
    4 --  Mail:	Dept. Computer Science
    5 --		University of Adelaide, SA 5005, Australia
    6 --  e-mail:	petera@cs.adelaide.edu.au
    7 --
    8 --  This program is free software; you can redistribute it and/or modify
    9 --  it under the terms of the GNU General Public License as published by
   10 --  the Free Software Foundation; either version 1, or (at your option)
   11 --  any later version.
   12 --
   13 --  This program is distributed in the hope that it will be useful,
   14 --  but WITHOUT ANY WARRANTY; without even the implied warranty of
   15 --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   16 --  GNU General Public License for more details.
   17 --
   18 --  You should have received a copy of the GNU General Public License
   19 --  along with this program; if not, write to the Free Software
   20 --  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   21 --
   22 --------------------------------------------------------------------------
   23 --
   24 --  $RCSfile: bv_test-bench.vhdl,v $  $Revision: 1.1 $  $Date: 2000/05/08 14:36:47 $
   25 --
   26 --------------------------------------------------------------------------
   27 --
   28 --  Architecture for test bench for bit vector arithmetic package.
   29 --
   30 
   31 
   32 use std.textio.all, work.bv_arithmetic.all;
   33 
   34 architecture bench of bv_test is
   35 
   36 begin
   37 
   38   process
   39 
   40     variable L : line;
   41     variable byte : bit_vector(0 to 7);
   42     variable word : bit_vector(1 to 32);
   43     variable half_byte : bit_vector(1 to 4);
   44     variable overflow, div_by_zero, result : boolean;
   45 
   46   begin
   47     WAIT for 1 ns;
   48 
   49     ----------------------------------------------------------------
   50     ----------------------------------------------------------------
   51     -- test bit_vector to numeric conversions
   52     ----------------------------------------------------------------
   53     ----------------------------------------------------------------
   54 
   55     write(L, string'("Testing bv_to_natural:"));
   56     writeline(output, L);
   57 
   58     write(L, string'("  bv_to_natural(X""02"") = "));
   59     write(L, bv_to_natural(X"02"));
   60     writeline(output, L);
   61     assert bv_to_natural(X"02") = 2;
   62 
   63     write(L, string'("  bv_to_natural(X""FE"") = "));
   64     write(L, bv_to_natural(X"FE"));
   65     writeline(output, L);
   66     assert bv_to_natural(X"FE") = 254;
   67 
   68     ----------------------------------------------------------------
   69 
   70     write(L, string'("Testing natural_to_bv:"));
   71     writeline(output, L);
   72 
   73     write(L, string'("  natural_to_bv(2) = "));
   74     write(L, natural_to_bv(2, 8));
   75     writeline(output, L);
   76     assert natural_to_bv(2, 8) = X"02";
   77 
   78     write(L, string'("  natural_to_bv(254) = "));
   79     write(L, natural_to_bv(254, 8));
   80     writeline(output, L);
   81     assert natural_to_bv(254, 8) = X"FE";
   82 
   83     ----------------------------------------------------------------
   84 
   85     write(L, string'("Testing bv_to_integer:"));
   86     writeline(output, L);
   87 
   88     write(L, string'("  bv_to_integer(X""02"") = "));
   89     write(L, bv_to_integer(X"02"));
   90     writeline(output, L);
   91     assert bv_to_integer(X"02") = 2;
   92 
   93     write(L, string'("  bv_to_integer(X""FE"") = "));
   94     write(L, bv_to_integer(X"FE"));
   95     writeline(output, L);
   96     assert bv_to_integer(X"FE") = -2;
   97 
   98     ----------------------------------------------------------------
   99 
  100     write(L, string'("Testing integer_to_bv:"));
  101     writeline(output, L);
  102 
  103     write(L, string'("  integer_to_bv(2) = "));
  104     write(L, integer_to_bv(2, 8));
  105     writeline(output, L);
  106     assert integer_to_bv(2, 8) = X"02";
  107 
  108     write(L, string'("  integer_to_bv(-2) = "));
  109     write(L, integer_to_bv(-2, 8));
  110     writeline(output, L);
  111     assert integer_to_bv(-2, 8) = X"FE";
  112 
  113 
  114     ----------------------------------------------------------------
  115     ----------------------------------------------------------------
  116     --  Arithmetic operations
  117     ----------------------------------------------------------------
  118     ----------------------------------------------------------------
  119 
  120     ----------------------------------------------------------------
  121     -- bv_add: Signed addition with overflow detection
  122     ----------------------------------------------------------------
  123 
  124     writeline(output, L);
  125     write(L, string'("Testing bv_add with overflow:"));
  126     writeline(output, L);
  127 
  128     write(L, string'("  2+2 = "));
  129     bv_add(X"02", X"02", byte, overflow);
  130     write(L, byte);
  131     write(L, string'(", overflow = "));  write(L, overflow);
  132     writeline(output, L);
  133     assert byte = X"04" and not overflow;
  134 
  135     write(L, string'("  2+(-3) = "));
  136     bv_add(X"02", X"FD", byte, overflow);
  137     write(L, byte);
  138     write(L, string'(", overflow = "));  write(L, overflow);
  139     writeline(output, L);
  140     assert byte = X"FF" and not overflow;
  141 
  142     write(L, string'("  64+64 = "));
  143     bv_add(X"40", X"40", byte, overflow);
  144     write(L, byte);
  145     write(L, string'(", overflow = "));  write(L, overflow);
  146     writeline(output, L);
  147     assert byte = X"80" and overflow;
  148 
  149     write(L, string'("  -64+(-64) = "));
  150     bv_add(X"C0", X"C0", byte, overflow);
  151     write(L, byte);
  152     write(L, string'(", overflow = "));  write(L, overflow);
  153     writeline(output, L);
  154     assert byte = X"80" and not overflow;
  155 
  156     ----------------------------------------------------------------
  157     -- "+": Signed addition without overflow detection
  158     ----------------------------------------------------------------
  159 
  160     writeline(output, L);
  161     write(L, string'("Testing ""+"" without overflow:"));
  162     writeline(output, L);
  163 
  164     write(L, string'("  2+2 = "));
  165     byte := X"02" + X"02";
  166     write(L, byte);
  167     writeline(output, L);
  168     assert byte = X"04";
  169 
  170     write(L, string'("  2+(-3) = "));
  171     byte := X"02" + X"FD";
  172     write(L, byte);
  173     writeline(output, L);
  174     assert byte = X"FF";
  175 
  176     write(L, string'("  64+64 = "));
  177     byte := X"40" + X"40";
  178     write(L, byte);
  179     writeline(output, L);
  180     assert byte = X"80";
  181 
  182     write(L, string'("  -64+(-64) = "));
  183     byte := X"C0" + X"C0";
  184     write(L, byte);
  185     writeline(output, L);
  186     assert byte = X"80";
  187 
  188     ----------------------------------------------------------------
  189     -- bv_sub: Signed subtraction with overflow detection
  190     ----------------------------------------------------------------
  191 
  192     writeline(output, L);
  193     write(L, string'("Testing bv_sub with overflow:"));
  194     writeline(output, L);
  195 
  196     write(L, string'("  2-2 = "));
  197     bv_sub(X"02", X"02", byte, overflow);
  198     write(L, byte);
  199     write(L, string'(", overflow = "));  write(L, overflow);
  200     writeline(output, L);
  201     assert byte = X"00" and not overflow;
  202 
  203     write(L, string'("  2-(-3) = "));
  204     bv_sub(X"02", X"FD", byte, overflow);
  205     write(L, byte);
  206     write(L, string'(", overflow = "));  write(L, overflow);
  207     writeline(output, L);
  208     assert byte = X"05" and not overflow;
  209 
  210     write(L, string'("  64-(-64) = "));
  211     bv_sub(X"40", X"C0", byte, overflow);
  212     write(L, byte);
  213     write(L, string'(", overflow = "));  write(L, overflow);
  214     writeline(output, L);
  215     assert byte = X"80" and overflow;
  216 
  217     write(L, string'("  -64-64 = "));
  218     bv_sub(X"C0", X"40", byte, overflow);
  219     write(L, byte);
  220     write(L, string'(", overflow = "));  write(L, overflow);
  221     writeline(output, L);
  222     assert byte = X"80" and not overflow;
  223 
  224     ----------------------------------------------------------------
  225     -- "-": Signed subtraction without overflow detection
  226     ----------------------------------------------------------------
  227 
  228     writeline(output, L);
  229     write(L, string'("Testing ""-"" without overflow:"));
  230     writeline(output, L);
  231 
  232     write(L, string'("  2-2 = "));
  233     byte := X"02" - X"02";
  234     write(L, byte);
  235     writeline(output, L);
  236     assert byte = X"00";
  237 
  238     write(L, string'("  2-(-3) = "));
  239     byte := X"02" - X"FD";
  240     write(L, byte);
  241     writeline(output, L);
  242     assert byte = X"05";
  243 
  244     write(L, string'("  64-(-64) = "));
  245     byte := X"40" - X"C0";
  246     write(L, byte);
  247     writeline(output, L);
  248     assert byte = X"80";
  249 
  250     write(L, string'("  -64-64 = "));
  251     byte := X"C0" - X"40";
  252     write(L, byte);
  253     writeline(output, L);
  254     assert byte = X"80";
  255 
  256     ----------------------------------------------------------------
  257     -- bv_addu:  Unsigned addition with overflow detection
  258     ----------------------------------------------------------------
  259 
  260     writeline(output, L);
  261     write(L, string'("Testing bv_addu with overflow:"));
  262     writeline(output, L);
  263 
  264     write(L, string'("  2+2 = "));
  265     bv_addu(X"02", X"02", byte, overflow);
  266     write(L, byte);
  267     write(L, string'(", overflow = "));  write(L, overflow);
  268     writeline(output, L);
  269     assert byte = X"04" and not overflow;
  270 
  271     write(L, string'("  64+64 = "));
  272     bv_addu(X"40", X"40", byte, overflow);
  273     write(L, byte);
  274     write(L, string'(", overflow = "));  write(L, overflow);
  275     writeline(output, L);
  276     assert byte = X"80" and not overflow;
  277 
  278     write(L, string'("  128+128 = "));
  279     bv_addu(X"80", X"80", byte, overflow);
  280     write(L, byte);
  281     write(L, string'(", overflow = "));  write(L, overflow);
  282     writeline(output, L);
  283     assert byte = X"00" and overflow;
  284 
  285     ----------------------------------------------------------------
  286     -- bv_addu: Unsigned addition without overflow detection
  287     ----------------------------------------------------------------
  288 
  289     writeline(output, L);
  290     write(L, string'("Testing bv_addu without overflow:"));
  291     writeline(output, L);
  292 
  293     write(L, string'("  2+2 = "));
  294     bv_addu(X"02", X"02", byte);
  295     write(L, byte);
  296     writeline(output, L);
  297     assert byte = X"04";
  298 
  299     write(L, string'("  64+64 = "));
  300     bv_addu(X"40", X"40", byte);
  301     write(L, byte);
  302     writeline(output, L);
  303     assert byte = X"80";
  304 
  305     write(L, string'("  128+128 = "));
  306     bv_addu(X"80", X"80", byte);
  307     write(L, byte);
  308     writeline(output, L);
  309     assert byte = X"00";
  310 
  311     ----------------------------------------------------------------
  312     -- bv_subu: Unsigned subtraction with overflow detection
  313     ----------------------------------------------------------------
  314 
  315     writeline(output, L);
  316     write(L, string'("Testing bv_subu with overflow:"));
  317     writeline(output, L);
  318 
  319     write(L, string'("  3-2 = "));
  320     bv_subu(X"03", X"02", byte, overflow);
  321     write(L, byte);
  322     write(L, string'(", overflow = "));  write(L, overflow);
  323     writeline(output, L);
  324     assert byte = X"01" and not overflow;
  325 
  326     write(L, string'("  64-64 = "));
  327     bv_subu(X"40", X"40", byte, overflow);
  328     write(L, byte);
  329     write(L, string'(", overflow = "));  write(L, overflow);
  330     writeline(output, L);
  331     assert byte = X"00" and not overflow;
  332 
  333     write(L, string'("  64-128 = "));
  334     bv_subu(X"40", X"80", byte, overflow);
  335     write(L, byte);
  336     write(L, string'(", overflow = "));  write(L, overflow);
  337     writeline(output, L);
  338     assert byte = X"C0" and overflow;
  339 
  340     ----------------------------------------------------------------
  341     -- bv_subu: Unsigned subtraction without overflow detection
  342     ----------------------------------------------------------------
  343 
  344     writeline(output, L);
  345     write(L, string'("Testing bv_subu without overflow:"));
  346     writeline(output, L);
  347 
  348     write(L, string'("  3-2 = "));
  349     bv_subu(X"03", X"02", byte);
  350     write(L, byte);
  351     writeline(output, L);
  352     assert byte = X"01";
  353 
  354     write(L, string'("  64-64 = "));
  355     bv_subu(X"40", X"40", byte);
  356     write(L, byte);
  357     writeline(output, L);
  358     assert byte = X"00";
  359 
  360     write(L, string'("  64-128 = "));
  361     bv_subu(X"40", X"80", byte);
  362     write(L, byte);
  363     writeline(output, L);
  364     assert byte = X"C0";
  365 
  366     ----------------------------------------------------------------
  367     -- bv_neg: Signed negation with overflow detection
  368     ----------------------------------------------------------------
  369 
  370     writeline(output, L);
  371     write(L, string'("Testing bv_neg with overflow:"));
  372     writeline(output, L);
  373 
  374     write(L, string'("  -(3) = "));
  375     bv_neg(X"03", byte, overflow);
  376     write(L, byte);
  377     write(L, string'(", overflow = "));  write(L, overflow);
  378     writeline(output, L);
  379     assert byte = X"FD" and not overflow;
  380 
  381     write(L, string'("  -(-3) = "));
  382     bv_neg(X"FD", byte, overflow);
  383     write(L, byte);
  384     write(L, string'(", overflow = "));  write(L, overflow);
  385     writeline(output, L);
  386     assert byte = X"03" and not overflow;
  387 
  388     write(L, string'("  -(127) = "));
  389     bv_neg(X"7F", byte, overflow);
  390     write(L, byte);
  391     write(L, string'(", overflow = "));  write(L, overflow);
  392     writeline(output, L);
  393     assert byte = X"81" and not overflow;
  394 
  395     write(L, string'("  -(-128) = "));
  396     bv_neg(X"80", byte, overflow);
  397     write(L, byte);
  398     write(L, string'(", overflow = "));  write(L, overflow);
  399     writeline(output, L);
  400     assert byte = X"80" and overflow;
  401 
  402     ----------------------------------------------------------------
  403     -- "-": Signed negation without overflow detection
  404     ----------------------------------------------------------------
  405 
  406     writeline(output, L);
  407     write(L, string'("Testing ""-"" without overflow:"));
  408     writeline(output, L);
  409 
  410     write(L, string'("  -(3) = "));
  411     byte := - X"03";
  412     write(L, byte);
  413     writeline(output, L);
  414     assert byte = X"FD";
  415 
  416     write(L, string'("  -(-3) = "));
  417     byte := - X"FD";
  418     write(L, byte);
  419     writeline(output, L);
  420     assert byte = X"03";
  421 
  422     write(L, string'("  -(127) = "));
  423     byte := - X"7F";
  424     write(L, byte);
  425     writeline(output, L);
  426     assert byte = X"81";
  427 
  428     write(L, string'("  -(-128) = "));
  429     byte := - X"80";
  430     write(L, byte);
  431     writeline(output, L);
  432     assert byte = X"80";
  433 
  434     ----------------------------------------------------------------
  435     -- bv_mult: Signed multiplication with overflow detection
  436     ----------------------------------------------------------------
  437 
  438     writeline(output, L);
  439     write(L, string'("Testing bv_mult with overflow:"));
  440     writeline(output, L);
  441 
  442     write(L, string'("  5*(-3) = "));
  443     bv_mult(X"05", X"FD", byte, overflow);
  444     write(L, byte);
  445     write(L, string'(", overflow = "));  write(L, overflow);
  446     writeline(output, L);
  447     assert byte = X"F1" and not overflow;
  448 
  449     write(L, string'("  (-5)*(-3) = "));
  450     bv_mult(X"FB", X"FD", byte, overflow);
  451     write(L, byte);
  452     write(L, string'(", overflow = "));  write(L, overflow);
  453     writeline(output, L);
  454     assert byte = X"0F" and not overflow;
  455 
  456     write(L, string'("  16*8 = "));
  457     bv_mult(X"10", X"08", byte, overflow);
  458     write(L, byte);
  459     write(L, string'(", overflow = "));  write(L, overflow);
  460     writeline(output, L);
  461     assert byte = X"80" and overflow;
  462 
  463     write(L, string'("  16*16 = "));
  464     bv_mult(X"10", X"10", byte, overflow);
  465     write(L, byte);
  466     write(L, string'(", overflow = "));  write(L, overflow);
  467     writeline(output, L);
  468     assert byte = X"00" and overflow;
  469 
  470     write(L, string'("  16*(-8) = "));
  471     bv_mult(X"10", X"F8", byte, overflow);
  472     write(L, byte);
  473     write(L, string'(", overflow = "));  write(L, overflow);
  474     writeline(output, L);
  475     assert byte = X"80" and not overflow;
  476 
  477     write(L, string'("  16*(-16) = "));
  478     bv_mult(X"10", X"F0", byte, overflow);
  479     write(L, byte);
  480     write(L, string'(", overflow = "));  write(L, overflow);
  481     writeline(output, L);
  482     assert byte = X"00" and overflow;
  483 
  484     ----------------------------------------------------------------
  485     -- "*":  Signed multiplication without overflow detection
  486     ----------------------------------------------------------------
  487 
  488     writeline(output, L);
  489     write(L, string'("Testing ""*"" without overflow:"));
  490     writeline(output, L);
  491 
  492     write(L, string'("  5*(-3) = "));
  493     byte := X"05" * X"FD";
  494     write(L, byte);
  495     writeline(output, L);
  496     assert byte = X"F1";
  497 
  498     write(L, string'("  (-5)*(-3) = "));
  499     byte := X"FB" * X"FD";
  500     write(L, byte);
  501     writeline(output, L);
  502     assert byte = X"0F";
  503 
  504     write(L, string'("  16*8 = "));
  505     byte := X"10" * X"08";
  506     write(L, byte);
  507     writeline(output, L);
  508     assert byte = X"80";
  509 
  510     write(L, string'("  16*16 = "));
  511     byte := X"10" * X"10";
  512     write(L, byte);
  513     writeline(output, L);
  514     assert byte = X"00";
  515 
  516     write(L, string'("  16*(-8) = "));
  517     byte := X"10" * X"F8";
  518     write(L, byte);
  519     writeline(output, L);
  520     assert byte = X"80";
  521 
  522     write(L, string'("  16*(-16) = "));
  523     byte := X"10" * X"F0";
  524     write(L, byte);
  525     writeline(output, L);
  526     assert byte = X"00";
  527 
  528     ----------------------------------------------------------------
  529     -- bv_multu:  Unsigned multiplication with overflow detection
  530     ----------------------------------------------------------------
  531 
  532     writeline(output, L);
  533     write(L, string'("Testing bv_multu with overflow:"));
  534     writeline(output, L);
  535 
  536     write(L, string'("  5*7 = "));
  537     bv_multu(X"05", X"07", byte, overflow);
  538     write(L, byte);
  539     write(L, string'(", overflow = "));  write(L, overflow);
  540     writeline(output, L);
  541     assert byte = X"23" and not overflow;
  542 
  543     write(L, string'("  16*8 = "));
  544     bv_multu(X"10", X"08", byte, overflow);
  545     write(L, byte);
  546     write(L, string'(", overflow = "));  write(L, overflow);
  547     writeline(output, L);
  548     assert byte = X"80" and not overflow;
  549 
  550     write(L, string'("  16*16 = "));
  551     bv_multu(X"10", X"10", byte, overflow);
  552     write(L, byte);
  553     write(L, string'(", overflow = "));  write(L, overflow);
  554     writeline(output, L);
  555     assert byte = X"00" and overflow;
  556 
  557     ----------------------------------------------------------------
  558     --  bv_multu: Unsigned multiplication without overflow detection
  559     ----------------------------------------------------------------
  560 
  561     writeline(output, L);
  562     write(L, string'("Testing bv_multu without overflow:"));
  563     writeline(output, L);
  564 
  565     write(L, string'("  5*7 = "));
  566     bv_multu(X"05", X"07", byte);
  567     write(L, byte);
  568     writeline(output, L);
  569     assert byte = X"23";
  570 
  571     write(L, string'("  16*8 = "));
  572     bv_multu(X"10", X"08", byte);
  573     write(L, byte);
  574     writeline(output, L);
  575     assert byte = X"80";
  576 
  577     write(L, string'("  16*16 = "));
  578     bv_multu(X"10", X"10", byte);
  579     write(L, byte);
  580     writeline(output, L);
  581     assert byte = X"00";
  582 
  583     ----------------------------------------------------------------
  584     -- bv_div: Signed division with divide by zero and overflow detection
  585     ----------------------------------------------------------------
  586 
  587     writeline(output, L);
  588     write(L, string'("Testing bv_div with flags:"));
  589     writeline(output, L);
  590 
  591     write(L, string'("  7/2 = "));
  592     bv_div(X"07", X"02", byte, div_by_zero, overflow);
  593     write(L, byte);
  594     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  595     write(L, string'(", overflow = "));  write(L, overflow);
  596     writeline(output, L);
  597     assert byte = X"03" and not div_by_zero and not overflow;
  598 
  599     write(L, string'("  -7/2 = "));
  600     bv_div(X"F9", X"02", byte, div_by_zero, overflow);
  601     write(L, byte);
  602     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  603     write(L, string'(", overflow = "));  write(L, overflow);
  604     writeline(output, L);
  605     assert byte = X"FD" and not div_by_zero and not overflow;
  606 
  607     write(L, string'("  7/-2 = "));
  608     bv_div(X"07", X"FE", byte, div_by_zero, overflow);
  609     write(L, byte);
  610     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  611     write(L, string'(", overflow = "));  write(L, overflow);
  612     writeline(output, L);
  613     assert byte = X"FD" and not div_by_zero and not overflow;
  614 
  615     write(L, string'("  -7/-2 = "));
  616     bv_div(X"F9", X"FE", byte, div_by_zero, overflow);
  617     write(L, byte);
  618     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  619     write(L, string'(", overflow = "));  write(L, overflow);
  620     writeline(output, L);
  621     assert byte = X"03" and not div_by_zero and not overflow;
  622 
  623     write(L, string'("  -128/1 = "));
  624     bv_div(X"80", X"01", byte, div_by_zero, overflow);
  625     write(L, byte);
  626     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  627     write(L, string'(", overflow = "));  write(L, overflow);
  628     writeline(output, L);
  629     assert byte = X"80" and not div_by_zero and not overflow;
  630 
  631     write(L, string'("  -128/-1 = "));
  632     bv_div(X"80", X"FF", byte, div_by_zero, overflow);
  633     write(L, byte);
  634     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  635     write(L, string'(", overflow = "));  write(L, overflow);
  636     writeline(output, L);
  637     assert byte = X"80" and not div_by_zero and overflow;
  638 
  639     write(L, string'("  -16/0 = "));
  640     bv_div(X"F0", X"00", byte, div_by_zero, overflow);
  641     write(L, byte);
  642     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  643     write(L, string'(", overflow = "));  write(L, overflow);
  644     writeline(output, L);
  645     assert byte = X"00" and div_by_zero and not overflow;
  646 
  647     ----------------------------------------------------------------
  648     -- "/": Signed division without divide by zero and overflow detection
  649     ----------------------------------------------------------------
  650 
  651     writeline(output, L);
  652     write(L, string'("Testing ""/"" without flags:"));
  653     writeline(output, L);
  654 
  655     write(L, string'("  7/2 = "));
  656     byte := X"07" / X"02";
  657     write(L, byte);
  658     writeline(output, L);
  659     assert byte = X"03";
  660 
  661     write(L, string'("  -7/2 = "));
  662     byte := X"F9" / X"02";
  663     write(L, byte);
  664     writeline(output, L);
  665     assert byte = X"FD";
  666 
  667     write(L, string'("  7/-2 = "));
  668     byte := X"07" / X"FE";
  669     write(L, byte);
  670     writeline(output, L);
  671     assert byte = X"FD";
  672 
  673     write(L, string'("  -7/-2 = "));
  674     byte := X"F9" / X"FE";
  675     write(L, byte);
  676     writeline(output, L);
  677     assert byte = X"03";
  678 
  679     write(L, string'("  -128/1 = "));
  680     byte := X"80" / X"01";
  681     write(L, byte);
  682     writeline(output, L);
  683     assert byte = X"80";
  684 
  685     write(L, string'("  -128/-1 = "));
  686     byte := X"80" / X"FF";
  687     write(L, byte);
  688     writeline(output, L);
  689     assert byte = X"80";
  690 
  691     write(L, string'("  -16/0 = "));
  692     byte := X"F0" / X"00";
  693     write(L, byte);
  694     writeline(output, L);
  695     assert byte = X"00";
  696 
  697     ----------------------------------------------------------------
  698     -- bv_divu: Unsigned division with divide by zero detection
  699     ----------------------------------------------------------------
  700 
  701     writeline(output, L);
  702     write(L, string'("Testing bv_divu with flag:"));
  703     writeline(output, L);
  704 
  705     write(L, string'("  7/2 = "));
  706     bv_divu(X"07", X"02", byte, div_by_zero);
  707     write(L, byte);
  708     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  709     writeline(output, L);
  710     assert byte = X"03" and not div_by_zero;
  711 
  712     write(L, string'("  14/7 = "));
  713     bv_divu(X"0E", X"07", byte, div_by_zero);
  714     write(L, byte);
  715     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  716     writeline(output, L);
  717     assert byte = X"02" and not div_by_zero;
  718 
  719     write(L, string'("  16/1 = "));
  720     bv_divu(X"10", X"01", byte, div_by_zero);
  721     write(L, byte);
  722     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  723     writeline(output, L);
  724     assert byte = X"10" and not div_by_zero;
  725 
  726     write(L, string'("  16/0 = "));
  727     bv_divu(X"10", X"00", byte, div_by_zero);
  728     write(L, byte);
  729     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  730     writeline(output, L);
  731     assert byte = X"10" and div_by_zero;
  732 
  733     write(L, string'("  16/16 = "));
  734     bv_divu(X"10", X"10", byte, div_by_zero);
  735     write(L, byte);
  736     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  737     writeline(output, L);
  738     assert byte = X"01" and not div_by_zero;
  739 
  740     write(L, string'("  1/16 = "));
  741     bv_divu(X"01", X"10", byte, div_by_zero);
  742     write(L, byte);
  743     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  744     writeline(output, L);
  745     assert byte = X"00" and not div_by_zero;
  746 
  747     write(L, string'("  255/1 = "));
  748     bv_divu(X"FF", X"01", byte, div_by_zero);
  749     write(L, byte);
  750     write(L, string'(", div_by_zero = "));  write(L, div_by_zero);
  751     writeline(output, L);
  752     assert byte = X"FF" and not div_by_zero;
  753 
  754     ----------------------------------------------------------------
  755     -- bv_divu: Unsigned division without divide by zero detection
  756     ----------------------------------------------------------------
  757 
  758     writeline(output, L);
  759     write(L, string'("Testing bv_divu without flag:"));
  760     writeline(output, L);
  761 
  762     write(L, string'("  7/2 = "));
  763     bv_divu(X"07", X"02", byte);
  764     write(L, byte);
  765     writeline(output, L);
  766     assert byte = X"03";
  767 
  768     write(L, string'("  14/7 = "));
  769     bv_divu(X"0E", X"07", byte);
  770     write(L, byte);
  771     writeline(output, L);
  772     assert byte = X"02";
  773 
  774     write(L, string'("  16/1 = "));
  775     bv_divu(X"10", X"01", byte);
  776     write(L, byte);
  777     writeline(output, L);
  778     assert byte = X"10";
  779 
  780     write(L, string'("  16/0 = "));
  781     bv_divu(X"10", X"00", byte);
  782     write(L, byte);
  783     writeline(output, L);
  784     assert byte = X"10";
  785 
  786     write(L, string'("  16/16 = "));
  787     bv_divu(X"10", X"10", byte);
  788     write(L, byte);
  789     writeline(output, L);
  790     assert byte = X"01";
  791 
  792     write(L, string'("  1/16 = "));
  793     bv_divu(X"01", X"10", byte);
  794     write(L, byte);
  795     writeline(output, L);
  796     assert byte = X"00";
  797 
  798     write(L, string'("  255/1 = "));
  799     bv_divu(X"FF", X"01", byte);
  800     write(L, byte);
  801     writeline(output, L);
  802     assert byte = X"FF";
  803 
  804 
  805     ----------------------------------------------------------------
  806     ----------------------------------------------------------------
  807     --  Logical operators
  808     --  (Provided for VHDL-87, built in for VHDL-93)
  809     ----------------------------------------------------------------
  810     ----------------------------------------------------------------
  811 
  812     ----------------------------------------------------------------
  813     -- bv_sll: Shift left logical (fill with '0' bits)
  814     ----------------------------------------------------------------
  815 
  816     writeline(output, L);
  817     write(L, string'("Testing bv_sll:"));
  818     writeline(output, L);
  819 
  820     write(L, string'("  10100101 sll 4 = "));
  821     byte := bv_sll(B"10100101", 4);
  822     write(L, byte);
  823     writeline(output, L);
  824     assert byte = B"01010000";
  825 
  826     ----------------------------------------------------------------
  827     -- bv_srl: Shift right logical (fill with '0' bits)
  828     ----------------------------------------------------------------
  829 
  830     writeline(output, L);
  831     write(L, string'("Testing bv_srl:"));
  832     writeline(output, L);
  833 
  834     write(L, string'("  10100101 srl 4 = "));
  835     byte := bv_srl(B"10100101", 4);
  836     write(L, byte);
  837     writeline(output, L);
  838     assert byte = B"00001010";
  839 
  840     ----------------------------------------------------------------
  841     -- bv_sra: Shift right arithmetic (fill with copy of sign bit)
  842     ----------------------------------------------------------------
  843 
  844     writeline(output, L);
  845     write(L, string'("Testing bv_sra:"));
  846     writeline(output, L);
  847 
  848     write(L, string'("  01011010 sra 4 = "));
  849     byte := bv_sra(B"01011010", 4);
  850     write(L, byte);
  851     writeline(output, L);
  852     assert byte = B"00000101";
  853 
  854     write(L, string'("  10100101 sra 4 = "));
  855     byte := bv_sra(B"10100101", 4);
  856     write(L, byte);
  857     writeline(output, L);
  858     assert byte = B"11111010";
  859 
  860     ----------------------------------------------------------------
  861     -- bv_rol: Rotate left
  862     ----------------------------------------------------------------
  863 
  864     writeline(output, L);
  865     write(L, string'("Testing bv_rol:"));
  866     writeline(output, L);
  867 
  868     write(L, string'("  10100101 rol 3 = "));
  869     byte := bv_rol(B"10100101", 3);
  870     write(L, byte);
  871     writeline(output, L);
  872     assert byte = B"00101101";
  873 
  874     ----------------------------------------------------------------
  875     -- bv_rol: Rotate right
  876     ----------------------------------------------------------------
  877 
  878     writeline(output, L);
  879     write(L, string'("Testing bv_ror:"));
  880     writeline(output, L);
  881 
  882     write(L, string'("  10100101 ror 3 = "));
  883     byte := bv_ror(B"10100101", 3);
  884     write(L, byte);
  885     writeline(output, L);
  886     assert byte = B"10110100";
  887 
  888 
  889     ----------------------------------------------------------------
  890     ----------------------------------------------------------------
  891     --  Arithmetic comparison operators.
  892     ----------------------------------------------------------------
  893     ----------------------------------------------------------------
  894 
  895     ----------------------------------------------------------------
  896     -- bv_lt: Signed less than comparison
  897     ----------------------------------------------------------------
  898 
  899     writeline(output, L);
  900     write(L, string'("Testing bv_lt:"));
  901     writeline(output, L);
  902 
  903     write(L, string'("  2 < 2 = "));
  904     result := bv_lt(X"02", X"02");
  905     write(L, result);
  906     writeline(output, L);
  907     assert NOT result;
  908 
  909     write(L, string'("  2 < 3 = "));
  910     result := bv_lt(X"02", X"03");
  911     write(L, result);
  912     writeline(output, L);
  913     assert result;
  914 
  915     write(L, string'("  -2 < 2 = "));
  916     result := bv_lt(X"FE", X"02");
  917     write(L, result);
  918     writeline(output, L);
  919     assert result;
  920 
  921     write(L, string'("  2 < -3 = "));
  922     result := bv_lt(X"02", X"FD");
  923     write(L, result);
  924     writeline(output, L);
  925     assert NOT result;
  926 
  927     ----------------------------------------------------------------
  928     -- bv_le: Signed less than or equal comparison
  929     ----------------------------------------------------------------
  930 
  931     writeline(output, L);
  932     write(L, string'("Testing bv_le:"));
  933     writeline(output, L);
  934 
  935     write(L, string'("  2 <= 2 = "));
  936     result := bv_le(X"02", X"02");
  937     write(L, result);
  938     writeline(output, L);
  939     assert result;
  940 
  941     write(L, string'("  2 <= 3 = "));
  942     result := bv_le(X"02", X"03");
  943     write(L, result);
  944     writeline(output, L);
  945     assert result;
  946 
  947     write(L, string'("  -2 <= 2 = "));
  948     result := bv_le(X"FE", X"02");
  949     write(L, result);
  950     writeline(output, L);
  951     assert result;
  952 
  953     write(L, string'("  2 <= -3 = "));
  954     result := bv_le(X"02", X"FD");
  955     write(L, result);
  956     writeline(output, L);
  957     assert NOT result;
  958 
  959     ----------------------------------------------------------------
  960     -- bv_gt: Signed greater than comparison
  961     ----------------------------------------------------------------
  962 
  963     writeline(output, L);
  964     write(L, string'("Testing bv_gt:"));
  965     writeline(output, L);
  966 
  967     write(L, string'("  2 > 2 = "));
  968     result := bv_gt(X"02", X"02");
  969     write(L, result);
  970     writeline(output, L);
  971     assert NOT result;
  972 
  973     write(L, string'("  3 > 2 = "));
  974     result := bv_gt(X"03", X"02");
  975     write(L, result);
  976     writeline(output, L);
  977     assert result;
  978 
  979     write(L, string'("  2 > -2 = "));
  980     result := bv_gt(X"02", X"FE");
  981     write(L, result);
  982     writeline(output, L);
  983     assert result;
  984 
  985     write(L, string'("  -3 > 2 = "));
  986     result := bv_gt(X"FD", X"02");
  987     write(L, result);
  988     writeline(output, L);
  989     assert NOT result;
  990 
  991     ----------------------------------------------------------------
  992     -- bv_ge: Signed greater than or equal comparison
  993     ----------------------------------------------------------------
  994 
  995     writeline(output, L);
  996     write(L, string'("Testing bv_ge:"));
  997     writeline(output, L);
  998 
  999     write(L, string'("  2 >= 2 = "));
 1000     result := bv_ge(X"02", X"02");
 1001     write(L, result);
 1002     writeline(output, L);
 1003     assert result;
 1004 
 1005     write(L, string'("  3 >= 2 = "));
 1006     result := bv_ge(X"03", X"02");
 1007     write(L, result);
 1008     writeline(output, L);
 1009     assert result;
 1010 
 1011     write(L, string'("  2 >= -2 = "));
 1012     result := bv_ge(X"02", X"FE");
 1013     write(L, result);
 1014     writeline(output, L);
 1015     assert result;
 1016 
 1017     write(L, string'("  -3 >= 2 = "));
 1018     result := bv_ge(X"FD", X"02");
 1019     write(L, result);
 1020     writeline(output, L);
 1021     assert NOT result;
 1022 
 1023     ----------------------------------------------------------------
 1024     ----------------------------------------------------------------
 1025     --  Extension operators - convert a bit vector to a longer one
 1026     ----------------------------------------------------------------
 1027     ----------------------------------------------------------------
 1028 
 1029     ----------------------------------------------------------------
 1030     -- bv_sext: Sign extension
 1031     ----------------------------------------------------------------
 1032 
 1033     writeline(output, L);
 1034     write(L, string'("Testing bv_sext:"));
 1035     writeline(output, L);
 1036 
 1037     write(L, string'("  sext(X""02"", 32) = "));
 1038     word := bv_sext(X"02", 32);
 1039     write(L, word);
 1040     writeline(output, L);
 1041     assert word = X"00000002";
 1042 
 1043     write(L, string'("  sext(X""FE"", 32) = "));
 1044     word := bv_sext(X"FE", 32);
 1045     write(L, word);
 1046     writeline(output, L);
 1047     assert word = X"FFFFFFFE";
 1048 
 1049     write(L, string'("  sext(X""02"", 8) = "));
 1050     byte := bv_sext(X"02", 8);
 1051     write(L, byte);
 1052     writeline(output, L);
 1053     assert byte = X"02";
 1054 
 1055     write(L, string'("  sext(X""FE"", 8) = "));
 1056     byte := bv_sext(X"FE", 8);
 1057     write(L, byte);
 1058     writeline(output, L);
 1059     assert byte = X"FE";
 1060 
 1061     write(L, string'("  sext(X""02"", 4) = "));
 1062     half_byte := bv_sext(X"02", 4);
 1063     write(L, half_byte);
 1064     writeline(output, L);
 1065     assert half_byte = X"2";
 1066 
 1067     write(L, string'("  sext(X""FE"", 4) = "));
 1068     half_byte := bv_sext(X"FE", 4);
 1069     write(L, half_byte);
 1070     writeline(output, L);
 1071     assert half_byte = X"E";
 1072 
 1073     ----------------------------------------------------------------
 1074     -- bv_zext" Zero extension
 1075     ----------------------------------------------------------------
 1076 
 1077     writeline(output, L);
 1078     write(L, string'("Testing bv_zext:"));
 1079     writeline(output, L);
 1080 
 1081     write(L, string'("  zext(X""02"", 32) = "));
 1082     word := bv_zext(X"02", 32);
 1083     write(L, word);
 1084     writeline(output, L);
 1085     assert word = X"00000002";
 1086 
 1087     write(L, string'("  zext(X""FE"", 32) = "));
 1088     word := bv_zext(X"FE", 32);
 1089     write(L, word);
 1090     writeline(output, L);
 1091     assert word = X"000000FE";
 1092 
 1093     write(L, string'("  zext(X""02"", 8) = "));
 1094     byte := bv_zext(X"02", 8);
 1095     write(L, byte);
 1096     writeline(output, L);
 1097     assert byte = X"02";
 1098 
 1099     write(L, string'("  zext(X""FE"", 8) = "));
 1100     byte := bv_zext(X"FE", 8);
 1101     write(L, byte);
 1102     writeline(output, L);
 1103     assert byte = X"FE";
 1104 
 1105     write(L, string'("  zext(X""02"", 4) = "));
 1106     half_byte := bv_zext(X"02", 4);
 1107     write(L, half_byte);
 1108     writeline(output, L);
 1109     assert half_byte = X"2";
 1110 
 1111     write(L, string'("  zext(X""FE"", 4) = "));
 1112     half_byte := bv_zext(X"FE", 4);
 1113     write(L, half_byte);
 1114     writeline(output, L);
 1115     assert half_byte = X"E";
 1116 
 1117 
 1118     wait;
 1119   end process;
 1120 
 1121 end bench;
 1122 

This page was generated using GHDL 0.14 (20040829) [Sokcho edition], a program written by Tristan Gingold