projects / tas-yagle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial version of donated sources by Avertec, 3.4p5.
[tas-yagle.git] / distrib / sources / yagle / yagle / yag_disa.c
1 /****************************************************************************/
2 /* */
3 /* Chaine de CAO & VLSI Alliance */
4 /* */
5 /* Produit : YAGLE v3.50 */
6 /* Fichier : yag_disa.c */
7 /* */
8 /* (c) copyright 1994 Laboratoire MASI equipe CAO & VLSI */
9 /* Tous droits reserves */
10 /* Support : e-mail alliance-support@asim.lip6.fr */
11 /* */
12 /* Auteur(s) : Anthony LESTER le : 12/04/1994 */
13 /* */
14 /* Modifie par : le : ../../.... */
15 /* Modifie par : le : ../../.... */
16 /* Modifie par : le : ../../.... */
17 /* */
18 /****************************************************************************/
19
20 #include "yag_headers.h"
21
22 yag_context_list *YAG_CONTEXT = NULL;
23
24 /* initialise first context to default values */
25
26 static void
27 yagInitialise()
28 {
29 YAG_CONTEXT->YAG_FILE = FALSE;
30 YAG_CONTEXT->YAG_CONE_NETLIST = FALSE;
31 YAG_CONTEXT->YAG_BEFIG = TRUE;
32 YAG_CONTEXT->YAG_BLACKBOX_SUPPRESS = FALSE;
33 YAG_CONTEXT->YAG_BLACKBOX_IGNORE = FALSE;
34 YAG_CONTEXT->YAG_NORC = FALSE;
35 YAG_CONTEXT->YAG_HIERARCHICAL_MODE = FALSE;
36 YAG_CONTEXT->YAG_CURLOFIG = NULL;
37 YAG_CONTEXT->YAG_CURCNSFIG = NULL;
38 YAG_CONTEXT->YAG_STAT_MODE = FALSE;
39 YAG_CONTEXT->YAG_LOOP_MODE = FALSE;
40 YAG_CONTEXT->YAG_SILENT_MODE = FALSE;
41 YAG_CONTEXT->YAG_HELP_S = FALSE;
42 YAG_CONTEXT->YAG_DEBUG_CONE = NULL;
43 YAG_CONTEXT->YAGLE_TOOLNAME = "yagle";
44 YAG_CONTEXT->YAGLE_LANG = 'E';
45 YAG_CONTEXT->YAGLE_ERR_FILE = NULL;
46 YAG_CONTEXT->YAGLE_STAT_FILE = NULL;
47 YAG_CONTEXT->YAGLE_LOOP_FILE = NULL;
48 YAG_CONTEXT->YAGLE_NB_ERR = 0;
49 YAG_CONTEXT->YAGLE_INSTANCE_BEFIGS = NULL;
50 YAG_CONTEXT->YAG_MAX_LINKS = 6;
51 YAG_CONTEXT->YAG_RELAX_LINKS = 6;
52 YAG_CONTEXT->YAG_BDDCEILING = 10000;
53 YAG_CONTEXT->YAG_MAXNODES = 0;
54 YAG_CONTEXT->YAG_LASTNODECOUNT = 0;
55 YAG_CONTEXT->YAG_FILENAME = NULL;
56 YAG_CONTEXT->YAG_FIGNAME = NULL;
57 YAG_CONTEXT->YAG_OUTNAME = NULL;
58 YAG_CONTEXT->YAG_REQUIRE_COMPLETE_GRAPH = TRUE;
59 YAG_CONTEXT->YAG_USE_FCF = 1;
60 YAG_CONTEXT->YAG_ONE_SUPPLY = 0;
61 YAG_CONTEXT->YAG_NO_SUPPLY = 0;
62 YAG_CONTEXT->YAG_ORIENT = 0;
63 YAG_CONTEXT->YAG_PROP_HZ = 0;
64 YAG_CONTEXT->YAG_MAKE_CELLS = 1;
65 YAG_CONTEXT->YAG_GENIUS = 0;
66 YAG_CONTEXT->YAG_ONLY_GENIUS = 0;
67 YAG_CONTEXT->YAG_CELL_SHARE = 0;
68 YAG_CONTEXT->YAG_DETECT_LATCHES = 1;
69 YAG_CONTEXT->YAG_DETECT_PRECHARGE = 0;
70 YAG_CONTEXT->YAG_BLEEDER_STRICTNESS = 1;
71 YAG_CONTEXT->YAG_LOOP_ANALYSIS = 1;
72 YAG_CONTEXT->YAG_AUTO_RS = 1;
73 YAG_CONTEXT->YAG_BUS_ANALYSIS = 0;
74 YAG_CONTEXT->YAG_FCL_DETECT = 0;
75 YAG_CONTEXT->YAG_ONLY_FCL = 0;
76 YAG_CONTEXT->YAG_DEPTH = 9;
77 YAG_CONTEXT->YAG_NOTSTRICT = 0;
78 YAG_CONTEXT->YAG_REMOVE_PARA = 1;
79 YAG_CONTEXT->YAG_MINIMISE_CONES = 0;
80 YAG_CONTEXT->YAG_RELAX_ALGO = 0;
81 YAG_CONTEXT->YAG_MINIMISE_INV = 0;
82 YAG_CONTEXT->YAG_GEN_SIGNATURE = 1;
83 YAG_CONTEXT->YAG_ASSUME_PRECEDE = 0;
84 YAG_CONTEXT->YAG_BLEEDER_PRECHARGE = 0;
85 YAG_CONTEXT->YAG_TRISTATE_MEMORY = 0;
86 YAG_CONTEXT->YAG_MARK_TRISTATE_MEMORY = 0;
87 YAG_CONTEXT->YAG_INTERFACE_VECTORS = 0;
88 YAG_CONTEXT->YAG_SIMPLIFY_EXPR = 0;
89 YAG_CONTEXT->YAG_SIMPLIFY_PROCESSES = 0;
90 YAG_CONTEXT->YAG_COMPACT_BEHAVIOUR = 0;
91 YAG_CONTEXT->YAG_ELP = 0;
92 YAG_CONTEXT->YAG_BLOCK_BIDIR = 0;
93 YAG_CONTEXT->YAG_STRICT_CKLATCH = 0;
94 YAG_CONTEXT->YAG_THRESHOLD = 3.0;
95 YAG_CONTEXT->YAG_TAS_TIMING = YAG_NO_TIMING;
96 YAG_CONTEXT->YAG_SPLITTIMING_RATIO = 3.0;
97 YAG_CONTEXT->YAG_SENSITIVE_RATIO = 0.0;
98 YAG_CONTEXT->YAG_SENSITIVE_MAX = 0;
99 YAG_CONTEXT->YAG_CONSTRAINT_LIST = NULL;
100 YAG_CONTEXT->YAG_BIABL_INDEX = 0;
101 YAG_CONTEXT->YAG_CURCIRCUIT = NULL;
102 YAG_CONTEXT->YAG_CONE_GRAPH = NULL;
103 YAG_CONTEXT->YAG_SUPPORT_GRAPH = NULL;
104 YAG_CONTEXT->YAG_ITERATIONS = 0;
105 YAG_CONTEXT->YAG_KEEP_REDUNDANT = 0;
106 YAG_CONTEXT->YAG_KEEP_GLITCHERS = 0;
107 YAG_CONTEXT->YAG_AUTOLOOP_CEILING = 15;
108 YAG_CONTEXT->YAG_AUTOLOOP_DEPTH = 9;
109 YAG_CONTEXT->YAG_BUS_DEPTH = 9;
110 YAG_CONTEXT->YAG_USESTMSOLVER = 0;
111 YAG_CONTEXT->YAG_UNMARK_BISTABLES = 0;
112 YAG_CONTEXT->YAG_LATCH_REQUIRE_CLOCK = 0;
113 YAG_CONTEXT->YAG_AUTO_FLIPFLOP = 1;
114 YAG_CONTEXT->YAG_AUTO_ASYNC = 0;
115 YAG_CONTEXT->YAG_AUTO_MEMSYM = 0;
116 YAG_CONTEXT->YAG_DETECT_REDUNDANT = 1;
117 YAG_CONTEXT->YAG_DETECT_LEVELHOLD = 0;
118 YAG_CONTEXT->YAG_SIMPLE_LATCH = 0;
119 YAG_CONTEXT->YAG_USE_CONNECTOR_DIRECTION = 0;
120 YAG_CONTEXT->YAG_CLOCK_GATE = 0;
121 YAG_CONTEXT->YAG_BEFIG_LIST = NULL;
122 YAG_CONTEXT->YAG_DETECT_SIMPLE_MEMSYM = 0;
123 YAG_CONTEXT->YAG_MEMSYM_HEURISTIC = 0;
124 YAG_CONTEXT->YAG_STUCK_LATCH = 1;
125 }
126
127 /****************************************************************************
128 * function yagDisassemble(); *
129 ****************************************************************************/
130
131 /**** disassembly of a transistor netlist ****/
132
133 cnsfig_list *yagDisassemble(char *figname, lofig_list *ptmbkfig, long mode)
134 {
135 cnsfig_list *ptcnsfig = NULL;
136 lofig_list *ptrootlofig = NULL;
137 lofig_list *ptcorelofig = NULL;
138 locon_list *ptcon = NULL;
139 locon_list *ptheadintcon = NULL;
140 locon_list *ptintcon = NULL;
141 losig_list *ptsig = NULL;
142 loins_list *ptins = NULL;
143 cone_list *ptcone = NULL;
144 cone_list *ptsymcone = NULL;
145 cone_list *ptloopcone = NULL;
146 cone_list *ptnextcone;
147 cell_list *ptcell;
148 cell_list *ptnextcell;
149 edge_list *ptinputs;
150 lotrs_list *pttrans = NULL, *ptothertrans = NULL;
151 chain_list *ptchain;
152 chain_list *recognised;
153 ptype_list *ptuser;
154 befig_list *ptbefig;
155 char *name;
156 char buffer[1024];
157 time_t start = 0;
158 time_t end = 0;
159 time_t counter;
160 struct rusage END;
161 struct rusage START;
162 long numpartial = 0;
163 long conesleft;
164 long previous;
165 long type;
166 long fcltype, otherfcltype;
167 int count;
168 int changes;
169 int build_befig;
170 int num_unused = 0;
171 int num_undrivengate = 0;
172 int num_bleeder = 0, num_levelhold = 0, num_latch = 0, num_rs = 0, num_flipflop = 0, num_dlatch = 0, num_bad = 0;
173 int num_loops = 0;
174 int num_noinputs = 0;
175 int num_nodrive = 0;
176 int num_bidir = 0;
177 int num_conf = 0;
178 int num_hz = 0;
179 int num_precharge = 0;
180 int numconunused = 0;
181 long num_cmosdual = 0;
182 long index = 1;
183 long value;
184 int relax = FALSE;
185 int close_err_file = FALSE;
186 int infval;
187 inffig_list *ifl;
188 chain_list *list0, *list1;
189 int loglvl1=0;
190 int stuck;
191
192 mbk_comcheck( mbk_signlofig(ptmbkfig), 0, 0 );
193
194 #ifdef AVT_EVAL
195 if (yagCountChains((chain_list *)ptmbkfig->LOTRS) > 3000) {
196 printf("\n\n");
197 printf("****************************************************\n");
198 printf("* Evaluation Version limited to 3000 Transistors *\n");
199 printf("****************************************************\n");
200 EXIT(0);
201 }
202 #endif
203
204 loglvl1 = avt_islog(1,LOGYAG);
205 if (YAG_CONTEXT == NULL) yagBug(DBG_NO_CONTEXT,"yagDisassemble",NULL,NULL,0);
206 if (YAG_CONTEXT->YAG_FIGNAME == NULL) YAG_CONTEXT->YAG_FIGNAME = ptmbkfig->NAME;
207 if (figname != NULL) YAG_CONTEXT->YAG_OUTNAME = figname;
208 if (YAG_CONTEXT->YAG_OUTNAME == NULL) YAG_CONTEXT->YAG_OUTNAME = YAG_CONTEXT->YAG_FIGNAME;
209 if ((mode & YAG_GENBEFIG) != 0) YAG_CONTEXT->YAG_BEFIG = TRUE;
210 else YAG_CONTEXT->YAG_BEFIG = FALSE;
211 #ifdef AVERTEC_LICENSE
212 if (YAG_CONTEXT->YAG_BEFIG) {
213 if(avt_givetoken("YAGLE_LICENSE_SERVER", "yagle")!=AVT_VALID_TOKEN) EXIT(1);
214 }
215 #endif
216
217 ifl=getloadedinffig(YAG_CONTEXT->YAG_FIGNAME);
218
219 if (ptmbkfig->LOTRS == NULL && ptmbkfig->LOINS == NULL) {
220 avt_errmsg(YAG_ERRMSG, "010", AVT_WARNING, ptmbkfig->NAME);
221 YAG_CONTEXT->YAG_CURCNSFIG = addcnsfig(CNS_HEADCNSFIG, YAG_CONTEXT->YAG_OUTNAME, ptmbkfig->LOCON, NULL, ptmbkfig->LOTRS, ptmbkfig->LOINS, NULL, NULL, NULL, NULL);
222 return YAG_CONTEXT->YAG_CURCNSFIG;
223 }
224 YAG_CONTEXT->YAG_CURLOFIG = ptmbkfig;
225
226 #ifdef AVERTEC_LICENSE
227 if(avt_givetoken("YAGLE_LICENSE_SERVER", YAG_CONTEXT->YAGLE_TOOLNAME)!=AVT_VALID_TOKEN) EXIT(1);
228 #endif
229
230
231 /*------------------------*
232 | Open .stat file |
233 *-------------------------*/
234
235 if (YAG_CONTEXT->YAG_STAT_MODE) {
236 YAG_CONTEXT->YAGLE_STAT_FILE=mbkfopen(YAG_CONTEXT->YAG_OUTNAME,"stat",WRITE_TEXT);
237 if(YAG_CONTEXT->YAGLE_STAT_FILE == NULL) {
238 char buff[YAGBUFSIZE];
239 sprintf(buff,"%s.stat",YAG_CONTEXT->YAG_OUTNAME);
240 avt_errmsg(YAG_ERRMSG, "006", AVT_FATAL, buff);
241 }
242 sprintf(buffer,"Statistic file : %s.stat\n",YAG_CONTEXT->YAG_OUTNAME);
243 avt_printExecInfo( YAG_CONTEXT->YAGLE_STAT_FILE, "#", buffer, "");
244 }
245
246 /*------------------------*
247 | Open .rep file |
248 *-------------------------*/
249
250 if (YAG_CONTEXT->YAGLE_ERR_FILE == NULL) {
251 YAG_CONTEXT->YAGLE_ERR_FILE=mbkfopen(YAG_CONTEXT->YAG_OUTNAME,"rep",WRITE_TEXT);
252 if(YAG_CONTEXT->YAGLE_ERR_FILE == NULL) {
253 char buff[YAGBUFSIZE];
254 sprintf(buff,"%s.rep",YAG_CONTEXT->YAG_OUTNAME);
255 avt_errmsg(YAG_ERRMSG, "006", AVT_FATAL, buff);
256 }
257
258 sprintf(buffer,"Report file : %s.rep\n",YAG_CONTEXT->YAG_OUTNAME);
259 avt_printExecInfo( YAG_CONTEXT->YAGLE_ERR_FILE, "#", buffer, "");
260
261 close_err_file = TRUE;
262 }
263
264 /*---------------------------------------------------------------------------*
265 | Report lofig statistics |
266 *----------------------------------------------------------------------------*/
267
268 if( YAG_CONTEXT->YAG_STAT_MODE == TRUE ) {
269 yagStatLofig(ptmbkfig) ;
270 }
271
272 /*---------------------------------------------------------------------------*
273 | Configuration check level II |
274 *----------------------------------------------------------------------------*/
275
276 if (1 /*TODO*/) {
277 chain_list *data, *lst;
278
279 data = NULL;
280
281 for (ptsig = ptmbkfig->LOSIG; ptsig; ptsig = ptsig->NEXT)
282 {
283 lst=dupchainlst(ptsig->NAMECHAIN);
284 data = append(lst, data);
285 }
286 if (ifl) {
287 inf_CheckRegistry(stdout,ifl,2,data);
288 }
289
290 freechain(data);
291 }
292
293
294 /*---------------------------------------------------------------------------*
295 | Mark power supply signals |
296 *----------------------------------------------------------------------------*/
297
298 yagFindSupplies(ifl, ptmbkfig, FALSE);
299 yagFindInternalSupplies(ifl, ptmbkfig, FALSE);
300 if(sim_SetPowerSupply (ptmbkfig)) stm_init();
301 mbk_CheckPowerSupplies(ptmbkfig);
302
303 /*--------------------------------------------------------------------------*
304 | Clean up the signal & connector names |
305 +---------------------------------------------------------------------------*/
306
307 yagAddVal_s(ifl, ptmbkfig);
308
309 for (ptsig = ptmbkfig->LOSIG; ptsig; ptsig = ptsig->NEXT) {
310 chain_list *savenames;
311 if ( loglvl1 ) {
312 ptsig->USER = addptype(ptsig->USER, YAG_CHECK_PTYPE, NULL);
313 }
314 name = yagGetName(ifl, ptsig);
315 savenames = ptsig->NAMECHAIN;
316 ptsig->NAMECHAIN = addchain(NULL, name);
317 for (ptchain = savenames; ptchain; ptchain = ptchain->NEXT) {
318 if (ptchain->DATA != name) ptsig->NAMECHAIN = addchain(ptsig->NAMECHAIN, ptchain->DATA);
319 }
320 ptsig->NAMECHAIN = reverse(ptsig->NAMECHAIN);
321 freechain(savenames);
322 }
323
324 if ( loglvl1 ) {
325 for (pttrans = ptmbkfig->LOTRS; pttrans; pttrans = pttrans->NEXT) {
326 if (getptype(pttrans->SOURCE->SIG->USER, YAG_CHECK_PTYPE) == NULL) {
327 fprintf(stderr, "Incoherent netlist at signal '%s'\n", (char *)pttrans->SOURCE->SIG->NAMECHAIN->DATA);
328 yagExit(1);
329 }
330 if (getptype(pttrans->DRAIN->SIG->USER, YAG_CHECK_PTYPE) == NULL) {
331 fprintf(stderr, "Incoherent netlist at signal '%s'\n", (char *)pttrans->DRAIN->SIG->NAMECHAIN->DATA);
332 yagExit(1);
333 }
334 if (getptype(pttrans->GRID->SIG->USER, YAG_CHECK_PTYPE) == NULL) {
335 fprintf(stderr, "Incoherent netlist at signal '%s'\n", (char *)pttrans->GRID->SIG->NAMECHAIN->DATA);
336 yagExit(1);
337 }
338 }
339 }
340
341 /*----------------------------------------------------------------------*
342 | Chain connector list to each signal |
343 *-----------------------------------------------------------------------*/
344
345 time(&start);
346 lofigchain(ptmbkfig);
347 time(&end);
348 end -= start;
349 fflush(stdout);
350
351 /*---------------------------------------------------------------------------*
352 | Mark the transparences |
353 *----------------------------------------------------------------------------*/
354
355 yagTestTransparence(ptmbkfig);
356
357 /*---------------------------------------------------------------------------*
358 | Mark Blackbox transistors as unused |
359 *----------------------------------------------------------------------------*/
360
361 yagMarkUnusedTrans(ptmbkfig);
362
363 /*---------------------------------------------------------------------------*
364 | Test des transistors |
365 *----------------------------------------------------------------------------*/
366
367 yagChrono(&START,&start);
368 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_TRANS_CHECKING,NULL);
369 yagTestTransistors(ptmbkfig, FALSE);
370 yagChrono(&END,&end);
371 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
372
373 /*---------------------------------------------------------------------------*
374 | Transfer INF_MARKSIG & INF_MARKTRANS |
375 *----------------------------------------------------------------------------*/
376
377 list0=inf_GetEntriesByType(ifl, INF_MARKTRANS, INF_ANY_VALUES);
378 if (list0 != NULL) {
379 yagInfMarkTrans(ifl, ptmbkfig, list0);
380 }
381 freechain(list0);
382 list0=inf_GetEntriesByType(ifl, INF_MARKSIG, INF_ANY_VALUES);
383 if (list0 != NULL) {
384 yagInfMarkSig(ifl, ptmbkfig, list0);
385 }
386 freechain(list0);
387
388 /*---------------------------------------------------------------------------*
389 | Hierarchical pattern recognition |
390 *----------------------------------------------------------------------------*/
391
392 if (YAG_CONTEXT->YAG_GENIUS || YAG_CONTEXT->YAG_ONLY_GENIUS) {
393 yagChrono(&START,&start);
394 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_GENIUS,NULL);
395 recognised = genius_main(ptmbkfig, NULL, NULL, YAG_CONTEXT->YAG_OUTNAME);
396
397 if (recognised != NULL) {
398
399 if (YAG_CONTEXT->YAG_ONLY_GENIUS) ptmbkfig = yagCutLofig(ifl, ptmbkfig, recognised, &ptrootlofig, FALSE);
400 else fclMarkInstances(ptmbkfig, recognised, FALSE, FALSE);
401 YAG_CONTEXT->YAG_CURLOFIG = ptmbkfig;
402 for (ptchain = recognised; ptchain; ptchain = ptchain->NEXT) {
403 ptins = (loins_list *)ptchain->DATA;
404 fclCleanTransList(ptins);
405 if ((ptbefig = beg_get_befigByName(ptins->INSNAME)) != NULL) {
406 YAG_CONTEXT->YAGLE_INSTANCE_BEFIGS = addchain(YAG_CONTEXT->YAGLE_INSTANCE_BEFIGS, ptbefig);
407 }
408 }
409 }
410
411 /* recreate LOFIGCHAIN */
412 lofigchain(ptmbkfig);
413
414 yagChrono(&END,&end);
415 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
416 }
417
418 if (YAG_CONTEXT->YAG_ONLY_GENIUS) {
419 if (recognised) {
420 lofig_list *ptrealrootfig;
421 char buf[YAGBUFSIZE];
422
423 sprintf(buf, "%s_yagroot", YAG_CONTEXT->YAG_FIGNAME);
424 ptrealrootfig = yagBuildGeniusBehHierarchy(ptrootlofig, ptmbkfig, recognised, namealloc(buf));
425 savelofig(ptrealrootfig);
426
427 /* delete GENIUS instances */
428 for (ptchain = recognised; ptchain; ptchain = ptchain->NEXT) {
429 fclDeleteInstance((loins_list *)ptchain->DATA);
430 }
431 freechain(recognised);
432
433 /* remove power supply markings and save core figure */
434 for (ptcon = ptmbkfig->LOCON; ptcon; ptcon = ptcon->NEXT) {
435 ptsig = ptcon->SIG;
436 if (ptsig->TYPE != 'E') {
437 ptsig->TYPE = 'E';
438 ptcon->DIRECTION = 'I';
439 }
440 }
441 for (ptsig = ptmbkfig->LOSIG; ptsig; ptsig = ptsig->NEXT) {
442 if (ptsig->TYPE != 'E' && ptsig->TYPE != 'I') {
443 ptsig->TYPE = 'I';
444 }
445 }
446 savelofig(ptmbkfig);
447 }
448 if (YAG_CONTEXT->YAG_STAT_MODE) fclose(YAG_CONTEXT->YAGLE_STAT_FILE);
449 fclose(YAG_CONTEXT->YAGLE_ERR_FILE);
450 return NULL;
451 }
452
453 /*---------------------------------------------------------------------------*
454 | Memory allocation and data structure initialisation |
455 *----------------------------------------------------------------------------*/
456
457 ptcnsfig = addcnsfig(CNS_HEADCNSFIG, YAG_CONTEXT->YAG_OUTNAME, ptmbkfig->LOCON, NULL, ptmbkfig->LOTRS, ptmbkfig->LOINS, NULL, NULL, ptmbkfig, NULL);
458 YAG_CONTEXT->YAG_CURCNSFIG = ptcnsfig;
459
460 /*---------------------------------------------------------------------------*
461 | Match cells from transistor net-list library |
462 *----------------------------------------------------------------------------*/
463
464 if (YAG_CONTEXT->YAG_FCL_DETECT) {
465 yagChrono(&START,&start);
466 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_MAKING_CELLS,NULL);
467 ptcnsfig->CELL = fclFindCells(ptmbkfig);
468 YAG_CONTEXT->YAGLE_INSTANCE_BEFIGS = append(YAG_CONTEXT->YAGLE_INSTANCE_BEFIGS, FCL_INSTANCE_BEFIGS);
469 yagChrono(&END,&end);
470 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
471 }
472 if (YAG_CONTEXT->YAG_ONLY_FCL) {
473 if (YAG_CONTEXT->YAG_STAT_MODE) fclose(YAG_CONTEXT->YAGLE_STAT_FILE);
474 fclose(YAG_CONTEXT->YAGLE_ERR_FILE);
475 return NULL;
476 }
477
478 /*---------------------------------------------------------------------------*
479 | Check switches after FCL |
480 *----------------------------------------------------------------------------*/
481 for (pttrans = ptmbkfig->LOTRS; pttrans; pttrans = pttrans->NEXT) {
482 fcltype = 0; otherfcltype = 0;
483 if ((ptuser = getptype(pttrans->USER, CNS_SWITCH)) != NULL) {
484 ptothertrans = (lotrs_list *)ptuser->DATA;
485 if ((ptuser = getptype(pttrans->USER, FCL_TRANSFER_PTYPE)) != NULL) {
486 fcltype = (long)ptuser->DATA;
487 }
488 if ((ptuser = getptype(ptothertrans->USER, FCL_TRANSFER_PTYPE)) != NULL) {
489 otherfcltype = (long)ptuser->DATA;
490 }
491 if (fcltype != otherfcltype) {
492 pttrans->USER = delptype(pttrans->USER, CNS_SWITCH);
493 ptothertrans->USER = delptype(ptothertrans->USER, CNS_SWITCH);
494 }
495 }
496 }
497
498 /*---------------------------------------------------------------------------*
499 | Restore parallel transistors |
500 *----------------------------------------------------------------------------*/
501 yagTransferParallel(ptmbkfig);
502 mbk_restoreparallel(ptmbkfig);
503 mbk_markparallel(ptmbkfig);
504 ptcnsfig->LOTRS = ptmbkfig->LOTRS;
505
506 ifl=getloadedinffig(YAG_CONTEXT->YAG_FIGNAME);
507
508 /*---------------------------------------------------------------------------*
509 | Create internal instance connectors |
510 *----------------------------------------------------------------------------*/
511
512 if ((ptuser = getptype(ptmbkfig->USER, FCL_LOCON_PTYPE)) != NULL) {
513 ptcnsfig->INTCON = ptuser->DATA;
514 }
515 ptheadintcon = NULL;
516 for (ptins = ptmbkfig->LOINS; ptins; ptins = ptins->NEXT) {
517 /* check for NEVER directive on instance */
518 if ((ptuser = getptype(ptins->USER, FCL_TRANSFER_PTYPE)) != NULL) {
519 if (((long)ptuser->DATA & FCL_NEVER) != 0) continue;
520 }
521 if ((ptbefig = beg_get_befigByName(ptins->INSNAME)) != NULL) {
522 YAG_CONTEXT->YAGLE_INSTANCE_BEFIGS = addchain(YAG_CONTEXT->YAGLE_INSTANCE_BEFIGS, ptbefig);
523 }
524 for (ptcon = ptins->LOCON; ptcon; ptcon = ptcon->NEXT) {
525 ptsig = ptcon->SIG;
526 if (ptsig->TYPE == CNS_SIGINT) {
527 ptsig->TYPE = CNS_SIGEXT;
528 ptintcon = (locon_list *)mbkalloc(sizeof(locon_list));
529 ptintcon->NAME = (char *)ptsig->NAMECHAIN->DATA;
530 ptintcon->SIG = ptsig;
531 ptintcon->ROOT = NULL;
532 ptintcon->DIRECTION = 'X';
533 ptintcon->TYPE = EXTERNAL;
534 ptintcon->USER = NULL;
535 ptintcon->NEXT = ptheadintcon;
536 ptintcon->PNODE = NULL;
537 ptheadintcon = ptintcon;
538 }
539 }
540 }
541 for (ptcon = ptheadintcon; ptcon; ptcon = ptcon->NEXT) {
542 ptcon->SIG->TYPE = 'I';
543 }
544 if (ptheadintcon != NULL) {
545 ptcnsfig->INTCON = (locon_list *)append((chain_list *)ptcnsfig->INTCON, (chain_list *)ptheadintcon);
546 }
547
548 /*---------------------------------------------------------------------------*
549 | Additional CNS initialisation |
550 *----------------------------------------------------------------------------*/
551
552 ptcnsfig->LOCON = ptmbkfig->LOCON;
553 ptcnsfig->LOTRS = ptmbkfig->LOTRS;
554 ptcnsfig->LOINS = ptmbkfig->LOINS;
555
556 for (ptcon=ptcnsfig->LOCON;ptcon != NULL;ptcon=ptcon->NEXT) {
557 // delloconuser( ptcon );
558 ptcon->ROOT = (void *)ptcnsfig;
559 // ptcon->USER = NULL;
560 }
561 if (ptcnsfig->INTCON != NULL) {
562 locon_list *ptprevcon = NULL;
563 locon_list *ptnextcon = NULL;
564
565 for (ptcon = ptcnsfig->INTCON; ptcon; ptcon = ptnextcon) {
566 ptnextcon = ptcon->NEXT;
567 ptcon->ROOT = (void *)ptcnsfig;
568 if (ptcon->SIG->TYPE == 'I') {
569 ptcon->SIG->TYPE = 'E';
570 ptuser = getptype(ptcon->SIG->USER, LOFIGCHAIN);
571 if (ptuser != NULL) {
572 ptuser->DATA = addchain(ptuser->DATA, ptcon);
573 }
574 ptprevcon = ptcon;
575 }
576 else {
577 if (ptprevcon == NULL) ptcnsfig->INTCON = ptnextcon;
578 else ptprevcon->NEXT = ptnextcon;
579 delloconuser(ptcon);
580 mbkfree(ptcon);
581 }
582 }
583 }
584
585 /*---------------------------------------------------------------------------*
586 | Mark INF_INPUT connectors |
587 *----------------------------------------------------------------------------*/
588
589 list0=inf_GetEntriesByType(ifl, INF_INPUTS, INF_ANY_VALUES);
590 if (list0 != NULL) {
591 for (ptcon = ptcnsfig->LOCON; ptcon != NULL; ptcon = ptcon->NEXT) {
592 for (ptchain = list0; ptchain; ptchain = ptchain->NEXT) {
593 if (mbk_TestREGEX(ptcon->NAME, (char *)ptchain->DATA) || mbk_LosigTestREGEX(ptcon->SIG, (char *)ptchain->DATA)) {
594 ptcon->USER = addptype(ptcon->USER, YAG_INPUT_PTYPE, NULL);
595 }
596 }
597 }
598 YAG_CONTEXT->YAG_FLAGS|=YAG_HAS_INF_INPUTS;
599 }
600 freechain(list0);
601
602 /*---------------------------------------------------------------------------*
603 | Report oriented signals |
604 *----------------------------------------------------------------------------*/
605
606 for (ptsig = ptmbkfig->LOSIG; ptsig; ptsig = ptsig->NEXT) {
607 if ((value = yagGetVal_s(ptsig)) >= 0) {
608 yagWarning(WAR_VALUE_S, NULL, (char *)ptsig->NAMECHAIN->DATA, NULL, (int)value);
609 }
610 }
611
612 /*---------------------------------------------------------------------------*
613 | Initialisation of Bdd toolbox |
614 *----------------------------------------------------------------------------*/
615
616 initializeBdd(0);
617
618 /*---------------------------------------------------------------------------*
619 | Fabrication of CMOS dual cones |
620 *----------------------------------------------------------------------------*/
621
622 yagChrono(&START,&start);
623 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_DUAL_EXTRACT,NULL);
624 ptcnsfig->CONE = yagMakeConeList(ifl, ptmbkfig, ptcnsfig);
625 yagChrono(&END,&end);
626 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
627
628 if ( loglvl1 ) yagCountDualTrans(ptcnsfig);
629
630 /*---------------------------------------------------------------------------*
631 | Configuration check level III |
632 *----------------------------------------------------------------------------*/
633
634 if (1 /*TODO*/) {
635 chain_list *data;
636 ptype_list *pt;
637
638 data = NULL;
639
640 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT)
641 {
642 pt=getptype(ptcone->USER, CNS_SIGNAL);
643 if (pt!=NULL)
644 data=append(dupchainlst(((losig_list *)pt->DATA)->NAMECHAIN), data);
645 else
646 data = addchain(data,ptcone->NAME);
647 }
648 if (ifl) {
649 inf_CheckRegistry(stdout,ifl,3,data);
650 }
651
652 freechain(data);
653 }
654
655 /*---------------------------------------------------------------------------*
656 | Mark INF_STOP cones |
657 *----------------------------------------------------------------------------*/
658
659 list0=inf_GetEntriesByType(ifl, INF_STOP, INF_ANY_VALUES);
660 if (list0!=NULL) {
661 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
662 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
663 for (ptchain = list0; ptchain; ptchain = ptchain->NEXT) {
664 if (mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
665 ptcone->TYPE |= YAG_STOP;
666 }
667 }
668 }
669 }
670 freechain(list0);
671
672 /*---------------------------------------------------------------------------*
673 | Mark INF_SENSITIVE cones |
674 *----------------------------------------------------------------------------*/
675
676 list0=inf_GetEntriesByType(ifl, INF_SENSITIVE, INF_ANY_VALUES);
677 if (list0 != NULL) {
678 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
679 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
680 for (ptchain = list0; ptchain; ptchain = ptchain->NEXT) {
681 if (mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
682 ptcone->TECTYPE |= YAG_SENSITIVE;
683 }
684 }
685 }
686 }
687 freechain(list0);
688
689 /*---------------------------------------------------------------------------*
690 | Mark INF_DLATCH cones |
691 *----------------------------------------------------------------------------*/
692
693 list0=inf_GetEntriesByType(ifl, INF_DLATCH, INF_YES);
694 list1=inf_GetEntriesByType(ifl, INF_DLATCH, INF_NO);
695 if (list0 != NULL || list1 != NULL) {
696 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
697 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
698 for (ptchain = list0; ptchain; ptchain = ptchain->NEXT) {
699 if (mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
700 if ((ptuser = getptype(ptcone->USER, YAG_INFO_PTYPE)) != NULL) {
701 ptuser->DATA = (void *)((long)ptuser->DATA | YAG_INFODLATCH);
702 }
703 else ptcone->USER = addptype(ptcone->USER, YAG_INFO_PTYPE, (void *)YAG_INFODLATCH);
704 }
705 }
706 for (ptchain = list1; ptchain; ptchain = ptchain->NEXT) {
707 if (mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
708 if ((ptuser = getptype(ptcone->USER, YAG_INFO_PTYPE)) != NULL) {
709 ptuser->DATA = (void *)((long)ptuser->DATA | YAG_INFONOTDLATCH);
710 }
711 else ptcone->USER = addptype(ptcone->USER, YAG_INFO_PTYPE, (void *)YAG_INFONOTDLATCH);
712 }
713 }
714 }
715 }
716 freechain(list0);
717 freechain(list1);
718
719 /*---------------------------------------------------------------------------*
720 | Mark INF_PRECHARGE cones |
721 *----------------------------------------------------------------------------*/
722
723 list0=inf_GetEntriesByType(ifl, INF_PRECHARGE, INF_YES);
724 list1=inf_GetEntriesByType(ifl, INF_PRECHARGE, INF_NO);
725 if (list0 != NULL || list1 != NULL) {
726 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
727 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
728 for (ptchain = list0; ptchain; ptchain = ptchain->NEXT) {
729 if (mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
730 ptcone->TYPE |= CNS_PRECHARGE;
731 if ((ptuser = getptype(ptcone->USER, YAG_INFO_PTYPE)) != NULL) {
732 ptuser->DATA = (void *)((long)ptuser->DATA | YAG_INFOPRECHARGE);
733 }
734 else ptcone->USER = addptype(ptcone->USER, YAG_INFO_PTYPE, (void *)YAG_INFOPRECHARGE);
735 }
736 }
737 for (ptchain = list1; ptchain; ptchain = ptchain->NEXT) {
738 if (mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
739 if ((ptuser = getptype(ptcone->USER, YAG_INFO_PTYPE)) != NULL) {
740 ptuser->DATA = (void *)((long)ptuser->DATA | YAG_INFONOTPRECHARGE);
741 }
742 else ptcone->USER = addptype(ptcone->USER, YAG_INFO_PTYPE, (void *)YAG_INFONOTPRECHARGE);
743 }
744 }
745 }
746 }
747 freechain(list0);
748 freechain(list1);
749
750 /*---------------------------------------------------------------------------*
751 | Mark INF_MARKRS cones |
752 *----------------------------------------------------------------------------*/
753
754 list0=inf_GetEntriesByType(ifl, INF_MARKRS, INF_ANY_VALUES);
755 if (list0 != NULL) {
756 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
757 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
758 for (ptchain = list0; ptchain; ptchain = ptchain->NEXT) {
759 if ((name = mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) != NULL) {
760 inf_GetInt (ifl, name, INF_MARKRS, &infval);
761 switch (infval) {
762 case INF_RS_ILLEGAL: type = YAG_INFORSILLEGAL; break;
763 case INF_RS_LEGAL: type = YAG_INFORSLEGAL; break;
764 case INF_RS_MARKONLY: type = YAG_INFORSMARK; break;
765 default: type = 0;
766 }
767 if (type != 0) {
768 if ((ptuser = getptype(ptcone->USER, YAG_INFO_PTYPE)) != NULL) {
769 ptuser->DATA = (void *)((long)ptuser->DATA | type);
770 }
771 else ptcone->USER = addptype(ptcone->USER, YAG_INFO_PTYPE, (void *)type);
772 }
773 }
774 }
775 }
776 }
777 freechain(list0);
778
779 /*---------------------------------------------------------------------------*
780 | Mark INF_MEMSYM cones |
781 *----------------------------------------------------------------------------*/
782
783 if (inf_GetPointer(ifl, INF_MEMSYM, "", (void **)&list0)) {
784 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
785 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
786 for (ptchain = list0; ptchain; ptchain = ptchain->NEXT) {
787 if (mbk_LosigTestREGEX(ptsig, ((inf_assoc *)ptchain->DATA)->orig)) {
788 ptcone->TYPE |= CNS_MEMSYM;
789 }
790 if (mbk_LosigTestREGEX(ptsig, ((inf_assoc *)ptchain->DATA)->dest)) {
791 ptcone->TYPE |= CNS_MEMSYM;
792 }
793 }
794 }
795 }
796
797 /*---------------------------------------------------------------------------*
798 | Mark INF_MODELLOOP cones |
799 *----------------------------------------------------------------------------*/
800
801 list0=inf_GetEntriesByType(ifl, INF_MODELLOOP, INF_YES);
802 list1=inf_GetEntriesByType(ifl, INF_MODELLOOP, INF_NO);
803 if (list0 != NULL || list1 != NULL) {
804 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
805 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
806 for (ptchain = list0; ptchain; ptchain = ptchain->NEXT) {
807 if (mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
808 if ((ptuser = getptype(ptcone->USER, YAG_INFO_PTYPE)) != NULL) {
809 ptuser->DATA = (void *)((long)ptuser->DATA | YAG_INFOMODELLOOP);
810 }
811 else ptcone->USER = addptype(ptcone->USER, YAG_INFO_PTYPE, (void *)YAG_INFOMODELLOOP);
812 }
813 }
814 for (ptchain = list1; ptchain; ptchain = ptchain->NEXT) {
815 if (mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
816 if ((ptuser = getptype(ptcone->USER, YAG_INFO_PTYPE)) != NULL) {
817 ptuser->DATA = (void *)((long)ptuser->DATA | YAG_INFONOTMODELLOOP);
818 }
819 else ptcone->USER = addptype(ptcone->USER, YAG_INFO_PTYPE, (void *)YAG_INFONOTMODELLOOP);
820 }
821 }
822 }
823 }
824 freechain(list0);
825 freechain(list1);
826
827 /*---------------------------------------------------------------------------*
828 | Chain the transistor gates to the driving cone |
829 *----------------------------------------------------------------------------*/
830
831 for (pttrans = ptcnsfig->LOTRS; pttrans != NULL; pttrans = pttrans->NEXT) {
832 yagChainTrans(pttrans);
833 }
834
835 /*---------------------------------------------------------------------------*
836 | Reset the BDD toolbox |
837 *----------------------------------------------------------------------------*/
838
839 yagControlBdd(1);
840
841 /*---------------------------------------------------------------------------*
842 | Chaining of CMOS dual cones |
843 *----------------------------------------------------------------------------*/
844
845 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
846 if ((ptcone->TECTYPE & CNS_DUAL_CMOS) != 0) {
847 yagChainDual(ptcone);
848 if (yagDetectTransfer(ptcone)) {
849 yagChainCone(ptcone);
850 ptcone->TYPE &= ~YAG_HASDUAL;
851 cnsConeFunction(ptcone, FALSE);
852 }
853 }
854 }
855
856 /*---------------------------------------------------------------------------*
857 | Mark inversion substitution for switches |
858 *----------------------------------------------------------------------------*/
859
860 yagAddSwitchInversion(ptcnsfig);
861
862 /*---------------------------------------------------------------------------*
863 | Bleeder Detection |
864 *----------------------------------------------------------------------------*/
865
866 yagChrono(&START,&start);
867 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_BLEED_EXTRACT,NULL);
868 for (ptcone = ptcnsfig->CONE; ptcone; ptcone = ptcone->NEXT) {
869 if ((ptcone->TECTYPE & CNS_DUAL_CMOS) != 0) {
870 count = yagCountActiveEdges(ptcone->INCONE);
871 if (count == 1 || (count == 2 && YAG_CONTEXT->YAG_BLEEDER_STRICTNESS < 2)) {
872 yagExtractBleeder(ifl, ptcone);
873 }
874 }
875 }
876 yagChrono(&END,&end);
877 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
878
879 /*---------------------------------------------------------------------------*
880 | Chaining of temporary cones |
881 *----------------------------------------------------------------------------*/
882 #ifdef DELAY_DEBUG_STAT
883 mbk_debugstat (NULL, 1);
884 #endif
885
886 ptuser = getptype(ptcnsfig->USER, YAG_TEMPCONE_PTYPE);
887 if (ptuser != NULL) {
888 for (ptcone = (cone_list *)ptuser->DATA; ptcone != NULL; ptcone = ptcone->NEXT) {
889 yagChainDual(ptcone);
890 }
891 }
892 #ifdef DELAY_DEBUG_STAT
893 mbk_debugstat ("chaindual:", 0);
894 #endif
895
896 /*---------------------------------------------------------------------------*
897 | Parallel branch and transistor detection on CMOS dual cones |
898 *----------------------------------------------------------------------------*/
899
900 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
901 if ((ptcone->TECTYPE & CNS_DUAL_CMOS) != 0) {
902 yagDetectParallelBranches(ptcone);
903 yagDetectParaTrans(ptcone);
904 }
905 }
906
907 #ifdef DELAY_DEBUG_STAT
908 mbk_debugstat ("detect // branches:", 0);
909 #endif
910
911 /*---------------------------------------------------------------------------*
912 | Mark INF_CONSTRAINT cones and connectors |
913 *----------------------------------------------------------------------------*/
914
915 list0=inf_GetEntriesByType(ifl, INF_STUCK, (char *)(long)0);
916 list1=inf_GetEntriesByType(ifl, INF_STUCK, (char *)(long)1);
917 if (list0 != NULL || list1!=NULL) {
918 for (ptcon = ptcnsfig->LOCON; ptcon; ptcon = ptcon->NEXT) {
919 for (ptchain=list0; ptchain!=NULL; ptchain=ptchain->NEXT) {
920 if (mbk_TestREGEX(ptcon->NAME, (char *)ptchain->DATA) || mbk_LosigTestREGEX(ptcon->SIG, (char *)ptchain->DATA)) {
921 if ((ptuser = getptype(ptcon->USER, CNS_TYPELOCON)) != NULL) {
922 ptuser->DATA = (void *)((long)ptuser->DATA | CNS_ZERO);
923 }
924 else ptcon->USER = addptype(ptcon->USER, CNS_TYPELOCON, (void *)CNS_ZERO);
925 }
926 }
927 for (ptchain=list1; ptchain!=NULL; ptchain=ptchain->NEXT) {
928 if (mbk_TestREGEX(ptcon->NAME, (char *)ptchain->DATA) || mbk_LosigTestREGEX(ptcon->SIG, (char *)ptchain->DATA)) {
929 if ((ptuser = getptype(ptcon->USER, CNS_TYPELOCON)) != NULL) {
930 ptuser->DATA = (void *)((long)ptuser->DATA | CNS_ONE);
931 }
932 else ptcon->USER = addptype(ptcon->USER, CNS_TYPELOCON, (void *)CNS_ONE);
933 }
934 }
935 }
936 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
937 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
938 for (ptchain=list0; ptchain!=NULL; ptchain=ptchain->NEXT) {
939 if (mbk_TestREGEX(ptcone->NAME, (char *)ptchain->DATA) || mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
940 ptcone->TECTYPE |= CNS_ZERO;
941 ptcone->TYPE |= YAG_FORCEPRIM;
942 ptcone->TYPE &= ~YAG_PARTIAL;
943 }
944 }
945 for (ptchain=list1; ptchain!=NULL; ptchain=ptchain->NEXT) {
946 if (mbk_TestREGEX(ptcone->NAME, (char *)ptchain->DATA) || mbk_LosigTestREGEX(ptsig, (char *)ptchain->DATA)) {
947 ptcone->TECTYPE |= CNS_ONE;
948 ptcone->TYPE |= YAG_FORCEPRIM;
949 ptcone->TYPE &= ~YAG_PARTIAL;
950 }
951 }
952 }
953 }
954 freechain(list0);
955 freechain(list1);
956
957 #ifdef DELAY_DEBUG_STAT
958 mbk_debugstat ("stuck:", 0);
959 #endif
960
961 /*---------------------------------------------------------------------------*
962 | Propagate stuck-at values |
963 *----------------------------------------------------------------------------*/
964
965 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
966 yagBuildOutputs(ptcone);
967 }
968 changes = FALSE;
969 do {
970 changes = FALSE;
971 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
972 if ((ptcone->TECTYPE & (CNS_ZERO|CNS_ONE)) != 0) {
973 if (yagPropagateStuck(ptcone)) changes = TRUE;
974 }
975 }
976 } while (changes);
977
978 #ifdef DELAY_DEBUG_STAT
979 mbk_debugstat ("propstuck:", 0);
980 #endif
981
982 /*---------------------------------------------------------------------------*
983 | Building of global graph |
984 *----------------------------------------------------------------------------*/
985
986 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
987 if ((ptcone->TYPE & YAG_PARTIAL) != 0) {
988 numpartial++;
989 ptinputs = yagGetConeInputs(ifl, ptcone);
990 ptcone->USER = addptype(ptcone->USER, YAG_INPUTS_PTYPE, ptinputs);
991 }
992 }
993
994 ptuser = getptype(ptcnsfig->USER, YAG_GLUECONE_PTYPE);
995 if (ptuser != NULL) {
996 for (ptcone = (cone_list *)ptuser->DATA; ptcone != NULL; ptcone = ptcone->NEXT) {
997 ptinputs = yagGetConeInputs(ifl, ptcone);
998 ptcone->USER = addptype(ptcone->USER, YAG_INPUTS_PTYPE, ptinputs);
999 }
1000 }
1001 #ifdef DELAY_DEBUG_STAT
1002 mbk_debugstat ("global graph:", 0);
1003 #endif
1004
1005 /*---------------------------------------------------------------------------*
1006 | Detect two cone loops in global graph |
1007 *----------------------------------------------------------------------------*/
1008
1009 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1010 yagMarkLoopConf(ptcone);
1011 }
1012
1013 #ifdef DELAY_DEBUG_STAT
1014 mbk_debugstat ("detect loop:", 0);
1015 #endif
1016
1017 /*---------------------------------------------------------------------------*
1018 | Contraint initialisation |
1019 *----------------------------------------------------------------------------*/
1020
1021 yagInitConstraints(ifl);
1022
1023 /*---------------------------------------------------------------------------*
1024 | Mark multi-voltage |
1025 *----------------------------------------------------------------------------*/
1026
1027 #ifndef WITHOUT_TAS
1028 if (YAG_CONTEXT->YAG_USESTMSOLVER) {
1029 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1030 yagPrepStmSolver(ptcone);
1031 }
1032 }
1033 #endif
1034 #ifdef DELAY_DEBUG_STAT
1035 mbk_debugstat ("init constraint + solver:", 0);
1036 #endif
1037
1038 /*---------------------------------------------------------------------------*
1039 | Glitcher detection in CMOS Duals |
1040 *----------------------------------------------------------------------------*/
1041
1042 if (V_INT_TAB[__YAGLE_KEEP_GLITCHERS].VALUE == 2) {
1043 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1044 yagDetectDualGlitcherBranches(ptcone);
1045 }
1046 }
1047
1048 /*---------------------------------------------------------------------------*
1049 | Building the cones |
1050 *----------------------------------------------------------------------------*/
1051
1052 YAG_CONTEXT->YAG_REQUIRE_COMPLETE_GRAPH = TRUE;
1053 yagChrono(&START,&start);
1054 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_MAKING_GATES, NULL);
1055 YAG_CONTEXT->YAG_ITERATIONS = 0;
1056 conesleft = numpartial;
1057 while (conesleft != 0) {
1058 previous = conesleft;
1059 conesleft = yagScanCones(ifl, ptcnsfig->CONE);
1060 if (previous == conesleft) {
1061 YAG_CONTEXT->YAG_MAX_LINKS = YAG_CONTEXT->YAG_RELAX_LINKS;
1062 if (YAG_CONTEXT->YAG_RELAX_ALGO) {
1063 YAG_CONTEXT->YAG_USE_FCF = FALSE;
1064 }
1065 else YAG_CONTEXT->YAG_REQUIRE_COMPLETE_GRAPH = FALSE;
1066 relax = TRUE;
1067 }
1068 }
1069 yagChrono(&END,&end);
1070 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
1071
1072 /*---------------------------------------------------------------------------*
1073 | Delete cells containing no cones and no befig |
1074 *----------------------------------------------------------------------------*/
1075
1076 for (ptcell = ptcnsfig->CELL; ptcell; ptcell = ptnextcell) {
1077 ptnextcell = ptcell->NEXT;
1078 if (ptcell->CONES == NULL && ptcell->BEFIG == NULL) {
1079 ptcnsfig->CELL = delcell(ptcnsfig->CELL, ptcell);
1080 }
1081 }
1082
1083 /*---------------------------------------------------------------------------*
1084 | Final pre-relaxation loop analysis and standard latch detection |
1085 *----------------------------------------------------------------------------*/
1086
1087 if (YAG_CONTEXT->YAG_LOOP_ANALYSIS || YAG_CONTEXT->YAG_DETECT_LATCHES || YAG_CONTEXT->YAG_SIMPLE_LATCH) {
1088 yagChrono(&START,&start);
1089 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_LATCH_DETECTION, NULL);
1090 }
1091
1092 if (YAG_CONTEXT->YAG_SIMPLE_LATCH) {
1093 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1094 yagMatchSimpleLatch(ptcone);
1095 }
1096 }
1097
1098 if (YAG_CONTEXT->YAG_LOOP_ANALYSIS) {
1099 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1100 if (yagDetectFalseConf(ptcone)) yagChainCone(ptcone);
1101 yagAnalyseLoop(ptcone, TRUE);
1102 }
1103 do {
1104 changes = FALSE;
1105 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1106 if (yagDetectFalseConf(ptcone)) ptcone->TYPE |= YAG_MARK;
1107 yagRmvThruLatch(ptcone);
1108 yagRmvThruBleed(ptcone);
1109 if ((ptcone->TYPE & YAG_MARK) != 0) {
1110 changes = TRUE;
1111 if ((ptcone->TYPE & YAG_AUTOLATCH) != 0) {
1112 yagUnmarkLatch(ptcone, FALSE, FALSE);
1113 }
1114 yagChainCone(ptcone);
1115 yagAnalyseCone(ptcone);
1116 ptcone->TYPE &= ~YAG_MARK;
1117 }
1118 }
1119 } while (changes);
1120 }
1121
1122 if (YAG_CONTEXT->YAG_DETECT_LATCHES) {
1123 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1124 if ((ptcone->TYPE & (CNS_LATCH|CNS_MEMSYM|CNS_RS|CNS_PRECHARGE)) == 0
1125 && ptcone->CELLS == NULL && (ptcone->TECTYPE & YAG_NOTLATCH) == 0) {
1126 yagMatchLatch(ptcone);
1127 }
1128 }
1129 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1130 if ((ptcone->TYPE & YAG_FALSECONF) != 0) {
1131 yagRmvThruLatch(ptcone);
1132 yagChainCone(ptcone);
1133 }
1134 if ((ptcone->TYPE & YAG_LOOPCONF) != 0) {
1135 yagDetectLoopConf(ptcone);
1136 }
1137 }
1138 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptnextcone) {
1139 ptnextcone = ptcone->NEXT;
1140 if ((ptcone->TYPE & YAG_MARK) == YAG_MARK) {
1141 yagAnalyseCone(ptcone);
1142 ptcone->TYPE &= ~YAG_MARK;
1143 }
1144 }
1145 }
1146
1147 if (YAG_CONTEXT->YAG_LOOP_ANALYSIS || YAG_CONTEXT->YAG_DETECT_LATCHES) {
1148 yagChrono(&END,&end);
1149 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
1150 }
1151
1152 /*---------------------------------------------------------------------------*
1153 | Bleeder Detection |
1154 *----------------------------------------------------------------------------*/
1155 for (ptcone = ptcnsfig->CONE; ptcone; ptcone = ptcone->NEXT) {
1156 if ((ptcone->TYPE & (CNS_LATCH|CNS_MEMSYM|CNS_RS|CNS_MASTER|CNS_SLAVE)) != 0) continue;
1157 yagDetectBleeder(ptcone);
1158 }
1159 for (ptcone = ptcnsfig->CONE; ptcone; ptcone = ptcone->NEXT) {
1160 if ((ptcone->TYPE & YAG_FALSECONF) != 0) {
1161 yagRmvThruBleed(ptcone);
1162 }
1163 if ((ptcone->TYPE & YAG_LOOPCONF) != 0) {
1164 yagDetectLoopConf(ptcone);
1165 }
1166 if ((ptcone->TYPE & YAG_MARK) != 0) {
1167 yagChainCone(ptcone);
1168 yagAnalyseCone(ptcone);
1169 ptcone->TYPE &= ~YAG_MARK;
1170 relax = TRUE;
1171 }
1172 }
1173
1174 /*---------------------------------------------------------------------------*
1175 | Select a latch in symmetric registers |
1176 *----------------------------------------------------------------------------*/
1177
1178 /* pair off CNS_MEMSYM cones */
1179 for (ptcone = ptcnsfig->CONE; ptcone; ptcone = ptcone->NEXT) {
1180 if ((ptcone->TYPE & CNS_MEMSYM) != 0) {
1181 if (getptype(ptcone->USER, YAG_MEMORY_PTYPE) == NULL) {
1182 yagPairMemsym(ifl, ptcone);
1183 }
1184 if (getptype(ptcone->USER, YAG_MEMORY_PTYPE) == NULL) {
1185 ptcone->TYPE &= ~CNS_MEMSYM;
1186 }
1187 }
1188 }
1189
1190 /*---------------------------------------------------------------------------*
1191 | Update two-cone loop marks and re-verify if necessary |
1192 *----------------------------------------------------------------------------*/
1193
1194 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1195 yagDetectLoopConf(ptcone);
1196 }
1197 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1198 if ((ptcone->TYPE & YAG_FALSECONF) != 0) {
1199 yagDetectFalseConf(ptcone);
1200 if ((ptcone->TYPE & YAG_FALSECONF) == 0) {
1201 yagChainCone(ptcone);
1202 yagAnalyseCone(ptcone);
1203 }
1204 }
1205 }
1206
1207 /*---------------------------------------------------------------------------*
1208 | Desb-like relaxation |
1209 *----------------------------------------------------------------------------*/
1210 if (relax == TRUE) {
1211 yagChrono(&START,&start);
1212 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_RELAX, NULL);
1213 YAG_CONTEXT->YAG_USE_FCF = TRUE;
1214 changes = TRUE;
1215 YAG_CONTEXT->YAG_ITERATIONS = 1;
1216 while (changes) {
1217 avt_log(LOGYAG,1, "Starting relaxation iteration %d\n\n", YAG_CONTEXT->YAG_ITERATIONS++);
1218 changes = yagDepthFirstProcess(ptcnsfig->CONE, yagRemoveFalseBranches);
1219 }
1220 yagChrono(&END,&end);
1221 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
1222 }
1223
1224 /*---------------------------------------------------------------------------*
1225 | Mark non-functional external branches |
1226 *----------------------------------------------------------------------------*/
1227 #ifdef DELAY_DEBUG_STAT
1228 mbk_debugstat (NULL, 1);
1229 #endif
1230
1231 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1232 if (ptcone->BREXT != NULL) yagRmvFalseBrext(ptcone);
1233 }
1234
1235 #ifdef DELAY_DEBUG_STAT
1236 mbk_debugstat ("remove false branch:", 0);
1237 #endif
1238
1239 /*---------------------------------------------------------------------------*
1240 | Loop Analysis after relaxation |
1241 *----------------------------------------------------------------------------*/
1242
1243 if (YAG_CONTEXT->YAG_LOOP_ANALYSIS) {
1244 int changed = FALSE;
1245 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1246 count = yagCountLoops(ptcone, FALSE);
1247 if (count > 0) {
1248 yagAnalyseLoop(ptcone, FALSE);
1249 changed = TRUE;
1250 ptcone->TYPE |= YAG_MARK;
1251 }
1252 }
1253 if (changed) {
1254 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1255 if ((ptcone->TYPE & YAG_FALSECONF) != 0) {
1256 yagRmvThruLatch(ptcone);
1257 yagChainCone(ptcone);
1258 }
1259 if ((ptcone->TYPE & YAG_LOOPCONF) != 0) {
1260 yagDetectLoopConf(ptcone);
1261 }
1262 }
1263 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptnextcone) {
1264 ptnextcone = ptcone->NEXT;
1265 if ((ptcone->TYPE & YAG_MARK) == YAG_MARK) {
1266 yagAnalyseCone(ptcone);
1267 ptcone->TYPE &= ~YAG_MARK;
1268 }
1269 }
1270 }
1271 }
1272 #ifdef DELAY_DEBUG_STAT
1273 mbk_debugstat ("loop analysis:", 0);
1274 #endif
1275
1276 /*---------------------------------------------------------------------------*
1277 | Final check for any FALSECONF and DEGRADED |
1278 *----------------------------------------------------------------------------*/
1279
1280 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1281 yagDetectDegraded(ptcone);
1282 if ((ptcone->TYPE & YAG_FALSECONF) == YAG_FALSECONF) yagAnalyseCone(ptcone);
1283 }
1284 #ifdef DELAY_DEBUG_STAT
1285 mbk_debugstat ("false conf:", 0);
1286 #endif
1287
1288 /*---------------------------------------------------------------------------*
1289 | check for poor redundant branches (partly heuristic) |
1290 *----------------------------------------------------------------------------*/
1291
1292 if (YAG_CONTEXT->YAG_DETECT_REDUNDANT) {
1293 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1294 if ((ptcone->TECTYPE & CNS_DUAL_CMOS) != CNS_DUAL_CMOS) {
1295 yagDetectRedundant(ptcone);
1296 yagDetectDegraded(ptcone);
1297 }
1298 }
1299 }
1300
1301 /*---------------------------------------------------------------------------*
1302 | Correction for switch transistor |
1303 *----------------------------------------------------------------------------*/
1304
1305 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1306 yagCorrectSwitch(ptcone);
1307 }
1308
1309 /*---------------------------------------------------------------------------*
1310 | Chain cone outputs |
1311 *----------------------------------------------------------------------------*/
1312
1313 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1314 if (ptcone->OUTCONE) {
1315 yagFreeEdgeList(ptcone->OUTCONE);
1316 ptcone->OUTCONE = NULL;
1317 }
1318 }
1319 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1320 yagBuildOutputs(ptcone);
1321 }
1322
1323 /*---------------------------------------------------------------------------*
1324 | Check possible input cones |
1325 *----------------------------------------------------------------------------*/
1326
1327 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptnextcone) {
1328 ptnextcone = ptcone->NEXT;
1329 yagCheckExtOut(ptcone);
1330 yagCheckExtIn(ptcone);
1331 }
1332
1333 /*---------------------------------------------------------------------------*
1334 | Remove empty cones unless in NOTSTRICT mode |
1335 *----------------------------------------------------------------------------*/
1336
1337 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptnextcone) {
1338 ptnextcone = ptcone->NEXT;
1339 if ((ptcone->TYPE & CNS_VDD) == CNS_VDD) continue;
1340 if ((ptcone->TYPE & CNS_VSS) == CNS_VSS) continue;
1341 if ((ptcone->TECTYPE & (CNS_ONE|CNS_ZERO)) != 0 && ptcone->OUTCONE != NULL) continue;
1342 if (ptcone->OUTCONE != NULL && YAG_CONTEXT->YAG_NOTSTRICT) continue;
1343 if (yagCheckBranches(ptcone) == FALSE) {
1344 yagResetCone(ptcone);
1345 CNS_HEADCNSFIG->CONE = delcone(CNS_HEADCNSFIG->CONE, ptcone);
1346 }
1347 }
1348
1349 /*---------------------------------------------------------------------------*
1350 | Select a latch in bistables (after building OUTCONE list ) |
1351 *----------------------------------------------------------------------------*/
1352
1353 if ((YAG_CONTEXT->YAG_AUTO_RS & YAG_RS_LATCH) != 0) {
1354 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1355 if ((ptcone->TYPE &(CNS_RS|CNS_LATCH)) == CNS_RS) {
1356 ptsymcone = (cone_list *)getptype(ptcone->USER, YAG_BISTABLE_PTYPE)->DATA;
1357 if ((ptsymcone->TYPE &(CNS_RS|CNS_LATCH)) == CNS_RS) {
1358 yagSelectRSLatch(ptcone, ptsymcone);
1359 }
1360 }
1361 }
1362 }
1363
1364 /*---------------------------------------------------------------------------*
1365 | Disable the appropriate timing arcs |
1366 *----------------------------------------------------------------------------*/
1367
1368 if (YAG_CONTEXT->YAG_AUTO_RS) {
1369 for (ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1370 if ((ptcone->TYPE & (CNS_RS|YAG_MARK)) == CNS_RS) {
1371 ptsymcone = (cone_list *)getptype(ptcone->USER, YAG_BISTABLE_PTYPE)->DATA;
1372 type = ptcone->TECTYPE & (CNS_NAND|CNS_NOR);
1373 if (type != 0) {
1374 yagDisableRSArcs(ptcone, ptsymcone, ptcone, ptsymcone, type, (YAG_CONTEXT->YAG_AUTO_RS & (YAG_RS_LEGAL|YAG_RS_ILLEGAL)));
1375 }
1376 ptsymcone->TYPE |= YAG_MARK;
1377 }
1378 ptcone->TYPE &= ~YAG_MARK;
1379 }
1380 }
1381
1382 /*---------------------------------------------------------------------------*
1383 | Loop detection |
1384 *----------------------------------------------------------------------------*/
1385
1386 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1387 yagDetectLoops(ptcone);
1388 }
1389
1390 /*---------------------------------------------------------------------------*
1391 | Build glue cones for befig |
1392 *----------------------------------------------------------------------------*/
1393
1394 if ((mode & YAG_GENBEFIG) != 0) {
1395 if ((ptuser = getptype(ptcnsfig->USER, YAG_GLUECONE_PTYPE)) != NULL) {
1396 for (ptcone = (cone_list *)ptuser->DATA; ptcone; ptcone = ptcone->NEXT) {
1397 yagExpandCone(ifl, ptcone);
1398 }
1399 }
1400 }
1401
1402 /*---------------------------------------------------------------------------*
1403 | Cell matching |
1404 *----------------------------------------------------------------------------*/
1405
1406 if (YAG_CONTEXT->YAG_MAKE_CELLS || YAG_CONTEXT->YAG_AUTO_FLIPFLOP) {
1407 yagChrono(&START,&start);
1408 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_MAKING_CELLS, NULL);
1409 build_befig = ((mode & (YAG_GENBEFIG|YAG_GENLOFIG)) != 0);
1410 if (YAG_CONTEXT->YAG_MAKE_CELLS) yagMatchFlipFlopCells(ptcnsfig->CONE, build_befig);
1411 if (YAG_CONTEXT->YAG_AUTO_FLIPFLOP) yagAutoFlipFlop(ptcnsfig->CONE, build_befig);
1412 yagChrono(&END,&end);
1413 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
1414 }
1415 #ifdef DELAY_DEBUG_STAT
1416 mbk_debugstat ("reste:", 0);
1417 #endif
1418
1419 /*---------------------------------------------------------------------------*
1420 | Delayed-RS |
1421 *----------------------------------------------------------------------------*/
1422
1423 if (YAG_CONTEXT->YAG_DELAYED_RS) {
1424 yagDetectDelayedRS(ptcnsfig);
1425 }
1426
1427 /*---------------------------------------------------------------------------*
1428 | External connector verification |
1429 *----------------------------------------------------------------------------*/
1430
1431 yagChrono(&START,&start);
1432 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_VERIF_EXTCON, NULL);
1433 yagOrientInterface(ptcnsfig);
1434 yagChrono(&END,&end);
1435 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
1436
1437 #ifdef AVERTEC_LICENSE
1438 if(avt_givetoken("YAGLE_LICENSE_SERVER", YAG_CONTEXT->YAGLE_TOOLNAME)!=AVT_VALID_TOKEN) EXIT(1);
1439 #endif
1440
1441 /*---------------------------------------------------------------------------*
1442 | Check transistor usage |
1443 *----------------------------------------------------------------------------*/
1444
1445 for (pttrans = ptmbkfig->LOTRS; pttrans != NULL; pttrans = pttrans->NEXT) {
1446 pttrans->TYPE &= ~USED;
1447 }
1448 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1449 yagMarkUsedTrans(ptcone);
1450 }
1451
1452 for (pttrans = ptmbkfig->LOTRS; pttrans != NULL; pttrans = pttrans->NEXT) {
1453 if ((ptuser = getptype(pttrans->USER, FCL_TRANSFER_PTYPE)) != NULL) {
1454 if (((long)ptuser->DATA & FCL_NEVER) != 0) continue;
1455 }
1456 if ((pttrans->TYPE & USED) == 0) {
1457 pttrans->USER = addptype(pttrans->USER, CNS_UNUSED, NULL);
1458 if ((pttrans->TYPE & CNS_TN) != 0) {
1459 yagWarning(WAR_UNUSED,NULL,"N",(char*)pttrans,0);
1460 }
1461 else {
1462 yagWarning(WAR_UNUSED,NULL,"P",(char*)pttrans,0);
1463 }
1464 num_unused++;
1465 }
1466 else {
1467 if (getptype(pttrans->USER, CNS_DRIVINGCONE)->DATA == NULL) {
1468 ptsig = ((locon_list *)getptype(pttrans->USER, YAG_GRIDCON_PTYPE)->DATA)->SIG;
1469 yagError(ERR_GATE_UNDRIVEN, NULL, ptsig->NAMECHAIN->DATA, NULL, 0, 0);
1470 num_undrivengate++;
1471 }
1472 }
1473 if (getptype(pttrans->USER, YAG_BIDIR_PTYPE) != NULL) {
1474 yagWarning(WAR_BIDIR_BLOCKED, NULL, "N", (char*)pttrans, 0);
1475 num_bidir++;
1476 }
1477 pttrans->TYPE &= (TRANSN|TRANSP);
1478 }
1479 if (YAG_CONTEXT->YAG_STAT_MODE) {
1480 fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "------------------------------------------------------------\n");
1481 if (num_unused > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d unused transistors\n", num_unused);
1482 if (num_undrivengate > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d undriven transistor gates\n", num_undrivengate);
1483 if (num_bidir > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d potentially bidirectional transistors\n", num_bidir);
1484 }
1485
1486 /*---------------------------------------------------------------------------*
1487 | Check figure |
1488 *----------------------------------------------------------------------------*/
1489
1490 yagChrono(&START,&start);
1491 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_FIG_CHECKING, NULL);
1492
1493 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1494 ptcone->INDEX = index++;
1495 stuck = FALSE;
1496 if ((ptcone->TYPE & (CNS_VDD|CNS_VSS)) != 0) continue;
1497 if ((ptcone->TECTYPE & CNS_DUAL_CMOS) == CNS_DUAL_CMOS) num_cmosdual++;
1498 if ((ptcone->TECTYPE & CNS_ZERO) == CNS_ZERO) {
1499 yagWarning(WAR_STUCK_ZERO, NULL, ptcone->NAME, NULL, 0);
1500 stuck = TRUE;
1501 }
1502 if ((ptcone->TECTYPE & CNS_ONE) == CNS_ONE) {
1503 yagWarning(WAR_STUCK_ONE, NULL, ptcone->NAME, NULL, 0);
1504 stuck = TRUE;
1505 }
1506 if (!stuck) {
1507 count = yagCountLoops(ptcone, FALSE);
1508 if (count > 0 && YAG_CONTEXT->YAG_LOOP_ANALYSIS) {
1509 yagAnalyseLoop(ptcone, FALSE);
1510 }
1511 }
1512 if ((ptcone->TECTYPE & YAG_LEVELHOLD) != 0) {
1513 num_levelhold++;
1514 yagWarning(WAR_LEVELHOLD_LOOP, NULL, ptcone->NAME, NULL, 0);
1515 }
1516 else if (getptype(ptcone->USER, CNS_BLEEDER) != NULL) {
1517 num_bleeder++;
1518 yagWarning(WAR_BLEED_LOOP, NULL, ptcone->NAME, NULL, 0);
1519 }
1520 if ((ptcone->TECTYPE & YAG_BADCONE) != 0) {
1521 num_bad++;
1522 yagWarning(WAR_BADCONE, NULL, ptcone->NAME, NULL, 0);
1523 }
1524 if ((ptcone->TYPE & CNS_LATCH) != 0 && (ptcone->TYPE & CNS_RS) == 0) {
1525 long info = 0;
1526 ptuser = getptype(ptcone->USER, YAG_LATCHINFO_PTYPE);
1527 if (ptuser != NULL) info = (long)ptuser->DATA;
1528 if (info == DLATCH) num_dlatch++;
1529 else num_latch++;
1530 if (ptcone->CELLS != NULL) ptcell = (cell_list *)ptcone->CELLS->DATA;
1531 else ptcell = NULL;
1532 if ((ptcone->TYPE & CNS_MASTER) == CNS_MASTER) {
1533 yagWarning(WAR_MASTER_LATCH_LOOP, (char *)ptcell, ptcone->NAME, (char *)ptcone->INDEX, info);
1534 }
1535 else if ((ptcone->TYPE & CNS_SLAVE) == CNS_SLAVE) {
1536 yagWarning(WAR_SLAVE_LATCH_LOOP, (char *)ptcell, ptcone->NAME, (char *)ptcone->INDEX, info);
1537 }
1538 else yagWarning(WAR_LATCH_LOOP, (char *)ptcell, ptcone->NAME, (char *)ptcone->INDEX, info);
1539 }
1540 if ((ptcone->TYPE & (CNS_RS)) == (CNS_RS)) {
1541 if (getptype(ptcone->USER, YAG_MARK_PTYPE) != NULL) {
1542 ptcone->USER = delptype(ptcone->USER, YAG_MARK_PTYPE);
1543 }
1544 else {
1545 num_rs++;
1546 ptloopcone = (cone_list *)getptype(ptcone->USER, YAG_BISTABLE_PTYPE)->DATA;
1547 yagWarning(WAR_BISTABLE_LOOP, ptcone->NAME, ptloopcone->NAME, NULL, 0);
1548 ptloopcone->USER = addptype(ptloopcone->USER, YAG_MARK_PTYPE, 0);
1549 }
1550 }
1551 if ((ptcone->TYPE & CNS_FLIP_FLOP) != 0) {
1552 num_flipflop++;
1553 yagWarning(WAR_FLIP_FLOP_LOOP, (char *)ptcell, ptcone->NAME, (char *)ptcone->INDEX, 0);
1554 }
1555 if ((ptcone->TYPE & CNS_PRECHARGE) != 0) {
1556 num_precharge++;
1557 yagWarning(WAR_PRECHARGE, NULL, ptcone->NAME, (char *)ptcone->INDEX, 0);
1558 }
1559 if ((ptcone->TYPE & CNS_CONFLICT) != 0) {
1560 num_conf++;
1561 if (getptype(ptcone->USER, YAG_LATCHBEFIG_PTYPE) != NULL) {
1562 yagWarning(WAR_LATCH_CONFLICT, NULL, ptcone->NAME, NULL, 0);
1563 }
1564 else if (getptype(ptcone->USER, YAG_BUSBEFIG_PTYPE) != NULL) {
1565 yagWarning(WAR_BUS_CONFLICT, NULL, ptcone->NAME, NULL, 0);
1566 }
1567 else yagWarning(WAR_CONFLICT, NULL, ptcone->NAME, NULL, 0);
1568 }
1569 if ((ptcone->TYPE & CNS_TRI) != 0) {
1570 num_hz++;
1571 if (getptype(ptcone->USER, YAG_LATCHBEFIG_PTYPE) != NULL) {
1572 yagWarning(WAR_LATCH_HZ, NULL, ptcone->NAME, NULL, 0);
1573 }
1574 else yagWarning(WAR_HZ, NULL, ptcone->NAME, NULL, 0);
1575 }
1576 if (!stuck && ptcone->OUTCONE == NULL) {
1577 num_nodrive++;
1578 yagWarning(WAR_DOESNT_DRIVE, NULL, ptcone->NAME, NULL, 0);
1579 }
1580 if (ptcone->INCONE == NULL) {
1581 num_noinputs++;
1582 yagWarning(WAR_NO_INPUTS, NULL, ptcone->NAME, NULL, 0);
1583 }
1584 }
1585 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1586 num_loops += yagCountLoops(ptcone, TRUE);
1587 }
1588 yagChrono(&END,&end);
1589 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
1590 if (YAG_CONTEXT->YAG_STAT_MODE) {
1591 fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "------------------------------------------------------------\n");
1592 if (num_bad > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d cones contain long current paths (Check MUTEX constraints)\n", num_bad);
1593 if (num_bleeder > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d bleeder loops\n", num_bleeder);
1594 if (num_levelhold > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d level-hold loops\n", num_levelhold);
1595 if (num_latch > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d latches\n", num_latch);
1596 if (num_dlatch > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d dynamic latches\n", num_dlatch);
1597 if (num_precharge > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d precharged signals\n", num_precharge);
1598 if (num_rs > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d RS bistables\n", num_rs);
1599 if (num_flipflop > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d flip-flops\n", num_flipflop);
1600 if (num_loops > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d unknown loops\n", num_loops);
1601 if (num_noinputs > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d signals without drivers\n", num_noinputs);
1602 if (num_nodrive > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d signal which drive nothing\n", num_nodrive);
1603 if (num_conf > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d potentially conflictual signals\n", num_conf);
1604 if (num_hz > 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d potentially tristate signals\n", num_hz);
1605 fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "------------------------------------------------------------\n");
1606 fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "CMOS DUAL cones : %ld\n", num_cmosdual);
1607 fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "Total cones : %ld\n", index-1);
1608 }
1609
1610 /*---------------------------------------------------------------------------*
1611 | Build the behavioural figure |
1612 *----------------------------------------------------------------------------*/
1613
1614 if ((mode & YAG_GENBEFIG) != 0 && YAG_CONTEXT->YAGLE_NB_ERR == 0) {
1615 chain_list *modeled = NULL;
1616 chain_list *unmodeled = NULL;
1617 char *savename;
1618
1619 yagChrono(&START,&start);
1620 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_BUILD_BEFIG, NULL);
1621 yagSortModeledInstances(ptmbkfig, &modeled, &unmodeled);
1622 if (unmodeled != NULL) {
1623 ptcorelofig = yagBuildHierarchy(ptcnsfig, ptmbkfig, &ptrootlofig, unmodeled);
1624 savename = ptrootlofig->NAME;
1625 if (YAG_CONTEXT->YAG_OUTNAME != NULL) ptrootlofig->NAME = YAG_CONTEXT->YAG_OUTNAME;
1626 yagGuessRootConnectorDirections(ptrootlofig);
1627 savelofig(ptrootlofig);
1628 ptrootlofig->NAME = savename;
1629 yagBuildCoreBefig(ptcorelofig, ptcnsfig, modeled);
1630 dellofig(ptcorelofig->NAME);
1631 }
1632 else yagBuildBefig(ptcnsfig, YAG_CONTEXT->YAG_OUTNAME);
1633 freechain(modeled);
1634 freechain(unmodeled);
1635 yagChrono(&END,&end);
1636 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
1637 }
1638
1639 /*---------------------------------------------------------------------------*
1640 | Check connectors |
1641 *----------------------------------------------------------------------------*/
1642
1643 for (ptcon = ptcnsfig->LOCON; ptcon; ptcon = ptcon->NEXT) {
1644 if (ptcon->DIRECTION == UNKNOWN) {
1645 numconunused++;
1646 yagWarning(WAR_CON_UNUSED, NULL, ptcon->NAME, NULL, 0);
1647 }
1648 }
1649 if (YAG_CONTEXT->YAG_STAT_MODE) {
1650 if (numconunused != 0) fprintf(YAG_CONTEXT->YAGLE_STAT_FILE, "%d unused connectors\n", numconunused);
1651 }
1652
1653 /*---------------------------------------------------------------------------*
1654 | Build the logical figure |
1655 *----------------------------------------------------------------------------*/
1656
1657 if ((mode & YAG_GENLOFIG) != 0 && YAG_CONTEXT->YAGLE_NB_ERR == 0) {
1658 yagChrono(&START,&start);
1659 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagMessage(MES_BUILD_LOFIG, NULL);
1660 yagBuildLofig(ptcnsfig, ptmbkfig);
1661 yagChrono(&END,&end);
1662 if (!YAG_CONTEXT->YAG_SILENT_MODE) yagPrintTime(&START,&END,start,end);
1663 }
1664
1665 /*---------------------------------------------------------------------------*
1666 | Add signature |
1667 *----------------------------------------------------------------------------*/
1668
1669 if (YAG_CONTEXT->YAG_GEN_SIGNATURE && YAG_CONTEXT->YAGLE_NB_ERR == 0) {
1670 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1671 if ((ptcone->TYPE & (CNS_LATCH|CNS_MASTER|CNS_SLAVE|CNS_MEMSYM)) != 0) continue;
1672 if ((mode & YAG_GENLOFIG) == 0) {
1673 yagMakeConeModel(ptcone);
1674 }
1675 ptuser = getptype(ptcone->USER, YAG_MODEL_PTYPE);
1676 if (ptuser != NULL) {
1677 if (ptuser->DATA != NULL && strlen(ptuser->DATA) > 0) {
1678 ptcone->USER = addptype(ptcone->USER, CNS_SIGNATURE, ptuser->DATA);
1679 }
1680 }
1681 }
1682 }
1683
1684 /*---------------------------------------------------------------------------*
1685 | Destruction of constraints |
1686 *----------------------------------------------------------------------------*/
1687
1688 yagDeleteConstraints();
1689
1690 #ifdef AVERTEC_LICENSE
1691 if(avt_givetoken("YAGLE_LICENSE_SERVER", YAG_CONTEXT->YAGLE_TOOLNAME)!=AVT_VALID_TOKEN) EXIT(1);
1692 #endif
1693
1694 /*---------------------------------------------------------------------------*
1695 | Generate .loop file |
1696 *----------------------------------------------------------------------------*/
1697
1698 if (YAG_CONTEXT->YAG_LOOP_MODE) {
1699 chain_list *loops = yagCircuitLoops(ptcnsfig);
1700
1701 if (loops != NULL) {
1702 YAG_CONTEXT->YAGLE_LOOP_FILE=mbkfopen(YAG_CONTEXT->YAG_OUTNAME,"loop",WRITE_TEXT);
1703 if(YAG_CONTEXT->YAGLE_LOOP_FILE == NULL) {
1704 char buff[YAGBUFSIZE];
1705 sprintf(buff,"%s.loop",YAG_CONTEXT->YAG_OUTNAME);
1706 avt_errmsg(YAG_ERRMSG, "006", AVT_FATAL, buff);
1707 }
1708 sprintf(buffer,"Loop file : %s.loop\n",YAG_CONTEXT->YAG_OUTNAME);
1709 avt_printExecInfo( YAG_CONTEXT->YAGLE_LOOP_FILE, "#", buffer, "");
1710 yagSaveCircuitLoops(loops);
1711 fclose(YAG_CONTEXT->YAGLE_LOOP_FILE);
1712 }
1713 }
1714
1715 /*---------------------------------------------------------------------------*
1716 | Generate .mutex file |
1717 *----------------------------------------------------------------------------*/
1718
1719 if (V_BOOL_TAB[__YAGLE_GUESS_MUTEX].VALUE) {
1720 FILE *fpmutex = mbkfopen(YAG_CONTEXT->YAG_OUTNAME,"mutex",WRITE_TEXT);
1721 chain_list *guess_mutex = yagGuessMutex(ptcnsfig);
1722 chain_list *ptmutexchain;
1723 int count = 0;
1724
1725 if (guess_mutex != NULL) {
1726 fpmutex = mbkfopen(YAG_CONTEXT->YAG_OUTNAME,"mutex",WRITE_TEXT);
1727 if(fpmutex == NULL) {
1728 char buff[YAGBUFSIZE];
1729 sprintf(buff,"%s.mutex",YAG_CONTEXT->YAG_OUTNAME);
1730 avt_errmsg(YAG_ERRMSG, "006", AVT_FATAL, buff);
1731 }
1732 sprintf(buffer,"MUTEX Guess file : %s.mutex\n",YAG_CONTEXT->YAG_OUTNAME);
1733 avt_printExecInfo(fpmutex, "#", buffer, "");
1734 for (ptmutexchain = guess_mutex; ptmutexchain; ptmutexchain = ptmutexchain->NEXT) {
1735 count++;
1736 fprintf(fpmutex, "MUTEX Group %d:\n", count);
1737 for (ptchain = ptmutexchain->DATA; ptchain; ptchain = ptchain->NEXT) {
1738 fprintf(fpmutex, " %s\n", (char *)ptchain->DATA);
1739 }
1740 fprintf(fpmutex, "\n");
1741 }
1742 fclose(fpmutex);
1743 }
1744 }
1745
1746 /*---------------------------------------------------------------------------*
1747 | Unmark latches and precharges not on given clock paths |
1748 *----------------------------------------------------------------------------*/
1749
1750 yagDetectClockLatch(ifl, ptcnsfig);
1751 yagDetectNotClockLatch(ifl, ptcnsfig);
1752 yagDetectClockPrech(ifl, ptcnsfig);
1753 yagInfUnmarkLatches(ifl, ptcnsfig);
1754 if (YAG_CONTEXT->YAG_CLOCK_GATE) yagDetectClockGating(ifl, ptcnsfig);
1755
1756 avt_log(LOGYAG,0,"------------------------------------------------------------\n");
1757 if (YAG_CONTEXT->YAGLE_NB_ERR > 0) {
1758 avt_log(LOGYAG,0," %ld ERROR(S) detected\n",YAG_CONTEXT->YAGLE_NB_ERR);
1759 }
1760 avt_log(LOGYAG,0,"See file '%s.rep' for more information\n",YAG_CONTEXT->YAG_OUTNAME);
1761 avt_log(LOGYAG,0,"------------------------------------------------------------\n");
1762
1763 /*---------------------------------------------------------------------------*
1764 | Destruction of Bdd toolbox |
1765 *----------------------------------------------------------------------------*/
1766
1767 destroyBdd(1);
1768 yag_freetable();
1769
1770 /*---------------------------------------------------------------------------*
1771 | Close files |
1772 *----------------------------------------------------------------------------*/
1773
1774 if (YAG_CONTEXT->YAG_STAT_MODE) {
1775 fclose(YAG_CONTEXT->YAGLE_STAT_FILE);
1776 }
1777 if (close_err_file) {
1778 fclose(YAG_CONTEXT->YAGLE_ERR_FILE);
1779 YAG_CONTEXT->YAGLE_ERR_FILE = NULL;
1780 }
1781 else fflush(YAG_CONTEXT->YAGLE_ERR_FILE);
1782
1783 /*---------------------------------------------------------------------------*
1784 | Cone type cleaning, supply cone renaming and lofig restoration |
1785 *----------------------------------------------------------------------------*/
1786
1787 for(ptcone = ptcnsfig->CONE; ptcone != NULL; ptcone = ptcone->NEXT) {
1788 yagCleanCone(ptcone);
1789 ptsig = (losig_list *)getptype(ptcone->USER, CNS_SIGNAL)->DATA;
1790 if ((ptcone->TYPE & (CNS_VDD|CNS_VSS)) != 0) {
1791 ptcone->NAME = ptsig->NAMECHAIN->DATA;
1792 }
1793 ptchain = (chain_list *)getptype(ptsig->USER, LOFIGCHAIN)->DATA;
1794 for (; ptchain != NULL; ptchain = ptchain->NEXT) {
1795 ptcon = (locon_list *)ptchain->DATA;
1796 if (ptcon->TYPE == 'T' && ptcon->NAME == CNS_GRIDNAME) {
1797 pttrans = (lotrs_list *)ptcon->ROOT;
1798 pttrans->GRID = ptcon;
1799 }
1800 }
1801 if (getptype(ptcone->USER, YAG_INFO_PTYPE) != NULL) {
1802 ptcone->USER = delptype(ptcone->USER, YAG_INFO_PTYPE);
1803 }
1804 }
1805 for (pttrans = ptcnsfig->LOTRS; pttrans; pttrans = pttrans->NEXT) {
1806 if (getptype(pttrans->USER, CNS_DRIVINGCONE)->DATA == NULL) {
1807 pttrans->GRID = (locon_list *)getptype(pttrans->USER, YAG_GRIDCON_PTYPE)->DATA;
1808 pttrans->USER = delptype(pttrans->USER, CNS_DRIVINGCONE);
1809 }
1810 }
1811 for (ptcon = ptcnsfig->INTCON; ptcon; ptcon = ptcon->NEXT) {
1812 ptcon->TYPE = 'C';
1813 if (ptcon->SIG->TYPE == 'E') {
1814 ptcon->SIG->TYPE = 'I';
1815 }
1816 }
1817 for (ptcell = ptcnsfig->CELL; ptcell != NULL; ptcell = ptcell->NEXT) {
1818 if ((ptuser=getptype(ptcell->USER, YAG_SIGLIST_PTYPE))!=NULL) {
1819 freechain(ptuser->DATA);
1820 ptcell->USER=delptype(ptcell->USER, YAG_SIGLIST_PTYPE);
1821 }
1822 }
1823 list0=inf_GetEntriesByType(ifl, INF_SUPPRESS, INF_ANY_VALUES);
1824 if (YAG_CONTEXT->YAG_TAS_TIMING == YAG_NO_TIMING && list0 == NULL && YAG_CONTEXT->YAG_MINIMISE_INV == FALSE) {
1825 yagCleanBequad(ptcnsfig->BEFIG);
1826 }
1827 freechain(list0);
1828
1829 /*---------------------------------------------------------------------------*
1830 | DISASSEMBLED!!! |
1831 *----------------------------------------------------------------------------*/
1832
1833 mbk_comcheck( 0, cns_signcns(ptcnsfig), 0 );
1834 return ptcnsfig;
1835 }
1836
1837 /****************************************************************************
1838 * function yagenv(); *
1839 ****************************************************************************/
1840
1841 /**** read the environment variables ****/
1842
1843 void yagenv(void (*initfunc)())
1844 {
1845 yag_context_list *newcontext;
1846 char *str = NULL;
1847 char buf[1024];
1848
1849 newcontext = (yag_context_list *)mbkalloc(sizeof(yag_context_list));
1850 if (YAG_CONTEXT != NULL) {
1851 *newcontext = *YAG_CONTEXT;
1852 newcontext->NEXT = YAG_CONTEXT;
1853 YAG_CONTEXT = newcontext;
1854 }
1855 else {
1856 newcontext->NEXT = NULL;
1857 YAG_CONTEXT = newcontext;
1858 yagInitialise();
1859 }
1860 if (initfunc != NULL) initfunc();
1861
1862 YAG_CONTEXT->YAG_STAT_MODE = V_BOOL_TAB[__YAGLE_STAT_MODE].VALUE;
1863 YAG_CONTEXT->YAG_LOOP_MODE = V_BOOL_TAB[__YAGLE_LOOP_MODE].VALUE;
1864 YAG_CONTEXT->YAG_SILENT_MODE = V_BOOL_TAB[__YAGLE_SILENT_MODE].VALUE;
1865
1866 str = V_STR_TAB[__AVT_LANGUAGE].VALUE;
1867 if (str != NULL) {
1868 if ((str[0]=='e') || (str[0]=='E')) {
1869 YAG_CONTEXT->YAGLE_LANG = 'E';
1870 }
1871 else YAG_CONTEXT->YAGLE_LANG = 'F';
1872 }
1873
1874 YAG_CONTEXT->YAG_MAX_LINKS = V_INT_TAB[__YAGLE_MAX_LINKS].VALUE;
1875 YAG_CONTEXT->YAG_RELAX_LINKS = V_INT_TAB[__YAGLE_RELAX_LINKS].VALUE;
1876 YAG_CONTEXT->YAG_BDDCEILING = V_INT_TAB[__YAGLE_BDDCEILING].VALUE;
1877 YAG_CONTEXT->YAG_THRESHOLD = V_FLOAT_TAB[__YAGLE_THRESHOLD].VALUE;
1878 YAG_CONTEXT->YAG_SPLITTIMING_RATIO = V_FLOAT_TAB[__YAGLE_SPLITTIMING_RATIO].VALUE;
1879 YAG_CONTEXT->YAG_SENSITIVE_RATIO = V_FLOAT_TAB[__YAGLE_SENSITIVE_RATIO].VALUE;
1880 YAG_CONTEXT->YAG_SENSITIVE_MAX = V_INT_TAB[__YAGLE_SENSITIVE_MAX].VALUE;
1881 YAG_CONTEXT->YAG_RELAX_ALGO = V_BOOL_TAB[__YAGLE_RELAX_ALGO].VALUE;
1882 YAG_CONTEXT->YAG_MINIMISE_CONES = V_BOOL_TAB[__YAGLE_MINIMISE_CONES].VALUE;
1883 YAG_CONTEXT->YAG_ASSUME_PRECEDE = V_BOOL_TAB[__YAGLE_BEH_ASSUME_PRECEDE].VALUE;
1884 YAG_CONTEXT->YAG_BLEEDER_PRECHARGE = V_BOOL_TAB[__YAGLE_BLEEDER_PRECHARGE].VALUE;
1885 YAG_CONTEXT->YAG_TRISTATE_MEMORY = V_BOOL_TAB[__YAGLE_TRISTATE_MEMORY].VALUE;
1886 YAG_CONTEXT->YAG_INTERFACE_VECTORS = V_BOOL_TAB[__YAGLE_INTERFACE_VECTORS].VALUE;
1887 YAG_CONTEXT->YAG_SIMPLIFY_EXPR = V_BOOL_TAB[__YAGLE_SIMPLIFY_EXPRESSIONS].VALUE;
1888 YAG_CONTEXT->YAG_SIMPLIFY_PROCESSES = V_BOOL_TAB[__YAGLE_SIMPLIFY_PROCESSES].VALUE;
1889 YAG_CONTEXT->YAG_MINIMISE_INV = V_BOOL_TAB[__YAGLE_MINIMISE_INVERTORS].VALUE;
1890 YAG_CONTEXT->YAG_COMPACT_BEHAVIOUR = V_BOOL_TAB[__YAGLE_COMPACT_BEHAVIOUR].VALUE;
1891 YAG_CONTEXT->YAG_GEN_SIGNATURE = V_BOOL_TAB[__YAGLE_GEN_SIGNATURE].VALUE;
1892
1893 str = V_STR_TAB[__YAGLE_DEBUG_CONE].VALUE;
1894 if (str != NULL) {
1895 YAG_CONTEXT->YAG_DEBUG_CONE = namealloc(str);
1896 }
1897
1898 YAG_CONTEXT->YAG_BLOCK_BIDIR = V_BOOL_TAB[__YAGLE_BLOCK_BIDIR].VALUE;
1899 YAG_CONTEXT->YAG_REMOVE_PARA = V_BOOL_TAB[__YAGLE_REMOVE_PARATRANS].VALUE;
1900 YAG_CONTEXT->YAG_BLEEDER_STRICTNESS = V_INT_TAB[__YAGLE_BLEEDER_STRICTNESS].VALUE;
1901 YAG_CONTEXT->YAG_DEPTH = V_INT_TAB[__YAGLE_DEPTH].VALUE;
1902 if (YAG_CONTEXT->YAG_DEPTH == 0) YAG_CONTEXT->YAG_USE_FCF = FALSE;
1903 YAG_CONTEXT->YAG_AUTOLOOP_DEPTH = V_INT_TAB[__YAGLE_AUTOLOOP_DEPTH].VALUE;
1904 YAG_CONTEXT->YAG_BUS_DEPTH = V_INT_TAB[__YAGLE_BUS_DEPTH].VALUE;
1905 YAG_CONTEXT->YAG_AUTOLOOP_CEILING = V_INT_TAB[__YAGLE_AUTOLOOP_CEILING].VALUE;
1906
1907 YAG_CONTEXT->YAG_ORIENT = V_BOOL_TAB[__YAGLE_ORIENT].VALUE;
1908 YAG_CONTEXT->YAG_PROP_HZ = V_BOOL_TAB[__YAGLE_PROP_HZ].VALUE;
1909
1910 if (V_BOOL_TAB[__YAGLE_MAKE_CELLS].SET)
1911 YAG_CONTEXT->YAG_MAKE_CELLS = V_BOOL_TAB[__YAGLE_MAKE_CELLS].VALUE;
1912
1913 YAG_CONTEXT->YAG_GENIUS = V_BOOL_TAB[__YAGLE_GENIUS].VALUE;
1914 YAG_CONTEXT->YAG_ONLY_GENIUS = V_BOOL_TAB[__YAGLE_ONLY_GENIUS].VALUE;
1915 YAG_CONTEXT->YAG_CELL_SHARE = V_BOOL_TAB[__YAGLE_CELL_SHARE].VALUE;
1916 YAG_CONTEXT->YAG_DETECT_LATCHES = V_BOOL_TAB[__YAGLE_DETECT_LATCHES].VALUE;
1917 YAG_CONTEXT->YAG_LOOP_ANALYSIS = V_BOOL_TAB[__YAGLE_LOOP_ANALYSIS].VALUE;
1918 YAG_CONTEXT->YAG_AUTO_FLIPFLOP = V_BOOL_TAB[__YAGLE_AUTO_FLIPFLOP].VALUE;
1919
1920 str = V_STR_TAB[__YAGLE_AUTO_ASYNC].VALUE;
1921 if (str != NULL) {
1922 if ((str[0]=='y') || (str[0]=='Y')) {
1923 YAG_CONTEXT->YAG_AUTO_ASYNC = TRUE;
1924 }
1925 else if (!strcasecmp(str, "remove")) {
1926 YAG_CONTEXT->YAG_AUTO_ASYNC = 2;
1927 }
1928 else YAG_CONTEXT->YAG_AUTO_ASYNC = FALSE;
1929 }
1930
1931 str = V_STR_TAB[__YAGLE_AUTO_RS].VALUE;
1932 if (str != NULL) {
1933 downstr(str, buf);
1934 if (!strcmp(buf, "no")) {
1935 YAG_CONTEXT->YAG_AUTO_RS = 0;
1936 }
1937 else {
1938 YAG_CONTEXT->YAG_AUTO_RS = 1;
1939 if (strstr(buf, "latch") != NULL) {
1940 YAG_CONTEXT->YAG_AUTO_RS |= YAG_RS_LATCH;
1941 }
1942 if (strstr(buf, "model") != NULL) {
1943 YAG_CONTEXT->YAG_AUTO_RS |= YAG_RS_MODEL;
1944 }
1945 if (strstr(buf, "tolerant") != NULL) {
1946 YAG_CONTEXT->YAG_AUTO_RS |= YAG_RS_TOLERANT;
1947 }
1948 if (strstr(buf, "illegal") != NULL) {
1949 YAG_CONTEXT->YAG_AUTO_RS |= YAG_RS_ILLEGAL;
1950 }
1951 else if (strstr(buf, "legal") != NULL) {
1952 YAG_CONTEXT->YAG_AUTO_RS |= YAG_RS_LEGAL;
1953 }
1954 }
1955 }
1956
1957 str = V_STR_TAB[__YAGLE_AUTO_MEMSYM].VALUE;
1958 if (str != NULL) {
1959 if ((str[0]=='y') || (str[0]=='Y')) {
1960 YAG_CONTEXT->YAG_AUTO_MEMSYM = TRUE;
1961 }
1962 else YAG_CONTEXT->YAG_AUTO_MEMSYM = FALSE;
1963 }
1964
1965 YAG_CONTEXT->YAG_BUS_ANALYSIS = V_BOOL_TAB[__YAGLE_BUS_ANALYSIS].VALUE;
1966 YAG_CONTEXT->YAG_FCL_DETECT = V_BOOL_TAB[__YAGLE_FCL_DETECT].VALUE;
1967 YAG_CONTEXT->YAG_ONLY_FCL = V_BOOL_TAB[__YAGLE_ONLY_FCL].VALUE;
1968 YAG_CONTEXT->YAG_ONE_SUPPLY = V_BOOL_TAB[__YAGLE_ONE_SUPPLY].VALUE;
1969 YAG_CONTEXT->YAG_NO_SUPPLY = V_BOOL_TAB[__YAGLE_NO_SUPPLY].VALUE;
1970
1971 if (V_BOOL_TAB[__YAGLE_NOTSTRICT].SET)
1972 YAG_CONTEXT->YAG_NOTSTRICT = V_BOOL_TAB[__YAGLE_NOTSTRICT].VALUE;
1973
1974 YAG_CONTEXT->YAG_ELP = V_BOOL_TAB[__YAGLE_ELP].VALUE;
1975
1976 str = V_STR_TAB[__YAGLE_TAS_TIMING].VALUE;
1977 if (str != NULL) {
1978 if (!strcasecmp(str, "max")) {
1979 YAG_CONTEXT->YAG_TAS_TIMING = YAG_MAX_TIMING;
1980 }
1981 else if (!strcasecmp(str, "med")) {
1982 YAG_CONTEXT->YAG_TAS_TIMING = YAG_MED_TIMING;
1983 }
1984 else if (!strcasecmp(str, "min")) {
1985 YAG_CONTEXT->YAG_TAS_TIMING = YAG_MIN_TIMING;
1986 }
1987 }
1988
1989 YAG_CONTEXT->YAG_HELP_S = V_BOOL_TAB[__YAGLE_HELP_S].VALUE;
1990
1991 if (V_STR_TAB[__YAGLE_FILENAME].SET) {
1992 YAG_CONTEXT->YAG_FILENAME = namealloc(V_STR_TAB[__YAGLE_FILENAME].VALUE);
1993 }
1994
1995 if (V_STR_TAB[__YAGLE_FIGNAME].SET) {
1996 YAG_CONTEXT->YAG_FIGNAME = namealloc(V_STR_TAB[__YAGLE_FIGNAME].VALUE);
1997 }
1998
1999 if (V_STR_TAB[__YAGLE_OUTNAME].SET) {
2000 YAG_CONTEXT->YAG_OUTNAME = namealloc(V_STR_TAB[__YAGLE_OUTNAME].VALUE);
2001 }
2002
2003 YAG_CONTEXT->YAG_FILE = V_BOOL_TAB[__YAGLE_FILE].VALUE;
2004 YAG_CONTEXT->YAG_CONE_NETLIST = V_BOOL_TAB[__YAGLE_CONE_NETLIST].VALUE;
2005 YAG_CONTEXT->YAG_BEFIG = V_BOOL_TAB[__YAGLE_VBE].VALUE;
2006 YAG_CONTEXT->YAG_BLACKBOX_SUPPRESS = V_BOOL_TAB[__YAGLE_BLACKBOX_SUPPRESS].VALUE;
2007 YAG_CONTEXT->YAG_BLACKBOX_IGNORE = V_BOOL_TAB[__YAGLE_BLACKBOX_IGNORE].VALUE;
2008 YAG_CONTEXT->YAG_NORC = V_BOOL_TAB[__YAGLE_NORC].VALUE;
2009 YAG_CONTEXT->YAG_HIERARCHICAL_MODE = V_BOOL_TAB[__YAGLE_HIERARCHICAL_MODE].VALUE;
2010 YAG_CONTEXT->YAG_MARK_TRISTATE_MEMORY = V_BOOL_TAB[__YAGLE_MARK_TRISTATE_MEMORY].VALUE;
2011 YAG_CONTEXT->YAG_KEEP_REDUNDANT = V_BOOL_TAB[__YAGLE_KEEP_REDUNDANT].VALUE;
2012 YAG_CONTEXT->YAG_KEEP_GLITCHERS = V_INT_TAB[__YAGLE_KEEP_GLITCHERS].VALUE;
2013 YAG_CONTEXT->YAG_DETECT_PRECHARGE = V_BOOL_TAB[__YAGLE_DETECT_PRECHARGE].VALUE;
2014 YAG_CONTEXT->YAG_STRICT_CKLATCH = V_BOOL_TAB[__YAGLE_STRICT_CKLATCH].VALUE;
2015 YAG_CONTEXT->YAG_USESTMSOLVER = V_BOOL_TAB[__YAGLE_USESTMSOLVER].VALUE;
2016 YAG_CONTEXT->YAG_LATCH_REQUIRE_CLOCK = V_BOOL_TAB[__YAGLE_LATCH_REQUIRE_CLOCK].VALUE;
2017 YAG_CONTEXT->YAG_DETECT_REDUNDANT = V_BOOL_TAB[__YAGLE_DETECT_REDUNDANT].VALUE;
2018
2019 str = V_STR_TAB[__YAGLE_SIMPLE_LATCH].VALUE;
2020 if (str != NULL) {
2021 downstr(str, buf);
2022 YAG_CONTEXT->YAG_SIMPLE_LATCH = FALSE;
2023 YAG_CONTEXT->YAG_DETECT_LEVELHOLD = 0;
2024 YAG_CONTEXT->YAG_DETECT_SIMPLE_MEMSYM = FALSE;
2025 if (strstr(buf, "latch") != NULL) {
2026 YAG_CONTEXT->YAG_SIMPLE_LATCH = TRUE;
2027 }
2028 if (strstr(buf, "memsym") != NULL) {
2029 YAG_CONTEXT->YAG_DETECT_SIMPLE_MEMSYM = TRUE;
2030 }
2031 if (strstr(buf, "strictlevelhold") != NULL) {
2032 YAG_CONTEXT->YAG_DETECT_LEVELHOLD = 2;
2033 }
2034 else if (strstr(buf, "levelhold") != NULL) {
2035 YAG_CONTEXT->YAG_DETECT_LEVELHOLD = 1;
2036 }
2037 }
2038
2039 str = getenv("YAGLE_DETECT_SIMPLE_MEMSYM");
2040 if (str != NULL) {
2041 if ((str[0]=='y') || (str[0]=='Y')) {
2042 YAG_CONTEXT->YAG_DETECT_SIMPLE_MEMSYM = TRUE;
2043 }
2044 else YAG_CONTEXT->YAG_DETECT_SIMPLE_MEMSYM = FALSE;
2045 }
2046
2047 YAG_CONTEXT->YAG_USE_CONNECTOR_DIRECTION = V_BOOL_TAB[__YAGLE_USE_CONNECTOR_DIRECTION].VALUE;
2048
2049 str = V_STR_TAB[__YAGLE_CLOCK_GATE].VALUE;
2050 if (str != NULL) {
2051 downstr(str, buf);
2052 YAG_CONTEXT->YAG_CLOCK_GATE = 0;
2053 if (strstr(buf, "yes") != NULL) {
2054 YAG_CONTEXT->YAG_CLOCK_GATE |= (short)0x3;
2055 }
2056 if (strstr(buf, "check") != NULL) {
2057 YAG_CONTEXT->YAG_CLOCK_GATE |= (short)0x1;
2058 }
2059 if (strstr(buf, "filter") != NULL) {
2060 YAG_CONTEXT->YAG_CLOCK_GATE |= (short)0x2;
2061 }
2062 }
2063
2064 YAG_CONTEXT->YAG_MEMSYM_HEURISTIC = V_BOOL_TAB[__YAGLE_MEMSYM_HEURISTIC].VALUE;
2065 YAG_CONTEXT->YAG_STUCK_LATCH = V_BOOL_TAB[__YAGLE_STUCK_LATCH].VALUE;
2066 YAG_CONTEXT->YAG_DELAYED_RS = V_BOOL_TAB[__YAGLE_DELAYED_RS].VALUE;
2067
2068 YAG_CONTEXT->YAG_FLAGS=0;
2069 }
2070
2071 void
2072 yagrestore()
2073 {
2074 yag_context_list *oldcontext;
2075
2076 if (YAG_CONTEXT == NULL) yagBug(DBG_NO_CONTEXT,"yagrestore",NULL,NULL,0);
2077 oldcontext = YAG_CONTEXT;
2078 YAG_CONTEXT = YAG_CONTEXT->NEXT;
2079 mbkfree(oldcontext);
2080 }