vvp/vpi_const.cc

   1 /*
   2  * Copyright (c) 2001-2008 Stephen Williams (steve@icarus.com)
   3  *
   4  *    This source code is free software; you can redistribute it
   5  *    and/or modify it in source code form under the terms of the GNU
   6  *    General Public License as published by the Free Software
   7  *    Foundation; either version 2 of the License, or (at your option)
   8  *    any later version.
   9  *
  10  *    This program is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *    GNU General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU General Public License
  16  *    along with this program; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  18  */
  19
  20 # include  "vpi_priv.h"
  21 # include  "compile.h"
  22 # include  <stdio.h>
  23 #ifdef HAVE_MALLOC_H
  24 # include  <malloc.h>
  25 #endif
  26 # include  <stdlib.h>
  27 # include  <string.h>
  28 # include  <assert.h>
  29
  30 static int string_get(int code, vpiHandle ref)
  31 {
  32     struct __vpiStringConst*rfp;
  33
  34       switch (code) {
  35           case vpiSize:
  36               rfp = (struct __vpiStringConst*)ref;
  37
  38               assert((ref->vpi_type->type_code == vpiConstant)
  39                      || ((ref->vpi_type->type_code == vpiParameter)));
  40
  41               //fprintf(stderr, "String:|%s|, Length: %d\n", rfp->value, strlen(rfp->value));
  42               return strlen(rfp->value)*8;
  43
  44           case vpiSigned:
  45               return 0;
  46
  47           case vpiConstType:
  48               return vpiStringConst;
  49
  50           default:
  51               fprintf(stderr, "vvp error: get %d not supported "
  52                       "by vpiStringConst\n", code);
  53               assert(0);
  54               return 0;
  55       }
  56 }
  57
  58 static void string_value(vpiHandle ref, p_vpi_value vp)
  59 {
  60       unsigned uint_value;
  61       p_vpi_vecval vecp;
  62       struct __vpiStringConst*rfp = (struct __vpiStringConst*)ref;
  63       int size = strlen(rfp->value);
  64       char*rbuf = 0;
  65       char*cp;
  66
  67       assert((ref->vpi_type->type_code == vpiConstant)
  68              || ((ref->vpi_type->type_code == vpiParameter)));
  69
  70       switch (vp->format) {
  71           case vpiObjTypeVal:
  72               /* String parameters by default have vpiStringVal values. */
  73             vp->format = vpiStringVal;
  74
  75           case vpiStringVal:
  76             rbuf = need_result_buf(size + 1, RBUF_VAL);
  77             strcpy(rbuf, (char*)rfp->value);
  78             vp->value.str = rbuf;
  79             break;
  80
  81           case vpiDecStrVal:
  82               if (size > 4){
  83                   // We only support standard integers. Ignore other bytes...
  84                   size = 4;
  85                   fprintf(stderr, "Warning (vpi_const.cc): %%d on constant strings only looks "
  86                           "at first 4 bytes!\n");
  87               }
  88               rbuf = need_result_buf(size + 1, RBUF_VAL);
  89               uint_value = 0;
  90               for(int i=0; i<size;i ++){
  91                   uint_value <<=8;
  92                   uint_value += (unsigned char)(rfp->value[i]);
  93               }
  94               sprintf(rbuf, "%u", uint_value);
  95               vp->value.str = rbuf;
  96               break;
  97
  98           case vpiBinStrVal:
  99               rbuf = need_result_buf(8 * size + 1, RBUF_VAL);
 100               cp = rbuf;
 101               for(int i=0; i<size;i ++){
 102                   for(int bit=7;bit>=0; bit--){
 103                       *cp++ = "01"[ (rfp->value[i]>>bit)&1 ];
 104                   }
 105               }
 106               *cp = 0;
 107               vp->value.str = rbuf;
 108               break;
 109
 110           case vpiHexStrVal:
 111               rbuf = need_result_buf(2 * size + 1, RBUF_VAL);
 112               cp = rbuf;
 113               for(int i=0; i<size;i++){
 114                   for(int nibble=1;nibble>=0; nibble--){
 115                       *cp++ = "0123456789abcdef"[ (rfp->value[i]>>(nibble*4))&15 ];
 116                   }
 117               }
 118               *cp = 0;
 119               vp->value.str = rbuf;
 120               break;
 121
 122           case vpiOctStrVal:
 123               fprintf(stderr, "ERROR (vpi_const.cc): %%o display of constant strings not yet implemented\n");
 124               assert(0);
 125               break;
 126
 127           case vpiIntVal:
 128               vp->value.integer = 0;
 129               for(int i=0; i<size;i ++){
 130                   for(int bit=7;bit>=0; bit--){
 131                       vp->value.integer <<= 1;
 132                       vp->value.integer += (rfp->value[i]>>bit)&1;
 133                   }
 134               }
 135               break;
 136
 137           case vpiVectorVal:
 138               vp->value.vector = (p_vpi_vecval) calloc((size+3)/4,
 139                                                        sizeof(s_vpi_vecval));
 140               uint_value = 0;
 141               vecp = vp->value.vector;
 142               for(int i=0; i<size;i ++){
 143                   vecp->aval |= rfp->value[i] << uint_value*8;
 144                   uint_value += 1;
 145                   if (uint_value > 3) {
 146                       uint_value = 0;
 147                       vecp += 1;
 148                   }
 149               }
 150               break;
 151
 152
 153           default:
 154             fprintf(stderr, "ERROR (vpi_const.cc): vp->format: %d\n", vp->format);
 155             assert(0);
 156
 157             vp->format = vpiSuppressVal;
 158             break;
 159       }
 160 }
 161
 162 static const struct __vpirt vpip_string_rt = {
 163       vpiConstant,
 164       string_get,
 165       0,
 166       string_value,
 167       0,
 168       0,
 169       0
 170 };
 171
 172 static int free_temp_string(vpiHandle obj)
 173 {
 174       struct __vpiStringConst*rfp = (struct __vpiStringConst*)obj;
 175       assert(obj->vpi_type->type_code == vpiConstant);
 176
 177       free(rfp->value);
 178       free(rfp);
 179       return 1;
 180 }
 181
 182 static const struct __vpirt vpip_string_temp_rt = {
 183       vpiConstant,
 184       string_get,
 185       0,
 186       string_value,
 187       0,
 188
 189       0,
 190       0,
 191       0,
 192
 193       free_temp_string
 194 };
 195
 196 /*
 197  * Strings are described at the level of the vvp source as a string
 198  * with literal characters or octal escapes. No other escapes are
 199  * included, they are processed already by the compiler that generated
 200  * the vvp source.
 201  */
 202 static void vpip_process_string(struct __vpiStringConst*obj)
 203 {
 204       char*chr = obj->value;
 205       char*dp = obj->value;
 206
 207       while (*chr) {
 208             char next_char = *chr;
 209
 210               /* Process octal escapes that I might find. */
 211             if (*chr == '\\') {
 212                   for (int idx = 1 ;  idx <= 3 ;  idx += 1) {
 213                         assert(chr[idx] != 0);
 214                         assert(chr[idx] < '8');
 215                         assert(chr[idx] >= '0');
 216                         next_char = next_char*8 + chr[idx] - '0';
 217                   }
 218                   chr += 3;
 219             }
 220             *dp++ = next_char;
 221             chr += 1;
 222       }
 223       *dp = 0;
 224       obj->value_len = dp - obj->value;
 225 }
 226
 227 vpiHandle vpip_make_string_const(char*text, bool persistent_flag)
 228 {
 229       struct __vpiStringConst*obj;
 230
 231       obj = (struct __vpiStringConst*)
 232             malloc(sizeof (struct __vpiStringConst));
 233       obj->base.vpi_type = persistent_flag
 234             ? &vpip_string_rt
 235             : &vpip_string_temp_rt;
 236       obj->value = text;
 237       obj->value_len = 0;
 238       vpip_process_string(obj);
 239
 240       return &obj->base;
 241 }
 242
 243
 244 struct __vpiStringParam  : public __vpiStringConst {
 245       const char*basename;
 246       struct __vpiScope* scope;
 247       unsigned file_idx;
 248       unsigned lineno;
 249 };
 250
 251 static int string_param_get(int code, vpiHandle ref)
 252 {
 253       struct __vpiStringParam*rfp = (struct __vpiStringParam*)ref;
 254
 255       assert(ref->vpi_type->type_code == vpiParameter);
 256
 257       if (code == vpiLineNo) {
 258             return rfp->lineno;
 259       }
 260
 261       return string_get(code, ref);
 262 }
 263
 264 static char* string_param_get_str(int code, vpiHandle obj)
 265 {
 266       struct __vpiStringParam*rfp = (struct __vpiStringParam*)obj;
 267
 268       assert(obj->vpi_type->type_code == vpiParameter);
 269
 270       if (code == vpiFile) {
 271             return simple_set_rbuf_str(file_names[rfp->file_idx]);
 272       }
 273
 274       return generic_get_str(code, &rfp->scope->base, rfp->basename, NULL);
 275 }
 276
 277 static vpiHandle string_param_handle(int code, vpiHandle obj)
 278 {
 279       struct __vpiStringParam*rfp = (struct __vpiStringParam*)obj;
 280
 281       assert(obj->vpi_type->type_code == vpiParameter);
 282
 283       switch (code) {
 284           case vpiScope:
 285             return &rfp->scope->base;
 286
 287           default:
 288             return 0;
 289       }
 290 }
 291
 292 static const struct __vpirt vpip_string_param_rt = {
 293       vpiParameter,
 294       string_param_get,
 295       string_param_get_str,
 296       string_value,
 297       0,
 298
 299       string_param_handle,
 300       0,
 301       0,
 302
 303       0
 304 };
 305
 306
 307 vpiHandle vpip_make_string_param(char*name, char*text,
 308                                  long file_idx, long lineno)
 309 {
 310       struct __vpiStringParam*obj;
 311
 312       obj = (struct __vpiStringParam*)
 313             malloc(sizeof (struct __vpiStringParam));
 314       obj->base.vpi_type = &vpip_string_param_rt;
 315       obj->value = text;
 316       obj->value_len = 0;
 317       obj->basename = name;
 318       obj->scope = vpip_peek_current_scope();
 319       obj->file_idx = (unsigned) file_idx;
 320       obj->lineno = (unsigned) lineno;
 321
 322       vpip_process_string(obj);
 323
 324       return &obj->base;
 325 }
 326
 327 static int binary_get(int code, vpiHandle ref)
 328 {
 329       struct __vpiBinaryConst*rfp = (struct __vpiBinaryConst*)ref;
 330       assert(ref->vpi_type->type_code == vpiConstant
 331              || ref->vpi_type->type_code == vpiParameter);
 332
 333       switch (code) {
 334           case vpiConstType:
 335             return vpiBinaryConst;
 336
 337           case vpiLineNo:
 338             return 0;  // Not implemented for now!
 339
 340           case vpiSigned:
 341             return rfp->signed_flag? 1 : 0;
 342
 343           case vpiSize:
 344             return rfp->bits.size();
 345
 346           default:
 347             fprintf(stderr, "vvp error: get %d not supported "
 348                     "by vpiBinaryConst\n", code);
 349             assert(0);
 350             return 0;
 351       }
 352 }
 353
 354
 355 static void binary_value(vpiHandle ref, p_vpi_value vp)
 356 {
 357       assert(ref->vpi_type->type_code == vpiConstant
 358              || ref->vpi_type->type_code == vpiParameter);
 359
 360       struct __vpiBinaryConst*rfp = (struct __vpiBinaryConst*)ref;
 361
 362
 363       switch (vp->format) {
 364
 365           case vpiObjTypeVal:
 366           case vpiBinStrVal:
 367           case vpiDecStrVal:
 368           case vpiOctStrVal:
 369           case vpiHexStrVal:
 370           case vpiScalarVal:
 371           case vpiIntVal:
 372           case vpiVectorVal:
 373           case vpiStringVal:
 374           case vpiRealVal:
 375             vpip_vec4_get_value(rfp->bits, rfp->bits.size(),
 376                                 rfp->signed_flag, vp);
 377             break;
 378
 379           default:
 380             fprintf(stderr, "vvp error: format %d not supported "
 381                     "by vpiBinaryConst\n", vp->format);
 382             vp->format = vpiSuppressVal;
 383             break;
 384       }
 385 }
 386
 387 static const struct __vpirt vpip_binary_rt = {
 388       vpiConstant,
 389       binary_get,
 390       0,
 391       binary_value,
 392       0,
 393       0,
 394       0
 395 };
 396
 397 /*
 398  * Make a VPI constant from a vector string. The string is normally a
 399  * ASCII string, with each letter a 4-value bit. The first character
 400  * may be an 's' if the vector is signed.
 401  */
 402 vpiHandle vpip_make_binary_const(unsigned wid, const char*bits)
 403 {
 404       struct __vpiBinaryConst*obj;
 405
 406       obj = new __vpiBinaryConst;
 407       obj->base.vpi_type = &vpip_binary_rt;
 408
 409       obj->signed_flag = 0;
 410       obj->sized_flag = 0;
 411       obj->bits = vvp_vector4_t(wid);
 412
 413       const char*bp = bits;
 414       if (*bp == 's') {
 415             bp += 1;
 416             obj->signed_flag = 1;
 417       }
 418
 419       for (unsigned idx = 0 ;  idx < wid ;  idx += 1) {
 420             vvp_bit4_t val = BIT4_0;
 421             switch (bp[wid-idx-1]) {
 422                 case '0':
 423                   val = BIT4_0;
 424                   break;
 425                 case '1':
 426                   val = BIT4_1;
 427                   break;
 428                 case 'x':
 429                   val = BIT4_X;
 430                   break;
 431                 case 'z':
 432                   val = BIT4_Z;
 433                   break;
 434             }
 435
 436             obj->bits.set_bit(idx, val);
 437       }
 438
 439       return &(obj->base);
 440 }
 441
 442 struct __vpiBinaryParam  : public __vpiBinaryConst {
 443       const char*basename;
 444       struct __vpiScope*scope;
 445       unsigned file_idx;
 446       unsigned lineno;
 447 };
 448
 449 static int binary_param_get(int code, vpiHandle ref)
 450 {
 451       struct __vpiBinaryParam*rfp = (struct __vpiBinaryParam*)ref;
 452
 453       assert(ref->vpi_type->type_code == vpiParameter);
 454
 455       if (code == vpiLineNo) {
 456             return rfp->lineno;
 457       }
 458
 459       return binary_get(code, ref);
 460 }
 461
 462 static char* binary_param_get_str(int code, vpiHandle obj)
 463 {
 464       struct __vpiBinaryParam*rfp = (struct __vpiBinaryParam*)obj;
 465
 466       assert(obj->vpi_type->type_code == vpiParameter);
 467
 468       if (code == vpiFile) {
 469             return simple_set_rbuf_str(file_names[rfp->file_idx]);
 470       }
 471
 472       return generic_get_str(code, &rfp->scope->base, rfp->basename, NULL);
 473 }
 474
 475 static vpiHandle binary_param_handle(int code, vpiHandle obj)
 476 {
 477       struct __vpiBinaryParam*rfp = (struct __vpiBinaryParam*)obj;
 478
 479       assert(obj->vpi_type->type_code == vpiParameter);
 480
 481       switch (code) {
 482           case vpiScope:
 483             return &rfp->scope->base;
 484
 485           default:
 486             return 0;
 487       }
 488 }
 489
 490 static const struct __vpirt vpip_binary_param_rt = {
 491       vpiParameter,
 492       binary_param_get,
 493       binary_param_get_str,
 494       binary_value,
 495       0,
 496
 497       binary_param_handle,
 498       0,
 499       0,
 500
 501       0
 502 };
 503
 504 vpiHandle vpip_make_binary_param(char*name, const vvp_vector4_t&bits,
 505                                  bool signed_flag,
 506                                  long file_idx, long lineno)
 507 {
 508       struct __vpiBinaryParam*obj = new __vpiBinaryParam;
 509
 510       obj->base.vpi_type = &vpip_binary_param_rt;
 511       obj->bits = bits;
 512       obj->signed_flag = signed_flag? 1 : 0;
 513       obj->sized_flag = 0;
 514       obj->basename = name;
 515       obj->scope = vpip_peek_current_scope();
 516       obj->file_idx = (unsigned) file_idx;
 517       obj->lineno = (unsigned) lineno;
 518
 519       return &obj->base;
 520 }
 521
 522
 523 static int dec_get(int code, vpiHandle ref)
 524 {
 525
 526       switch (code) {
 527           case vpiConstType:
 528             return vpiDecConst;
 529
 530           case vpiSigned:
 531             return 1;
 532
 533           case vpiSize:
 534             return 32;
 535
 536           default:
 537             fprintf(stderr, "vvp error: get %d not supported "
 538                     "by vpiDecConst\n", code);
 539             assert(0);
 540             return 0;
 541       }
 542 }
 543
 544
 545 static void dec_value(vpiHandle ref, p_vpi_value vp)
 546 {
 547       struct __vpiDecConst*rfp = (struct __vpiDecConst*)ref;
 548       assert(ref->vpi_type->type_code == vpiConstant);
 549       char*rbuf = need_result_buf(64 + 1, RBUF_VAL);
 550       char*cp = rbuf;
 551
 552       switch (vp->format) {
 553
 554           case vpiObjTypeVal:
 555           case vpiIntVal: {
 556                 vp->value.integer = rfp->value;
 557                 break;
 558           }
 559
 560           case vpiDecStrVal:
 561               sprintf(rbuf, "%d", rfp->value);
 562
 563               vp->value.str = rbuf;
 564               break;
 565
 566           case vpiBinStrVal:
 567               for(int bit=31; bit<=0;bit--){
 568                   *cp++ = "01"[ (rfp->value>>bit)&1 ];
 569               }
 570               *cp = 0;
 571
 572               vp->value.str = rbuf;
 573               break;
 574
 575           case vpiHexStrVal:
 576               sprintf(rbuf, "%08x", rfp->value);
 577
 578               vp->value.str = rbuf;
 579               break;
 580
 581           case vpiOctStrVal:
 582               sprintf(rbuf, "%011x", rfp->value);
 583
 584               vp->value.str = rbuf;
 585               break;
 586
 587           default:
 588             fprintf(stderr, "vvp error (vpi_const.cc): format %d not supported "
 589                     "by vpiDecConst\n", vp->format);
 590             vp->format = vpiSuppressVal;
 591             break;
 592       }
 593 }
 594
 595 static const struct __vpirt vpip_dec_rt = {
 596       vpiConstant,
 597       dec_get,
 598       0,
 599       dec_value,
 600       0,
 601       0,
 602       0
 603 };
 604
 605 vpiHandle vpip_make_dec_const(struct __vpiDecConst*obj, int value)
 606 {
 607       obj->base.vpi_type = &vpip_dec_rt;
 608       obj->value = value;
 609
 610       return &(obj->base);
 611 }
 612
 613 vpiHandle vpip_make_dec_const(int value)
 614 {
 615       struct __vpiDecConst*obj;
 616
 617       obj = (struct __vpiDecConst*)
 618             malloc(sizeof (struct __vpiDecConst));
 619       return vpip_make_dec_const(obj, value);
 620 }
 621
 622
 623 static int real_get(int code, vpiHandle ref)
 624 {
 625
 626       switch (code) {
 627           case vpiLineNo:
 628             return 0;  // Not implemented for now!
 629
 630           case vpiSize:
 631             return 1;
 632
 633           case vpiConstType:
 634             return vpiRealConst;
 635
 636           case vpiSigned:
 637             return 1;
 638
 639           default:
 640             fprintf(stderr, "vvp error: get %d not supported "
 641                     "by vpiDecConst\n", code);
 642             assert(0);
 643             return 0;
 644       }
 645 }
 646
 647 static void real_value(vpiHandle ref, p_vpi_value vp)
 648 {
 649       struct __vpiRealConst*rfp = (struct __vpiRealConst*)ref;
 650       assert((ref->vpi_type->type_code == vpiConstant) ||
 651              (ref->vpi_type->type_code == vpiParameter));
 652
 653       switch (vp->format) {
 654           case vpiObjTypeVal:
 655             vp->format = vpiRealVal;
 656           case vpiRealVal:
 657             vp->value.real = rfp->value;
 658             break;
 659           default:
 660             fprintf(stderr, "vvp error: unsupported format %d.\n", vp->format);
 661             assert(0);
 662       }
 663 }
 664
 665 static const struct __vpirt vpip_real_rt = {
 666       vpiConstant,
 667       real_get,
 668       0,
 669       real_value,
 670       0,
 671       0,
 672       0
 673 };
 674
 675 vpiHandle vpip_make_real_const(struct __vpiRealConst*obj, double value)
 676 {
 677       obj->base.vpi_type = &vpip_real_rt;
 678       obj->value = value;
 679       return &(obj->base);
 680 }
 681
 682 vpiHandle vpip_make_real_const(double value)
 683 {
 684       struct __vpiRealConst*obj;
 685       obj =(struct __vpiRealConst*) malloc(sizeof (struct __vpiRealConst));
 686       return vpip_make_real_const(obj, value);
 687 }
 688
 689 struct __vpiRealParam  : public __vpiRealConst {
 690       const char*basename;
 691       struct __vpiScope* scope;
 692       unsigned file_idx;
 693       unsigned lineno;
 694 };
 695
 696 static int real_param_get(int code, vpiHandle ref)
 697 {
 698       struct __vpiRealParam*rfp = (struct __vpiRealParam*)ref;
 699
 700       assert(ref->vpi_type->type_code == vpiParameter);
 701
 702       if (code == vpiLineNo) {
 703             return rfp->lineno;
 704       }
 705
 706       return real_get(code, ref);
 707 }
 708
 709 static char* real_param_get_str(int code, vpiHandle obj)
 710 {
 711       struct __vpiRealParam*rfp = (struct __vpiRealParam*)obj;
 712
 713       assert(obj->vpi_type->type_code == vpiParameter);
 714
 715       if (code == vpiFile) {
 716             return simple_set_rbuf_str(file_names[rfp->file_idx]);
 717       }
 718
 719       return generic_get_str(code, &rfp->scope->base, rfp->basename, NULL);
 720 }
 721
 722 static vpiHandle real_param_handle(int code, vpiHandle obj)
 723 {
 724       struct __vpiRealParam*rfp = (struct __vpiRealParam*)obj;
 725
 726       assert(obj->vpi_type->type_code == vpiParameter);
 727
 728       switch (code) {
 729           case vpiScope:
 730             return &rfp->scope->base;
 731
 732           default:
 733             return 0;
 734       }
 735 }
 736
 737 static const struct __vpirt vpip_real_param_rt = {
 738       vpiParameter,
 739       real_param_get,
 740       real_param_get_str,
 741       real_value,
 742       0,
 743
 744       real_param_handle,
 745       0,
 746       0,
 747
 748       0
 749 };
 750
 751 vpiHandle vpip_make_real_param(char*name, double value,
 752                                long file_idx, long lineno)
 753 {
 754       struct __vpiRealParam*obj;
 755
 756       obj = (struct __vpiRealParam*)
 757             malloc(sizeof (struct __vpiRealParam));
 758       obj->base.vpi_type = &vpip_real_param_rt;
 759       obj->value = value;
 760       obj->basename = name;
 761       obj->scope = vpip_peek_current_scope();
 762       obj->file_idx = (unsigned) file_idx;
 763       obj->lineno = (unsigned) lineno;
 764
 765       return &obj->base;
 766 }