Ejemplo n.º 1
0
LOCAL VOID pushnextargs P4C(LVAL, fcn, int, n, LVAL, args, int, i)
{
  LVAL *newfp, next, value = NULL;

  /* build a new argument stack frame */
  newfp = xlsp;
  pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
  pusharg(fcn);
  pusharg(cvfixnum((FIXTYPE)n));
  
  /* push the arguments and shift the list pointers */
  for (next = args; consp(next); next = cdr(next)) {
    switch (ntype(car(next))) {
    case VECTOR:
      value = getelement(car(next), i);
      break;
    case TVEC:
      value = gettvecelement(car(next), i);
      break;
    case CONS:
      value = car(car(next));
      rplaca(next, cdr(car(next)));
      break;
    }
    pusharg(value);
  }

  /* establish the new stack frame */
  xlfp = newfp;
}
Ejemplo n.º 2
0
/* evalhook - call the evalhook function */
LOCAL LVAL evalhook(LVAL expr)
{
    LVAL *newfp,olddenv,val;

    /* create the new call frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(getvalue(s_evalhook));
    pusharg(cvfixnum((FIXTYPE)2));
    pusharg(expr);
    pusharg(cons(xlenv,xlfenv));
    xlfp = newfp;

    /* rebind the hook functions to nil */
    olddenv = xldenv;
    xldbind(s_evalhook,NIL);
    xldbind(s_applyhook,NIL);

    /* call the hook function */
    val = xlapply(2);

    /* unbind the symbols */
    xlunbind(olddenv);

    /* return the value */
    return (val);
}
Ejemplo n.º 3
0
/* evpushargs - evaluate and push a list of arguments */
LOCAL int evpushargs(LVAL fun, LVAL args)
{
    LVAL *newfp;
    int argc;
    
    /* protect the argument list */
    xlprot1(args);

    /* build a new argument stack frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(fun);
    pusharg(NIL); /* will be argc */

    /* evaluate and push each argument */
    for (argc = 0; consp(args); args = cdr(args), ++argc)
        pusharg(xleval(car(args)));

    /* establish the new stack frame */
    newfp[2] = cvfixnum((FIXTYPE)argc);
    xlfp = newfp;
    
    /* restore the stack */
    xlpop();

    /* return the number of arguments */
    return (argc);
}
Ejemplo n.º 4
0
/* dotest2 - call a test function with two arguments */
int dotest2 P3C(LVAL, arg1, LVAL, arg2, LVAL, fun)
{
    FRAMEP newfp;

    /* Speedup for default case TAA MOD */
    if (fun == getfunction(s_eql))
        return (eql(arg1,arg2));

    /* Speedup for EQ and EQUAL for hash tables */
    if (fun == getfunction(s_eq))
        return (arg1 == arg2);
    if (fun == getfunction(s_equal))
        return (equal(arg1,arg2));

    /* create the new call frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(fun);
    pusharg(cvfixnum((FIXTYPE)2));
    pusharg(arg1);
    pusharg(arg2);
    xlfp = newfp;

    /* return the result of applying the test function */
    return (xlapply(2) != NIL);

}
Ejemplo n.º 5
0
void note_i_file (const char *fname, const char *org_fname) {
    const char *suffix=0;
    /*const char *speced=0;*/
    switch (stop_at) {
    case STOP_AT_M: /* .i files from cilk2c have no dependencies */
    case STOP_AT_CILKI:
    case STOP_AT_CILKC:
    case STOP_AT_I: break;
    case STOP_AT_S: suffix=".s"; /*speced="-S";*/ goto earlystop;
    case STOP_AT_O: suffix=".o"; /*speced="-c";*/ goto earlystop;
    earlystop:
	{
	    const char *outfname = output_name ? output_name : replace_suffix(org_fname, suffix);
	    pushpair(&i_files, fname, outfname);
	}
	break;
    case STOP_AT_END:
	if (current_output_x!=L_i && current_output_x!=L_none) {
	    pusharg(cc_args, "-x");
	    pusharg(cc_args, xarg_of_lang(L_i));
	    current_output_x = L_i;
	}
	n_gcc_files++;
	pusharg(cc_args, fname);
	break;
    }
}
Ejemplo n.º 6
0
/*
  parseargs -> parseargs	// Implicit, actually a while loop
		| pipestate
		| redirinstate
		| rediroutstate
		| waitstate
		| NULL
*/
struct CmdGroup *parseargs(struct CmdGroup *cmdgroup, struct CmdNode *cmdnode){
	int type;
	struct Pair *entry;
	char argname[10];
	int argno = 0;
	while(TRUE){
		switch(type = yylex()){
			case EXIT:
			case CD:
			case SETVAR:
				type = WORD;
			case STRING:
			case WORD:
				sprintf(argname, "arg %d", ++argno);
				printparse(type, argname);
				if(pusharg(cmdnode, tokentext)){
					break;
				}
				else{
					/* ERR: memory allocation */
					return cmderror(NONE, cmdgroup, "Could not allocate memory for argument '%s'\n", tokentext);
				}
			case VARIABLE:
				if((entry = find(vartable, tokentext))){
					tokentext = entry->value;
					sprintf(argname, "arg %d", ++argno);
					printparse(WORD, argname);
					if(pusharg(cmdnode, tokentext)){
						break;
					}
					else{
						/* ERR: memory allocation */
						return cmderror(NONE, cmdgroup, "Could not allocate memory for argument '%s'\n", tokentext);
					}
				}
				else{
					/* ERR: missing variable */
					return cmderror(type, cmdgroup, "Missing variable %s\n", tokentext);
				}
			case EOL:
				printparse(type, "EOL");
				return cmdgroup;
			case PIPE:
				printparse(type, "pipe");
				return pipestate(cmdgroup);
			case WAIT:
				printparse(type, "wait");
				return waitstate(cmdgroup);
			case REDIRIN:
				printparse(type, "redirect stdin");
				return redirinstate(cmdgroup);
			case REDIROUT:
				printparse(type, "redirect stdout");
				return rediroutstate(cmdgroup);
			default:
				return cmderror(type, cmdgroup, "'%s' not allowed mid-command\n", tokentext);
		}
	}
}
Ejemplo n.º 7
0
/* callmacro - call a read macro */
LVAL callmacro(LVAL fptr, int ch)
{
    LVAL *newfp;

    /* create the new call frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(cdr(getelement(getvalue(s_rtable),ch)));
    pusharg(cvfixnum((FIXTYPE)2));
    pusharg(fptr);
    pusharg(cvchar(ch));
    xlfp = newfp;
    return (xlapply(2));
}
Ejemplo n.º 8
0
/* xlapp1 - apply a function of a single argument */
LVAL xlapp1 P2C(LVAL, fun, LVAL, arg)
{
    FRAMEP newfp;

    /* create the new call frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(fun);
    pusharg(cvfixnum((FIXTYPE)1));
    pusharg(arg);
    xlfp = newfp;

    /* return the result of applying the function */
    return xlapply(1);

}
Ejemplo n.º 9
0
/* can't handle quoted spaces */
void push_stringified_args (MY_ARGV argv, const char *sargs)
{
     char *CF=strdup(sargs);
     char *b, *e;
     char old;

     b = CF;

     for (;;) {
	  while (*b == ' ')
	       ++b;

	  e = b;
	  while (*e != ' ' && *e != 0)
	       ++e;

	  old = *e; *e = 0;
	  if (b != e) 
	       pusharg(argv, strdup(b));
	  *e = old;

	  if (*e == 0) break;
	  b = e + 1;
     }
     free(CF);
}
Ejemplo n.º 10
0
static NODE *
moveargs(NODE *p, int *regp)
{
	NODE *r, **rp;
	int reg;

	if (p->n_op == CM) {
		p->n_left = moveargs(p->n_left, regp);
		r = p->n_right;
		rp = &p->n_right;
	} else {
		r = p;
		rp = &p;
	}

	reg = *regp;

	if (reg > R3 && r->n_op != STARG) {
		*rp = pusharg(r, regp);
	} else if (r->n_op == STARG) {
		*rp = movearg_struct(r, regp);
	} else if (DEUNSIGN(r->n_type) == LONGLONG) {
		*rp = movearg_64bit(r, regp);
	} else if (r->n_type == DOUBLE || r->n_type == LDOUBLE) {
		*rp = movearg_double(r, regp);
	} else if (r->n_type == FLOAT) {
		*rp = movearg_float(r, regp);
	} else {
		*rp = movearg_32bit(r, regp);
	}

	return straighten(p);
}
Ejemplo n.º 11
0
/* dotest1 - call a test function with one argument */
int dotest1(LVAL arg, LVAL fun)
{
    LVAL *newfp;

    /* create the new call frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(fun);
    pusharg(cvfixnum((FIXTYPE)1));
    pusharg(arg);
    xlfp = newfp;

    /* return the result of applying the test function */
    return (xlapply(1) != NIL);

}
Ejemplo n.º 12
0
static void
bootargs(ulong base)
{
 	int i, ac;
	uchar *av[32];
	uchar *bootpath;
	uchar **lsp;

	/*
 	 *  the sizeof(Sargs) is to make the validaddr check in
	 *  trap.c's syscall() work even when we have less than the
	 *  max number of args.
	 */
	sp = (uchar*)base + BY2PG - sizeof(Sargs);

	bootpath = pusharg("/boot/boot");
	ac = 0;
	av[ac++] = pusharg("boot");

	/* 4 byte word align stack */
	sp = (uchar*)((ulong)sp & ~3);

	/* build argc, argv on stack */
	sp -= (ac+1)*sizeof(sp);
	lsp = (uchar**)sp;
	for(i = 0; i < ac; i++)
		*lsp++ = av[i] + ((USTKTOP - BY2PG) - base);
	*lsp = 0;

	/* push argv onto stack */
	sp -= BY2WD;
	lsp = (uchar**)sp;
	*lsp = sp + BY2WD + ((USTKTOP - BY2PG) - base);

	/* push pointer to "/boot" */
	sp -= BY2WD;
	lsp = (uchar**)sp;
	*lsp = bootpath + ((USTKTOP - BY2PG) - base);

	/* leave space for where the initcode's caller's return PC would normally reside */
	sp -= BY2WD;

	/* relocate stack to user's virtual addresses */
	sp += (USTKTOP - BY2PG) - base;
}
Ejemplo n.º 13
0
/* dotest1 - call a test function with one argument */
int dotest1 P3C(LVAL, arg, LVAL, fun, LVAL, kfun)
{
    FRAMEP newfp;

    if (kfun != NIL) arg = xlapp1(kfun,arg);

    /* create the new call frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(fun);
    pusharg(cvfixnum((FIXTYPE)1));
    pusharg(arg);
    xlfp = newfp;

    /* return the result of applying the test function */
    return (xlapply(1) != NIL);

}
Ejemplo n.º 14
0
void
arginit(void)
{
	char **av;

	av = (char**)argbuf;
	sp = argbuf + sizeof(argbuf);
	*av++ = pusharg("boot");
	*av = 0;
}
Ejemplo n.º 15
0
/* called from moveargs() */
static NODE *
movearg_64bit(NODE *p, int *regp)
{
	int reg = *regp;
	NODE *q, *r;

#if ALLONGLONG == 64
	/* alignment */
	++reg;
	reg &= ~1;
	*regp = reg;
#endif

	if (reg > R3) {
		q = pusharg(p, regp);
	} else if (reg == R3) {
		/* half in and half out of the registers */
		r = tcopy(p);
		if (!features(FEATURE_BIGENDIAN)) {
			q = block(SCONV, p, NIL, INT, 0, 0);
			q = movearg_32bit(q, regp);     /* little-endian */
			r = buildtree(RS, r, bcon(32));
			r = block(SCONV, r, NIL, INT, 0, 0);
			r = pusharg(r, regp); /* little-endian */
		} else {
			q = buildtree(RS, p, bcon(32));
			q = block(SCONV, q, NIL, INT, 0, 0);
			q = movearg_32bit(q, regp);     /* big-endian */
			r = block(SCONV, r, NIL, INT, 0, 0);
			r = pusharg(r, regp); /* big-endian */
		}
		q = straighten(block(CM, q, r, p->n_type, p->n_df, p->n_ap));
	} else {
		q = block(REG, NIL, NIL, p->n_type, p->n_df, p->n_ap);
		regno(q) = R0R1 + (reg - R0);
		q = buildtree(ASSIGN, q, p);
		*regp = reg + 2;
	}

	return q;
}
Ejemplo n.º 16
0
/* xfuncall - the built-in function 'funcall' */
LVAL xfuncall(void)
{
    LVAL *newfp;
    int argc;
    
    /* build a new argument stack frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(xlgetarg());
    pusharg(NIL); /* will be argc */

    /* push each argument */
    for (argc = 0; moreargs(); ++argc)
        pusharg(nextarg());

    /* establish the new stack frame */
    newfp[2] = cvfixnum((FIXTYPE)argc);
    xlfp = newfp;

    /* apply the function to the arguments */
    return (xlapply(argc));
}
Ejemplo n.º 17
0
/* pushargs - push a list of arguments */
int pushargs(LVAL fun, LVAL args)
{
    LVAL *newfp;
    int argc;
    
    /* build a new argument stack frame */
    newfp = xlsp;
    pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
    pusharg(fun);
    pusharg(NIL); /* will be argc */

    /* push each argument */
    for (argc = 0; consp(args); args = cdr(args), ++argc)
        pusharg(car(args));

    /* establish the new stack frame */
    newfp[2] = cvfixnum((FIXTYPE)argc);
    xlfp = newfp;

    /* return the number of arguments */
    return (argc);
}
Ejemplo n.º 18
0
void
bootargs(void *base)
{
 	int i, ac;
	uchar *av[32];
	uchar **lsp;
	char *cp = BOOTLINE;
	char buf[64];

	sp = (uchar*)base + BY2PG - Ustkheadroom;

	ac = 0;
	av[ac++] = pusharg("/386/9dos");

	/* when boot is changed to only use rc, this code can go away */
	cp[BOOTLINELEN-1] = 0;
	buf[0] = 0;
	if(strncmp(cp, "fd", 2) == 0){
		snprint(buf, sizeof buf, "local!#f/fd%lddisk",
			strtol(cp+2, 0, 0));
		av[ac++] = pusharg(buf);
	} else if(strncmp(cp, "sd", 2) == 0){
		snprint(buf, sizeof buf, "local!#S/sd%c%c/fs", *(cp+2), *(cp+3));
		av[ac++] = pusharg(buf);
	} else if(strncmp(cp, "ether", 5) == 0)
		av[ac++] = pusharg("-n");

	/* 4 byte word align stack */
	sp = (uchar*)((ulong)sp & ~3);

	/* build argc, argv on stack */
	sp -= (ac+1)*sizeof(sp);
	lsp = (uchar**)sp;
	for(i = 0; i < ac; i++)
		*lsp++ = av[i] + ((USTKTOP - BY2PG) - (ulong)base);
	*lsp = 0;
	sp += (USTKTOP - BY2PG) - (ulong)base - sizeof(ulong);
}
Ejemplo n.º 19
0
LVAL xlcallsubr1 P2C(subrfun, f, LVAL, x)
{
  LVAL *oldargv, *oldsp, val;
  int oldargc;
  
  oldsp = xlsp;
  oldargc = xlargc;
  oldargv = xlargv;
  pusharg(x);
  xlargv = oldsp;
  xlargc = 1;
  val = (*f)();
  xlargc = oldargc;
  xlargv = oldargv;
  xlsp = oldsp;
  return(val);
}
Ejemplo n.º 20
0
LVAL xlapplysubr P2C(subrfun, f, LVAL, args)
{
  LVAL *oldargv, *oldsp, val;
  int argc, oldargc;
  
  oldsp = xlsp;
  oldargc = xlargc;
  oldargv = xlargv;
  for (argc = 0; consp(args); args = cdr(args), argc++)
    pusharg(car(args));
  xlargv = oldsp;
  xlargc = argc;
  val = (*f)();
  xlargc = oldargc;
  xlargv = oldargv;
  xlsp = oldsp;
  return(val);
}
Ejemplo n.º 21
0
int main(int argc, char *argv[])
{
	int opt;
	char *cmd, *opts;

	progname = strbsnm(argv[0]);

	if (argc < 2)
		error(EXIT_FAILURE, 0, "missing FILE");

	cmd = strbsnm(argv[1]);
	pusharg("/bin/rc");
	pusharg(argv[1]);
	opts = optstr(argv[1]);
	opterr = 0;
	argc--, argv++;

	while ((opt = getopt(argc, argv, opts)) != -1) {
		switch (opt) {
		case '?':
			progname = cmd;
			error(EXIT_FAILURE, 0, "unknown option: -%c", optopt);
		case ':':
			progname = cmd;
			error(EXIT_FAILURE, 0, "option requires argument: -%c", optopt);
		default:
			pusharg(optctos(opt));
			if (strchr(opts, opt)[1] == ':')
				pusharg(optarg);
		}
	}
	pusharg("--");
	while (optind < argc)
		pusharg(argv[optind++]);
	pusharg(NULL);

	setenv("cmd", cmd, 1);
	setenv("fn_err", "{echo >[1=2] $cmd^: $*; exit 1}", 1);
	setenv("fn_usage", "{echo usage: $cmd $usage}", 1);

	execvp(arg.v[0], arg.v);
	error(EXIT_FAILURE, errno, "exec: %s", arg.v[0]);

	return 0;
}
Ejemplo n.º 22
0
void do_cpp2(void) {
    PAIRLIST cf;
    for (cf=cilkc_files; cf; cf=cf->rest) {
	MY_ARGV ma = make_my_argv();
	push_stringified_args(ma, get_cc());
	pusharg(ma, "-E");
	pusharg(ma, "-I" CILKHEADER_DIR);
#       ifdef CILK_RTSBUILD_DIR
	pusharg(cpp1_args, "-I" CILK_RTSBUILD_DIR );
#       endif
	pusharg(ma, "-D_REENTRANT");
	pusharg(ma, "-x");
	pusharg(ma, "c");
	pusharg(ma, cf->a);
	assert(cf->b);

	push_stringified_args(ma, CILKC_PTHREAD_CFLAGS);
	VERBOSE(2, pusharg(ma, "-v"));
	VERBOSE(1,print_my_argv(stderr, ma, cf->b));
	if (my_system(ma, cf->b)!=0) barf("failed running cpp2");
	free_my_argv(ma);
    }
}
Ejemplo n.º 23
0
void do_M (void) {
    if (cilk_files) {
	/* Create dependencies for cilk programs . */
	MY_ARGV ma = make_my_argv();
	push_stringified_args(ma, get_cc());
	pusharg(ma, stop_at_m_arg);
	pusharg(ma, "-xc");
	pusharg(ma, "-include");
	pusharg(ma, CILK_H_LOCATION);
	{
	    PAIRLIST cf;
	    for (cf=cilk_files; cf; cf=cf->rest) {
		assert(cf->b==0);
		pusharg(ma, cf->a);
	    }
	}
	pushargs(ma, cpp1_args);
	push_stringified_args(ma, CILKC_PTHREAD_CFLAGS);
	VERBOSE(2, pusharg(ma, "-v"));
	VERBOSE(1, print_my_argv(stderr, ma, 0));
	if (my_system(ma, 0)!=0)
	    barf("creating dependencies for cilk files");
	free_my_argv(ma);
    }
    if (n_gcc_files>0) {
	MY_ARGV ma = make_my_argv();
	push_stringified_args(ma, get_cc());
	pusharg(ma, stop_at_m_arg);
	pushargs(ma, cc_args);
	push_stringified_args(ma, CILKC_PTHREAD_CFLAGS);
	VERBOSE(2, pusharg(ma, "-v"));
	VERBOSE(1, print_my_argv(stderr, ma, 0));
	if (my_system(ma, 0)!=0)
	    barf("creating dependencies for cilk files");
	free_my_argv(ma);
    }
}
Ejemplo n.º 24
0
void do_cilk2c(void) {
    PAIRLIST cf;
    for (cf=cilki_files; cf; cf=cf->rest) {
	MY_ARGV ma = make_my_argv();
	pusharg(ma, CILK2C_LOCATION);
	pusharg(ma, cf->a);
	assert(cf->b);
	pusharg(ma, "-o");
	pusharg(ma, cf->b);
	if (cilk_hint) pusharg(ma, "-hint");
	pushargs(ma, cilkc_args);
	VERBOSE(2, pusharg(ma, "-v"));
	VERBOSE(1,print_my_argv(stderr, ma, 0));
	if (my_system(ma, 0)!=0) barf("failed running cilk2c");
	free_my_argv(ma);
    }
}
Ejemplo n.º 25
0
void do_cpp1(void) {
    PAIRLIST cf;
    for (cf=cilk_files; cf; cf=cf->rest) {
	MY_ARGV ma = make_my_argv();
	push_stringified_args(ma, get_cc());
	pusharg(ma, "-E");
	pusharg(ma, "-xc");
	pusharg(ma, "-include");
	pusharg(ma, CILK_H_LOCATION);
	pusharg(ma, cf->a);

	assert(cf->b);
	pushargs(ma, cpp1_args);

	push_stringified_args(ma, CILKC_PTHREAD_CFLAGS);
	VERBOSE(2, pusharg(ma, "-v"));
	VERBOSE(1, print_my_argv(stderr, ma, cf->b));
	if (my_system(ma, cf->b)!=0)  barf("failed running cpp1");
	free_my_argv(ma);
    }
}
Ejemplo n.º 26
0
/* map - internal mapping function */
LOCAL LVAL map(int carflag, int valflag)
{
    LVAL *newfp,fun,lists,val,last,p,x,y;
    int argc;

    /* protect some pointers */
    xlstkcheck(3);
    xlsave(fun);
    xlsave(lists);
    xlsave(val);

    /* get the function to apply and the first list */
    fun = xlgetarg();
    lists = xlgalist();

    /* initialize the result list */
    val = (valflag ? NIL : lists);

    /* build a list of argument lists */
    for (lists = last = consa(lists); moreargs(); last = cdr(last))
        rplacd(last,cons(xlgalist(),NIL));

    /* loop through each of the argument lists */
    for (;;) {
        /* build an argument list from the sublists */
        newfp = xlsp;
        pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
        pusharg(fun);
        pusharg(NIL);
        argc = 0;
        for (x = lists; x && (y = car(x)) && consp(y); x = cdr(x)) {
            pusharg(carflag ? car(y) : y);
            rplaca(x,cdr(y));
            ++argc;
        }

        /* quit if any of the lists were empty */
        if (x) {
            xlsp = newfp;
            break;
        }

        /* apply the function to the arguments */
        newfp[2] = cvfixnum((FIXTYPE)argc);
        xlfp = newfp;
        if (valflag) {
            p = consa(xlapply(argc));
            if (val) rplacd(last,p);
            else val = p;
            last = p;
        }
        else
            xlapply(argc);
    }

    /* restore the stack */
    xlpopn(3);

    /* return the last test expression value */
    return (val);
}
Ejemplo n.º 27
0
static void pushargs(MY_ARGV to_ma, const MY_ARGV from_ma) {
    unsigned int i;
    for (i=0; i<from_ma->argc; i++) {
	pusharg(to_ma, from_ma->argv[i]);
    }
}
Ejemplo n.º 28
0
/* return 0 on success */
void parse_args2 (int argc, const char *argv[]) {
    int n_input_files = 0;
    cilkc_args = make_my_argv();
    cc_early_args = make_my_argv();
    cc_args = make_my_argv();
    cpp1_args = make_my_argv();
    argc--; argv++;
    while (argc>0) {
      /*printf("argv=%s\n", *argv);*/
      if (match(*argv, "-cc")) {
	  if (argc == 1) 
	      barf("Missing arg to -cc");
	  argc--; argv++;
	  compiler = *argv;
      } else if (
	   match(*argv, "-E0")
	   || match(*argv, "-E1")
	   || match(*argv, "-E")
	   || match(*argv, "-c")
	   || match(*argv, "-S")
	   || match(*argv, "-v")
	   || match(*argv, "-v2")
	   || match(*argv,"-v1")
	   || match(*argv, "-cilk-profile")
	   || match(*argv, "-cilk-debug")
	   || match(*argv, "-cilk-span")
	   || match(*argv, "-cilk-critical-path")
	   || match(*argv, "-cilk-hint")
	   || match(*argv, "-save-temps") /* leave temp files (*.cilkc, *.cilki, *.i) generated from *.cilk */
	   || match(*argv, "-M")   /* generate Make rules */
	   || match(*argv, "-MM")
	   || match(*argv, "-n")
	   ) {
	    /* nothing, since we already parsed those.*/ 
	} else if (match(*argv, "-o")) {
	    /* nothing, since we already parsed those.*/ 
	    argv++; argc--;
	} else if (match(*argv, "-I")) {
	    /* Pass this and the next argument to the preprocessor (which means also cc at the end). */
	    if (argc==1) barf("Missing arg to %s", *argv);
	    pusharg(cpp1_args, *argv);
	    pusharg(cc_args, *argv);
	    argc--; argv++;
	    pusharg(cpp1_args, *argv);
	    pusharg(cc_args, *argv);
	} else if (match(*argv, "--param")) {
	    /* Pass this and the next argument to the compiler. */
	    if (argc==1) barf("Missing arg to %s", *argv);
	    pusharg(cc_args, *argv);
	    argc--; argv++;
	    pusharg(cc_args, *argv);
	} else if (headmatch(*argv,"-D") ||
		   headmatch(*argv,"-A")  || /* assertions for preprocessor */
		   headmatch(*argv,"-include")  ||
		   headmatch(*argv,"-I") ||
		   headmatch(*argv,"-Wp,")) { /* pass options through the driver to preprocessor */
	    /* Pass these to the preprocessor. */
	    pusharg(cpp1_args, *argv);
	    pusharg(cc_args, *argv);
	} else if (match(*argv, "-l") ||
		   match(*argv, "-L")
		   ) {
	    if (argc==1) barf("Missing arg to %s", *argv);
	    pusharg(cc_args, *argv);
	    argc--; argv++;
	    pusharg(cc_args, *argv);
	} else if (match(*argv, "-g") ||         /* generate debug info */
		   headmatch(*argv, "-O") ||     /* optimization level */
		   match(*argv, "-ansi") ||
		   match(*argv, "-pedantic")
		   ) {
	    pusharg(cc_args, *argv);
	    pusharg(cc_early_args, *argv);
	} else if (match(*argv, "-woff")) { /* -woff is MIPSPRO specific */
	    if (argc == 1) barf("Missing arg to -woff");
	    argc--; argv++;
	    pusharg(cc_args, "-woff");
	    pusharg(cc_args, *argv);
	    pusharg(cc_early_args, "-woff");
	    pusharg(cc_early_args, *argv);
	} else if (headmatch(*argv, "-Wa,") || /* extra arguments to pass to the assembler (gcc specific) */
		   headmatch(*argv, "-Wp,") || /* extra arguments to pass to the preprocessor (gcc specific) */
		   headmatch(*argv, "-m") || /* -m is gcc specific */
		   headmatch(*argv, "-f")) { /* -f is gcc specific */
	    /* All of these are simply passed through without modification */
	    pusharg(cc_early_args, *argv);
	    pusharg(cc_args,       *argv);
	    pusharg(cpp1_args,     *argv);
	} else if (headmatch(*argv, "-Wc,")){  /* extra arguments to pass to the C compiler (works with any compiler by stripping of the -Wc, */
	    pusharg(cc_early_args, (*argv)+4);
	    pusharg(cc_args,       (*argv)+4);
	    pusharg(cpp1_args,     (*argv)+4);
	} else if (headmatch(*argv, "-Wl,") || /* linker options bypassing compiler driver */
		   headmatch(*argv, "-l") || /* if it was "-l foo.a" then the previous case matched, otherwise it is "-lfoo.a" here. */
		   headmatch(*argv, "-L") ||
		   match(*argv, "-static")
		   ) {
	    pusharg(cc_args, *argv);
	} else if (match(*argv, "-W") || match(*argv, "-Wall")) {
	    pusharg(cilkc_args, "-W5");
	    /* gcc-specific */
	    pusharg(cc_early_args, *argv);
	    pusharg(cc_args, *argv);
	    /* printf("pushed %s to cc_args\n", *argv); */
	} else if (headmatch(*argv, "-W")) {
	    if (strlen(*argv)==2 && '1'<=*argv[1] && *argv[1] <= '5') {
		pusharg(cilkc_args, *argv);
	    } else {
		 /* gcc-specific */
		 pusharg(cc_early_args, *argv);
		 pusharg(cc_args, *argv);
	    }
	} else if (match(*argv, "-x")) {
	    if (compiler != NULL) {
		fprintf(stderr, "Warning:  -x probably doesn't work except with gcc.  I'll try anyway\n");
	    }
	    if (argc==1) barf("Missing arg to -x");
	    /* Don't actually push the -x args to the gcc arglist until we get a file. */
	    argc--; argv++;
	    current_input_x = language_of_xarg(*argv);
	} else if (match(*argv, "-version")) {
	    do_print_version=1;
	} else if (match(*argv, "-help")) {
	    do_print_help=1;
	} else if (**argv!='-') { /* It is a filename */
	    int finish_up = (stop_at==STOP_AT_END) || (stop_at==STOP_AT_M);
	    enum LANG lang_of_this_arg = language_of_file(current_input_x, *argv);

	    n_input_files++;

	    switch (lang_of_this_arg) {
	    case L_cilk: 
	    case L_cilki:
	    case L_cilkc:
	    case L_c:
	    case L_m:
	    case L_cpp:
	    case L_S:
	      /*
	       * cilk, cilki, cilkc, c, m, and cc files produce a separate output unless we finish
	       * also assembler-with-cpp produces an output unless we finish
	       */
	      if (!finish_up) n_input_files_that_can_make_one_output_file++; /* cilk files produce a separate output unless we finish */
		break;
	    case L_h:
	      break;  /* .h files never produce a separate output */
	    case L_i:
	    case L_ii:
	      /* .i and .ii files produce an output if we do -S or -c */
		if (stop_at==STOP_AT_S || stop_at==STOP_AT_O) n_input_files_that_can_make_one_output_file++;
		break;
	    case L_s:
	      /* .s files produce an output if we do -c */
		if (stop_at==STOP_AT_O) n_input_files_that_can_make_one_output_file++;
		break;
	    case L_none:
	      /* .o files and other random files produce no separate output */
		break;
	    }
	    /**/;
	    switch (lang_of_this_arg) {
	    case L_cilk:  note_cilk_file(*argv, *argv);  break;
	    case L_cilki: note_cilki_file(*argv, *argv); break;
	    case L_cilkc: note_cilkc_file(*argv, *argv); break;
	    case L_c:
	    case L_m:
	    case L_cpp:
	    case L_h:
	    case L_i:
	    case L_ii:
	    case L_s:
	    case L_S:
	    case L_none:
		if ((lang_of_this_arg==current_output_x)) {
		    /* don't need to emit anything if last emitted -x arg matches the language */
		} else if (current_output_x==L_none && lang_of_this_arg==language_of_file(L_none, *argv)) {
		    /* don't need to emit anthing if we emitted -x none but the suffix tells us the right answer */
		} else {
		    pusharg(cc_args, "-x");
		    pusharg(cc_args, xarg_of_lang(lang_of_this_arg));
		    current_output_x = lang_of_this_arg;
		}
		n_gcc_files++;
		pusharg(cc_args, *argv);
		break;
	    }
	} else {
	    barf("What is this? %s", *argv);
	}
	argc--; argv++;
    }
    
    if (output_name && (n_input_files_that_can_make_one_output_file>1))
	barf("You specified an output file, but more than one input file produces an output file in this mode");

    if (n_input_files==0 && !do_print_version && !do_print_help)
	barf("You specified no input files");

    pusharg(cpp1_args, "-I" CILKHEADER_DIR );
#   ifdef CILK_RTSBUILD_DIR
    pusharg(cpp1_args, "-I" CILK_RTSBUILD_DIR );
#   endif
    pusharg(cpp1_args, "-D__CILK__");
    pusharg(cpp1_args, "-D__CILK2C__");
    pusharg(cpp1_args, "-D__REENTRANT");
    if (cilk_debug)   pusharg(cpp1_args, "-DCILK_DEBUG=1");
    if (cilk_profile) {
	pusharg(cpp1_args, "-DCILK_STATS=1");
	pusharg(cpp1_args, "-DCILK_TIMING=1");
    }
    if (cilk_critical_path) {
	if (!cilk_profile) {
	    barf("-cilk-span requires -cilk-profile");
	}
	pusharg(cpp1_args, "-DCILK_CRITICAL_PATH=1");
    }
    if (cilk_debug) {
	pusharg(cpp1_args, "-DCILK_DEBUG=1");
    }
}
Ejemplo n.º 29
0
/* called from moveargs() */
static NODE *
movearg_struct(NODE *p, int *regp)
{
	int reg = *regp;
	NODE *l, *q, *t, *r;
	int tmpnr;
	int navail;
	int num;
	int sz;
	int ty;
	int i;

	assert(p->n_op == STARG);

	navail = NARGREGS - (reg - R0);
	navail = navail < 0 ? 0 : navail;
	sz = tsize(p->n_type, p->n_df, p->n_ap) / SZINT;
	num = sz > navail ? navail : sz;

	/* remove STARG node */
	l = p->n_left;
	nfree(p);
	ty = l->n_type;

	/*
	 * put it into a TEMP, rather than tcopy(), since the tree
	 * in p may have side-affects
	 */
	t = tempnode(0, ty, l->n_df, l->n_ap);
	tmpnr = regno(t);
	q = buildtree(ASSIGN, t, l);

	/* copy structure into registers */
	for (i = 0; i < num; i++) {
		t = tempnode(tmpnr, ty, 0, 0);
		t = block(SCONV, t, NIL, PTR+INT, 0, 0);
		t = block(PLUS, t, bcon(4*i), PTR+INT, 0, 0);
		t = buildtree(UMUL, t, NIL);

		r = block(REG, NIL, NIL, INT, 0, 0);
		regno(r) = reg++;
		r = buildtree(ASSIGN, r, t);

		q = block(CM, q, r, INT, 0, 0);
	}

	/* put the rest of the structure on the stack */
	for (i = num; i < sz; i++) {
		t = tempnode(tmpnr, ty, 0, 0);
		t = block(SCONV, t, NIL, PTR+INT, 0, 0);
		t = block(PLUS, t, bcon(4*i), PTR+INT, 0, 0);
		t = buildtree(UMUL, t, NIL);
		r = pusharg(t, &reg);
		q = block(CM, q, r, INT, 0, 0);
	}

	q = reverse(q);

	*regp = reg;
	return q;
}
Ejemplo n.º 30
0
void do_cc(void) {
    if (i_files) {
	PAIRLIST pl;
	/* The i_files variable was only filled in if we are stoping after -S or -c */
	assert(stop_at==STOP_AT_S || stop_at==STOP_AT_O);
	for (pl=i_files; pl; pl=pl->rest) {
	    MY_ARGV ma = make_my_argv();
	    push_stringified_args(ma, get_cc());
	    pusharg(ma, pl->a);
	    pusharg(ma, "-o");
	    pusharg(ma, pl->b);
	    pushargs(ma, cc_early_args);
	    if (stop_at==STOP_AT_S) pusharg(ma, "-S");
	    else if (stop_at==STOP_AT_O) pusharg(ma, "-c");
	    else abort(); /* This cannot happen.  See the assert() above. */
	    push_stringified_args(ma, CILKC_PTHREAD_CFLAGS);
	    if (save_temps) pusharg(ma, "-save-temps");
	    VERBOSE(2, pusharg(ma, "-v"));
	    VERBOSE(1, print_my_argv(stderr, ma, 0));
	    if (my_system(ma, 0)!=0) barf("failed running the final %s to produce %s", get_cc(), pl->b);
	    free_my_argv(ma);
	}
    }
    if (n_gcc_files>0) {
	MY_ARGV ma = make_my_argv();
	push_stringified_args(ma, get_cc());
	switch (stop_at) {
	case STOP_AT_M:     barf("I called final cc when I was supposed to do -M");
	case STOP_AT_CILKI:
	case STOP_AT_CILKC: barf("I called final cc when I was supposed to stop earlier");
	case STOP_AT_I: pusharg(ma, "-E"); break;
	case STOP_AT_S: pusharg(ma, "-S"); break;
	case STOP_AT_O: pusharg(ma, "-c"); break;
	case STOP_AT_END: break;
	}
	pushargs(ma, cc_args);
	if (stop_at==STOP_AT_END) {
	    pusharg(ma, "-L" LIBS_DIR);
	    pusharg(ma, "-L" LIBS2_DIR);
	    if (cilk_debug) {
	      if (cilk_profile) { pusharg(ma, "-lcilkrt0gp"); pusharg(ma, "-lcilk.g.p"); }
		else              { pusharg(ma, "-lcilkrt0g");  pusharg(ma, "-lcilk.g"); }
	    } else {
		if (cilk_profile) { pusharg(ma, "-lcilkrt0p");  pusharg(ma, "-lcilk.p"); }
		else              { pusharg(ma, "-lcilkrt0");   pusharg(ma, "-lcilk"); }
	    }
#           ifdef WITH_GNU_LD
	       pusharg(ma, "-Wl,-rpath," LIBS_DIR);
#           endif
	}
	push_stringified_args(ma, CILKC_PTHREAD_CFLAGS);
	push_stringified_args(ma, CILKC_PTHREAD_LIBS);
	if (output_name) {
	    pusharg(ma, "-o");
	    pusharg(ma, output_name);
	}
	VERBOSE(2, pusharg(ma, "-v"));
	VERBOSE(1, print_my_argv(stderr, ma, 0));
	if (my_system(ma, 0)!=0) barf("failed running the final %s", get_cc());
	free_my_argv(ma);
    }
}