![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / trace|
Return to trace4.c CVS log | Up to [Research Unix] / researchv8dc / cmd / trace |
1.1 ! root 1: #include "stdio.h" ! 2: #include "trace.h" ! 3: #include "trace.d" ! 4: ! 5: extern char lockplus, prefix, ignvars, ignques; ! 6: extern char mask[MAXPROC]; ! 7: ! 8: extern struct QUEUE *s_last; ! 9: extern int *processes, *globvars, *state; ! 10: extern int nrprocs, nrrefs, nrvars, level; ! 11: extern double zapper; ! 12: extern long loopsf, zapped; ! 13: extern struct PROCSTACK **procstack; ! 14: extern struct VARPARS *procpars; ! 15: ! 16: double iseen = 0; ! 17: double ireseen = 0; ! 18: ! 19: struct VISIT *lastvisit; ! 20: struct STATE *giveme(), *setstate(); ! 21: char *Smalloc(), *emalloc(); ! 22: ! 23: struct STATE * ! 24: inloop() ! 25: { struct STATE *tmp; ! 26: register struct VISIT *hook; ! 27: register int i, x; char aa; ! 28: int h = hashvalue(); ! 29: ! 30: for (x = member(h); x > 0; x--) ! 31: { tmp = giveme(h, x); ! 32: hook = tmp->next; ! 33: if (samestate(tmp)) ! 34: { for (i = tmp->nrvisits; i >= 1; i--, hook = hook->next) ! 35: { ! 36: if (hook->analyzed) ! 37: { if (ignques || Queuesmatch(hook)) ! 38: { if (prefix) ! 39: output("prefix: ", 0); ! 40: return NULL; ! 41: } ! 42: } else ! 43: { if (Queuesmatch(hook)) ! 44: { loopsf++; ! 45: aa = assertholds(); ! 46: if (aa == 0 || lockplus) ! 47: putloop(hook->prop.h, aa); ! 48: return NULL; ! 49: } ! 50: } } ! 51: return setstate(tmp, h); ! 52: } ! 53: } ! 54: return setstate((struct STATE *) NULL, h); ! 55: } ! 56: ! 57: cmplvars(one, two) ! 58: struct LOCVARS *one; ! 59: struct VARPARS *two; ! 60: { int i; ! 61: ! 62: if (one->nrlvars != two->nrlvars) ! 63: whoops("cannot happen - cmplocal"); ! 64: ! 65: for (i = 0; i < one->nrlvars; i++) ! 66: if (one->lvarvals[i] != two->lvarvals[i]) ! 67: return 0; ! 68: ! 69: return 1; ! 70: } ! 71: ! 72: cmplocals(one, two) ! 73: struct VARPARS *one, *two; ! 74: { int i; ! 75: ! 76: if (one->nrlvars != two->nrlvars) ! 77: whoops("cannot happen - cmplocal"); ! 78: ! 79: for (i = 0; i < one->nrlvars; i++) ! 80: if (one->lvarvals[i] != two->lvarvals[i]) ! 81: return 0; ! 82: ! 83: return 1; ! 84: } ! 85: ! 86: cmparams(one, two) ! 87: struct VARPARS *one, *two; ! 88: { register int i; ! 89: ! 90: if (one->nrms != two->nrms || one->nrvs != two->nrvs) ! 91: whoops("cannot happen - cmparams"); ! 92: ! 93: for (i = 0; i < one->nrms; i++) ! 94: if (one->ms[i] != two->ms[i]) ! 95: return 0; ! 96: for (i = 0; i < one->nrvs; i++) ! 97: if (one->vs[i] != two->vs[i]) ! 98: return 0; ! 99: ! 100: return 1; ! 101: } ! 102: ! 103: cmpstacks(older, newer) ! 104: struct PROCSTACK *older, *newer; ! 105: { struct PROCSTACK *tmp1 = older; ! 106: struct PROCSTACK *tmp2 = newer; ! 107: ! 108: while (tmp2 != NULL) ! 109: { ! 110: if (tmp1->uptable != tmp2->uptable ! 111: || tmp1->uptransf != tmp2->uptransf) ! 112: return 0; ! 113: ! 114: if (cmplocals(tmp1->varparsaved, tmp2->varparsaved) == 0 ! 115: || cmparams (tmp1->varparsaved, tmp2->varparsaved) == 0) ! 116: return 0; ! 117: ! 118: tmp1 = tmp1->follow; ! 119: tmp2 = tmp2->follow; ! 120: } ! 121: return 1; ! 122: } ! 123: ! 124: samestate(at) ! 125: struct STATE *at; ! 126: { register int i; ! 127: ! 128: for (i = 0; i < nrprocs; i++) ! 129: { if (mask[i]) ! 130: continue; ! 131: ! 132: if (at->trip[i].prev != (short) state[i] ! 133: || at->trip[i].pmap != (short) processes[i]) ! 134: return 0; ! 135: if (ignvars == 0 ! 136: && (cmplvars(at->l_vars[i], &(procpars[i])) == 0 || ! 137: (nrrefs > 0 && cmpstacks(at->traceback[i], procstack[i]) == 0) ! 138: )) ! 139: return 0; ! 140: } ! 141: ! 142: if (!ignvars) ! 143: for (i = 0; i < nrvars; i++) ! 144: if (at->g_vars[i] != (short) globvars[i]) ! 145: return 0; ! 146: ! 147: return 1; ! 148: } ! 149: ! 150: cpylvars(into, from) ! 151: struct LOCVARS *into; ! 152: struct VARPARS *from; ! 153: { register int i; ! 154: ! 155: into->nrlvars = from->nrlvars; ! 156: into->lvarvals = (short *) ! 157: Smalloc(from->nrlvars * sizeof(short)); ! 158: for (i = 0; i < from->nrlvars; i++) ! 159: into->lvarvals[i] = from->lvarvals[i]; ! 160: } ! 161: ! 162: cpylocals(into, from) ! 163: struct VARPARS *into, *from; ! 164: { register int i; ! 165: ! 166: into->nrlvars = from->nrlvars; ! 167: into->lvarvals = (short *) ! 168: Smalloc(from->nrlvars * sizeof(short)); ! 169: for (i = 0; i < from->nrlvars; i++) ! 170: into->lvarvals[i] = from->lvarvals[i]; ! 171: } ! 172: ! 173: cpyparams(into, from) ! 174: struct VARPARS *into, *from; ! 175: { int i; ! 176: ! 177: into->nrms = from->nrms; ! 178: into->ms = (short *) ! 179: Smalloc(from->nrms * sizeof(short)); ! 180: for (i = 0; i < from->nrms; i++) ! 181: into->ms[i] = from->ms[i]; ! 182: ! 183: into->nrvs = from->nrvs; ! 184: into->vs = (short *) ! 185: Smalloc(from->nrvs * sizeof(short)); ! 186: for (i = 0; i < from->nrvs; i++) ! 187: into->vs[i] = from->vs[i]; ! 188: } ! 189: ! 190: cpystacks(left, right) ! 191: struct PROCSTACK *left, *right; ! 192: { struct PROCSTACK *into = left; ! 193: struct PROCSTACK *from = right; ! 194: ! 195: while (from != NULL) ! 196: { into->varparsaved = (struct VARPARS *) ! 197: Smalloc(sizeof(struct VARPARS)); ! 198: ! 199: cpylocals(into->varparsaved, from->varparsaved); ! 200: cpyparams(into->varparsaved, from->varparsaved); ! 201: ! 202: into->uptable = from->uptable; ! 203: into->uptransf = from->uptransf; ! 204: ! 205: if ((from = from->follow) != NULL) ! 206: { into->follow = (struct PROCSTACK *) ! 207: Smalloc(sizeof(struct PROCSTACK)); ! 208: into = into->follow; ! 209: } } ! 210: } ! 211: ! 212: struct STATE * ! 213: newstate(pha) ! 214: int pha; ! 215: { struct STATE *hook; ! 216: int i; ! 217: struct VISIT *findastate(); ! 218: ! 219: hook = (struct STATE *) ! 220: Smalloc(sizeof(struct STATE)); ! 221: hook->trip = (struct TUPLE *) ! 222: Smalloc(nrprocs * sizeof(struct TUPLE)); ! 223: ! 224: if (!ignvars) ! 225: { hook->l_vars = (struct LOCVARS **) ! 226: Smalloc(nrprocs * sizeof(struct LOCVARS *)); ! 227: ! 228: hook->g_vars = (short *) ! 229: Smalloc(nrvars * sizeof(short)); ! 230: for (i = 0; i < nrvars; i++) ! 231: hook->g_vars[i] = (short) globvars[i]; ! 232: ! 233: if (nrrefs > 0) ! 234: hook->traceback = (struct PROCSTACK **) ! 235: Smalloc(nrprocs * sizeof(struct PROCSTACK *)); ! 236: } ! 237: ! 238: for (i = 0; i < nrprocs; i++) ! 239: { hook->trip[i].prev = (short) state[i]; ! 240: hook->trip[i].pmap = (short) processes[i]; ! 241: ! 242: if (!ignvars) ! 243: { hook->l_vars[i] = (struct LOCVARS *) ! 244: Smalloc(sizeof(struct LOCVARS)); ! 245: ! 246: cpylvars(hook->l_vars[i], &(procpars[i])); ! 247: ! 248: if (nrrefs > 0) ! 249: { if (procstack[i] != NULL) ! 250: { hook->traceback[i] = (struct PROCSTACK *) ! 251: Smalloc(sizeof(struct PROCSTACK)); ! 252: ! 253: cpystacks(hook->traceback[i], procstack[i]); ! 254: } else ! 255: hook->traceback[i] = NULL; ! 256: } } } ! 257: ! 258: hook->hash = (short) pha; ! 259: hook->nrvisits = 1; ! 260: hook->next = findastate(hook); ! 261: ! 262: insert(pha, hook); /* make index in hash table */ ! 263: ! 264: return hook; ! 265: } ! 266: ! 267: struct VISIT * ! 268: oldstate(where) ! 269: struct STATE *where; ! 270: { struct VISIT *tmp; ! 271: struct VISIT *findastate(); ! 272: int i; ! 273: ! 274: if (where->nrvisits > 0) ! 275: { tmp = where->next; ! 276: for (i = where->nrvisits; i > 1; i--) ! 277: tmp = tmp->next; ! 278: ! 279: if (tmp == NULL) ! 280: whoops("cannot happen - oldstate"); ! 281: ! 282: tmp->next = findastate(where); ! 283: where->nrvisits += 1; ! 284: ireseen += (double)1; ! 285: ! 286: return tmp->next; ! 287: } else ! 288: { where->next = findastate(where); ! 289: where->nrvisits = 1; ! 290: ireseen += (double)1; ! 291: ! 292: return where->next; ! 293: } ! 294: } ! 295: ! 296: struct STATE * ! 297: setstate(where, ha) ! 298: struct STATE *where; ! 299: { struct STATE *tmp; ! 300: struct VISIT *work; ! 301: ! 302: if (where == NULL) ! 303: { tmp = newstate(ha); ! 304: work = tmp->next; ! 305: } else ! 306: { tmp = where; ! 307: work = oldstate(where); ! 308: } ! 309: ! 310: work->prop.h = (struct STUFF *) emalloc( sizeof(struct STUFF) ); ! 311: work->prop.h->s = s_last; ! 312: work->analyzed = 0; ! 313: ! 314: lastvisit = work; ! 315: relink(work); ! 316: ! 317: return tmp; ! 318: } ! 319: ! 320: struct VISIT * ! 321: pickstate(at) ! 322: struct STATE *at; ! 323: { struct VISIT *latter = NULL; ! 324: register struct VISIT *hook = at->next; ! 325: register int i; ! 326: ! 327: for (i = at->nrvisits; i >= 1; i--, hook = hook->next) ! 328: { if (hook->analyzed == 1) ! 329: { ! 330: if (latter == NULL) ! 331: at->next = hook->next; ! 332: else ! 333: latter->next = hook->next; ! 334: ! 335: efree(hook->prop.c); ! 336: ! 337: at->nrvisits -= 1; ! 338: zapped++; ! 339: return hook; ! 340: } ! 341: latter = hook; ! 342: } ! 343: return NULL; ! 344: } ! 345: ! 346: struct VISIT * ! 347: picknown(at, want) ! 348: struct STATE *at; ! 349: struct VISIT *want; ! 350: { struct VISIT *latter = NULL; ! 351: register struct VISIT *hook = at->next; ! 352: register int i, j = at->nrvisits; ! 353: ! 354: for (i = 0; i < j; i++, hook = hook->next) ! 355: { if (hook == want) ! 356: break; ! 357: latter = hook; ! 358: } ! 359: if (i == j) ! 360: whoops("cannot happen - picknown"); ! 361: ! 362: if (latter == NULL) ! 363: at->next = hook->next; ! 364: else ! 365: latter->next = hook->next; ! 366: ! 367: efree(hook->prop.c); ! 368: at->nrvisits -= 1; ! 369: zapped++; ! 370: ! 371: return hook; ! 372: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.