/**
* Read a packet's data and put that data into the user buffer
* @param devptr UDP device table entry
* @param buf User buffer
* @param len Length of data to be read and put into user buffer
* @return OK if data read completes properly, otherwise SYSERR
*/
devcall udpRead(device *devptr, void *buf, uint len)
{
struct udp *udpptr;
struct udpPkt *udppkt;
uchar *buffer = buf;
uchar *data;
int count = 0;
irqmask im;
udpptr = &udptab[devptr->minor];
im = disable();
if ((udpptr->flags & UDP_FLAG_NOBLOCK) && (udpptr->icount < 1))
{
restore(im);
return 0;
}
restore(im);
wait(udpptr->isem);
im = disable();
/* Get a pointer to the stored packet in the current position */
udppkt = udpptr->in[udpptr->istart];
/* Make sure the packet is not NULL */
if (NULL == udppkt)
{
restore(im);
return SYSERR;
}
/* Increment the start value to preserve the circular buffer */
udpptr->istart = (udpptr->istart + 1) % UDP_MAX_PKTS;
/* Decrement the count value before removing the packet from the buffer */
udpptr->icount--;
/* Put the UDP packet's data in the user's buffer */
if (UDP_FLAG_INCHDR & udpptr->flags)
{
count = udppkt->len;
data = (uchar *)udppkt;
}
else
{
count = udppkt->len - UDP_HDR_LEN;
data = udppkt->data;
}
restore(im);
if (count > len)
{
count = len;
}
memcpy(buffer, data, count);
/* Free the packet buffer */
udpFreebuf(udppkt);
return count;
}
void worker::workMedium_anti(MediumWorkMsg *m)
{
restore(this);
}
/*------------------------------------------------------------------------
* udp_in - handle an incoming UDP packet
*------------------------------------------------------------------------
*/
void udp_in(void) { /* currpkt points to the packet */
intmask mask; /* saved interrupt mask */
int32 i; /* index into udptab */
struct udpentry *udptr; /* pointer to udptab entry */
struct ipv4_packet *ippkt = (struct ipv4_packet *)(currpkt->net_ethdata);
struct udp_packet * udppkt = (struct udp_packet *)(ippkt->net_ipdata);
/* Insure only one process can access the UDP table at a time */
mask = disable();
//kprintf("Inside udp_in\r\n");
/* Convert IP and UDP header fields to host byte order */
udp_ntoh(udppkt);
/*
if (ippkt->net_ipproto == IP_UDP) {
kprintf("proto UDP (%d), length %d",
ippkt->net_ipproto, ntohs(ippkt->net_iplen));
kprintf(")\n");
kprintf("\t%d.%d.%d.%d > ",
((ippkt->net_ipsrc)>>24)&0xff,
((ippkt->net_ipsrc)>>16)&0xff,
((ippkt->net_ipsrc)>>8)&0xff,
((ippkt->net_ipsrc)&0xff));
kprintf("%d.%d.%d.%d: ",
((ippkt->net_ipdst)>>24)&0xff,
((ippkt->net_ipdst)>>16)&0xff,
((ippkt->net_ipdst)>>8)&0xff,
((ippkt->net_ipdst)&0xff));
//kprintf("PDUMP Check 9\r\n");
kprintf("[udp checksum none] ");
kprintf("UDP, src port %d, dst port %d, length %d\n",
(udppkt->net_udpsport),
(udppkt->net_udpdport),
(udppkt->net_udplen) - UDP_HDR_LEN);
}
*/
for (i=0; i<UDP_SLOTS; i++) {
udptr = &udptab[i];
if ( (udptr->udstate != UDP_FREE) &&
(udppkt->net_udpdport == udptr->udlocport) &&
((udptr->udremport == 0) ||
(udppkt->net_udpsport == udptr->udremport)) &&
( ((udptr->udremip==0) ||
(ippkt->net_ipsrc == udptr->udremip))) ) {
/* Entry matches incoming packet */
if (udptr->udcount < UDP_QSIZ) {
udptr->udcount++;
udptr->udqueue[udptr->udtail++] = (struct eth_packet *)currpkt;
if (udptr->udtail >= UDP_QSIZ) {
udptr->udtail = 0;
}
currpkt = (struct eth_packet *)getbuf(netbufpool);
if (udptr->udstate == UDP_RECV) {
udptr->udstate = UDP_USED;
send (udptr->udpid, OK);
}
restore(mask);
return;
}
}
}
/* No match - simply discard packet */
//kprintf("Done with udp_in\r\n");
restore(mask);
return;
}
WrestlerAddress::WrestlerAddress( int id, Keeper *keeper ) : Object(keeper)
{
init();
restore( id );
}
void worker::workLarge_anti(LargeWorkMsg *m)
{
restore(this);
}
/**
* Control function for ethloop devices.
* @param devptr ethloop device table entry
* @param func control function to execute
* @param arg1 first argument for the control function
* @param arg2 second argument for the control function
* @return the result of the control function
*/
devcall ethloopControl(device *devptr, int func, long arg1, long arg2)
{
struct ethloop *elpptr;
struct netaddr *addr;
uchar old;
irqmask im;
char *buf;
char *hold;
int holdlen;
elpptr = &elooptab[devptr->minor];
im = disable();
if (ELOOP_STATE_ALLOC != elpptr->state)
{
restore(im);
return SYSERR;
}
switch (func)
{
/* Get link header length. */
case NET_GET_LINKHDRLEN:
restore(im);
return ETH_HDR_LEN;
/* Get MAC address from card. */
case NET_GET_HWADDR:
restore(im);
addr = (struct netaddr *)arg1;
addr->type = NETADDR_ETHERNET;
addr->len = ETH_ADDR_LEN;
addr->addr[0] = 0xAA;
addr->addr[1] = 0xBB;
addr->addr[2] = 0xCC;
addr->addr[3] = 0xDD;
addr->addr[4] = 0xEE;
addr->addr[5] = 0xFF;
break;
/* Get broadcast MAC address. */
case NET_GET_HWBRC:
restore(im);
addr = (struct netaddr *)arg1;
addr->type = NETADDR_ETHERNET;
addr->len = ETH_ADDR_LEN;
addr->addr[0] = 0xFF;
addr->addr[1] = 0xFF;
addr->addr[2] = 0xFF;
addr->addr[3] = 0xFF;
addr->addr[4] = 0xFF;
addr->addr[5] = 0xFF;
break;
/* Get MTU. */
case NET_GET_MTU:
restore(im);
return ELOOP_MTU;
/* Get next packet off hold queue */
case ELOOP_CTRL_GETHOLD:
buf = (char *)arg1;
/* Wait for held packet */
wait(elpptr->hsem);
/* Get and clear held packet */
hold = elpptr->hold;
holdlen = elpptr->holdlen;
elpptr->hold = NULL;
elpptr->holdlen = 0;
restore(im);
/* Copy held packet to buffer */
if (arg2 < holdlen)
{
holdlen = arg2;
}
memcpy(buf, hold, holdlen);
/* Free hold buffer */
buffree(hold);
return holdlen;
/* Set flags */
case ELOOP_CTRL_SETFLAG:
old = elpptr->flags & arg1;
elpptr->flags |= (arg1);
restore(im);
return old;
/* Clear flags */
case ELOOP_CTRL_CLRFLAG:
old = elpptr->flags & arg1;
elpptr->flags &= ~(arg1);
restore(im);
return old;
default:
restore(im);
return SYSERR;
}
restore(im);
return OK;
}
int main (int argc, char *argv[])
{
int my_rank, proc_num;
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &proc_num);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
double diff; /* change in value */
int i, j, m, n;
int N=DEFAULT_N;
double epsilon=0.01;
double mean;
FILE *fp;
/* Argument processing */
int edgeElems = DEFAULT_ELEM; /* edge elements */
int cfreq = DEFAULT_FREQ; /* checkpoint frequency */
char *cpath = DEFAULT_PATH; /* checkpoint path */
int nok = 0; /* arguments not OK */
int pinit=1;
char *s;
while (--argc > 0 && (*++argv)[0] == '-') {
for(s=argv[0]+1;*s;s++)
switch (*s) {
case 'd':
if (isdigit(s[1]))
edgeElems = atoi(s+1);
else
nok = 1;
s+=strlen(s+1);
break;
case 'c':
if (isdigit(s[i]))
cfreq = atoi(s+1);
else
nok = 1;
s+=strlen(s+1);
break;
case 'p':
cpath = s+1;
s+=strlen(s+1);
break;
case 'r':
pinit = 0;
break;
case 'n':
if (isdigit(s[1]))
N = atoi(s+1);
else
nok = 1;
s+=strlen(s+1);
break;
case 'e':
if (isdigit(s[1]))
epsilon = atof(s+1);
else
nok = 1;
s+=strlen(s+1);
break;
default:
nok = 1;
break;
}
}
if (nok) {
fprintf(stderr, "Usage: %s -e<int> -c<int> -p<str> -r -n<int> -epsilon<double>\n", argv[0]);
fprintf(stderr, " -d edge elements, default: %d\n", DEFAULT_ELEM);
fprintf(stderr, " -c checkpoint frequency, default: %d\n", DEFAULT_FREQ);
fprintf(stderr, " -p path to checkpoint file, default: %s\n", DEFAULT_PATH);
fprintf(stderr, " -r restore\n");
fprintf(stderr, " -n size of n, default:1000\n");
fprintf(stderr, " -e epsilon, default:0.01\n");
exit(EXIT_FAILURE);
}
#ifdef DEBUG
if(my_rank==0)
printf("n=%d, epsilon=%lf\n", N, epsilon);
#endif
if(N>1000){
printf("Too big value for N, use no more than 1000, or change DEFAULT_N\n");
return 0;
}
// Persistent memory initialization
const char *mode = (pinit) ? "w+" : "r+";
char back_fname[128];
char my_rank_str[4];
perm(PERM_START, PERM_SIZE);
strcpy(back_fname, cpath);
strcat(back_fname,"hw5_mpi.back.");
sprintf(my_rank_str, "%d", my_rank);
strcat(back_fname,my_rank_str);
// printf("mopen: %s\n", back_fname);
mopen(back_fname, mode, MMAP_SIZE);
strcpy(back_fname, cpath);
strcat(back_fname,"hw5_mpi.mmap.");
strcat(back_fname,my_rank_str);
// printf("bopen: %s\n", back_fname);
bopen(back_fname, mode);
if (!pinit){
restore();
printf("Resotored, iter=%d, myN=%d\n", iter, myN);
}
else{
iter = 0;
/* Set boundary values and compute mean boundary value */
mean = 0.0;
for (i=0; i<N; i++) {
u[i][0] = u[i][N-1] = u[0][i] = 100.0;
u[N-1][i] = 0.0;
mean += u[i][0] + u[i][N-1] + u[0][i] + u[N-1][i];
}
mean /= (4.0 *N);
/* Initialize interior values */
for (i =1; i<N-1; i++)
for (j=1; j<N-1; j++)
u[i][j] = mean;
// distribute data
myN = N / proc_num;
if(N%proc_num!=0){
if(my_rank==proc_num-1)
myN=N-(proc_num-1)*myN;
}
if(proc_num > 1) {
// ghost rows
if(my_rank == 0 || my_rank == proc_num - 1)
myN++;
else
myN += 2;
}
// initial value
for(i = 0; i < myN; i++) {
for(j = 0; j < N; j++) {
if(my_rank == 0)
myu[i][j] = u[i][j];
else
myu[i][j] = u[my_rank*(N/proc_num)-1+i][j];
myw[i][j]=myu[i][j];
}
}
mflush();
backup();
}
struct timeval start_tv, end_tv;
gettimeofday(&start_tv, NULL);
double alldiff=0;
int left = my_rank - 1;
int right = my_rank +1;
MPI_Request send_req1, recv_req1;
MPI_Request send_req2, recv_req2;
while(1)
{
iter++;
diff = 0.0;
for (i=1; i<myN-1; i++) {
for (j=1; j<N-1; j++) {
myw[i][j] = (myu[i-1][j] + myu[i+1][j] + myu[i][j-1] + myu[i][j+1])/4.0;
if (fabs (myw[i][j] - myu[i][j]) > diff)
diff = fabs(myw[i][j] - myu[i][j]);
}
}
// reduce diff
MPI_Allreduce(&diff, &alldiff, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
#ifdef PRINTITER
if(my_rank==0){
printf("iter=%d, diff=%lf\n", iter, alldiff);
fflush(stdout);
}
#endif
if (alldiff <= epsilon)
break;
if(proc_num > 1) {
// send second top row
if(my_rank != 0){
MPI_Isend(myw[1], N, MPI_DOUBLE, left, 0, MPI_COMM_WORLD, &send_req1);
//printf("Send: %d->%d\n", my_rank, left);
}
// send second to bottom row
if(my_rank != proc_num - 1){
MPI_Isend(myw[myN-2], N, MPI_DOUBLE, right, 1, MPI_COMM_WORLD, &send_req2);
//printf("Send %d->%d\n", my_rank, right);
}
// recive top
if(my_rank != 0){
MPI_Irecv(myw[0], N, MPI_DOUBLE, left, 1, MPI_COMM_WORLD, &recv_req1);
//printf("Recv: %d->%d\n", my_rank, left);
}
// receive bottom
if(my_rank != proc_num - 1) {
MPI_Irecv(myw[myN-1], N, MPI_DOUBLE, right, 0, MPI_COMM_WORLD, &recv_req2);
//printf("Recv %d->%d\n", my_rank, right);
}
if(my_rank != 0)
MPI_Wait(&send_req1, &status);
if(my_rank != proc_num - 1)
MPI_Wait(&send_req2, &status);
if(my_rank != 0)
MPI_Wait(&recv_req1, &status);
if(my_rank != proc_num - 1)
MPI_Wait(&recv_req2, &status);
}
for (i=0; i<myN; i++) {
if( (i==0&&my_rank==0) ||(i==myN-1&&my_rank==proc_num-1))
continue;
for (j=1; j<N-1; j++)
myu[i][j] = myw[i][j];
}
// backup
if(iter%cfreq == 0)
backup();
}
gettimeofday(&end_tv, NULL);
printf("Elapsed time: %f sec\n",
(double)( (double)(end_tv.tv_sec - start_tv.tv_sec) + ( (double)(end_tv.tv_usec - start_tv.tv_usec)/1000000)) );
// gather data
if(my_rank==0) {
for (i=0; i<myN; i++) {
for(j=0; j<N; j++) {
u[i][j] = myu[i][j];
}
}
if(proc_num > 1) {
for (i=1; i<proc_num-1; i++)
MPI_Recv(u[i*(N/proc_num)], (N/proc_num)*N, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
// special care for last one
if(N%proc_num==0)
MPI_Recv(u[i*(N/proc_num)], (N/proc_num)*N, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
else{
MPI_Recv(u[i*(N/proc_num)], (N-(N/proc_num)*(proc_num-1))*N, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
}
}
}
else {
if(N%proc_num==0)
MPI_Send(myu[1], (N/proc_num)*N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
else{
if(my_rank != proc_num-1)
MPI_Send(myu[1], (myN-2)*N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
else
MPI_Send(myu[1], (myN-1)*N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}
}
if(my_rank == 0) {
/* Print Solution */
fp = fopen("output.dat", "w");
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
fprintf(fp, "%6.2f ", u[i][j]);
}
fprintf(fp, "\n");
}
fclose(fp);
}
mclose();
bclose();
MPI_Finalize();
return 0;
}
void create()
{
if( !restore() && !mapp(emote) )
emote = ([]);
}
void create()
{
seteuid(getuid());
restore();
}
Camera::Camera(Node *parent)
: p_parent(parent)
{
FZ_ASSERT(parent, "Parent can not be NULL.");
restore();
}
/*------------------------------------------------------------------------
* create - create a process to start running a procedure
*------------------------------------------------------------------------
*/
pid32 create_9_4(
void *procaddr, /* procedure address */
uint32 ssize, /* stack size in words */
pri16 priority, /* process priority > 0 */
char *name, /* name (for debugging) */
uint32 nargs, /* number of args that follow */
...
)
{
uint32 savsp, *pushsp;
intmask mask; /* interrupt mask */
pid32 pid; /* stores new process id */
struct procent *prptr; /* pointer to proc. table entry */
int32 i;
uint32 *a; /* points to list of args */
uint32 *saddr; /* stack address */
mask = disable();
if (ssize < MINSTK)
ssize = MINSTK;
ssize = (uint32) roundew(ssize);
if (((saddr = (uint32 *)getstk_new(ssize)) ==
(uint32 *)SYSERR ) ||
(pid=newpid()) == SYSERR || priority < 1 ) {
restore(mask);
return SYSERR;
}
prcount++;
prptr = &proctab[pid];
/* initialize process table entry for new process */
prptr->prstate = PR_SUSP; /* initial state is suspended */
prptr->prprio = priority;
prptr->prstkbase = (char *)saddr;
prptr->prstklen = ssize;
prptr->prname[PNMLEN-1] = NULLCH;
for (i=0 ; i<PNMLEN-1 && (prptr->prname[i]=name[i])!=NULLCH; i++)
;
prptr->prsem = -1;
prptr->prparent = (pid32)getpid();
prptr->prhasmsg = FALSE;
/* set up initial device descriptors for the shell */
prptr->prdesc[0] = CONSOLE; /* stdin is CONSOLE device */
prptr->prdesc[1] = CONSOLE; /* stdout is CONSOLE device */
prptr->prdesc[2] = CONSOLE; /* stderr is CONSOLE device */
/* Initialize stack as if the process was called */
*saddr = STACKMAGIC;
savsp = (uint32)saddr;
/* push arguments */
a = (uint32 *)(&nargs + 1); /* start of args */
a += nargs -1; /* last argument */
for ( ; nargs > 4 ; nargs--) /* machine dependent; copy args */
*--saddr = *a--; /* onto created process' stack */
*--saddr = (long)procaddr;
for(i = 11; i >= 4; i--)
*--saddr = 0;
for(i = 4; i > 0; i--) {
if(i <= nargs)
*--saddr = *a--;
else
*--saddr = 0;
}
*--saddr = (long)INITRET; /* push on return address */
*--saddr = (long)0x00000053; /* CPSR, A, F bits set, */
/* Supervisor mode */
prptr->prstkptr = (char *)saddr;
restore(mask);
return pid;
/* The following entries on the stack must match what ctxsw */
/* expects a saved process state to contain: ret address, */
/* ebp, interrupt mask, flags, registerss, and an old SP */
*--saddr = (long)procaddr; /* Make the stack look like it's*/
/* half-way through a call to */
/* ctxsw that "returns" to the */
/* new process */
*--saddr = savsp; /* This will be register ebp */
/* for process exit */
savsp = (uint32) saddr; /* start of frame for ctxsw */
*--saddr = 0x00000200; /* New process runs with */
/* interrupts enabled */
/* Basically, the following emulates a x86 "pushal" instruction */
*--saddr = 0; /* %eax */
*--saddr = 0; /* %ecx */
*--saddr = 0; /* %edx */
*--saddr = 0; /* %ebx */
*--saddr = 0; /* %esp; value filled in below */
pushsp = saddr; /* remember this location */
*--saddr = savsp; /* %ebp (while finishing ctxsw) */
*--saddr = 0; /* %esi */
*--saddr = 0; /* %edi */
*pushsp = (unsigned long) (prptr->prstkptr = (char *)saddr);
restore(mask);
return pid;
}
//------------------------------ generate_exception_blob ---------------------------
// creates exception blob at the end
// Using exception blob, this code is jumped from a compiled method.
// (see emit_exception_handler in sparc.ad file)
//
// Given an exception pc at a call we call into the runtime for the
// handler in this method. This handler might merely restore state
// (i.e. callee save registers) unwind the frame and jump to the
// exception handler for the nmethod if there is no Java level handler
// for the nmethod.
//
// This code is entered with a jmp.
//
// Arguments:
// O0: exception oop
// O1: exception pc
//
// Results:
// O0: exception oop
// O1: exception pc in caller or ???
// destination: exception handler of caller
//
// Note: the exception pc MUST be at a call (precise debug information)
//
void OptoRuntime::generate_exception_blob() {
// allocate space for code
ResourceMark rm;
int pad = VerifyThread ? 256 : 0;// Extra slop space for more verify code
// setup code generation tools
// Measured 8/7/03 at 256 in 32bit debug build (no VerifyThread)
// Measured 8/7/03 at 528 in 32bit debug build (VerifyThread)
CodeBuffer buffer("exception_blob", 600+pad, 512);
MacroAssembler* masm = new MacroAssembler(&buffer);
int framesize_in_bytes = __ total_frame_size_in_bytes(0);
int framesize_in_words = framesize_in_bytes / wordSize;
int framesize_in_slots = framesize_in_bytes / sizeof(jint);
Label L;
int start = __ offset();
__ verify_thread();
__ st_ptr(Oexception, G2_thread, JavaThread::exception_oop_offset());
__ st_ptr(Oissuing_pc, G2_thread, JavaThread::exception_pc_offset());
// This call does all the hard work. It checks if an exception catch
// exists in the method.
// If so, it returns the handler address.
// If the nmethod has been deoptimized and it had a handler the handler
// address is the deopt blob unpack_with_exception entry.
//
// If no handler exists it prepares for stack-unwinding, restoring the callee-save
// registers of the frame being removed.
//
__ save_frame(0);
__ mov(G2_thread, O0);
__ set_last_Java_frame(SP, noreg);
__ save_thread(L7_thread_cache);
// This call can block at exit and nmethod can be deoptimized at that
// point. If the nmethod had a catch point we would jump to the
// now deoptimized catch point and fall thru the vanilla deopt
// path and lose the exception
// Sure would be simpler if this call didn't block!
__ call(CAST_FROM_FN_PTR(address, OptoRuntime::handle_exception_C), relocInfo::runtime_call_type);
__ delayed()->mov(L7_thread_cache, O0);
// Set an oopmap for the call site. This oopmap will only be used if we
// are unwinding the stack. Hence, all locations will be dead.
// Callee-saved registers will be the same as the frame above (i.e.,
// handle_exception_stub), since they were restored when we got the
// exception.
OopMapSet *oop_maps = new OopMapSet();
oop_maps->add_gc_map( __ offset()-start, new OopMap(framesize_in_slots, 0));
__ bind(L);
__ restore_thread(L7_thread_cache);
__ reset_last_Java_frame();
__ mov(O0, G3_scratch); // Move handler address to temp
__ restore();
// Restore SP from L7 if the exception PC is a MethodHandle call site.
__ lduw(Address(G2_thread, JavaThread::is_method_handle_return_offset()), O7);
__ tst(O7);
__ movcc(Assembler::notZero, false, Assembler::icc, L7_mh_SP_save, SP);
// G3_scratch contains handler address
// Since this may be the deopt blob we must set O7 to look like we returned
// from the original pc that threw the exception
__ ld_ptr(G2_thread, JavaThread::exception_pc_offset(), O7);
__ sub(O7, frame::pc_return_offset, O7);
assert(Assembler::is_simm13(in_bytes(JavaThread::exception_oop_offset())), "exception offset overflows simm13, following ld instruction cannot be in delay slot");
__ ld_ptr(G2_thread, JavaThread::exception_oop_offset(), Oexception); // O0
#ifdef ASSERT
__ st_ptr(G0, G2_thread, JavaThread::exception_handler_pc_offset());
__ st_ptr(G0, G2_thread, JavaThread::exception_pc_offset());
#endif
__ JMP(G3_scratch, 0);
// Clear the exception oop so GC no longer processes it as a root.
__ delayed()->st_ptr(G0, G2_thread, JavaThread::exception_oop_offset());
// -------------
// make sure all code is generated
masm->flush();
_exception_blob = ExceptionBlob::create(&buffer, oop_maps, framesize_in_words);
}
int mouse_doing(void)
{
int fd;
int press_flag = 0;
int end_flag = 0;
mouse_event m_event;
fd = open("/dev/input/mice", O_RDWR|O_NONBLOCK); //?
if (fd == -1)
{
perror("mice");
exit(0);
}
mx = fb_v.w / 2; //initial the coordinates.
my = fb_v.h / 2;
draw_cursor(mx, my);
while (1)
{
if (get_m_info(fd, &m_event) > 0)
{
restore(mx, my);
mx += m_event.dx;
my += m_event.dy;
mx = (mx < 0) ? 0 : mx;
my = (my < 0) ? 0 : my;
if (mx > (fb_v.w - C_W))
{
mx = fb_v.w - C_W;
}
if (my > (fb_v.h - C_H))
{
my = fb_v.h - C_H;
}
switch (m_event.button)
{
case 0:
if (press_flag == 1)
{
press_flag = 0;
if (end_flag == 0)
{
end_flag = chess_do();
}
else
{
print_board(GRAY, YELLOW);
end_flag = 0;
}
}
else if (press_flag == 2)
{
press_flag = 0;
chess_do();
}
break;
case 1: press_flag = 1; break;
case 2: press_flag = 2; break;
case 3: break;
case 4: break;
default: break;
}
draw_cursor(mx, my);
}
usleep(1000);
}
return 0;
}
/*------------------------------------------------------------------------
* getmem - Allocate heap storage, returning lowest word address
*------------------------------------------------------------------------
*/
char *getmem(
uint32 nbytes /* Size of memory requested */
)
{
intmask mask; /* Saved interrupt mask */
struct memblk *prev, *curr, *leftover;
mask = disable();
if (nbytes == 0) {
restore(mask);
return (char *)SYSERR;
}
nbytes = (uint32) roundmb(nbytes); /* Use memblk multiples */
prev = &memlist;
curr = memlist.mnext;
while (curr != NULL) { /* Search free list */
if (curr->mlength == nbytes) { /* Block is exact match */
prev->mnext = curr->mnext;
/* jteague6 - allow prev node re-linking to support
* from-the-back node searching */
if( curr == memtail.mprev ) {
memtail.mprev = prev;
}
else {
curr->mnext->mprev = prev;
}
memlist.mlength -= nbytes;
restore(mask);
return (char *)(curr);
} else if (curr->mlength > nbytes) { /* Split big block */
leftover = (struct memblk *)((uint32) curr +
nbytes);
prev->mnext = leftover;
leftover->mnext = curr->mnext;
leftover->mlength = curr->mlength - nbytes;
memlist.mlength -= nbytes;
/* jteague6 - support prev node re-linking to allow
* from-the-back memory searching */
leftover->mprev = curr->mprev;
if( curr == memtail.mprev ) {
memtail.mprev = leftover;
}
else {
curr->mnext->mprev = leftover;
}
restore(mask);
return (char *)(curr);
} else { /* Move to next block */
prev = curr;
curr = curr->mnext;
}
}
restore(mask);
return (char *)SYSERR;
}
OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
OopMapSet* oop_maps = NULL;
// for better readability
const bool must_gc_arguments = true;
const bool dont_gc_arguments = false;
// stub code & info for the different stubs
switch (id) {
case forward_exception_id:
{
oop_maps = generate_handle_exception(id, sasm);
}
break;
case new_instance_id:
case fast_new_instance_id:
case fast_new_instance_init_check_id:
{
Register G5_klass = G5; // Incoming
Register O0_obj = O0; // Outgoing
if (id == new_instance_id) {
__ set_info("new_instance", dont_gc_arguments);
} else if (id == fast_new_instance_id) {
__ set_info("fast new_instance", dont_gc_arguments);
} else {
assert(id == fast_new_instance_init_check_id, "bad StubID");
__ set_info("fast new_instance init check", dont_gc_arguments);
}
if ((id == fast_new_instance_id || id == fast_new_instance_init_check_id) &&
UseTLAB && FastTLABRefill) {
Label slow_path;
Register G1_obj_size = G1;
Register G3_t1 = G3;
Register G4_t2 = G4;
assert_different_registers(G5_klass, G1_obj_size, G3_t1, G4_t2);
// Push a frame since we may do dtrace notification for the
// allocation which requires calling out and we don't want
// to stomp the real return address.
__ save_frame(0);
if (id == fast_new_instance_init_check_id) {
// make sure the klass is initialized
__ ldub(G5_klass, in_bytes(InstanceKlass::init_state_offset()), G3_t1);
__ cmp_and_br_short(G3_t1, InstanceKlass::fully_initialized, Assembler::notEqual, Assembler::pn, slow_path);
}
#ifdef ASSERT
// assert object can be fast path allocated
{
Label ok, not_ok;
__ ld(G5_klass, in_bytes(Klass::layout_helper_offset()), G1_obj_size);
// make sure it's an instance (LH > 0)
__ cmp_and_br_short(G1_obj_size, 0, Assembler::lessEqual, Assembler::pn, not_ok);
__ btst(Klass::_lh_instance_slow_path_bit, G1_obj_size);
__ br(Assembler::zero, false, Assembler::pn, ok);
__ delayed()->nop();
__ bind(not_ok);
__ stop("assert(can be fast path allocated)");
__ should_not_reach_here();
__ bind(ok);
}
#endif // ASSERT
// if we got here then the TLAB allocation failed, so try
// refilling the TLAB or allocating directly from eden.
Label retry_tlab, try_eden;
__ tlab_refill(retry_tlab, try_eden, slow_path); // preserves G5_klass
__ bind(retry_tlab);
// get the instance size
__ ld(G5_klass, in_bytes(Klass::layout_helper_offset()), G1_obj_size);
__ tlab_allocate(O0_obj, G1_obj_size, 0, G3_t1, slow_path);
__ initialize_object(O0_obj, G5_klass, G1_obj_size, 0, G3_t1, G4_t2);
__ verify_oop(O0_obj);
__ mov(O0, I0);
__ ret();
__ delayed()->restore();
__ bind(try_eden);
// get the instance size
__ ld(G5_klass, in_bytes(Klass::layout_helper_offset()), G1_obj_size);
__ eden_allocate(O0_obj, G1_obj_size, 0, G3_t1, G4_t2, slow_path);
__ incr_allocated_bytes(G1_obj_size, G3_t1, G4_t2);
__ initialize_object(O0_obj, G5_klass, G1_obj_size, 0, G3_t1, G4_t2);
__ verify_oop(O0_obj);
__ mov(O0, I0);
__ ret();
__ delayed()->restore();
__ bind(slow_path);
// pop this frame so generate_stub_call can push it's own
__ restore();
}
oop_maps = generate_stub_call(sasm, I0, CAST_FROM_FN_PTR(address, new_instance), G5_klass);
// I0->O0: new instance
}
break;
case counter_overflow_id:
// G4 contains bci, G5 contains method
oop_maps = generate_stub_call(sasm, noreg, CAST_FROM_FN_PTR(address, counter_overflow), G4, G5);
break;
case new_type_array_id:
case new_object_array_id:
{
Register G5_klass = G5; // Incoming
Register G4_length = G4; // Incoming
Register O0_obj = O0; // Outgoing
Address klass_lh(G5_klass, Klass::layout_helper_offset());
assert(Klass::_lh_header_size_shift % BitsPerByte == 0, "bytewise");
assert(Klass::_lh_header_size_mask == 0xFF, "bytewise");
// Use this offset to pick out an individual byte of the layout_helper:
const int klass_lh_header_size_offset = ((BytesPerInt - 1) // 3 - 2 selects byte {0,1,0,0}
- Klass::_lh_header_size_shift / BitsPerByte);
if (id == new_type_array_id) {
__ set_info("new_type_array", dont_gc_arguments);
} else {
__ set_info("new_object_array", dont_gc_arguments);
}
#ifdef ASSERT
// assert object type is really an array of the proper kind
{
Label ok;
Register G3_t1 = G3;
__ ld(klass_lh, G3_t1);
__ sra(G3_t1, Klass::_lh_array_tag_shift, G3_t1);
int tag = ((id == new_type_array_id)
? Klass::_lh_array_tag_type_value
: Klass::_lh_array_tag_obj_value);
__ cmp_and_brx_short(G3_t1, tag, Assembler::equal, Assembler::pt, ok);
__ stop("assert(is an array klass)");
__ should_not_reach_here();
__ bind(ok);
}
#endif // ASSERT
if (UseTLAB && FastTLABRefill) {
Label slow_path;
Register G1_arr_size = G1;
Register G3_t1 = G3;
Register O1_t2 = O1;
assert_different_registers(G5_klass, G4_length, G1_arr_size, G3_t1, O1_t2);
// check that array length is small enough for fast path
__ set(C1_MacroAssembler::max_array_allocation_length, G3_t1);
__ cmp_and_br_short(G4_length, G3_t1, Assembler::greaterUnsigned, Assembler::pn, slow_path);
// if we got here then the TLAB allocation failed, so try
// refilling the TLAB or allocating directly from eden.
Label retry_tlab, try_eden;
__ tlab_refill(retry_tlab, try_eden, slow_path); // preserves G4_length and G5_klass
__ bind(retry_tlab);
// get the allocation size: (length << (layout_helper & 0x1F)) + header_size
__ ld(klass_lh, G3_t1);
__ sll(G4_length, G3_t1, G1_arr_size);
__ srl(G3_t1, Klass::_lh_header_size_shift, G3_t1);
__ and3(G3_t1, Klass::_lh_header_size_mask, G3_t1);
__ add(G1_arr_size, G3_t1, G1_arr_size);
__ add(G1_arr_size, MinObjAlignmentInBytesMask, G1_arr_size); // align up
__ and3(G1_arr_size, ~MinObjAlignmentInBytesMask, G1_arr_size);
__ tlab_allocate(O0_obj, G1_arr_size, 0, G3_t1, slow_path); // preserves G1_arr_size
__ initialize_header(O0_obj, G5_klass, G4_length, G3_t1, O1_t2);
__ ldub(klass_lh, G3_t1, klass_lh_header_size_offset);
__ sub(G1_arr_size, G3_t1, O1_t2); // body length
__ add(O0_obj, G3_t1, G3_t1); // body start
__ initialize_body(G3_t1, O1_t2);
__ verify_oop(O0_obj);
__ retl();
__ delayed()->nop();
__ bind(try_eden);
// get the allocation size: (length << (layout_helper & 0x1F)) + header_size
__ ld(klass_lh, G3_t1);
__ sll(G4_length, G3_t1, G1_arr_size);
__ srl(G3_t1, Klass::_lh_header_size_shift, G3_t1);
__ and3(G3_t1, Klass::_lh_header_size_mask, G3_t1);
__ add(G1_arr_size, G3_t1, G1_arr_size);
__ add(G1_arr_size, MinObjAlignmentInBytesMask, G1_arr_size);
__ and3(G1_arr_size, ~MinObjAlignmentInBytesMask, G1_arr_size);
__ eden_allocate(O0_obj, G1_arr_size, 0, G3_t1, O1_t2, slow_path); // preserves G1_arr_size
__ incr_allocated_bytes(G1_arr_size, G3_t1, O1_t2);
__ initialize_header(O0_obj, G5_klass, G4_length, G3_t1, O1_t2);
__ ldub(klass_lh, G3_t1, klass_lh_header_size_offset);
__ sub(G1_arr_size, G3_t1, O1_t2); // body length
__ add(O0_obj, G3_t1, G3_t1); // body start
__ initialize_body(G3_t1, O1_t2);
__ verify_oop(O0_obj);
__ retl();
__ delayed()->nop();
__ bind(slow_path);
}
if (id == new_type_array_id) {
oop_maps = generate_stub_call(sasm, I0, CAST_FROM_FN_PTR(address, new_type_array), G5_klass, G4_length);
} else {
oop_maps = generate_stub_call(sasm, I0, CAST_FROM_FN_PTR(address, new_object_array), G5_klass, G4_length);
}
// I0 -> O0: new array
}
break;
case new_multi_array_id:
{ // O0: klass
// O1: rank
// O2: address of 1st dimension
__ set_info("new_multi_array", dont_gc_arguments);
oop_maps = generate_stub_call(sasm, I0, CAST_FROM_FN_PTR(address, new_multi_array), I0, I1, I2);
// I0 -> O0: new multi array
}
break;
case register_finalizer_id:
{
__ set_info("register_finalizer", dont_gc_arguments);
// load the klass and check the has finalizer flag
Label register_finalizer;
Register t = O1;
__ load_klass(O0, t);
__ ld(t, in_bytes(Klass::access_flags_offset()), t);
__ set(JVM_ACC_HAS_FINALIZER, G3);
__ andcc(G3, t, G0);
__ br(Assembler::notZero, false, Assembler::pt, register_finalizer);
__ delayed()->nop();
// do a leaf return
__ retl();
__ delayed()->nop();
__ bind(register_finalizer);
OopMap* oop_map = save_live_registers(sasm);
int call_offset = __ call_RT(noreg, noreg,
CAST_FROM_FN_PTR(address, SharedRuntime::register_finalizer), I0);
oop_maps = new OopMapSet();
oop_maps->add_gc_map(call_offset, oop_map);
// Now restore all the live registers
restore_live_registers(sasm);
__ ret();
__ delayed()->restore();
}
break;
case throw_range_check_failed_id:
{ __ set_info("range_check_failed", dont_gc_arguments); // arguments will be discarded
// G4: index
oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_range_check_exception), true);
}
break;
case throw_index_exception_id:
{ __ set_info("index_range_check_failed", dont_gc_arguments); // arguments will be discarded
// G4: index
oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_index_exception), true);
}
break;
case throw_div0_exception_id:
{ __ set_info("throw_div0_exception", dont_gc_arguments);
oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_div0_exception), false);
}
break;
case throw_null_pointer_exception_id:
{ __ set_info("throw_null_pointer_exception", dont_gc_arguments);
oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_null_pointer_exception), false);
}
break;
case handle_exception_id:
{ __ set_info("handle_exception", dont_gc_arguments);
oop_maps = generate_handle_exception(id, sasm);
}
break;
case handle_exception_from_callee_id:
{ __ set_info("handle_exception_from_callee", dont_gc_arguments);
oop_maps = generate_handle_exception(id, sasm);
}
break;
case unwind_exception_id:
{
// O0: exception
// I7: address of call to this method
__ set_info("unwind_exception", dont_gc_arguments);
__ mov(Oexception, Oexception->after_save());
__ add(I7, frame::pc_return_offset, Oissuing_pc->after_save());
__ call_VM_leaf(L7_thread_cache, CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address),
G2_thread, Oissuing_pc->after_save());
__ verify_not_null_oop(Oexception->after_save());
// Restore SP from L7 if the exception PC is a method handle call site.
__ mov(O0, G5); // Save the target address.
__ lduw(Address(G2_thread, JavaThread::is_method_handle_return_offset()), L0);
__ tst(L0); // Condition codes are preserved over the restore.
__ restore();
__ jmp(G5, 0);
__ delayed()->movcc(Assembler::notZero, false, Assembler::icc, L7_mh_SP_save, SP); // Restore SP if required.
}
break;
case throw_array_store_exception_id:
{
__ set_info("throw_array_store_exception", dont_gc_arguments);
oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_array_store_exception), true);
}
break;
case throw_class_cast_exception_id:
{
// G4: object
__ set_info("throw_class_cast_exception", dont_gc_arguments);
oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_class_cast_exception), true);
}
break;
case throw_incompatible_class_change_error_id:
{
__ set_info("throw_incompatible_class_cast_exception", dont_gc_arguments);
oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_incompatible_class_change_error), false);
}
break;
case slow_subtype_check_id:
{ // Support for uint StubRoutine::partial_subtype_check( Klass sub, Klass super );
// Arguments :
//
// ret : G3
// sub : G3, argument, destroyed
// super: G1, argument, not changed
// raddr: O7, blown by call
Label miss;
__ save_frame(0); // Blow no registers!
__ check_klass_subtype_slow_path(G3, G1, L0, L1, L2, L4, NULL, &miss);
__ mov(1, G3);
__ ret(); // Result in G5 is 'true'
__ delayed()->restore(); // free copy or add can go here
__ bind(miss);
__ mov(0, G3);
__ ret(); // Result in G5 is 'false'
__ delayed()->restore(); // free copy or add can go here
}
case monitorenter_nofpu_id:
case monitorenter_id:
{ // G4: object
// G5: lock address
__ set_info("monitorenter", dont_gc_arguments);
int save_fpu_registers = (id == monitorenter_id);
// make a frame and preserve the caller's caller-save registers
OopMap* oop_map = save_live_registers(sasm, save_fpu_registers);
int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorenter), G4, G5);
oop_maps = new OopMapSet();
oop_maps->add_gc_map(call_offset, oop_map);
restore_live_registers(sasm, save_fpu_registers);
__ ret();
__ delayed()->restore();
}
break;
case monitorexit_nofpu_id:
case monitorexit_id:
{ // G4: lock address
// note: really a leaf routine but must setup last java sp
// => use call_RT for now (speed can be improved by
// doing last java sp setup manually)
__ set_info("monitorexit", dont_gc_arguments);
int save_fpu_registers = (id == monitorexit_id);
// make a frame and preserve the caller's caller-save registers
OopMap* oop_map = save_live_registers(sasm, save_fpu_registers);
int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorexit), G4);
oop_maps = new OopMapSet();
oop_maps->add_gc_map(call_offset, oop_map);
restore_live_registers(sasm, save_fpu_registers);
__ ret();
__ delayed()->restore();
}
break;
case deoptimize_id:
{
__ set_info("deoptimize", dont_gc_arguments);
OopMap* oop_map = save_live_registers(sasm);
int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, deoptimize));
oop_maps = new OopMapSet();
oop_maps->add_gc_map(call_offset, oop_map);
restore_live_registers(sasm);
DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
assert(deopt_blob != NULL, "deoptimization blob must have been created");
AddressLiteral dest(deopt_blob->unpack_with_reexecution());
__ jump_to(dest, O0);
__ delayed()->restore();
}
break;
case access_field_patching_id:
{ __ set_info("access_field_patching", dont_gc_arguments);
oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, access_field_patching));
}
break;
case load_klass_patching_id:
{ __ set_info("load_klass_patching", dont_gc_arguments);
oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_klass_patching));
}
break;
case load_mirror_patching_id:
{ __ set_info("load_mirror_patching", dont_gc_arguments);
oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_mirror_patching));
}
break;
case dtrace_object_alloc_id:
{ // O0: object
__ set_info("dtrace_object_alloc", dont_gc_arguments);
// we can't gc here so skip the oopmap but make sure that all
// the live registers get saved.
save_live_registers(sasm);
__ save_thread(L7_thread_cache);
__ call(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc),
relocInfo::runtime_call_type);
__ delayed()->mov(I0, O0);
__ restore_thread(L7_thread_cache);
restore_live_registers(sasm);
__ ret();
__ delayed()->restore();
}
break;
#if INCLUDE_ALL_GCS
case g1_pre_barrier_slow_id:
{ // G4: previous value of memory
BarrierSet* bs = Universe::heap()->barrier_set();
if (bs->kind() != BarrierSet::G1SATBCTLogging) {
__ save_frame(0);
__ set((int)id, O1);
__ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), I0);
__ should_not_reach_here();
break;
}
__ set_info("g1_pre_barrier_slow_id", dont_gc_arguments);
Register pre_val = G4;
Register tmp = G1_scratch;
Register tmp2 = G3_scratch;
Label refill, restart;
bool with_frame = false; // I don't know if we can do with-frame.
int satb_q_index_byte_offset =
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_index());
int satb_q_buf_byte_offset =
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_buf());
__ bind(restart);
// Load the index into the SATB buffer. PtrQueue::_index is a
// size_t so ld_ptr is appropriate
__ ld_ptr(G2_thread, satb_q_index_byte_offset, tmp);
// index == 0?
__ cmp_and_brx_short(tmp, G0, Assembler::equal, Assembler::pn, refill);
__ ld_ptr(G2_thread, satb_q_buf_byte_offset, tmp2);
__ sub(tmp, oopSize, tmp);
__ st_ptr(pre_val, tmp2, tmp); // [_buf + index] := <address_of_card>
// Use return-from-leaf
__ retl();
__ delayed()->st_ptr(tmp, G2_thread, satb_q_index_byte_offset);
__ bind(refill);
__ save_frame(0);
__ mov(pre_val, L0);
__ mov(tmp, L1);
__ mov(tmp2, L2);
__ call_VM_leaf(L7_thread_cache,
CAST_FROM_FN_PTR(address,
SATBMarkQueueSet::handle_zero_index_for_thread),
G2_thread);
__ mov(L0, pre_val);
__ mov(L1, tmp);
__ mov(L2, tmp2);
__ br(Assembler::always, /*annul*/false, Assembler::pt, restart);
__ delayed()->restore();
}
break;
case g1_post_barrier_slow_id:
{
BarrierSet* bs = Universe::heap()->barrier_set();
if (bs->kind() != BarrierSet::G1SATBCTLogging) {
__ save_frame(0);
__ set((int)id, O1);
__ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), I0);
__ should_not_reach_here();
break;
}
__ set_info("g1_post_barrier_slow_id", dont_gc_arguments);
Register addr = G4;
Register cardtable = G5;
Register tmp = G1_scratch;
Register tmp2 = G3_scratch;
jbyte* byte_map_base = ((CardTableModRefBS*)bs)->byte_map_base;
Label not_already_dirty, restart, refill;
#ifdef _LP64
__ srlx(addr, CardTableModRefBS::card_shift, addr);
#else
__ srl(addr, CardTableModRefBS::card_shift, addr);
#endif
AddressLiteral rs(byte_map_base);
__ set(rs, cardtable); // cardtable := <card table base>
__ ldub(addr, cardtable, tmp); // tmp := [addr + cardtable]
assert(CardTableModRefBS::dirty_card_val() == 0, "otherwise check this code");
__ cmp_and_br_short(tmp, G0, Assembler::notEqual, Assembler::pt, not_already_dirty);
// We didn't take the branch, so we're already dirty: return.
// Use return-from-leaf
__ retl();
__ delayed()->nop();
// Not dirty.
__ bind(not_already_dirty);
// Get cardtable + tmp into a reg by itself
__ add(addr, cardtable, tmp2);
// First, dirty it.
__ stb(G0, tmp2, 0); // [cardPtr] := 0 (i.e., dirty).
Register tmp3 = cardtable;
Register tmp4 = tmp;
// these registers are now dead
addr = cardtable = tmp = noreg;
int dirty_card_q_index_byte_offset =
in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_index());
int dirty_card_q_buf_byte_offset =
in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf());
__ bind(restart);
// Get the index into the update buffer. PtrQueue::_index is
// a size_t so ld_ptr is appropriate here.
__ ld_ptr(G2_thread, dirty_card_q_index_byte_offset, tmp3);
// index == 0?
__ cmp_and_brx_short(tmp3, G0, Assembler::equal, Assembler::pn, refill);
__ ld_ptr(G2_thread, dirty_card_q_buf_byte_offset, tmp4);
__ sub(tmp3, oopSize, tmp3);
__ st_ptr(tmp2, tmp4, tmp3); // [_buf + index] := <address_of_card>
// Use return-from-leaf
__ retl();
__ delayed()->st_ptr(tmp3, G2_thread, dirty_card_q_index_byte_offset);
__ bind(refill);
__ save_frame(0);
__ mov(tmp2, L0);
__ mov(tmp3, L1);
__ mov(tmp4, L2);
__ call_VM_leaf(L7_thread_cache,
CAST_FROM_FN_PTR(address,
DirtyCardQueueSet::handle_zero_index_for_thread),
G2_thread);
__ mov(L0, tmp2);
__ mov(L1, tmp3);
__ mov(L2, tmp4);
__ br(Assembler::always, /*annul*/false, Assembler::pt, restart);
__ delayed()->restore();
}
break;
#endif // INCLUDE_ALL_GCS
case predicate_failed_trap_id:
{
__ set_info("predicate_failed_trap", dont_gc_arguments);
OopMap* oop_map = save_live_registers(sasm);
int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, predicate_failed_trap));
oop_maps = new OopMapSet();
oop_maps->add_gc_map(call_offset, oop_map);
DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
assert(deopt_blob != NULL, "deoptimization blob must have been created");
restore_live_registers(sasm);
AddressLiteral dest(deopt_blob->unpack_with_reexecution());
__ jump_to(dest, O0);
__ delayed()->restore();
}
break;
default:
{ __ set_info("unimplemented entry", dont_gc_arguments);
__ save_frame(0);
__ set((int)id, O1);
__ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), O1);
__ should_not_reach_here();
}
break;
}
return oop_maps;
}
DomainPerformanceControl_002::~DomainPerformanceControl_002(void)
{
restore();
}
int Context2D::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: changed((*reinterpret_cast< const QImage(*)>(_a[1]))); break;
case 1: save(); break;
case 2: restore(); break;
case 3: scale((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2]))); break;
case 4: rotate((*reinterpret_cast< qreal(*)>(_a[1]))); break;
case 5: translate((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2]))); break;
case 6: transform((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6]))); break;
case 7: setTransform((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6]))); break;
case 8: { CanvasGradient _r = createLinearGradient((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])));
if (_a[0]) *reinterpret_cast< CanvasGradient*>(_a[0]) = _r; } break;
case 9: { CanvasGradient _r = createRadialGradient((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6])));
if (_a[0]) *reinterpret_cast< CanvasGradient*>(_a[0]) = _r; } break;
case 10: clearRect((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 11: fillRect((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 12: strokeRect((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 13: beginPath(); break;
case 14: closePath(); break;
case 15: moveTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2]))); break;
case 16: lineTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2]))); break;
case 17: quadraticCurveTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 18: bezierCurveTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6]))); break;
case 19: arcTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5]))); break;
case 20: rect((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 21: arc((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< bool(*)>(_a[6]))); break;
case 22: fill(); break;
case 23: stroke(); break;
case 24: clip(); break;
case 25: { bool _r = isPointInPath((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])));
if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; } break;
case 26: drawImage((*reinterpret_cast< DomImage*(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3]))); break;
case 27: drawImage((*reinterpret_cast< DomImage*(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5]))); break;
case 28: drawImage((*reinterpret_cast< DomImage*(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6])),(*reinterpret_cast< qreal(*)>(_a[7])),(*reinterpret_cast< qreal(*)>(_a[8])),(*reinterpret_cast< qreal(*)>(_a[9]))); break;
case 29: { ImageData _r = getImageData((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])));
if (_a[0]) *reinterpret_cast< ImageData*>(_a[0]) = _r; } break;
case 30: putImageData((*reinterpret_cast< ImageData(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3]))); break;
default: ;
}
_id -= 31;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< qreal*>(_v) = globalAlpha(); break;
case 1: *reinterpret_cast< QString*>(_v) = globalCompositeOperation(); break;
case 2: *reinterpret_cast< QVariant*>(_v) = strokeStyle(); break;
case 3: *reinterpret_cast< QVariant*>(_v) = fillStyle(); break;
case 4: *reinterpret_cast< qreal*>(_v) = lineWidth(); break;
case 5: *reinterpret_cast< QString*>(_v) = lineCap(); break;
case 6: *reinterpret_cast< QString*>(_v) = lineJoin(); break;
case 7: *reinterpret_cast< qreal*>(_v) = miterLimit(); break;
case 8: *reinterpret_cast< qreal*>(_v) = shadowOffsetX(); break;
case 9: *reinterpret_cast< qreal*>(_v) = shadowOffsetY(); break;
case 10: *reinterpret_cast< qreal*>(_v) = shadowBlur(); break;
case 11: *reinterpret_cast< QString*>(_v) = shadowColor(); break;
}
_id -= 12;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setGlobalAlpha(*reinterpret_cast< qreal*>(_v)); break;
case 1: setGlobalCompositeOperation(*reinterpret_cast< QString*>(_v)); break;
case 2: setStrokeStyle(*reinterpret_cast< QVariant*>(_v)); break;
case 3: setFillStyle(*reinterpret_cast< QVariant*>(_v)); break;
case 4: setLineWidth(*reinterpret_cast< qreal*>(_v)); break;
case 5: setLineCap(*reinterpret_cast< QString*>(_v)); break;
case 6: setLineJoin(*reinterpret_cast< QString*>(_v)); break;
case 7: setMiterLimit(*reinterpret_cast< qreal*>(_v)); break;
case 8: setShadowOffsetX(*reinterpret_cast< qreal*>(_v)); break;
case 9: setShadowOffsetY(*reinterpret_cast< qreal*>(_v)); break;
case 10: setShadowBlur(*reinterpret_cast< qreal*>(_v)); break;
case 11: setShadowColor(*reinterpret_cast< QString*>(_v)); break;
}
_id -= 12;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 12;
}
#endif // QT_NO_PROPERTIES
return _id;
}
/**
* Receive a UDP packet and place it in the UDP device's input buffer
* @param pkt Incoming UDP packet
* @param src Source address
* @param dst Destination address
* @return OK if UDP packet is received properly, otherwise SYSERR
*/
syscall udpRecv(struct packet *pkt, struct netaddr *src,
struct netaddr *dst)
{
struct udpPkt *udppkt;
struct udp *udpptr;
struct udpPkt *tpkt;
#ifdef TRACE_UDP
char strA[20];
char strB[20];
#endif /* TRACE_UDP */
irqmask im;
/* Point to the start of the UDP header */
udppkt = (struct udpPkt *)pkt->curr;
if (NULL == udppkt)
{
UDP_TRACE("Invalid UDP packet.");
netFreebuf(pkt);
return SYSERR;
}
/* Calculate checksum */
if (0 != udpChksum(pkt, net2hs(udppkt->len), src, dst))
{
UDP_TRACE("Invalid UDP checksum.");
netFreebuf(pkt);
return SYSERR;
}
/* Convert UDP header fields to host order */
udppkt->srcPort = net2hs(udppkt->srcPort);
udppkt->dstPort = net2hs(udppkt->dstPort);
udppkt->len = net2hs(udppkt->len);
im = disable();
/* Locate the UDP socket (device) for the UDP packet */
udpptr = udpDemux(udppkt->dstPort, udppkt->srcPort, dst, src);
if (NULL == udpptr)
{
#ifdef TRACE_UDP
UDP_TRACE("No UDP socket found for this UDP packet.");
netaddrsprintf(strA, src);
netaddrsprintf(strB, dst);
UDP_TRACE("Source: %s:%d, Destination: %s:%d", strA,
udppkt->srcPort, strB, udppkt->dstPort);
#endif /* TRACE_UDP */
restore(im);
/* Send ICMP port unreachable message */
icmpDestUnreach(pkt, ICMP_PORT_UNR);
netFreebuf(pkt);
return SYSERR;
}
if (udpptr->icount >= UDP_MAX_PKTS)
{
UDP_TRACE("UDP buffer is full. Dropping UDP packet.");
restore(im);
netFreebuf(pkt);
return SYSERR;
}
/* Check "bind first" flag and update connection if set,
* and clear the flag */
if (UDP_FLAG_BINDFIRST & udpptr->flags)
{
udpptr->remotept = udppkt->srcPort;
netaddrcpy(&(udpptr->localip), dst);
netaddrcpy(&(udpptr->remoteip), src);
udpptr->flags &= ~UDP_FLAG_BINDFIRST;
}
/* Get some buffer space to store the packet */
tpkt = udpGetbuf(udpptr);
if (SYSERR == (int)tpkt)
{
UDP_TRACE("Unable to get UDP buffer from pool. Dropping packet.");
netFreebuf(pkt);
return SYSERR;
}
/* Copy the data of the packet into the input buffer at the current
* position */
memcpy(tpkt, udppkt, udppkt->len);
/* Store the temporary UDP packet in a FIFO buffer */
udpptr->in[(udpptr->istart + udpptr->icount) % UDP_MAX_PKTS] = tpkt;
udpptr->icount++;
restore(im);
signal(udpptr->isem);
netFreebuf(pkt);
return OK;
}
/**
* user intersects: follow
* by moving the guide first
*/
bool Guide::whenIntersect(WObject *pcur, WObject *pold)
{
static bool first = true;
if (perpetual) return true;
if (pcur->type != USER_TYPE) {
pold->copyPositionAndBB(pcur);
return true;
}
// user only
inside = true;
if (restored) {
restored = false;
first = true;
}
if (first) {
// save initial position of the user
uinitial[0] = pold->pos.x;
uinitial[1] = pold->pos.y;
uinitial[2] = pold->pos.z;
uinitial[3] = pold->pos.az;
localuser->pos.x = pos.x;
localuser->pos.y = pos.y;
localuser->pos.z += (pos.z + pos.bbsize.v[2]); // jump on the skate
localuser->pos.az = pos.az;
if (path[pt][4]) { // pause
signal(SIGALRM, sigguide);
alarm((uint32_t) path[pt][4]);
pause = true;
}
first = false;
}
if (path[pt][3]) {
/* user follows the guide */
float dx, dy, dz;
motion(&dx, &dy, &dz);
localuser->updatePositionAndGrid(localuser->pos);
localuser->pos.x += dx;
localuser->pos.y += dy;
localuser->pos.z += dz + .05; // + 1cm
//error("follow: %.2f %.2f %.2f, %.3f %.3f %.3f", localuser->pos.x,localuser->pos.y,localuser->pos.z,dx,dy,dz);
if (localuser->pos.x == pold->pos.x && localuser->pos.y == pold->pos.y)
pold->copyPositionAndBB(localuser);
else localuser->pos.z += DELTAZ;
updatePositionAndGrid(pold->pos); //HACK! I don't know why!
localuser->updatePositionAndGrid(localuser->pos);
if ((floor(pos.x) == path[pt+1][0]) &&
(floor(pos.y) == path[pt+1][1])) { // new segment
pt++; // next point
if (path[pt][3] == 0) goto endtour; // null speed
if (path[pt][4]) { // pause
signal(SIGALRM, sigguide);
alarm((uint32_t) path[pt][4]); // set delay
pause = true;
float azn = atan((path[pt+1][1] - path[pt][1]) /
(path[pt+1][0] - path[pt][0]));
if ((path[pt+1][0] - path[pt][0]) < 0) azn += M_PI;
float azo = atan((path[pt][1] - path[pt-1][1]) /
(path[pt][0] - path[pt-1][0]));
if ((path[pt][0] - path[pt-1][0]) < 0) azo += M_PI;
float da = deltaAngle(azn, 0);
move.aspeed.v[0] = da / path[pt][4];
}
else {
signal(SIGALRM, SIG_IGN);
motion(&dx, &dy, &dz);
localuser->updatePositionAndGrid(localuser->pos);
localuser->pos.x += dx;
localuser->pos.y += dy;
localuser->pos.z += dz;
localuser->updatePosition();
}
// new orientation
float az = atan((path[pt+1][1] - path[pt][1]) /
(path[pt+1][0] - path[pt][0]));
if ((path[pt+1][0] - path[pt][0]) < 0) az += M_PI;
pos.az = az;
localuser->pos.az = pos.az; // user takes same orientation than guide
}
// update user
localuser->updatePositionAndGrid(localuser->pos);
}
else {
endtour:
first = true;
restore((User *)localuser);
}
return true;
}
void MeshData::parse_mesh(void)
{
int dummy_int;
double dummy_dbl;
std::ifstream inFile(mesh_file_.c_str());
std::string line, word, temp_word, next_word;
int counter(0);
bool isVert(false), isElt(false), isBdy(false), isCurv(false), isRef(false), isVar(false);
while (std::getline(inFile,line))
{
// Remove all comments, unnecessary blank spaces, commas and paranthesis
strip(line);
if(line.find_first_not_of("\t ") != line.npos)
{
std::istringstream stream(line);
stream >> word;
if(*word.rbegin() == '=')
{
word.erase(word.size() - 1);
if(word == "vertices")
{
isVert = true;
isElt = false; isBdy = false; isCurv = false; isRef = false; isVar = false;
counter = -1;
}
else if(word == "elements")
{
isElt = true;
isVert = false; isBdy = false; isCurv = false; isRef = false; isVar = false;
counter = -1;
}
else if(word == "boundaries")
{
isBdy = true;
isVert = false; isElt = false; isCurv = false; isRef = false; isVar = false;
counter = -1;
}
else if(word == "curves")
{
isCurv = true;
isVert = false; isElt = false; isBdy = false; isRef = false; isVar = false;
counter = -1;
}
else if(word == "refinements")
{
isRef = true;
isVert = false; isElt = false; isBdy = false; isCurv = false; isVar = false;
counter = -1;
}
else
{
isVar = true;
isVert = false; isElt = false; isBdy = false; isCurv = false; isRef = false;
counter = -1;
temp_word = restore(word);
}
}
if(counter == -1)
counter = 0;
else
{
if(isVert)
{
std::istringstream istr(word);
if(!(istr >> dummy_dbl))
x_vertex.push_back(atof(vars_[restore(word)][0].c_str()));
else
x_vertex.push_back(atof(word.c_str()));
++counter;
}
if(isElt)
{
std::istringstream istr(word);
if(!(istr >> dummy_int))
en1.push_back(atoi(vars_[restore(word)][0].c_str()));
else
en1.push_back(atoi(word.c_str()));
++counter;
}
else if(isBdy)
WrestlerAddress::WrestlerAddress ( const TQueryMap &opts, Keeper *keeper ) : Object(keeper)
{
init();
restore( opts );
}
/*------------------------------------------------------------------------
* udp_recvaddr - Receive a UDP packet and record the sender's address
*------------------------------------------------------------------------
*/
int32 udp_recvaddr (
uid32 slot, /* Slot in table to use */
uint32 *remip, /* Loc for remote IP address */
uint16 *remport, /* Loc for remote protocol port */
char *buff, /* Buffer to hold UDP data */
int32 len, /* Length of buffer */
uint32 timeout /* Read timeout in msec */
)
{
intmask mask; /* Saved interrupt mask */
struct udpentry *udptr; /* Pointer to udptab entry */
umsg32 msg; /* Message from recvtime() */
struct netpacket *pkt; /* Pointer to packet being read */
int32 msglen; /* Length of UDP data in packet */
int32 i; /* Counts bytes copied */
char *udataptr; /* Pointer to UDP data */
/* Ensure only one process can access the UDP table at a time */
mask = disable();
/* Verify that the slot is valid */
if ((slot < 0) || (slot >= UDP_SLOTS)) {
restore(mask);
return SYSERR;
}
/* Get pointer to table entry */
udptr = &udptab[slot];
/* Verify that the slot has been registered and is valid */
if (udptr->udstate != UDP_USED) {
restore(mask);
return SYSERR;
}
/* Wait for a packet to arrive */
if (udptr->udcount == 0) { /* No packet is waiting */
udptr->udstate = UDP_RECV;
udptr->udpid = currpid;
msg = recvclr();
msg = recvtime(timeout); /* Wait for a packet */
udptr->udstate = UDP_USED;
if (msg == TIMEOUT) {
restore(mask);
return TIMEOUT;
} else if (msg != OK) {
restore(mask);
return SYSERR;
}
}
/* Packet has arrived -- dequeue it */
pkt = udptr->udqueue[udptr->udhead++];
if (udptr->udhead >= UDP_QSIZ) {
udptr->udhead = 0;
}
/* Record sender's IP address and UDP port number */
*remip = pkt->net_ipsrc;
*remport = pkt->net_udpsport;
udptr->udcount--;
/* Copy UDP data from packet into caller's buffer */
msglen = pkt->net_udplen - UDP_HDR_LEN;
udataptr = (char *)pkt->net_udpdata;
if (len < msglen) {
msglen = len;
}
for (i=0; i<msglen; i++) {
*buff++ = *udataptr++;
}
freebuf((char *)pkt);
restore(mask);
return msglen;
}
/**
* @ingroup snoop
*
* Opens a capture from a network device.
* @param cap pointer to capture structure
* @param name of underlying device, ALL for all network devices
* @return OK if open was successful, otherwise SYSERR
* @pre-condition filter settings should already be setup in cap
*/
int snoopOpen(struct snoop *cap, char *devname)
{
int i;
int count = 0;
int devnum;
irqmask im;
/* Error check pointers */
if ((NULL == cap) || (NULL == devname))
{
return SYSERR;
}
SNOOP_TRACE("Opening capture on %s", devname);
/* Reset statistics */
cap->ncap = 0;
cap->nmatch = 0;
cap->novrn = 0;
/* Allocated mailbox for queue packets */
cap->queue = mailboxAlloc(SNOOP_QLEN);
if (SYSERR == (int)cap->queue)
{
SNOOP_TRACE("Failed to allocate mailbox");
return SYSERR;
}
/* Attach capture to all running network interfaces for devname "ALL" */
if (0 == strcmp(devname, "ALL"))
{
im = disable();
#if NNETIF
for (i = 0; i < NNETIF; i++)
{
if (NET_ALLOC == netiftab[i].state)
{
netiftab[i].capture = cap;
count++;
SNOOP_TRACE("Attached capture to interface %d", i);
}
}
#endif
restore(im);
if (0 == count)
{
SNOOP_TRACE("Capture not attached to any interface");
mailboxFree(cap->queue);
return SYSERR;
}
return OK;
}
/* Determine network interface to attach capture to */
devnum = getdev(devname);
if (SYSERR == devnum)
{
SNOOP_TRACE("Invalid device");
mailboxFree(cap->queue);
return SYSERR;
}
im = disable();
#if NNETIF
for (i = 0; i < NNETIF; i++)
{
if ((NET_ALLOC == netiftab[i].state)
&& (netiftab[i].dev == devnum))
{
netiftab[i].capture = cap;
restore(im);
SNOOP_TRACE("Attached capture to interface %d", i);
return OK;
}
}
#endif
/* No network interface found */
restore(im);
SNOOP_TRACE("No network interface found");
mailboxFree(cap->queue);
return SYSERR;
}
/*------------------------------------------------------------------------
* udp_sendto - Send a UDP packet to a specified destination
*------------------------------------------------------------------------
*/
status udp_sendto (
uid32 slot, /* UDP table slot to use */
uint32 remip, /* Remote IP address to use */
uint16 remport, /* Remote protocol port to use */
char *buff, /* Buffer of UDP data */
int32 len /* Length of data in buffer */
)
{
intmask mask; /* Saved interrupt mask */
struct netpacket *pkt; /* Pointer to a packet buffer */
int32 pktlen; /* Total packet length */
static uint16 ident = 1; /* Datagram IDENT field */
struct udpentry *udptr; /* Pointer to a UDP table entry */
char *udataptr; /* Pointer to UDP data */
/* Ensure only one process can access the UDP table at a time */
mask = disable();
/* Verify that the slot is valid */
if ( (slot < 0) || (slot >= UDP_SLOTS) ) {
restore(mask);
return SYSERR;
}
/* Get pointer to table entry */
udptr = &udptab[slot];
/* Verify that the slot has been registered and is valid */
if (udptr->udstate == UDP_FREE) {
restore(mask);
return SYSERR;
}
/* Allocate a network buffer to hold the packet */
pkt = (struct netpacket *)getbuf(netbufpool);
if ((int32)pkt == SYSERR) {
restore(mask);
return SYSERR;
}
/* Compute packet length as UDP data size + fixed header size */
pktlen = ((char *)&pkt->net_udpdata - (char *)pkt) + len;
/* Create UDP packet in pkt */
memcpy((char *)pkt->net_ethsrc,NetData.ethucast,ETH_ADDR_LEN);
pkt->net_ethtype = 0x0800; /* Type is IP */
pkt->net_ipvh = 0x45; /* IP version and hdr length */
pkt->net_iptos = 0x00; /* Type of service */
pkt->net_iplen= pktlen - ETH_HDR_LEN;/* total IP datagram length*/
pkt->net_ipid = ident++; /* Datagram gets next IDENT */
pkt->net_ipfrag = 0x0000; /* IP flags & fragment offset */
pkt->net_ipttl = 0xff; /* IP time-to-live */
pkt->net_ipproto = IP_UDP; /* Datagram carries UDP */
pkt->net_ipcksum = 0x0000; /* Initial checksum */
pkt->net_ipsrc = NetData.ipucast;/* IP source address */
pkt->net_ipdst = remip; /* IP destination address */
pkt->net_udpsport = udptr->udlocport;/* local UDP protocol port */
pkt->net_udpdport = remport; /* Remote UDP protocol port */
pkt->net_udplen = (uint16)(UDP_HDR_LEN+len); /* UDP length */
pkt->net_udpcksum = 0x0000; /* Ignore UDP checksum */
udataptr = (char *) pkt->net_udpdata;
for (; len>0; len--) {
*udataptr++ = *buff++;
}
/* Call ipsend to send the datagram */
ip_send(pkt);
restore(mask);
return OK;
}
void worker::workSmall_anti(SmallWorkMsg *m)
{
restore(this);
}
UnixTerminal::~UnixTerminal()
{
restore();
}
/*------------------------------------------------------------------------
* udp_recvaddr - receive a UDP packet and record the sender's address
*------------------------------------------------------------------------
*/
int32 udp_recvaddr (
uint32 *remip, /* loc to record remote IP addr.*/
uint16 *remport, /* loc to record remote port */
uint16 locport, /* local UDP protocol port */
char *buff, /* buffer to hold UDP data */
int32 len, /* length of buffer */
uint32 timeout /* read timeout in msec */
)
{
intmask mask; /* saved interrupt mask */
int32 i; /* index into udptab */
struct udpentry *udptr; /* pointer to udptab entry */
umsg32 msg; /* message from recvtime() */
struct eth_packet *pkt; /* ptr to packet being read */
struct ipv4_packet *ippkt = NULL;
struct udp_packet * udppkt = NULL;
int32 msglen; /* length of UDP data in packet */
char *udataptr; /* pointer to UDP data */
/* Insure only one process access UDP table at a time */
mask = disable();
for (i=0; i<UDP_SLOTS; i++) {
udptr = &udptab[i];
if ( (udptr->udremip == 0 ) &&
(locport == udptr->udlocport) ) {
/* Entry in table matches request */
break;
}
}
if (i >= UDP_SLOTS) {
restore(mask);
return SYSERR;
}
if (udptr->udcount == 0) { /* no packet is waiting */
udptr->udstate = UDP_RECV;
udptr->udpid = currpid;
msg = recvclr();
msg = recvtime(timeout); /* wait for packet */
udptr->udstate = UDP_USED;
if (msg == TIMEOUT) {
restore(mask);
return TIMEOUT;
} else if (msg != OK) {
restore(mask);
return SYSERR;
}
}
/* Packet has arrived -- dequeue it */
pkt = udptr->udqueue[udptr->udhead++];
ippkt = (struct ipv4_packet *)(pkt->net_ethdata);
udppkt = (struct udp_packet *)(ippkt->net_ipdata);
if (udptr->udhead >= UDP_SLOTS) {
udptr->udhead = 0;
}
udptr->udcount--;
/* Record sender's IP address and UDP port number */
*remip = ippkt->net_ipsrc;
*remport = udppkt->net_udpsport;
/* Copy UDP data from packet into caller's buffer */
msglen = udppkt->net_udplen - UDP_HDR_LEN;
udataptr = (char *)udppkt->net_udpdata;
for (i=0; i<msglen; i++) {
if (i >= len) {
break;
}
*buff++ = *udataptr++;
}
freebuf((char *)pkt);
restore(mask);
return i;
}
OopMapSet* Runtime1::generate_handle_exception(StubID id, StubAssembler* sasm) {
__ block_comment("generate_handle_exception");
// Save registers, if required.
OopMapSet* oop_maps = new OopMapSet();
OopMap* oop_map = NULL;
switch (id) {
case forward_exception_id:
// We're handling an exception in the context of a compiled frame.
// The registers have been saved in the standard places. Perform
// an exception lookup in the caller and dispatch to the handler
// if found. Otherwise unwind and dispatch to the callers
// exception handler.
oop_map = generate_oop_map(sasm, true);
// transfer the pending exception to the exception_oop
__ ld_ptr(G2_thread, in_bytes(JavaThread::pending_exception_offset()), Oexception);
__ ld_ptr(Oexception, 0, G0);
__ st_ptr(G0, G2_thread, in_bytes(JavaThread::pending_exception_offset()));
__ add(I7, frame::pc_return_offset, Oissuing_pc);
break;
case handle_exception_id:
// At this point all registers MAY be live.
oop_map = save_live_registers(sasm);
__ mov(Oexception->after_save(), Oexception);
__ mov(Oissuing_pc->after_save(), Oissuing_pc);
break;
case handle_exception_from_callee_id:
// At this point all registers except exception oop (Oexception)
// and exception pc (Oissuing_pc) are dead.
oop_map = new OopMap(frame_size_in_bytes / sizeof(jint), 0);
sasm->set_frame_size(frame_size_in_bytes / BytesPerWord);
__ save_frame_c1(frame_size_in_bytes);
__ mov(Oexception->after_save(), Oexception);
__ mov(Oissuing_pc->after_save(), Oissuing_pc);
break;
default: ShouldNotReachHere();
}
__ verify_not_null_oop(Oexception);
// save the exception and issuing pc in the thread
__ st_ptr(Oexception, G2_thread, in_bytes(JavaThread::exception_oop_offset()));
__ st_ptr(Oissuing_pc, G2_thread, in_bytes(JavaThread::exception_pc_offset()));
// use the throwing pc as the return address to lookup (has bci & oop map)
__ mov(Oissuing_pc, I7);
__ sub(I7, frame::pc_return_offset, I7);
int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, exception_handler_for_pc));
oop_maps->add_gc_map(call_offset, oop_map);
// Note: if nmethod has been deoptimized then regardless of
// whether it had a handler or not we will deoptimize
// by entering the deopt blob with a pending exception.
// Restore the registers that were saved at the beginning, remove
// the frame and jump to the exception handler.
switch (id) {
case forward_exception_id:
case handle_exception_id:
restore_live_registers(sasm);
__ jmp(O0, 0);
__ delayed()->restore();
break;
case handle_exception_from_callee_id:
// Restore SP from L7 if the exception PC is a method handle call site.
__ mov(O0, G5); // Save the target address.
__ lduw(Address(G2_thread, JavaThread::is_method_handle_return_offset()), L0);
__ tst(L0); // Condition codes are preserved over the restore.
__ restore();
__ jmp(G5, 0); // jump to the exception handler
__ delayed()->movcc(Assembler::notZero, false, Assembler::icc, L7_mh_SP_save, SP); // Restore SP if required.
break;
default: ShouldNotReachHere();
}
return oop_maps;
}
void
arctan(void)
{
double d;
save();
p1 = pop();
if (car(p1) == symbol(TAN)) {
push(cadr(p1));
restore();
return;
}
if (isdouble(p1)) {
errno = 0;
d = atan(p1->u.d);
if (errno)
stop("arctan function error");
push_double(d);
restore();
return;
}
if (iszero(p1)) {
push(zero);
restore();
return;
}
if (isnegative(p1)) {
push(p1);
negate();
arctan();
negate();
restore();
return;
}
// arctan(sin(a) / cos(a)) ?
if (find(p1, symbol(SIN)) && find(p1, symbol(COS))) {
push(p1);
numerator();
p2 = pop();
push(p1);
denominator();
p3 = pop();
if (car(p2) == symbol(SIN) && car(p3) == symbol(COS) && equal(cadr(p2), cadr(p3))) {
push(cadr(p2));
restore();
return;
}
}
// arctan(1/sqrt(3)) -> pi/6
if (car(p1) == symbol(POWER) && equaln(cadr(p1), 3) && equalq(caddr(p1), -1, 2)) {
push_rational(1, 6);
push(symbol(PI));
multiply();
restore();
return;
}
// arctan(1) -> pi/4
if (equaln(p1, 1)) {
push_rational(1, 4);
push(symbol(PI));
multiply();
restore();
return;
}
// arctan(sqrt(3)) -> pi/3
if (car(p1) == symbol(POWER) && equaln(cadr(p1), 3) && equalq(caddr(p1), 1, 2)) {
push_rational(1, 3);
push(symbol(PI));
multiply();
restore();
return;
}
push_symbol(ARCTAN);
push(p1);
list(2);
restore();
}
/*
** 'restore_retparm' is called when a 'return parameter' block is found on the
** stack. It saves the value currently in the parameter at the address stored as
** the return parameter address and then returns the local variable to its
** correct value
*/
void restore_retparm(int32 parmcount) {
stack_retparm *p;
int32 vartype, intvalue;
float64 floatvalue;
basicstring stringvalue;
p = basicvars.stacktop.retparmsp; /* Not needed, but the code is unreadable otherwise */
#ifdef DEBUG
if (basicvars.debug_flags.stack) fprintf(stderr, "Restoring RETURN variable at %p from %p, return dest=%p\n",
p->savedetails.address.intaddr, p, p->retdetails.address.intaddr);
#endif
basicvars.stacktop.retparmsp++;
switch (p->savedetails.typeinfo & PARMTYPEMASK) { /* Fetch value from local variable and restore local var */
case VAR_INTWORD: /* Integer variable */
intvalue = *p->savedetails.address.intaddr; /* Fetch current value of local variable */
*p->savedetails.address.intaddr = p->value.savedint; /* Restore local variable to its old value */
vartype = VAR_INTWORD;
break;
case VAR_FLOAT: /* Floating point variable */
floatvalue = *p->savedetails.address.floataddr;
*p->savedetails.address.floataddr = p->value.savedfloat;
vartype = VAR_FLOAT;
break;
case VAR_STRINGDOL: /* String variable */
stringvalue = *p->savedetails.address.straddr;
*p->savedetails.address.straddr = p->value.savedstring;
vartype = VAR_STRINGDOL;
break;
case VAR_INTBYTEPTR: /* Indirect byte integer variable */
intvalue = basicvars.offbase[p->savedetails.address.offset];
basicvars.offbase[p->savedetails.address.offset] = p->value.savedint;
vartype = VAR_INTWORD;
break;
case VAR_INTWORDPTR: /* Indirect word integer variable */
intvalue = get_integer(p->savedetails.address.offset);
store_integer(p->savedetails.address.offset, p->value.savedint);
vartype = VAR_INTWORD;
break;
case VAR_FLOATPTR: /* Indirect floating point variable */
floatvalue = get_float(p->savedetails.address.offset);
store_float(p->savedetails.address.offset, p->value.savedfloat);
vartype = VAR_FLOAT;
break;
case VAR_DOLSTRPTR: /* Indirect string variable */
intvalue = stringvalue.stringlen = get_stringlen(p->savedetails.address.offset);
stringvalue.stringaddr = alloc_string(intvalue);
if (intvalue>0) memmove(stringvalue.stringaddr, &basicvars.offbase[p->savedetails.address.offset], intvalue);
memmove(&basicvars.offbase[p->savedetails.address.offset], p->value.savedstring.stringaddr, p->value.savedstring.stringlen);
free_string(p->value.savedstring); /* Discard saved copy of original '$ string' */
vartype = VAR_DOLSTRPTR;
break;
case VAR_INTARRAY: case VAR_FLOATARRAY: case VAR_STRARRAY: /* Array - Do nothing */
break;
default:
error(ERR_BROKEN, __LINE__, "stack");
}
/* Now restore the next parameter */
parmcount--;
if (parmcount>0) { /* There are still some parameters to do */
if (basicvars.stacktop.intsp->itemtype==STACK_LOCAL)
restore(parmcount);
else { /* Must be a return parameter */
restore_retparm(parmcount);
}
}
/* Now we can store the returned value in original variable */
switch (p->retdetails.typeinfo) {
case VAR_INTWORD:
*p->retdetails.address.intaddr = vartype==VAR_INTWORD ? intvalue : TOINT(floatvalue);
break;
case VAR_FLOAT:
*p->retdetails.address.floataddr = vartype==VAR_INTWORD ? TOFLOAT(intvalue) : floatvalue;
break;
case VAR_STRINGDOL:
free_string(*p->retdetails.address.straddr);
*p->retdetails.address.straddr = stringvalue;
break;
case VAR_INTBYTEPTR:
basicvars.offbase[p->retdetails.address.offset] = vartype==VAR_INTWORD ? intvalue : TOINT(floatvalue);
break;
case VAR_INTWORDPTR:
store_integer(p->retdetails.address.offset, vartype==VAR_INTWORD ? intvalue : TOINT(floatvalue));
break;
case VAR_FLOATPTR:
store_float(p->retdetails.address.offset, vartype==VAR_INTWORD ? TOFLOAT(intvalue) : floatvalue);
break;
case VAR_DOLSTRPTR:
if (stringvalue.stringlen>0) memmove(&basicvars.offbase[p->retdetails.address.offset], stringvalue.stringaddr, stringvalue.stringlen);
if (vartype==VAR_STRINGDOL) { /* Local var was a normal string variable */
basicvars.offbase[p->retdetails.address.offset+stringvalue.stringlen] = CR; /* So add a 'CR' at the end of the string */
}
free_string(stringvalue);
break;
case VAR_INTARRAY: case VAR_FLOATARRAY: case VAR_STRARRAY: /* 'RETURN' dest is array - Do nothing */
break;
default:
error(ERR_BROKEN, __LINE__, "stack");
}
}