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);
}
