static NODE * builtin_isany(NODE *a, TWORD rt, int cmpt) { NODE *p, *q; TWORD t; if ((t = mtcheck(a)) == 0) return bcon(0); p = buildtree(OROR, mtisnan(a->n_left), mtisnan(a->n_right)); p = buildtree(NOT, p, NIL); q = buildtree(cmpt, cast(ccopy(a->n_left), t, 0), cast(ccopy(a->n_right), t, 0)); p = buildtree(ANDAND, p, q); tfree(a); return p; }
void mk_alternating(tl_Node *p) /* generates an alternating automaton for p */ { if (tl_stats) { getrusage(RUSAGE_SELF, &tr_debut); } node_size = calculate_node_size(p) + 1; /* number of states in the automaton */ label = (tl_Node **) tl_emalloc(node_size * sizeof(tl_Node *)); transition = (ATrans **) tl_emalloc(node_size * sizeof(ATrans *)); node_size = node_size / (8 * sizeof(int)) + 1; sym_size = calculate_sym_size(p); /* number of predicates */ if (sym_size) { sym_table = (char **) tl_emalloc(sym_size * sizeof(char *)); } sym_size = sym_size / (8 * sizeof(int)) + 1; final_set = make_set(-1, 0); transition[0] = boolean(p); /* generates the alternating automaton */ if (tl_verbose) { fprintf(tl_out, "\nAlternating automaton before simplification\n"); print_alternating(); } if (tl_simp_diff) { simplify_astates(); /* keeps only accessible states */ if (tl_verbose) { fprintf(tl_out, "\nAlternating automaton after simplification\n"); print_alternating(); } } if (tl_stats) { getrusage(RUSAGE_SELF, &tr_fin); fprintf(tl_out, "\n%i states, %i transitions\n", astate_count, atrans_count); } releasenode(1, p); tfree(label); }
void db_print_pnode_tree(struct pnode *p, char *print) { #if 1 NG_IGNORE(print); db_print_pnode(stdout, p); #else char *buf; size_t buf_size; FILE *db_stream = open_memstream(&buf, &buf_size); db_print_pnode(db_stream, p); fclose(db_stream); if (print) printf("%s:%d: %s {%s}\n%s\n", __FILE__, __LINE__, __func__, print, buf); tfree(buf); #endif }
/* * Find number of beginning 0's in a word of type t. * t should be deunsigned. */ static NODE * builtin_ff(NODE *f, NODE *a, TWORD t) { NODE *t101, *t102; NODE *rn, *p; int l15, l16, l17; int sz; tfree(f); t = ctype(t); sz = (int)tsize(t, 0, 0)+1; t101 = tempnode(0, INT, 0, 0); t102 = tempnode(0, t, 0, 0); l15 = getlab(); l16 = getlab(); l17 = getlab(); rn = buildtree(ASSIGN, ccopy(t101), bcon(0)); rn = cmop(rn, buildtree(ASSIGN, ccopy(t102), a)); p = buildtree(CBRANCH, buildtree(EQ, ccopy(t102), bcon(0)), bcon(l15)); rn = cmop(rn, p); rn = cmop(rn, buildtree(INCR, ccopy(t101), bcon(1))); rn = cmop(rn, lblnod(l16)); p = buildtree(CBRANCH, buildtree(GE, ccopy(t101), bcon(sz)), bcon(l15)); rn = cmop(rn, p); p = buildtree(CBRANCH, buildtree(EQ, buildtree(AND, ccopy(t102), bcon(1)), bcon(0)), bcon(l17)); rn = cmop(rn, p); rn = cmop(rn, block(GOTO, bcon(l15), NIL, INT, 0, 0)); rn = cmop(rn, lblnod(l17)); rn = cmop(rn, buildtree(RSEQ, t102, bcon(1))); rn = cmop(rn, buildtree(INCR, ccopy(t101), bcon(1))); rn = cmop(rn, block(GOTO, bcon(l16), NIL, INT, 0, 0)); rn = cmop(rn, lblnod(l15)); return cmop(rn, t101); }
GState *remove_gstate(GState *s, GState *s1) /* removes a state */ { GState *prv = s->prv; s->prv->nxt = s->nxt; s->nxt->prv = s->prv; free_gtrans(s->trans->nxt, s->trans, 0); s->trans = (GTrans *)0; tfree(s->nodes_set); s->nodes_set = 0; s->nxt = gremoved->nxt; gremoved->nxt = s; s->prv = s1; for(s1 = gremoved->nxt; s1 != gremoved; s1 = s1->nxt) if(s1->prv == s) s1->prv = s->prv; return prv; }
/* * define function. Returns 1 if function is being undefined (t == 0) and * function did not exist, returns 0 otherwise. */ int define(const char *name, struct op *t) { uint32_t nhash; struct tbl *tp; bool was_set = false; nhash = hash(name); while (/* CONSTCOND */ 1) { tp = findfunc(name, nhash, true); if (tp->flag & ISSET) was_set = true; /* * If this function is currently being executed, we zap * this table entry so findfunc() won't see it */ if (tp->flag & FINUSE) { tp->name[0] = '\0'; /* ensure it won't be found */ tp->flag &= ~DEFINED; tp->flag |= FDELETE; } else break; } if (tp->flag & ALLOC) { tp->flag &= ~(ISSET|ALLOC); tfree(tp->val.t, tp->areap); } if (t == NULL) { /* undefine */ ktdelete(tp); return (was_set ? 0 : 1); } tp->val.t = tcopy(t->left, tp->areap); tp->flag |= (ISSET|ALLOC); if (t->u.ksh_func) tp->flag |= FKSH; return (0); }
/* * Create a reference for a TLS variable. * This is the "General dynamic" version. */ static NODE * tlspic(NODE *p) { NODE *q, *r, *s; char *s1, *s2; /* * .byte 0x66 * leaq x@TLSGD(%rip),%rdi * .word 0x6666 * rex64 * call __tls_get_addr@PLT */ /* Need the .byte stuff around. Why? */ /* Use inline assembler */ q = mkx("%rdx", bcon(0)); q = cmop(q, mkx("%rcx", bcon(0))); q = cmop(q, mkx("%rsi", bcon(0))); q = cmop(q, mkx("%rdi", bcon(0))); q = cmop(q, mkx("%r8", bcon(0))); q = cmop(q, mkx("%r9", bcon(0))); q = cmop(q, mkx("%r10", bcon(0))); q = cmop(q, mkx("%r11", bcon(0))); s = ccopy(r = tempnode(0, INCREF(p->n_type), p->n_df, p->n_ap)); r = mkx("=a", r); r = block(XASM, r, q, INT, 0, 0); /* Create the magic string */ s1 = ".byte 0x66\n\tleaq "; s2 = "@TLSGD(%%rip),%%rdi\n" "\t.word 0x6666\n\trex64\n\tcall __tls_get_addr@PLT"; if (attr_find(p->n_sp->sap, ATTR_SONAME) == NULL) { p->n_sp->sap = attr_add(p->n_sp->sap, attr_new(ATTR_SONAME, 1)); p->n_sp->sap->sarg(0) = p->n_sp->sname; } r->n_name = addstring(mk3str(s1, attr_find(p->n_sp->sap, ATTR_SONAME)->sarg(0), s2)); r = block(COMOP, r, s, INCREF(p->n_type), p->n_df, p->n_ap); r = buildtree(UMUL, r, NIL); tfree(p); return r; }
/* * Do the actual conversion of offstar-found OREGs into real OREGs. */ void myormake(NODE *q) { NODE *p, *r; if (x2debug) printf("myormake(%p)\n", q); p = q->n_left; if (p->n_op == PLUS && (r = p->n_right)->n_op == LS && r->n_right->n_op == ICON && getlval(r->n_right) == 2 && p->n_left->n_op == REG && r->n_left->n_op == REG) { q->n_op = OREG; setlval(q, 0); q->n_rval = R2PACK(p->n_left->n_rval, r->n_left->n_rval, 0); tfree(p); } }
void com_load(wordlist *wl) { char *copypath; if (!wl) ft_loadfile(ft_rawfile); else while (wl) { /*ft_loadfile(cp_unquote(wl->wl_word)); DG: bad memory leak*/ copypath = cp_unquote(wl->wl_word);/*DG*/ ft_loadfile(copypath); tfree(copypath); wl = wl->wl_next; } /* note: default is to display the vectors in the last (current) plot */ com_display(NULL); }
/* * replace an alloca function with direct allocation on stack. * return a destination temp node. */ static NODE * builtin_alloca(NODE *f, NODE *a, TWORD rt) { struct symtab *sp; NODE *t, *u; #ifdef notyet if (xnobuiltins) return NULL; #endif sp = f->n_sp; t = tempnode(0, VOID|PTR, 0, MKAP(INT) /* XXX */); u = tempnode(regno(t), VOID|PTR, 0, MKAP(INT) /* XXX */); spalloc(t, a, SZCHAR); tfree(f); return u; }
/* * Extract attributes from a node tree and return attribute entries * based on its contents. */ struct attr * gcc_attr_parse(NODE *p) { struct attr *b, *c; if (p == NIL) return NULL; if (p->n_op != CM) { b = gcc_attribs(p); tfree(p); } else { b = gcc_attr_parse(p->n_left); c = gcc_attr_parse(p->n_right); nfree(p); b = b ? attr_add(b, c) : c; } return b; }
static NODE * builtin_islessgreater(const struct bitable *bt, NODE *a) { NODE *p, *q, *r; TWORD t; if ((t = mtcheck(a)) == 0) return bcon(0); p = buildtree(OROR, mtisnan(a->n_left), mtisnan(a->n_right)); p = buildtree(NOT, p, NIL); q = buildtree(GT, cast(ccopy(a->n_left), t, 0), cast(ccopy(a->n_right), t, 0)); r = buildtree(LT, cast(ccopy(a->n_left), t, 0), cast(ccopy(a->n_right), t, 0)); q = buildtree(OROR, q, r); p = buildtree(ANDAND, p, q); tfree(a); return p; }
/* * Reference to a struct as a :: name. */ NODE * cxxrstruct(int soru, NODE *attr, NODE *t, char *n) { struct symtab *ns, *sp; ns = pfind(t, spole->sup); if (ns == NULL) goto undecl; tfree(t); sp = sfind(n, ns); while (sp != NULL) { if (sp->sclass == soru) return mkty(sp->stype, 0, sp->sap); sp = sfind(n, sp->snext); } undecl: uerror("%s undeclared", n); return mkty(INT, 0, 0); }
/* * Watch out for references to static members. */ NODE * cxxstructref(NODE *p, int f, char *n) { struct symtab *sp = strmemb(p->n_ap); if (sp == NULL) cerror("ref to unknown struct"); sp = sfind(n, sp); while (sp != NULL) { if (ISFTN(sp->stype) == 0) { if (sp->sclass == STATIC || sp->sclass == USTATIC) { tfree(p); return nametree(sp); } break; } sp = sfind(n, sp->snext); } return structref(p, f, n); }
void KinsolNonlinSolverFreePublicXtra() { PFModule *this_module = ThisPFModule; PublicXtra *public_xtra = (PublicXtra*)PFModulePublicXtra(this_module); if (public_xtra) { if (public_xtra->richards_jacobian_eval != NULL) { PFModuleFreeModule(public_xtra->richards_jacobian_eval); } if (public_xtra->precond != NULL) { PFModuleFreeModule(public_xtra->precond); } PFModuleFreeModule(public_xtra->nl_function_eval); tfree(public_xtra); } }
/* * Sanitycheck "new" keyword. */ NODE * cxx_new(NODE *p) { NODE *q = p; NODE *t1 = bcon(1); int nw = NM_NEW; while (p->n_op == LB) { nw = NM_NWA; t1 = buildtree(MUL, t1, eve(p->n_right)); p->n_right = bcon(0); p = p->n_left; } if (p->n_op != TYPE) uerror("new used illegally"); t1 = buildtree(MUL, t1, xbcon(tsize(p->n_type, p->n_df, p->n_ap)/SZCHAR, NULL, INTPTR)); tfree(q); return callftn(decoratename(NULL, nw), t1, NULL); }
static void fixinit(Node *orig) { Graph *p1, *g; Symbol *q1, *q2 = ZS; ng(tl_lookup("init"), ZS, ZN, ZN, ZN); p1 = pop_stack(); p1->nxt = Nodes_Set; p1->Other = p1->Old = orig; Nodes_Set = p1; for (g = Nodes_Set; g; g = g->nxt) { for (q1 = g->incoming; q1; q1 = q2) { q2 = q1->next; Addout(g->name->name, q1->name); tfree((void *) q1); } g->incoming = ZS; } }
LPSTR CrackChrome(PBYTE pass) { DATA_BLOB data_in, data_out; DWORD dwBlobSize; CHAR *decrypted; data_out.pbData = 0; data_out.cbData = 0; data_in.pbData = pass; for (dwBlobSize = 128; dwBlobSize <= 2048; dwBlobSize += 16) { data_in.cbData = dwBlobSize; if (CryptUnprotectData(&data_in, NULL, NULL, NULL, NULL, 0, &data_out)) break; } if (dwBlobSize >= 2048) return NULL; LPSTR strClearData = (LPSTR)talloc((data_out.cbData + 1)*sizeof(char)); if (!strClearData) { LocalFree(data_out.pbData); printf("chrome crack failed\n"); return NULL; } //FIXFIXFIXFIX decrypted = (LPSTR)talloc((data_out.cbData + 1)*sizeof(char)); memset(decrypted, 0, data_out.cbData); memcpy(decrypted, data_out.pbData, data_out.cbData); sprintf_s(strClearData, data_out.cbData + 1, "%s", decrypted); LocalFree(data_out.pbData); tfree(decrypted); return strClearData; }
void mk_alternating(Node *p) /* generates an alternating automaton for p */ { if(tl_stats) getrusage(RUSAGE_SELF, &tr_debut); node_size = calculate_node_size(p) + 1; /* number of states in the automaton */ label = (Node **) tl_emalloc(node_size * sizeof(Node *)); transition = (ATrans **) tl_emalloc(node_size * sizeof(ATrans *)); node_size = node_size / (8 * sizeof(int)) + 1; sym_size = calculate_sym_size(p); /* number of predicates */ if(sym_size) sym_table = (char **) tl_emalloc(sym_size * sizeof(char *)); sym_size = sym_size / (8 * sizeof(int)) + 1; final_set = make_set(-1, 0); transition[0] = boolean(p); /* generates the alternating automaton */ if(tl_verbose) { fprintf(tl_out, "\nAlternating automaton before simplification\n"); print_alternating(); } if(tl_simp_diff) { simplify_astates(); /* keeps only accessible states */ if(tl_verbose) { fprintf(tl_out, "\nAlternating automaton after simplification\n"); print_alternating(); } } #ifndef __MINGW__ if(tl_stats) { getrusage(RUSAGE_SELF, &tr_fin); timeval_subtract (&t_diff, &tr_fin.ru_utime, &tr_debut.ru_utime); fprintf(tl_out, "\nBuilding and simplification of the alternating automaton: %i.%06is", t_diff.tv_sec, t_diff.tv_usec); fprintf(tl_out, "\n%i states, %i transitions\n", astate_count, atrans_count); } #endif releasenode(1, p); tfree(label); }
void ft_dotsaves(void) { wordlist *iline, *wl = NULL; char *s, *fr; if (!ft_curckt) /* Shouldn't happen. */ return; for (iline = ft_curckt->ci_commands; iline; iline = iline->wl_next) if (ciprefix(".save", iline->wl_word)) { s = iline->wl_word; /* skip .save */ fr = gettok(&s); tfree(fr); wl = wl_append(wl, gettoks(s)); } com_save(wl); wl_free(wl); }
static void fixdotplot(wordlist *wl) { char *s; char numbuf[128]; /* Printnum Fix */ double *d, d1, d2; while (wl) { wl->wl_word = fixem(wl->wl_word); /* Is this a trailing (a,b) ? Note that we require it to be * one word. */ if (!wl->wl_next && (*wl->wl_word == '(')) /*)*/ { s = wl->wl_word + 1; d = ft_numparse(&s, FALSE); if (*s != ',') { fprintf(cp_err, "Error: bad limits \"%s\"\n", wl->wl_word); return; } d1 = *d; s++; d = ft_numparse(&s, FALSE); if ((*s != /*(*/ ')') || s[1]) { fprintf(cp_err, "Error: bad limits \"%s\"\n", wl->wl_word); return; } d2 = *d; tfree(wl->wl_word); wl->wl_word = copy("xlimit"); printnum(numbuf, d1); wl_append_word(NULL, &wl, copy(numbuf)); printnum(numbuf, d2); wl_append_word(NULL, &wl, copy(numbuf)); } wl = wl->wl_next; } }
NODE * amd64_builtin_stdarg_start(const struct bitable *bt, NODE *a) { NODE *p, *r; /* use the values from the function header */ p = a->n_left; r = buildtree(ASSIGN, structref(ccopy(p), STREF, reg_save_area), mkstkref(-rsaoff, VOID)); r = buildtree(COMOP, r, buildtree(ASSIGN, structref(ccopy(p), STREF, overflow_arg_area), mkstkref(thisrsp, VOID))); r = buildtree(COMOP, r, buildtree(ASSIGN, structref(ccopy(p), STREF, gp_offset), bcon(thisgpr*(SZLONG/SZCHAR)))); r = buildtree(COMOP, r, buildtree(ASSIGN, structref(ccopy(p), STREF, fp_offset), bcon(thissse*(SZDOUBLE*2/SZCHAR)+48))); tfree(a); return r; }
int main() { Value *val1 = talloc(sizeof(Value)); val1->type = INT_TYPE; val1->i = 12; Value *val2 = talloc(sizeof(Value)); val2->type = DOUBLE_TYPE; val2->d = 4.3; Value *head = makeNull(); head = cons(val1, head); head = cons(val2, head); display(head); printf("\n"); head = reverse(head); display(head); tfree(); printf("I can see this.\n"); texit(1); Value *val5 = talloc(sizeof(Value)); printf("I should never see this.\n"); }
/* afs_osi_TimedSleep * * Arguments: * event - event to sleep on * ams --- max sleep time in milliseconds * aintok - 1 if should sleep interruptibly * * Returns 0 if timeout and EINTR if signalled. */ int afs_osi_TimedSleep(void *event, afs_int32 ams, int aintok) { int code = 0; struct afs_event *evp; struct timestruc_t ticks; struct trb *trb; int rc; ticks.tv_sec = ams / 1000; ticks.tv_nsec = (ams - (ticks.tv_sec * 1000)) * 1000000; evp = afs_getevent(event); trb = talloc(); if (trb == NULL) osi_Panic("talloc returned NULL"); trb->flags = 0; trb->func = AfsWaitHack; trb->eventlist = EVENT_NULL; trb->ipri = INTTIMER; trb->func_data = thread_self(); trb->timeout.it_value = ticks; e_assert_wait(&evp->cond, aintok); AFS_GUNLOCK(); tstart(trb); rc = e_block_thread(); while (tstop(trb)); if (rc == THREAD_INTERRUPTED) code = EINTR; tfree(trb); AFS_GLOCK(); relevent(evp); return code; }
/* * Take integer absolute value. * Simply does: ((((x)>>(8*sizeof(x)-1))^(x))-((x)>>(8*sizeof(x)-1))) */ static NODE * builtin_abs(NODE *f, NODE *a, TWORD rt) { NODE *p, *q, *r, *t, *t2, *t3; int tmp1, tmp2, shift; if (a->n_type != INT) a = cast(a, INT, 0); tfree(f); if (a->n_op == ICON) { if (a->n_lval < 0) a->n_lval = -a->n_lval; p = a; } else { t = tempnode(0, a->n_type, a->n_df, a->n_ap); tmp1 = regno(t); p = buildtree(ASSIGN, t, a); t = tempnode(tmp1, a->n_type, a->n_df, a->n_ap); shift = (int)tsize(a->n_type, a->n_df, a->n_ap) - 1; q = buildtree(RS, t, bcon(shift)); t2 = tempnode(0, a->n_type, a->n_df, a->n_ap); tmp2 = regno(t2); q = buildtree(ASSIGN, t2, q); t = tempnode(tmp1, a->n_type, a->n_df, a->n_ap); t2 = tempnode(tmp2, a->n_type, a->n_df, a->n_ap); t3 = tempnode(tmp2, a->n_type, a->n_df, a->n_ap); r = buildtree(MINUS, buildtree(ER, t, t2), t3); p = buildtree(COMOP, p, buildtree(COMOP, q, r)); } return p; }
void com_rset(wordlist *wl) { struct variable *v, *next; NG_IGNORE(wl); if (ft_curckt == NULL) { fprintf(cp_err, "Error: there is no circuit loaded.\n"); return; } INPkillMods(); if_cktfree(ft_curckt->ci_ckt, ft_curckt->ci_symtab); for (v = ft_curckt->ci_vars; v; v = next) { next = v->va_next; tfree(v); } ft_curckt->ci_vars = NULL; inp_dodeck(ft_curckt->ci_deck, ft_curckt->ci_name, NULL, TRUE, ft_curckt->ci_options, ft_curckt->ci_filename); }
void simplify_astates() /* simplifies the alternating automaton */ { ATrans *t; int i, *acc = make_set(-1, 0); /* no state is accessible initially */ for(t = transition[0]; t; t = t->nxt, i = 0) merge_sets(acc, t->to, 0); /* all initial states are accessible */ for(i = node_id - 1; i > 0; i--) { if (!in_set(acc, i)) { /* frees unaccessible states */ label[i] = ZN; free_atrans(transition[i], 1); transition[i] = (ATrans *)0; continue; } astate_count++; simplify_atrans(&transition[i]); for(t = transition[i]; t; t = t->nxt) merge_sets(acc, t->to, 0); } tfree(acc); }
static int get_dh_config_on_answer (struct tgl_state *TLS, struct query *q, void *D) { struct tl_ds_messages_dh_config *DS_MDC = D; if (DS_MDC->magic == CODE_messages_dh_config) { assert (DS_MDC->p->len == 256); bl_do_set_dh_params (TLS, DS_LVAL (DS_MDC->g), (void *)DS_MDC->p->data, DS_LVAL (DS_MDC->version)); } else { assert (TLS->encr_param_version); } unsigned char *random = talloc (256); assert (DS_MDC->random->len == 256); memcpy (random, DS_MDC->random->data, 256); if (q->extra) { void **x = q->extra; ((void (*)(struct tgl_state *, void *, void *, void *, void *))(*x))(TLS, x[1], random, q->callback, q->callback_extra); tfree (x, 2 * sizeof (void *)); tfree_secure (random, 256); } else { tfree_secure (random, 256); } return 0; }
/* * Read, parse, and execute a command line. */ static void rpx_line(void) { struct tnode *t; sigset_t nmask, omask; char *wp; linep = line; wordp = word; error_message = NULL; nul_count = 0; tree_count = 0; do { wp = linep; get_word(); } while (*wp != EOL); *wordp = NULL; if (error_message != NULL) { err(SH_ERR, FMT1S, error_message); return; } if (wordp - word > 1) { (void)sigfillset(&nmask); (void)sigprocmask(SIG_SETMASK, &nmask, &omask); t = NULL; t = syntax(word, wordp); (void)sigprocmask(SIG_SETMASK, &omask, NULL); if (error_message != NULL) err(SH_ERR, FMT1S, error_message); else execute(t, NULL, NULL); tfree(t); t = NULL; } }
NODE * builtin_frame_address(const struct bitable *bt, NODE *a) { int nframes; NODE *f; if (a->n_op != ICON) goto bad; nframes = (int)a->n_lval; tfree(a); f = block(REG, NIL, NIL, PTR+VOID, 0, 0); regno(f) = FPREG; while (nframes--) f = block(UMUL, f, NIL, PTR+VOID, 0, 0); return f; bad: uerror("bad argument to __builtin_frame_address"); return bcon(0); }