distrib/sources/tas/stb/stb_relaxation_correction.c

   1 #include MUT_H
   2 #include STB_H
   3
   4 #include "stb_util.h"
   5 #include "stb_transfer.h"
   6 #include "stb_error.h"
   7 #include "stb_directives.h"
   8 #include "stb_falseslack.h"
   9 #include "stb_relaxation_correction.h"
  10 #include "stb_debug.h"
  11
  12 typedef struct node_path_info_per_phase
  13 {
  14   struct node_path_info_per_phase *next;
  15   long delaymax, delaymin;
  16   long movemax, movemin;
  17   long startmin, startmax;
  18   char phase;
  19 } node_path_info_per_phase;
  20
  21 typedef struct node_path_info
  22 {
  23   struct node_path_info *next;
  24   node_path_info_per_phase *PP;
  25   char output_phase;
  26   ttvevent_list *start, *cmd;
  27 } node_path_info;
  28
  29
  30 static node_path_info *create_node_path_info()
  31 {
  32   node_path_info *npi;
  33   npi=(node_path_info *)mbkalloc(sizeof(node_path_info));
  34   npi->PP=NULL;
  35   npi->output_phase=STB_NO_INDEX;
  36   npi->start=NULL;
  37   npi->next=NULL;
  38   return npi;
  39 }
  40
  41 static node_path_info_per_phase *create_node_path_info_PP()
  42 {
  43   node_path_info_per_phase *npipp;
  44   npipp=(node_path_info_per_phase *)mbkalloc(sizeof(node_path_info_per_phase));
  45   npipp->movemax=npipp->movemin=0;
  46   npipp->startmin=npipp->startmax=0;
  47   npipp->delaymin=npipp->delaymax=TTV_NOTIME;
  48   npipp->phase=STB_NO_INDEX;
  49   return npipp;
  50 }
  51
  52 static valid_range_info *give_valid_range_info(ttvline_list *tl, int nbindex)
  53 {
  54   ptype_list *pt;
  55   valid_range_info *vri;
  56   int i;
  57
  58   if ((pt=getptype(tl->USER, STB_TRANSFERT_CORRECTION_PTYPE))!=NULL)
  59     return (valid_range_info *)pt->DATA;
  60
  61   vri=(valid_range_info *)mbkalloc(sizeof(valid_range_info)*nbindex);
  62   for (i=0; i<nbindex; i++)
  63   {
  64 //    vri[i].validmin=vri[i].validmax=TTV_NOTIME;
  65     vri[i].realpair=NULL;
  66   }
  67
  68   tl->USER=addptype(tl->USER, STB_TRANSFERT_CORRECTION_PTYPE, vri);
  69   return vri;
  70 }
  71
  72 valid_range_info *get_valid_range_info(ttvline_list *tl)
  73 {
  74   ptype_list *pt;
  75
  76   if ((pt=getptype(tl->USER, STB_TRANSFERT_CORRECTION_PTYPE))!=NULL)
  77     return (valid_range_info *)pt->DATA;
  78
  79   return NULL;
  80 }
  81
  82
  83 void stb_clean_relax_correction_info (stbfig_list *stbfig)
  84 {
  85   ttvevent_list *event;
  86   ttvline_list *line;
  87   char level;
  88   chain_list *cl;
  89   ptype_list *pt;
  90   valid_range_info *vri;
  91   int i;
  92
  93   for (cl=stbfig->NODE; cl!=NULL; cl=cl->NEXT)
  94     {
  95       event=(ttvevent_list *)cl->DATA;
  96       if ((stbfig->STABILITYMODE & STB_STABILITY_LAST) == STB_STABILITY_LAST)
  97         level = stbfig->FIG->INFO->LEVEL;
  98       else
  99         level = event->ROOT->ROOT->INFO->LEVEL;
 100
 101       if (stbfig->GRAPH == STB_RED_GRAPH)
 102         {
 103           ttv_expfigsig (stbfig->FIG, event->ROOT, level, stbfig->FIG->INFO->LEVEL,
 104                          TTV_STS_CL_PJT, TTV_FILE_TTX);
 105           line = event->INPATH;
 106         }
 107       else
 108         {
 109           ttv_expfigsig (stbfig->FIG, event->ROOT, level, stbfig->FIG->INFO->LEVEL,
 110                          TTV_STS_CLS_FED, TTV_FILE_DTX);
 111           line = event->INLINE;
 112         }
 113
 114       for (; line; line = line->NEXT)
 115         {
 116           if ((pt=getptype(line->USER, STB_TRANSFERT_CORRECTION_PTYPE))!=NULL)
 117             {
 118               vri=(valid_range_info *)pt->DATA;
 119               for (i=0; i<(int)stbfig->PHASENUMBER; i++)
 120               {
 121                 stb_freestbpair(vri[i].realpair);
 122               }
 123               mbkfree(vri);
 124               line->USER=delptype(line->USER, STB_TRANSFERT_CORRECTION_PTYPE);
 125             }
 126         }
 127     }
 128 }
 129
 130 void stb_clean_relax_correction_path_info (stbfig_list *stbfig)
 131 {
 132   ttvevent_list *event;
 133   chain_list *cl;
 134   node_path_info *npi, *nnpi;
 135   node_path_info_per_phase *npipp, *nnpipp;
 136
 137   ptype_list *pt;
 138
 139   for (cl=stbfig->NODE; cl!=NULL; cl=cl->NEXT)
 140     {
 141       event=(ttvevent_list *)cl->DATA;
 142       if ((pt=getptype(event->USER, STB_PATH_LIST))!=NULL)
 143         {
 144           for (npi=(node_path_info *)pt->DATA; npi!=NULL; npi=nnpi)
 145             {
 146               nnpi=npi->next;
 147               for (npipp=npi->PP; npipp!=NULL; npipp=nnpipp)
 148                 {
 149                   nnpipp=npipp->next;
 150                   mbkfree(npipp);
 151                 }
 152               mbkfree(npi);
 153             }
 154           event->USER=delptype(event->USER, STB_PATH_LIST);
 155         }
 156     }
 157 }
 158
 159 node_path_info *stb_assign_paths(stbfig_list *stbfig, ttvevent_list *tve)
 160 {
 161   long find, l;
 162   int oldprecisionlevel;
 163   ttvpath_list *path, *scanpath;
 164   ptype_list *ptype;
 165   ht *startht;
 166   node_path_info *pathl=NULL, *npi;
 167   node_path_info_per_phase *npipp;
 168   chain_list *cl;
 169   ptype_list *pt;
 170   ttvevent_list *start;
 171   ttvpath_stb_stuff *tps;
 172   char ophase;
 173
 174   if ((pt=getptype(tve->USER, STB_PATH_LIST))!=NULL) return (node_path_info *)pt->DATA;
 175
 176
 177   ttv_search_mode(1, TTV_MORE_OPTIONS_KEEP_PHASE_INFO);
 178
 179   oldprecisionlevel=ttv_SetPrecisionLevel(0);
 180
 181   startht=addht(100);
 182
 183   if(stbfig->GRAPH == STB_RED_GRAPH)
 184     find = TTV_FIND_PATH ;
 185   else
 186     find = TTV_FIND_LINE ;
 187
 188   if (tve->TYPE & TTV_NODE_UP)
 189     find |= TTV_FIND_NOT_UPDW | TTV_FIND_NOT_DWDW;
 190   else
 191     find |= TTV_FIND_NOT_UPUP | TTV_FIND_NOT_DWUP;
 192
 193   if (stbfig->CLOCK && (stbfig->FLAGS & STB_HAS_FALSE_ACCESS)!=0 && V_BOOL_TAB[__STB_HANDLE_FALSE_ACCESS].VALUE)
 194   {
 195     if(ttv_canbeinfalsepath(tve, 'o'))
 196     {
 197       if (ttv_hasaccessfalsepath(stbfig->FIG, tve, stbfig->CLOCK))
 198       {
 199         ttv_set_ttv_getpath_clock_list(stbfig->CLOCK);
 200         ttv_activate_path_and_access_mode(1);
 201         find|=TTV_FIND_ACCESS;
 202       }
 203     }
 204   }
 205
 206   path = ttv_getpathnocross_v2(stbfig->FIG,NULL,tve->ROOT,NULL, TTV_DELAY_MAX,TTV_DELAY_MIN,TTV_FIND_MAX|find,0) ;
 207
 208   for(scanpath = path ; scanpath != NULL ; scanpath = scanpath->NEXT)
 209     {
 210       if ((scanpath->TYPE & TTV_FIND_HZ) == TTV_FIND_HZ) continue ;
 211       if (scanpath->LATCH==NULL && getptype(scanpath->NODE->ROOT->USER, STB_IS_CLOCK)!=NULL
 212           && (scanpath->TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_FLAG_THRU_FILTER_FOUND)==0)
 213         continue;
 214
 215       if ((scanpath->ROOT->ROOT->TYPE & TTV_SIG_R) != 0)
 216         {
 217           ptype=getptype(scanpath->USER, TTV_PATH_PREVIOUS_NODE);
 218           scanpath->CMD=(ttvevent_list *)ptype->DATA;
 219         }
 220
 221       start=scanpath->LATCH?scanpath->LATCH:scanpath->NODE;
 222       if ((l=gethtitem(startht, start))!=EMPTYHT)
 223         {
 224           for (cl=(chain_list *)l; cl!=NULL && (npi=(node_path_info *)cl->DATA)->cmd!=scanpath->CMD; cl=cl->NEXT) ;
 225           if (cl!=NULL) continue;
 226           cl=(chain_list *)l;
 227         }
 228       else cl=NULL;
 229
 230       npi=create_node_path_info();
 231       npi->start=start;
 232       npi->cmd=scanpath->CMD;
 233       npi->next=pathl;
 234       pathl=npi;
 235       addhtitem(startht, start, (long)addchain(cl, npi));
 236       if ((pt=getptype(scanpath->USER, TTV_PATH_OUTPUT_PHASE))!=NULL)
 237         {
 238           if ((ophase=(char)(long)pt->DATA)==TTV_NO_PHASE) ophase=STB_NO_INDEX;
 239           npi->output_phase=ophase;
 240         }
 241       else npi->output_phase=STB_NO_INDEX;
 242
 243       pt=getptype(scanpath->USER,TTV_PATH_PHASE_INFO);
 244       if (pt!=NULL)
 245         {
 246           for (tps=(ttvpath_stb_stuff *)pt->DATA; tps!=NULL; tps=tps->NEXT)
 247             {
 248               npipp=create_node_path_info_PP();
 249               npipp->next=npi->PP;
 250               npi->PP=npipp;
 251               npipp->phase=tps->STARTPHASE;
 252               npipp->startmax=tps->STARTTIME;
 253               npipp->delaymax=scanpath->DELAY-scanpath->CLOCKPATHDELAY;
 254               npipp->movemax=tps->PERIOD_CHANGE;
 255             }
 256           ttv_freepathstblist((ttvpath_stb_stuff *)pt->DATA);
 257         }
 258       else
 259         {
 260           npipp=create_node_path_info_PP();
 261           npipp->next=npi->PP;
 262           npi->PP=npipp;
 263           npipp->phase=STB_NO_INDEX;
 264           npipp->startmax=TTV_NOTIME;
 265           npipp->delaymax=scanpath->DELAY-scanpath->CLOCKPATHDELAY;
 266           npipp->movemax=0;
 267         }
 268     }
 269   ttv_freepathlist(path) ;
 270
 271   path = ttv_getpathnocross_v2(stbfig->FIG,NULL,tve->ROOT,NULL, TTV_DELAY_MAX,TTV_DELAY_MIN,TTV_FIND_MIN|find,0) ;
 272
 273   for(scanpath = path ; scanpath != NULL ; scanpath = scanpath->NEXT)
 274     {
 275       if((scanpath->TYPE & TTV_FIND_HZ) == TTV_FIND_HZ) continue ;
 276       if (scanpath->LATCH==NULL && getptype(scanpath->NODE->ROOT->USER, STB_IS_CLOCK)!=NULL
 277           && (scanpath->TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_FLAG_THRU_FILTER_FOUND)==0)
 278         continue;
 279
 280       if ((scanpath->ROOT->ROOT->TYPE & TTV_SIG_R) != 0)
 281         {
 282           ptype=getptype(scanpath->USER, TTV_PATH_PREVIOUS_NODE);
 283           scanpath->CMD=(ttvevent_list *)ptype->DATA;
 284         }
 285
 286       start=scanpath->LATCH?scanpath->LATCH:scanpath->NODE;
 287       if ((l=gethtitem(startht, start))!=EMPTYHT)
 288         {
 289           for (cl=(chain_list *)l; cl!=NULL && (npi=(node_path_info *)cl->DATA)->cmd!=scanpath->CMD; cl=cl->NEXT) ;
 290 //          if (cl==NULL) exit(60);
 291         }
 292       else cl=NULL;
 293
 294       if (cl==NULL)
 295         {
 296           npi=create_node_path_info();
 297           npi->next=pathl;
 298           pathl=npi;
 299           if (l!=EMPTYHT) cl=(chain_list *)l;
 300           addhtitem(startht, start, (long)addchain(cl, npi));
 301           if ((pt=getptype(scanpath->USER, TTV_PATH_OUTPUT_PHASE))!=NULL)
 302             {
 303               if ((ophase=(char)(long)pt->DATA)==TTV_NO_PHASE) ophase=STB_NO_INDEX;
 304               npi->output_phase=ophase;
 305             }
 306           else npi->output_phase=STB_NO_INDEX;
 307           npi->start=start;
 308           npi->cmd=scanpath->CMD;
 309         }
 310
 311       pt=getptype(scanpath->USER,TTV_PATH_PHASE_INFO);
 312
 313       if (pt!=NULL)
 314         {
 315           for (tps=(ttvpath_stb_stuff *)pt->DATA; tps!=NULL; tps=tps->NEXT)
 316             {
 317               for (npipp=npi->PP; npipp!=NULL && npipp->phase!=tps->STARTPHASE; npipp=npipp->next) ;
 318               if (npipp==NULL)
 319                 {
 320                   npipp=create_node_path_info_PP();
 321                   npipp->next=npi->PP;
 322                   npi->PP=npipp;
 323                   npipp->phase=tps->STARTPHASE;
 324                 }
 325               npipp->startmin=tps->STARTTIME;
 326               npipp->delaymin=scanpath->DELAY-scanpath->CLOCKPATHDELAY;
 327               npipp->movemin=tps->PERIOD_CHANGE;
 328             }
 329           ttv_freepathstblist((ttvpath_stb_stuff *)pt->DATA);
 330         }
 331       else
 332         {
 333           for (npipp=npi->PP; npipp!=NULL && npipp->phase!=STB_NO_INDEX; npipp=npipp->next) ;
 334           if (npipp==NULL)
 335             {
 336               npipp=create_node_path_info_PP();
 337               npipp->next=npi->PP;
 338               npi->PP=npipp;
 339               npipp->phase=STB_NO_INDEX;
 340             }
 341           npipp->startmin=TTV_NOTIME;
 342           npipp->delaymin=scanpath->DELAY-scanpath->CLOCKPATHDELAY;
 343           npipp->movemin=0;
 344         }
 345
 346     }
 347   ttv_freepathlist(path) ;
 348
 349   ttv_search_mode(0, TTV_MORE_OPTIONS_KEEP_PHASE_INFO);
 350
 351   cl=GetAllHTElems(startht);
 352   while (cl!=NULL)
 353     {
 354       freechain((chain_list *)cl->DATA);
 355       cl=delchain(cl,cl);
 356     }
 357   delht(startht);
 358
 359   ttv_SetPrecisionLevel(oldprecisionlevel);
 360   tve->USER=addptype(tve->USER, STB_PATH_LIST, pathl);
 361   ttv_set_ttv_getpath_clock_list(NULL);
 362   ttv_activate_path_and_access_mode(0);
 363
 364   return pathl;
 365 }
 366
 367 static int stb_inrelax=0;
 368
 369 void stb_set_relax(int val)
 370 {
 371   stb_inrelax=val;
 372 }
 373
 374 #ifdef RELAX_CORRECT_DEBUG
 375 #define DISPDIR(x) ((x->TYPE & TTV_NODE_UP)!=0?'u':'d')
 376 #endif
 377
 378 void stb_compute_falsepath_and_falseslack_effect(stbfig_list *sf, stbnode *node, ttvline_list *line, ttvevent_list *linecmd, stbck *nodeck, int flags)
 379 {
 380   node_path_info *npi;
 381   valid_range_info *vri;
 382   stbck *ck, *ick;
 383   stbnode *startnode;
 384   int i, res, startindex;
 385 //  long validmin, validmax;
 386   stbpair_list *STBTAB[256], *STBHZ[256], *ptstbpair, *pair;
 387   int ckindex;
 388   long periodeSetup, periodeHold, output_periode, input_periode;
 389   int nb0, nb1, first=0;
 390   char ckedge;
 391   node_path_info_per_phase *npipp, *backupnpipp;
 392 #ifdef RELAX_CORRECT_DEBUG
 393   int deb=0;
 394   if (strcmp(node->EVENT->ROOT->NAME,"F2171467")==0 && (node->EVENT->TYPE & TTV_NODE_UP)==0) deb=1;
 395 #endif
 396
 397   if (node->EVENT->ROOT->TYPE & TTV_SIG_R)
 398     linecmd=line->NODE;
 399
 400   if (!stb_inrelax && get_valid_range_info(line)!=NULL) return;
 401
 402   vri=give_valid_range_info(line, node->NBINDEX);
 403
 404   npi=stb_assign_paths(sf, node->EVENT);
 405   while (npi!=NULL)
 406     {
 407       if (npi->cmd==linecmd)
 408         {
 409           startnode=stb_getstbnode(npi->start);
 410           ck=startnode->CK;
 411           do
 412             {
 413               first++;
 414
 415 #ifdef RELAX_CORRECT_DEBUG
 416               if (strcmp(npi->start->ROOT->NAME,"F1867251")==0)
 417                   printf("");
 418 #endif
 419               for (i=0; i<node->NBINDEX; i++) STBHZ[i]=NULL, STBTAB[i]=NULL;
 420
 421               if (getptype(npi->start->ROOT->USER, STB_IS_CLOCK)!=NULL)
 422                 create_clock_stability(startnode, STBTAB);
 423               else if (!stb_inrelax/*(startnode->FLAG & STB_NODE_DONE)==0*/)
 424                {
 425                  for (i=0; i<node->NBINDEX; i++) STBTAB[i]=stb_dupstbpairlist(startnode->STBTAB[i]);
 426                }
 427               else
 428                 stb_transferstbline (sf, npi->start, startnode, STBTAB, STBHZ, 0, 1, NULL, ck, 1, 0) ;
 429
 430               if (ck==NULL)
 431                 for (ckindex=0; ckindex<node->NBINDEX && STBTAB[ckindex]==NULL; ckindex++) ;
 432               else
 433                 ckindex=(int)ck->CKINDEX;
 434
 435               if (ckindex<node->NBINDEX)
 436                 {
 437                   res=0;
 438                   startindex=ckindex;
 439                   if (STBTAB[startindex]!=NULL)
 440                     {
 441                       for (npipp=npi->PP, backupnpipp=NULL; npipp!=NULL && npipp->phase!=startindex; npipp=npipp->next)
 442                         if (npipp->phase==STB_NO_INDEX) backupnpipp=npipp;
 443
 444                       if (npipp==NULL) npipp=backupnpipp;
 445
 446                       if (npipp!=NULL)
 447                         {
 448                           if (stb_hasfalseslack(sf, node->EVENT))
 449                             {
 450                               ttvevent_list *startclock, *endclocksetup, *endclockhold;
 451                               int fs=0, fh=0;
 452
 453                                stb_getslacktopclocks(NULL, node, 0, ck, nodeck, &startclock, &endclocksetup, &endclockhold);
 454                                if (startclock!=NULL && endclocksetup!=NULL)
 455                                  fs=stb_isfalseslack(sf, startclock, npi->start, node->EVENT, endclocksetup, INF_FALSESLACK_SETUP);
 456
 457                                if (startclock!=NULL && endclockhold!=NULL)
 458                                  fh=stb_isfalseslack(sf, startclock, npi->start, node->EVENT, endclockhold, INF_FALSESLACK_HOLD);
 459                                if ((fs & INF_FALSESLACK_NOTHZ)!=0 && (fh & INF_FALSESLACK_NOTHZ)!=0) res=1;
 460                               /*                               if (res!=0)
 461                                  printf("found %s -> %s\n", npi->start->ROOT->NETNAME, node->EVENT->ROOT->NETNAME);*/
 462 #ifdef RELAX_CORRECT_DEBUG
 463                           if (deb && stb_hasfalseslack(sf, node->EVENT))
 464                             printf("  [FS %d] %s(%c) %s(%c) %s(%c) %s(%c)", res, startclock?startclock->ROOT->NAME:"?", DISPDIR(startclock),
 465                                             npi->start->ROOT->NAME, DISPDIR(npi->start),
 466                                             node->EVENT->ROOT->NAME, DISPDIR(node->EVENT),
 467                                             endclocksetup?endclocksetup->ROOT->NAME:"?", endclocksetup?DISPDIR(endclocksetup):'x');
 468 #endif
 469                             }
 470                           if (npipp->delaymin==TTV_NOTIME) npipp->delaymin=npipp->delaymax;
 471                           if (npipp->delaymax==TTV_NOTIME) npipp->delaymax=npipp->delaymin;
 472                           if (npipp->delaymin>npipp->delaymax) npipp->delaymin=npipp->delaymax;
 473
 474                           if (npi->output_phase!=STB_NO_INDEX) // filtre
 475                             ckindex=npi->output_phase;
 476
 477
 478                           if (res==0)
 479                             {
 480                               input_periode=0;
 481                               ick=stb_getclock(sf, startindex, NULL, &ckedge, NULL);
 482                               if (ick!=NULL) input_periode=ick->PERIOD;
 483
 484                               output_periode=input_periode;
 485                               if (nodeck!=NULL)
 486                                 {
 487                                   ick=stb_getclock(sf, nodeck->CKINDEX, NULL, &ckedge, NULL);
 488                                   if (ick!=NULL) output_periode=ick->PERIOD;
 489                                 }
 490
 491                               if ((flags & STB_TRANSFERT_NOFILTERING)==0)
 492                                 stb_getmulticycleperiod(npi->start, node->EVENT, input_periode, output_periode, &periodeSetup, &periodeHold, &nb0, &nb1);
 493                               else
 494                                 periodeSetup=periodeHold=0;
 495
 496                               //                        if (periodeSetup!=0)
 497                               {
 498                                 long dmin, dmax;
 499                                 dmax=npipp->delaymax-periodeSetup-npipp->movemax;
 500                                 dmin=npipp->delaymin-periodeSetup-npipp->movemin;
 501                                 if (dmax<dmin)
 502                                   {
 503                                     long temp;
 504                                     temp=dmax;
 505                                     dmax=dmin;
 506                                     dmin=temp;
 507                                   }
 508                                 pair = stb_dupstbpairlist (STBTAB[startindex]);
 509                                 pair = stb_clippair( pair, npipp->startmin, npipp->startmax);
 510 //                                stb_assign_phase_to_stbpair(pair, startindex);
 511 #ifdef RELAX_CORRECT_DEBUG
 512                                 if (deb && pair)
 513                                 {
 514                                   printf(" this[%d %d]", pair->D+dmin, pair->U+dmax);
 515                                 }
 516 #endif
 517                                 if (first==1)
 518                                 {
 519                                   stb_freestbpair(vri[ckindex].realpair);
 520                                   vri[ckindex].realpair=NULL;
 521                                 }
 522                                 vri[ckindex].realpair = stb_transferstbpair (pair, vri[ckindex].realpair, dmax, dmin, 0, 0);
 523                                 if ((sf->ANALYSIS == STB_GLOB_ANALYSIS) && vri[ckindex].realpair!=NULL && vri[ckindex].realpair->NEXT!=NULL)
 524                                   {
 525                                     stbpair_list *sbp;
 526                                     vri[ckindex].realpair = stb_globalstbpair(sbp=vri[ckindex].realpair);
 527                                     stb_freestbpair(sbp);
 528                                   }
 529
 530 #ifdef RELAX_CORRECT_DEBUG
 531                                 if (deb)
 532                                 {
 533                                 ptstbpair = stb_globalstbpair(STBTAB[startindex]);
 534                                 printf(" MC:  startstab from %s (%c): [%ld %ld] (mcs=%ld) move:(%ld/%ld) totstab: \n", npi->start->ROOT->NAME, (npi->start->TYPE & TTV_NODE_UP)!=0?'u':'d', ptstbpair->D, ptstbpair->U, periodeSetup, npipp->movemin, npipp->movemax);
 535
 536                                 for (pair=vri[ckindex].realpair; pair!=NULL; pair=pair->NEXT)
 537                                   printf("[%ld %ld]", pair->D, pair->U);
 538                                 printf("\n");
 539                                 stb_freestbpair(ptstbpair);
 540                                 }
 541 #endif
 542                               }
 543                             }
 544 #ifdef RELAX_CORRECT_DEBUG
 545                            else if (deb)
 546                              printf("\n");
 547 #endif
 548
 549                         }
 550                     }
 551                 }
 552               stb_freestbtabpair(STBTAB, node->NBINDEX);
 553               stb_freestbtabpair(STBHZ, node->NBINDEX);
 554               if (ck==NULL) break;
 555               ck=ck->NEXT;
 556             } while (ck!=NULL);
 557
 558         }
 559       npi=npi->next;
 560     }
 561 }
 562
 563 int path_false_slack_check(ttvpath_list *tp, ttvevent_list *opencmd, ttvevent_list *topopenclock)
 564 {
 565   ttvevent_list *startclock, *endclocksetup, *endclockhold;
 566   int fs=0, fh=0;
 567   stbnode *node;
 568   stbck *nodeck;
 569   stbfig_list *sf;
 570
 571
 572   if (tp->LATCH==NULL) return 0;
 573
 574   node=stb_getstbnode(tp->ROOT);
 575   if (node==NULL) return 0;
 576
 577   for (nodeck=node->CK; nodeck!=NULL && nodeck->CMD!=opencmd; nodeck=nodeck->NEXT) ;
 578
 579   if (nodeck==NULL) return 0;
 580
 581   sf=stb_getstbfig(tp->NODE->ROOT->ROOT);
 582   stb_getslacktopclocks(NULL, node, 0, NULL, nodeck, &startclock, &endclocksetup, &endclockhold);
 583   if (endclocksetup!=NULL && (topopenclock==NULL || endclocksetup->ROOT==topopenclock->ROOT))
 584     fs=stb_isfalseslack(sf, tp->NODE, tp->LATCH, node->EVENT, endclocksetup, INF_FALSESLACK_SETUP);
 585
 586   if (endclockhold!=NULL && (topopenclock==NULL || endclockhold->ROOT==topopenclock->ROOT))
 587     fh=stb_isfalseslack(sf, tp->NODE, tp->LATCH, node->EVENT, endclockhold, INF_FALSESLACK_HOLD);
 588   if ((fs & INF_FALSESLACK_NOTHZ)!=0 && (fh & INF_FALSESLACK_NOTHZ)!=0) return 1;
 589   return 0;
 590 }