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