tgt-vvp/draw_vpi.c

   1 /*
   2  * Copyright (c) 2003 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 #ifdef HAVE_CVS_IDENT
  20 #ident "$Id: draw_vpi.c,v 1.17 2007/02/14 05:59:24 steve Exp $"
  21 #endif
  22
  23 # include  "vvp_priv.h"
  24 # include  <string.h>
  25 #ifdef HAVE_MALLOC_H
  26 # include  <malloc.h>
  27 #endif
  28 # include  <stdlib.h>
  29 # include  <assert.h>
  30
  31 static const char* magic_sfuncs[] = {
  32       "$time",
  33       "$stime",
  34       "$realtime",
  35       "$simtime",
  36       0
  37 };
  38
  39 static int is_magic_sfunc(const char*name)
  40 {
  41       int idx;
  42       for (idx = 0 ;  magic_sfuncs[idx] ;  idx += 1)
  43             if (strcmp(magic_sfuncs[idx],name) == 0)
  44                   return 1;
  45
  46       return 0;
  47 }
  48
  49 static int is_fixed_memory_word(ivl_expr_t net)
  50 {
  51       ivl_signal_t sig;
  52
  53       if (ivl_expr_type(net) != IVL_EX_SIGNAL)
  54             return 0;
  55
  56       sig = ivl_expr_signal(net);
  57
  58       if (ivl_signal_array_count(sig) == 1)
  59             return 1;
  60
  61       if (number_is_immediate(ivl_expr_oper1(net), 8*sizeof(unsigned)))
  62             return 1;
  63
  64       return 0;
  65 }
  66
  67 static void draw_vpi_taskfunc_args(const char*call_string,
  68                                    ivl_statement_t tnet,
  69                                    ivl_expr_t fnet)
  70 {
  71       unsigned idx;
  72       unsigned parm_count = tnet
  73             ? ivl_stmt_parm_count(tnet)
  74             : ivl_expr_parms(fnet);
  75       struct vector_info *vec = 0x0;
  76       unsigned int vecs= 0;
  77       unsigned int veci= 0;
  78
  79       ivl_parameter_t par;
  80
  81         /* Figure out how many expressions are going to be evaluated
  82            for this task call. I won't need to evaluate expressions
  83            for items that are VPI objects directly. */
  84       for (idx = 0 ;  idx < parm_count ;  idx += 1) {
  85             ivl_expr_t expr = tnet
  86                   ? ivl_stmt_parm(tnet, idx)
  87                   : ivl_expr_parm(fnet, idx);
  88
  89             switch (ivl_expr_type(expr)) {
  90
  91                     /* These expression types can be handled directly,
  92                        with VPI handles of their own. Therefore, skip
  93                        them in the process of evaluating expressions. */
  94                 case IVL_EX_NONE:
  95                 case IVL_EX_ARRAY:
  96                 case IVL_EX_NUMBER:
  97                 case IVL_EX_STRING:
  98                 case IVL_EX_EVENT:
  99                 case IVL_EX_SCOPE:
 100                   continue;
 101
 102                 case IVL_EX_SFUNC:
 103                   if (is_magic_sfunc(ivl_expr_name(expr)))
 104                         continue;
 105
 106                   break;
 107
 108                 case IVL_EX_SIGNAL:
 109                     /* If the signal node is narrower then the signal
 110                        itself, then this is a part select so I'm going
 111                        to need to evaluate the expression.
 112
 113                        Also, if the signedness of the expression is
 114                        different from the signedness of the
 115                        signal. This could be caused by a $signed or
 116                        $unsigned system function.
 117
 118                        If I don't need to do any evaluating, then skip
 119                        it as I'll be passing the handle to the signal
 120                        itself. */
 121                   if (ivl_expr_width(expr) !=
 122                       ivl_signal_width(ivl_expr_signal(expr))) {
 123                         break;
 124
 125                   } else if (ivl_expr_signed(expr) !=
 126                              ivl_signal_signed(ivl_expr_signal(expr))) {
 127                         break;
 128                   } else if (! is_fixed_memory_word(expr)){
 129                         break;
 130                   } else {
 131                           /* Some array selects need to be evaluated. */
 132                         ivl_expr_t word_ex = ivl_expr_oper1(expr);
 133                         if (word_ex && !number_is_immediate(word_ex,
 134                                           8*sizeof(unsigned))) {
 135                               break;
 136                         }
 137                         continue;
 138                   }
 139
 140
 141                 case IVL_EX_MEMORY:
 142                   if (!ivl_expr_oper1(expr)) {
 143                         continue;
 144                   }
 145
 146                     /* Everything else will need to be evaluated and
 147                        passed as a constant to the vpi task. */
 148                 default:
 149                   break;
 150             }
 151
 152             vec = (struct vector_info *)
 153                   realloc(vec, (vecs+1)*sizeof(struct vector_info));
 154
 155             switch (ivl_expr_value(expr)) {
 156                 case IVL_VT_LOGIC:
 157                 case IVL_VT_BOOL:
 158                   vec[vecs] = draw_eval_expr(expr, 0);
 159                   break;
 160                 case IVL_VT_REAL:
 161                   vec[vecs].base = draw_eval_real(expr);
 162                   vec[vecs].wid = 0;
 163                   break;
 164                 default:
 165                   assert(0);
 166             }
 167             vecs++;
 168       }
 169
 170       fprintf(vvp_out, "%s", call_string);
 171
 172       for (idx = 0 ;  idx < parm_count ;  idx += 1) {
 173             ivl_expr_t expr = tnet
 174                   ? ivl_stmt_parm(tnet, idx)
 175                   : ivl_expr_parm(fnet, idx);
 176
 177             switch (ivl_expr_type(expr)) {
 178                 case IVL_EX_NONE:
 179                   fprintf(vvp_out, ", \" \"");
 180                   continue;
 181
 182                 case IVL_EX_ARRAY:
 183                   fprintf(vvp_out, ", v%p", ivl_expr_signal(expr));
 184                   continue;
 185
 186                 case IVL_EX_NUMBER: {
 187                       unsigned bit, wid = ivl_expr_width(expr);
 188                       const char*bits = ivl_expr_bits(expr);
 189
 190                       fprintf(vvp_out, ", %u'%sb", wid,
 191                               ivl_expr_signed(expr)? "s" : "");
 192                       for (bit = wid ;  bit > 0 ;  bit -= 1)
 193                             fputc(bits[bit-1], vvp_out);
 194                       continue;
 195                 }
 196
 197                 case IVL_EX_SIGNAL:
 198                     /* If this is a part select, then the value was
 199                        calculated above. Otherwise, just pass the
 200                        signal. */
 201                   if (ivl_expr_width(expr) !=
 202                       ivl_signal_width(ivl_expr_signal(expr))) {
 203                         break;
 204
 205                   } else if (ivl_expr_signed(expr) !=
 206                              ivl_signal_signed(ivl_expr_signal(expr))) {
 207                         break;
 208
 209                   } else if (! is_fixed_memory_word(expr)){
 210                         break;
 211
 212                   } else {
 213                         ivl_signal_t sig = ivl_expr_signal(expr);
 214                         unsigned use_word = 0;
 215                         ivl_expr_t word_ex = ivl_expr_oper1(expr);
 216                         if (word_ex) {
 217                                 /* Some array select have been evaluated. */
 218                               if (!number_is_immediate(word_ex,
 219                                      8*sizeof(unsigned))) {
 220                                     break;
 221                               }
 222                               use_word = get_number_immediate(word_ex);
 223                         }
 224                         fprintf(vvp_out, ", v%p_%u", sig, use_word);
 225                         continue;
 226                   }
 227                   assert(0);
 228                   continue;
 229
 230                 case IVL_EX_STRING:
 231                   if (( par = ivl_expr_parameter(expr) )) {
 232                         fprintf(vvp_out, ", P_%p", par);
 233
 234                   } else {
 235                         fprintf(vvp_out, ", \"%s\"",
 236                                 ivl_expr_string(expr));
 237                   }
 238                   continue;
 239
 240                 case IVL_EX_EVENT:
 241                   fprintf(vvp_out, ", E_%p", ivl_expr_event(expr));
 242                   continue;
 243
 244                 case IVL_EX_SCOPE:
 245                   fprintf(vvp_out, ", S_%p", ivl_expr_scope(expr));
 246                   continue;
 247
 248                 case IVL_EX_SFUNC:
 249                   if (is_magic_sfunc(ivl_expr_name(expr))) {
 250                         fprintf(vvp_out, ", %s", ivl_expr_name(expr));
 251                         continue;
 252                   }
 253                   break;
 254
 255                 default:
 256                   break;
 257             }
 258             assert(veci < vecs);
 259
 260             switch (ivl_expr_value(expr)) {
 261
 262                 case IVL_VT_LOGIC:
 263                 case IVL_VT_BOOL:
 264                   fprintf(vvp_out, ", T<%u,%u,%s>", vec[veci].base,
 265                           vec[veci].wid, ivl_expr_signed(expr)? "s" : "u");
 266                   break;
 267
 268                 case IVL_VT_REAL:
 269                   fprintf(vvp_out, ", W<%u,r>", vec[veci].base);
 270                   break;
 271
 272                 default:
 273                   assert(0);
 274             }
 275             veci++;
 276       }
 277
 278       assert(veci == vecs);
 279
 280       if (vecs) {
 281             for (idx = 0; idx < vecs; idx++) {
 282                   if (vec[idx].wid > 0)
 283                         clr_vector(vec[idx]);
 284                   else if (vec[idx].wid == 0)
 285                         clr_word(vec[idx].base);
 286             }
 287             free(vec);
 288       }
 289
 290       fprintf(vvp_out, ";\n");
 291 }
 292
 293 void draw_vpi_task_call(ivl_statement_t tnet)
 294 {
 295       char call_string[1024];
 296       sprintf(call_string, "    %%vpi_call \"%s\"", ivl_stmt_name(tnet));
 297       draw_vpi_taskfunc_args(call_string, tnet, 0);
 298 }
 299
 300 struct vector_info draw_vpi_func_call(ivl_expr_t fnet, unsigned wid)
 301 {
 302       char call_string[1024];
 303       struct vector_info res;
 304
 305       res.base = allocate_vector(wid);
 306       res.wid  = wid;
 307       sprintf(call_string, "    %%vpi_func \"%s\", %u, %u",
 308               ivl_expr_name(fnet), res.base, res.wid);
 309
 310       draw_vpi_taskfunc_args(call_string, 0, fnet);
 311
 312       return res;
 313 }
 314
 315 int draw_vpi_rfunc_call(ivl_expr_t fnet)
 316 {
 317       char call_string[1024];
 318       int res = allocate_word();
 319
 320       sprintf(call_string, "    %%vpi_func/r \"%s\", %d",
 321               ivl_expr_name(fnet), res);
 322
 323       draw_vpi_taskfunc_args(call_string, 0, fnet);
 324
 325       return res;
 326 }
 327