int plot_radec_count_inbounds(plot_args_t* pargs, plotradec_t* args) {
rd_t myrd;
rd_t* rd = NULL;
int i, Nrd, nib;
rd = get_rd(args, &myrd);
if (!rd) return -1;
Nrd = rd_n(rd);
// If N is specified, apply it as a max.
if (args->nobjs)
Nrd = MIN(Nrd, args->nobjs);
nib = 0;
for (i=args->firstobj; i<Nrd; i++) {
double x,y;
double ra = rd_getra(rd, i);
double dec = rd_getdec(rd, i);
if (!plotstuff_radec2xy(pargs, ra, dec, &x, &y))
continue;
if (!plotstuff_marker_in_bounds(pargs, x, y))
continue;
nib++;
}
if (rd != &myrd)
rd_free(rd);
return nib;
}
int plot_radec_plot(const char* command, cairo_t* cairo,
plot_args_t* pargs, void* baton) {
plotradec_t* args = (plotradec_t*)baton;
// Plot it!
rd_t myrd;
rd_t* rd = NULL;
//rd_t* freerd = NULL;
int Nrd;
int i;
if (!pargs->wcs) {
ERROR("plotting radec but not plot_wcs has been set.");
return -1;
}
if (args->fn && dl_size(args->radecvals)) {
ERROR("Can only plot one of rdlist filename and radec_vals");
return -1;
}
if (!args->fn && !dl_size(args->radecvals)) {
ERROR("Neither rdlist filename nor radec_vals given!");
return -1;
}
plotstuff_builtin_apply(cairo, pargs);
rd = get_rd(args, &myrd);
if (!rd) return -1;
Nrd = rd_n(rd);
// If N is specified, apply it as a max.
if (args->nobjs)
Nrd = MIN(Nrd, args->nobjs);
// Plot markers.
for (i=args->firstobj; i<Nrd; i++) {
double x,y;
double ra = rd_getra(rd, i);
double dec = rd_getdec(rd, i);
if (!plotstuff_radec2xy(pargs, ra, dec, &x, &y))
continue;
if (!plotstuff_marker_in_bounds(pargs, x, y))
continue;
plotstuff_stack_marker(pargs, x-1, y-1);
}
plotstuff_plot_stack(pargs, cairo);
if (rd != &myrd)
rd_free(rd);
//rd_free(freerd);
return 0;
}
char *un_instr_disas(instruction instr, char *op_name) {
struct Operand dest = get_rd(instr);
struct Operand source = get_rs(instr);
char *disas;
char *dest_disas, *source_disas;
disas = (char *)malloc(LEN*sizeof(char));
dest_disas = get_opw_disas(&dest);
source_disas = get_opw_disas(&source);
sprintf(disas, "%s %s, %s", op_name, source_disas, dest_disas);
free(dest_disas);
free(source_disas);
return disas;
}
char *sa_instr_disas(instruction instr, char *op_name) {
struct Operand dest = get_rd(instr);
char *disas;
char *dest_disas;
disas = (char *)malloc(LEN*sizeof(char));
if (instr.sa_instr.bw == 0) {
dest_disas = get_opb_disas(&dest);
} else {
dest_disas = get_opw_disas(&dest);
}
sprintf(disas, "%s %s", op_name, dest_disas);
free(dest_disas);
return disas;
}
/* CALCULATE THE COORDINATES OF THE TOP LEFT CORNER OF THE SAMPLING UNITS */
static int calc_unit_loc(double radius, int top, int bot, int left, int right,
double ratio, int u_w, int u_l, int method,
double intv, int num, int h_d, int v_d, double *ux,
double *uy, int *sites, double startx, int starty,
int fmask, double nx, double x, double y)
{
char *sites_mapset, sites_file_name[GNAME_MAX], *cmd;
struct Map_info Map;
struct Cell_head region;
double D_u_to_a_col(), D_u_to_a_row();
int i, j, k, cnt = 0, w_w = right - left, w_l = bot - top, exp1, exp2,
dx = w_w, dy = w_l, l, t, left1 = left, top1 = top, n, tmp,
ulrow, ulcol, *row_buf, lap = 0;
static struct line_pnts *Points;
struct line_cats *Cats;
int ltype;
/* VARIABLES:
UNITS FOR ALL DIMENSION VARIABLES IN THIS ROUTINE ARE IN PIXELS
top = sampling frame top row in pixels
bot = sampling frame bottom row in pixels
left = sampling frame left in pixels
right = sampling frame right in pixels
left1 = col of left side of sampling frame or each stratum
top1 = row of top side of sampling frame or each stratum
l = random # cols to be added to left1
r = random # rows to be added to top1
ratio =
u_w = sampling unit width in pixels
u_l = sampling unit length in pixels
method = method of sampling unit distribution (1-5)
intv = interval between sampling units when method=3
num = number of sampling units
h_d = number of horizontal strata
v_d = number of vertical strata
ux =
uy =
sites =
startx = col of UL corner starting pt for strata
starty = row of UL corner starting pt for strata
dx = number of cols per stratum
dy = number of rows per stratum
w_w = width of sampling frame in cols
w_l = length of sampling frame in rows
*/
/* if user hits Ctrl+C, abort this
calculation */
setjmp(jmp);
if (tag) {
tag = 0;
return 0;
}
/* for syst. noncontig. distribution */
if (method == 3) {
u_w += intv;
u_l += intv;
}
/* for stratified random distribution */
if (method == 4) {
dx = (int)((double)(w_w - startx) / (double)(h_d));
dy = (int)((double)(w_l - starty) / (double)(v_d));
}
/* for syst. contig. and noncontig.
distribution */
else if (method == 2 || method == 3) {
if (nx >= num)
dx = (w_w - startx) - (num - 1) * u_w;
else {
dx = (w_w - startx) - (nx - 1) * u_w;
dy = (w_l - starty) - (num / nx - 1) * u_l;
}
}
if (10 > (exp1 = (int)pow(10.0, ceil(log10((double)(dx - u_w + 10))))))
exp1 = 10;
if (10 > (exp2 = (int)pow(10.0, ceil(log10((double)(dy - u_l + 10))))))
exp2 = 10;
/* for random nonoverlapping and stratified
random */
if (method == 1 || method == 4) {
fprintf(stderr,
"\n 'Ctrl+C' and choose fewer units if the requested number");
fprintf(stderr, " is not reached\n");
for (i = 0; i < num; i++) {
/* if Cntl+C */
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
signal(SIGINT, f);
/* for stratified random distribution */
if (method == 4) {
j = 0;
if (n = i % h_d)
left1 += dx;
else {
left1 = left + startx;
if (i < h_d)
top1 = top + starty;
else
top1 += dy;
}
get_rd(exp1, exp2, dx, dy, u_w, u_l, &l, &t);
}
/* for random nonoverlapping distribution */
if (method == 1) {
/* get random numbers */
back:
get_rd(exp1, exp2, dx, dy, u_w, u_l, &l, &t);
if (left1 + l + u_w > right || top1 + t + u_l > bot ||
left1 + l < left || top1 + t < top)
goto back;
/* if there is a mask, check to see that
the unit will be within the mask area */
if (fmask > 0) {
row_buf = Rast_allocate_c_buf();
Rast_get_c_row_nomask(fmask, row_buf, t + top1);
if (!
(*(row_buf + l + left1) &&
*(row_buf + l + left1 + u_w - 1)))
goto back;
Rast_zero_c_buf(row_buf);
Rast_get_c_row_nomask(fmask, row_buf, t + top1 + u_l - 1);
if (!
(*(row_buf + l + left1) &&
*(row_buf + l + left1 + u_w - 1)))
goto back;
G_free(row_buf);
}
/* check for sampling unit overlap */
lap = 0;
for (j = 0; j < cnt; j++) {
if (overlap
(l + left1, t + top1, (int)ux[j], (int)uy[j], u_w,
u_l))
lap = 1;
}
if (lap)
goto back;
cnt++;
}
/* fill the array of upper left coordinates
for the sampling units */
*(ux + i) = l + left1;
*(uy + i) = t + top1;
/* draw the sampling units on the
screen */
R_open_driver();
R_standard_color(D_translate_color("red"));
if (radius)
draw_circle((int)((double)(ux[i]) / x),
(int)((double)(uy[i]) / y),
(int)((double)(ux[i] + u_w) / x),
(int)((double)(uy[i] + u_l) / y), 3);
else
draw_box((int)((double)(ux[i]) / x),
(int)((double)(uy[i]) / y),
(int)((double)(ux[i] + u_w) / x),
(int)((double)(uy[i] + u_l) / y), 1);
R_close_driver();
fprintf(stderr, " Distributed unit %4d of %4d requested\r",
i + 1, num);
}
}
/* for syst. contig. & syst. noncontig. */
else if (method == 2 || method == 3) {
for (i = 0; i < num; i++) {
*(ux + i) =
left + startx + u_w * (i - nx * floor((double)i / nx));
*(uy + i) = top + starty + u_l * floor((double)i / nx);
}
}
/* for centered over sites */
else if (method == 5) {
sites_mapset =
G_ask_vector_old(" Enter name of vector points map",
sites_file_name);
if (sites_mapset == NULL) {
G_system("d.frame -e");
exit(0);
}
if (Vect_open_old(&Map, sites_file_name, sites_mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), sites_file_name);
/* fprintf(stderr, "\n Can't open vector points file %s\n", sites_file_name); */
*sites = 0;
i = 0;
n = 0;
Points = Vect_new_line_struct(); /* init line_pnts struct */
Cats = Vect_new_cats_struct();
while (1) {
ltype = Vect_read_next_line(&Map, Points, Cats);
if (ltype == -1)
G_fatal_error(_("Cannot read vector"));
if (ltype == -2)
break; /* EOF */
/* point features only. (GV_POINTS is pts AND centroids, GV_POINT is just pts) */
if (!(ltype & GV_POINT))
continue;
ulcol = ((int)(D_u_to_a_col(Points->x[0]))) + 1 - u_w / 2;
ulrow = ((int)(D_u_to_a_row(Points->y[0]))) + 1 - u_l / 2;
if (ulcol <= left || ulrow <= top || ulcol + u_w - 1 > right ||
ulrow + u_l - 1 > bot) {
fprintf(stderr,
" No sampling unit over site %d at east=%8.1f north=%8.1f\n",
n + 1, Points->x[0], Points->y[0]);
fprintf(stderr,
" as it would extend outside the map\n");
}
else {
*(ux + i) = ulcol - 1;
*(uy + i) = ulrow - 1;
i++;
}
n++;
if (n > 250)
G_fatal_error
("There are more than the maximum of 250 sites\n");
}
fprintf(stderr, " Total sites with sampling units = %d\n", i);
*sites = i;
cmd = G_malloc(100);
sprintf(cmd, "d.vect %s color=black", sites_file_name);
G_system(cmd);
G_free(cmd);
Vect_close(&Map);
G_free(Points);
G_free(Cats);
}
return 1;
}
void i_fg_build (void) {
unsigned i;
i_puint32 cp = i_buf; /* Start of code to analyze */
i_puint32 lp = i_lim; /* End of code to analyze */
i_uint32 op; /* Current opcode */
i_bb_t b; /* Current basic block */
num_bb = 0;
b = bb_alloc();
b->h = cp;
if (i_ralloctype == RA_EZ) {
i_fg_root = i_fg_tail = b;
b->t = lp - i_isize;
return;
}
i_calls_cur = i_calls_lim = 0;
NEW0(lbl2bb, i_lab_cur);
NEW(fwdrefs, i_nbb); fwdref_cur = 0;
i_fg_root = b;
do {
assert(b && !b->init);
op = get_op(cp);
switch(i_op2class[op]) {
case I_BOP: case I_BOPF:
case I_MOPR: case I_MOPRF:
assert(!isimmed(op));
markuse(b, get_rs(cp));
markuse(b, get_rs2(cp));
markdef(b, get_rd(cp));
break;
case I_BOPI: case I_MOPRI: case I_MOPRIF:
assert(isimmed(op));
markuse(b, get_rs(cp));
markdef(b, get_rd(cp));
break;
case I_MOPW: case I_MOPWF:
assert(!isimmed(op));
markuse(b, get_rd(cp));
markuse(b, get_rs(cp));
markuse(b, get_rs2(cp));
break;
case I_MOPWI: case I_MOPWIF:
assert(isimmed(op));
markuse(b, get_rd(cp));
markuse(b, get_rs(cp));
break;
case I_UOP: case I_UOPF:
assert(!isimmed(op));
markuse(b, get_rs(cp));
markdef(b, get_rd(cp));
break;
case I_UOPI:
assert(isimmed(op));
markdef(b, get_rd(cp));
break;
case I_SET: case I_SETF:
markdef(b, get_rd(cp));
break;
case I_LEA: case I_LEAF:
SCLASS(get_rs(cp)) = STACK;
markuse(b, get_rs(cp));
markdef(b, get_rd(cp));
break;
case I_RET: case I_RETF:
if (op != i_op_retv)
markuse(b, get_rd(cp));
case I_RETI:
b = bb_finalize(b, cp, lp, i_isize, false);
break;
case I_BR: case I_BRF:
markuse(b, get_rs2(cp));
case I_BRI:
markuse(b, get_rs(cp));
bb_linklbl(b, get_rd(cp));
b = bb_finalize(b, cp, lp, i_isize, true);
break;
case I_CALL: case I_CALLF:
markuse(b, get_rs(cp));
case I_CALLI: case I_CALLIF:
if (op != i_op_callv && op != i_op_callvi)
markdef(b, get_rd(cp));
markcall(cp);
b = bb_finalize(b, cp, lp, 2*i_isize, true);
cp += i_isize; /* Calls are 2x as long as other insns */
break;
case I_ARG: case I_ARGF:
markuse(b, get_rd(cp));
break;
case I_JMP:
assert(get_rd(cp) < num_i);
markuse(b, get_rd(cp));
b = bb_finalize(b, cp, lp, i_isize, false);
break;
case I_JMPI:
bb_linklbl(b, get_imm(cp));
b = bb_finalize(b, cp, lp, i_isize, false);
break;
case I_MISC:
switch (op) {
case i_op_lbl:
if (cp > b->h) /* If not at head of current block ... */
/* ... make this the head of a new block */
b = bb_finalize(b, cp-i_isize, lp, i_isize, true);
lbl2bb[get_rd(cp)] = b;
break;
default: /* refmul, refdiv, self, nop */
break;
}
break;
default:
assert(0);
}
} while ((cp += i_isize) < lp);
i_fg_tail = b;
for (i = 0; i < fwdref_cur; i++)
bb_linkbb(fwdrefs[i].src, lbl2bb[fwdrefs[i].dst]);
#ifndef NDEBUG
for (i = 0, b = i_fg_root; b; b = b->lnext) i++;
assert(i == num_bb);
#endif
}
/* i_ig_build: collect live variable information from the flow graph, and
build up the interference graph */
void i_ig_build (void) {
bvt iv=0, fv=0; /* Temp bit vector */
i_bb_t b; /* Temp bblock */
i_puint32 cp; /* Code pointer */
unsigned int op; /* Current opcode */
unsigned int nii, nfi; /* Marks new int/float liveness info */
i_local_t j; /* Temporary local for use in macros */
if (num_i) /* Create new integer IG */
iig = i_igcreate(num_i);
if (num_f) /* Create new float IG */
fig = i_igcreate(num_f);
b = i_fg_root;
while (b) {
iv = b->ilv_out; /* We will modify b->lv_[f]out, since we no */
fv = b->flv_out; /* longer need them */
assert(b->t >= b->h);
for (cp = b->t; cp >= b->h; cp -= i_isize) {
op = get_op(cp);
nii = nfi = 0;
switch(i_op2class[op]) {
case I_MOPW: case I_MOPWF:
gen(get_rd(cp)); gen(get_rs(cp));
gen(get_rs2(cp));
updateig();
break;
case I_MOPWI: case I_MOPWIF:
gen(get_rd(cp)); gen(get_rs(cp));
updateig();
break;
case I_MOPR: case I_BOP:
case I_MOPRF: case I_BOPF:
case I_MOPRI: case I_BOPI: case I_MOPRIF:
/* Substract def */
if (! kill(get_rd(cp))) { mk_nop(cp); break; }
/* Fall through */
case I_BR: case I_BRI: case I_BRF:
gen(get_rs(cp));
if (!isimmed(op)) gen(get_rs2(cp));
updateig();
break;
case I_UOP: case I_UOPI: case I_UOPF:
case I_LEA: case I_LEAF:
/* Substract def */
if (!kill(get_rd(cp))) { mk_nop(cp); break; }
/* Add use */
if (!isimmed(op)) gen(get_rs(cp));
updateig();
break;
case I_SET: case I_SETF:
/* Subtract def */
if (!kill(get_rd(cp)))
mk_nop(cp);
break;
case I_ARG: case I_ARGF:
case I_RET: case I_RETI: case I_RETF: case I_JMP:
/* Add use */
if (op != i_op_retv && !isimmed(op)) {
gen(get_rd(cp));
updateig();
}
break;
case I_CALL: case I_CALLF:
case I_CALLI: case I_CALLIF:
/* Substract def */
if (op != i_op_callv && op != i_op_callvi)
kill(get_rd(cp));
/* Handle caller-saved registers */
if (num_f) fcallsav(cp, bv_cp(fv));
if (num_i) icallsav(cp, bv_cp(iv));
/* Add use of callee if not immediate */
if (!isimmed(op)) { gen(get_rs(cp)); updateig(); }
break;
case I_MISC: case I_JMPI:
continue;
default: assert(0);
}
}
b = b->lnext;
}
}
/* Compute the delta between 2 resources snapshots.
* the ResourceDiff can have dangling pointers in old and nu, so dont clear
* them before being done with rd in the processing loop
*/
static struct ResourceDiff *NewStateDiff(const struct TrackedResources *old,
const struct TrackedResources *nu)
{
/* FIXME */
struct OpenedResourceNode *orn;
struct ResourceDiff *rd;
rd = get_rd();
if (!rd)
return NULL;
NEWLIST(&rd->modifiedOpened);
for(orn=(struct OpenedResourceNode *)nu->opened.lh_Head;
orn->node.ln_Succ!=NULL;
orn=(struct OpenedResourceNode *)orn->node.ln_Succ)
{
struct OpenedResourceNode *other;
BOOL seen = FALSE;
for(other=(struct OpenedResourceNode *)old->opened.lh_Head;
other->node.ln_Succ!=NULL;
other=(struct OpenedResourceNode *)other->node.ln_Succ)
{
if (orn->addr == other->addr)
{
if (!strcmp(orn->name, other->name))
{
seen = TRUE;
if (orn->count != other->count)
{
struct ModifiedResource *mr = get_mr();
if (!mr)
return NULL;
mr->type = other->type;
mr->name = other->name;
mr->addr = other->addr;
mr->before_count = other->count;
mr->after_count = orn->count;
Enqueue(&rd->modifiedOpened, (struct Node *)mr);
}
}
}
}
if (!seen)
{
struct ModifiedResource *mr = get_mr();
if (!mr)
return NULL;
mr->type = orn->type;
mr->name = orn->name;
mr->addr = orn->addr;
mr->before_count = 0;
mr->after_count = orn->count;
Enqueue(&rd->modifiedOpened, (struct Node *)mr);
}
}
rd->memLost = old->freeMem - nu->freeMem;
return rd;
}
int handle_callback(int i, instruction instr) {
int addr, addrs;
int inc = 0;
struct Operand dest = get_rd(instr);
struct Operand source;
short disp;
switch (table[i].type) {
case SA:
if (instr.sa_instr.bw == 0) {
addr = get_opb(&dest);
inc = 1;
} else {
addr = get_opw(&dest);
inc = 2;
}
table[i].callback(addr, 0);
return 0;
case DA:
source = get_rs(instr);
if (instr.da_instr.bw == 0) {
addr = get_opb(&dest);
addrs = get_opb(&source);
inc = 1;
} else {
addr = get_opw(&dest);
addrs = get_opw(&source);
inc = 2;
}
table[i].callback(addr, addrs);
addr_inc(&source, inc);
break;
case UN:
source = get_rs(instr);
addr = get_opw(&dest);
addrs = get_opw(&source);
inc = 2;
table[i].callback(addr, addrs);
addr_inc(&source, inc);
break;
case BR:
disp = MAXBYTE & instr.instr;
if (disp & SIGN) {
disp = disp | HBYTE;
}
if ((table[i].callback(0, 0)) != 0) {
memory.R[7] += 2 * disp;
}
return 0;
case CTR_INT:
addr = get_opw(&dest);
case CTR:
return table[i].callback(addr, 0);
default:
return 0;
}
addr_inc(&dest, inc);
return 0;
}
void i_li_full (void) {
bvt iskip=0, fskip=0; /* Variables live at both start & end of bb */
bvt ilv=0, flv=0; /* Live variables at each step */
i_bb_t b; /* Temp bblock */
i_puint32 cp; /* Code pointer */
i_cnt_t pos = max_cnt; /* Absolute layout-order position */
unsigned int op; /* Current opcode */
/* Allocate live ranges */
if (num_i) NEW0(i_ilrs, num_i);
if (num_f) NEW0(i_flrs, num_f);
i_ilr_cur = num_i-1; i_flr_cur = num_f-1;
/* Now calculate the live ranges */
for (b = i_fg_tail; b; pos--, b = b->lprev) {
tpos = pos;
hpos = pos - (b->t - b->h)/i_isize;
/* Compute skip set */
if (num_i) {
iskip = bv_rinter(b->ilv_out, b->ilv_in);
ilv = bv_rdiff(b->ilv_out, iskip);
bv_eachbit(iskip, lriskip, b);
}
if (num_f) {
fskip = bv_rinter(b->flv_out, b->flv_in);
flv = bv_rdiff(b->flv_out, fskip);
bv_eachbit(fskip, lrfskip, b);
}
assert(b && b->t >= b->h);
for (cp = b->t; cp >= b->h; pos--, cp -= i_isize) {
op = get_op(cp);
switch(i_op2class[op]) {
case I_MOPW: case I_MOPWF:
USE(get_rs2(cp));
/* Fall through */
case I_MOPWI: case I_MOPWIF:
USE(get_rd(cp));
USE(get_rs(cp));
break;
case I_MOPR: case I_BOP:
case I_MOPRF: case I_BOPF:
case I_MOPRI: case I_BOPI: case I_MOPRIF:
DEF(get_rd(cp));
/* Fall through */
case I_BR: case I_BRI: case I_BRF:
USE(get_rs(cp));
if (!isimmed(op)) USE(get_rs2(cp));
break;
case I_UOP: case I_UOPI: case I_UOPF:
DEF(get_rd(cp));
if (!isimmed(op)) USE(get_rs(cp));
break;
case I_SET: case I_SETF:
DEF(get_rd(cp));
break;
case I_LEA: case I_LEAF:
DEF(get_rd(cp));
USE(get_rs(cp));
break;
case I_ARG: case I_ARGF:
case I_RETF: case I_JMP:
USE(get_rd(cp));
break;
case I_RET:
if (op != i_op_retv) USE(get_rd(cp));
break;
case I_CALL: case I_CALLF:
case I_CALLI: case I_CALLIF:
if (op != i_op_callv && op != i_op_callvi)
DEFKP(get_rd(cp));
/* Add use of callee if not immediate; it is in
an int register, so treat it like an int */
if (!isimmed(op)) USE(get_rs(cp));
/* Set info for caller-saved registers */
if (num_i) icallsav(cp, bv_runion(ilv, iskip));
if (num_f) fcallsav(cp, bv_runion(flv, fskip));
break;
case I_MISC: case I_JMPI: case I_RETI:
continue;
default: assert(0);
}
}
assert(pos+1 == hpos);
if (num_i) bv_eachbit(ilv, lriuseiter, (void *)hpos);
if (num_f) bv_eachbit(flv, lrfuseiter, (void *)hpos);
}
DEBUG(i_li_unparse());
}
