static unsigned char
dlx_jr_type (struct disassemble_info* info)
{
struct _jr_opcode
{
unsigned long opcode;
char *name;
}
dlx_jr_opcode[] =
{
{ OPC(JROP), "jr" }, /* Store byte. */
{ OPC(JALROP), "jalr" } /* Store halfword. */
};
int dlx_jr_opcode_num =
(sizeof dlx_jr_opcode) / (sizeof dlx_jr_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_jr_opcode_num; idx++)
if (dlx_jr_opcode[idx].opcode == opc)
{
(*info->fprintf_func) (info->stream, "%s", dlx_jr_opcode[idx].name);
operand_deliminator (info, dlx_jr_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d", (int)rs1);
return (unsigned char) IJR_TYPE;
}
return (unsigned char) NIL;
}
int mapQ(int code, KQVEC(x), QVEC(r)) {
TCF* x2p = (TCF*)xp;
TCF* r2p = (TCF*)rp;
int k;
REQUIRES(xn == rn,BAD_SIZE);
DEBUGMSG("mapQ");
switch (code) {
OPb(0,csinf)
OPb(1,ccosf)
OPb(2,ctanf)
OPC(3,complex_abs_complex)
OPb(4,casinf)
OPb(5,cacosf)
OPb(6,catanf)
OPb(7,csinhf)
OPb(8,ccoshf)
OPb(9,ctanhf)
OPb(10,casinhf)
OPb(11,cacoshf)
OPb(12,catanhf)
OPb(13,cexpf)
OPb(14,clogf)
OPC(15,complex_signum_complex)
OPb(16,csqrtf)
default: ERROR(BAD_CODE);
}
}
static unsigned char
dlx_br_type (struct disassemble_info* info)
{
struct _br_opcode
{
unsigned long opcode;
char *name;
}
dlx_br_opcode[] =
{
{ OPC(BEQOP), "beqz" }, /* Store byte. */
{ OPC(BNEOP), "bnez" } /* Store halfword. */
};
int dlx_br_opcode_num =
(sizeof dlx_br_opcode) / (sizeof dlx_br_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_br_opcode_num; idx++)
if (dlx_br_opcode[idx].opcode == opc)
{
if (imm16 & 0x00008000)
imm16 |= 0xFFFF0000;
imm16 += (current_insn_addr + 4);
(*info->fprintf_func) (info->stream, "%s", dlx_br_opcode[idx].name);
operand_deliminator (info, dlx_br_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int) rs1);
(*info->fprintf_func) (info->stream, "0x%08x", (int) imm16);
return (unsigned char) IBR_TYPE;
}
return (unsigned char) NIL;
}
static unsigned char
dlx_store_type (struct disassemble_info* info)
{
struct _store_opcode
{
unsigned long opcode;
char *name;
}
dlx_store_opcode[] =
{
{ OPC(SBOP), "sb" }, /* Store byte. */
{ OPC(SHOP), "sh" }, /* Store halfword. */
{ OPC(SWOP), "sw" }, /* Store word. */
};
int dlx_store_opcode_num =
(sizeof dlx_store_opcode) / (sizeof dlx_store_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_store_opcode_num; idx++)
if (dlx_store_opcode[idx].opcode == opc)
{
(*info->fprintf_func) (info->stream, "%s", dlx_store_opcode[idx].name);
operand_deliminator (info, dlx_store_opcode[idx].name);
(*info->fprintf_func) (info->stream, "0x%04x[r%d],", (int)imm16, (int)rs1);
(*info->fprintf_func) (info->stream, "r%d", (int)rs2);
return (unsigned char) IST_TYPE;
}
return (unsigned char) NIL;
}
static unsigned char
dlx_load_type (struct disassemble_info* info)
{
struct _load_opcode
{
unsigned long opcode;
char *name;
}
dlx_load_opcode[] =
{
{ OPC(LHIOP), "lhi" }, /* Load HI to register. */
{ OPC(LBOP), "lb" }, /* load byte sign extended. */
{ OPC(LBUOP), "lbu" }, /* load byte unsigned. */
{ OPC(LSBUOP),"ldstbu"}, /* load store byte unsigned. */
{ OPC(LHOP), "lh" }, /* load halfword sign extended. */
{ OPC(LHUOP), "lhu" }, /* load halfword unsigned. */
{ OPC(LSHUOP),"ldsthu"}, /* load store halfword unsigned. */
{ OPC(LWOP), "lw" }, /* load word. */
{ OPC(LSWOP), "ldstw" } /* load store word. */
};
int dlx_load_opcode_num =
(sizeof dlx_load_opcode) / (sizeof dlx_load_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_load_opcode_num; idx++)
if (dlx_load_opcode[idx].opcode == opc)
{
if (opc == OPC (LHIOP))
{
(*info->fprintf_func) (info->stream, "%s", dlx_load_opcode[idx].name);
operand_deliminator (info, dlx_load_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
(*info->fprintf_func) (info->stream, "0x%04x", (int)imm16);
}
else
{
(*info->fprintf_func) (info->stream, "%s", dlx_load_opcode[idx].name);
operand_deliminator (info, dlx_load_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
(*info->fprintf_func) (info->stream, "0x%04x[r%d]", (int)imm16, (int)rs1);
}
return (unsigned char) ILD_TYPE;
}
return (unsigned char) NIL;
}
static unsigned char
dlx_jmp_type (struct disassemble_info* info)
{
struct _jmp_opcode
{
unsigned long opcode;
char *name;
}
dlx_jmp_opcode[] =
{
{ OPC(JOP), "j" }, /* Store byte. */
{ OPC(JALOP), "jal" }, /* Store halfword. */
{ OPC(BREAKOP), "break" }, /* Store halfword. */
{ OPC(TRAPOP), "trap" }, /* Store halfword. */
{ OPC(RFEOP), "rfe" } /* Store halfword. */
};
int dlx_jmp_opcode_num =
(sizeof dlx_jmp_opcode) / (sizeof dlx_jmp_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_jmp_opcode_num; idx++)
if (dlx_jmp_opcode[idx].opcode == opc)
{
if (imm26 & 0x02000000)
imm26 |= 0xFC000000;
imm26 += (current_insn_addr + 4);
(*info->fprintf_func) (info->stream, "%s", dlx_jmp_opcode[idx].name);
operand_deliminator (info, dlx_jmp_opcode[idx].name);
(*info->fprintf_func) (info->stream, "0x%08x", (int)imm26);
return (unsigned char) IJ_TYPE;
}
return (unsigned char) NIL;
}
static unsigned char
dlx_aluI_type (struct disassemble_info* info)
{
struct _aluI_opcode
{
unsigned long opcode;
char *name;
}
dlx_aluI_opcode[] =
{
{ OPC(ADDIOP), "addi" }, /* Store byte. */
{ OPC(ADDUIOP), "addui" }, /* Store halfword. */
{ OPC(SUBIOP), "subi" }, /* Store word. */
{ OPC(SUBUIOP), "subui" }, /* Store word. */
{ OPC(ANDIOP), "andi" }, /* Store word. */
{ OPC(ORIOP), "ori" }, /* Store word. */
{ OPC(XORIOP), "xori" }, /* Store word. */
{ OPC(SLLIOP), "slli" }, /* Store word. */
{ OPC(SRAIOP), "srai" }, /* Store word. */
{ OPC(SRLIOP), "srli" }, /* Store word. */
{ OPC(SEQIOP), "seqi" }, /* Store word. */
{ OPC(SNEIOP), "snei" }, /* Store word. */
{ OPC(SLTIOP), "slti" }, /* Store word. */
{ OPC(SGTIOP), "sgti" }, /* Store word. */
{ OPC(SLEIOP), "slei" }, /* Store word. */
{ OPC(SGEIOP), "sgei" }, /* Store word. */
{ OPC(SEQUIOP), "sequi" }, /* Store word. */
{ OPC(SNEUIOP), "sneui" }, /* Store word. */
{ OPC(SLTUIOP), "sltui" }, /* Store word. */
{ OPC(SGTUIOP), "sgtui" }, /* Store word. */
{ OPC(SLEUIOP), "sleui" }, /* Store word. */
{ OPC(SGEUIOP), "sgeui" }, /* Store word. */
#if 0
{ OPC(MVTSOP), "mvts" }, /* Store word. */
{ OPC(MVFSOP), "mvfs" }, /* Store word. */
#endif
};
int dlx_aluI_opcode_num =
(sizeof dlx_aluI_opcode) / (sizeof dlx_aluI_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_aluI_opcode_num; idx++)
if (dlx_aluI_opcode[idx].opcode == opc)
{
(*info->fprintf_func) (info->stream, "%s", dlx_aluI_opcode[idx].name);
operand_deliminator (info, dlx_aluI_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
(*info->fprintf_func) (info->stream, "r%d,", (int)rs1);
(*info->fprintf_func) (info->stream, "0x%04x", (int)imm16);
return (unsigned char) IAL_TYPE;
}
return (unsigned char) NIL;
}
static unsigned char
dlx_r_type (struct disassemble_info *info)
{
unsigned char r_opc[] = { OPC(ALUOP) }; /* Fix ME */
int r_opc_num = (sizeof r_opc) / (sizeof (char));
struct _r_opcode
{
unsigned long func;
char *name;
}
dlx_r_opcode[] =
{
{ NOPF, "nop" }, /* NOP */
{ ADDF, "add" }, /* Add */
{ ADDUF, "addu" }, /* Add Unsigned */
{ SUBF, "sub" }, /* SUB */
{ SUBUF, "subu" }, /* Sub Unsigned */
{ MULTF, "mult" }, /* MULTIPLY */
{ MULTUF, "multu" }, /* MULTIPLY Unsigned */
{ DIVF, "div" }, /* DIVIDE */
{ DIVUF, "divu" }, /* DIVIDE Unsigned */
{ ANDF, "and" }, /* AND */
{ ORF, "or" }, /* OR */
{ XORF, "xor" }, /* Exclusive OR */
{ SLLF, "sll" }, /* SHIFT LEFT LOGICAL */
{ SRAF, "sra" }, /* SHIFT RIGHT ARITHMETIC */
{ SRLF, "srl" }, /* SHIFT RIGHT LOGICAL */
{ SEQF, "seq" }, /* Set if equal */
{ SNEF, "sne" }, /* Set if not equal */
{ SLTF, "slt" }, /* Set if less */
{ SGTF, "sgt" }, /* Set if greater */
{ SLEF, "sle" }, /* Set if less or equal */
{ SGEF, "sge" }, /* Set if greater or equal */
{ SEQUF, "sequ" }, /* Set if equal */
{ SNEUF, "sneu" }, /* Set if not equal */
{ SLTUF, "sltu" }, /* Set if less */
{ SGTUF, "sgtu" }, /* Set if greater */
{ SLEUF, "sleu" }, /* Set if less or equal */
{ SGEUF, "sgeu" }, /* Set if greater or equal */
{ MVTSF, "mvts" }, /* Move to special register */
{ MVFSF, "mvfs" }, /* Move from special register */
{ BSWAPF, "bswap" }, /* Byte swap ?? */
{ LUTF, "lut" } /* ????????? ?? */
};
int dlx_r_opcode_num = (sizeof dlx_r_opcode) / (sizeof dlx_r_opcode[0]);
int idx;
for (idx = 0; idx < r_opc_num; idx++)
{
if (r_opc[idx] != opc)
continue;
else
break;
}
if (idx == r_opc_num)
return NIL;
for (idx = 0 ; idx < dlx_r_opcode_num; idx++)
if (dlx_r_opcode[idx].func == func)
{
(*info->fprintf_func) (info->stream, "%s", dlx_r_opcode[idx].name);
if (func != NOPF)
{
/* This is not a nop. */
operand_deliminator (info, dlx_r_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int)rd);
(*info->fprintf_func) (info->stream, "r%d", (int)rs1);
if (func != MVTSF && func != MVFSF)
(*info->fprintf_func) (info->stream, ",r%d", (int)rs2);
}
return (unsigned char) R_TYPE;
}
return (unsigned char) R_ERROR;
}
void Opacity_Compute()
{
long inx,iny,inz; /* Voxel location in object space */
long outx,outy,outz; /* Loop indices in image space */
long density;
float magnitude;
float opacity, grd_x,grd_y,grd_z;
long zstart,zstop;
long num_xqueue,num_yqueue,num_zqueue,num_queue;
long xstart,xstop,ystart,ystop;
long my_node;
THREAD_INIT_FREE();
LOCK(Global->IndexLock);
my_node = Global->Index++;
UNLOCK(Global->IndexLock);
my_node = my_node%num_nodes;
/* POSSIBLE ENHANCEMENT: Here's where one might bind the process to a
processor, if one wanted to.
*/
num_xqueue = ROUNDUP((float)opc_len[X]/(float)voxel_section[X]);
num_yqueue = ROUNDUP((float)opc_len[Y]/(float)voxel_section[Y]);
num_zqueue = ROUNDUP((float)opc_len[Z]/(float)voxel_section[Z]);
num_queue = num_xqueue * num_yqueue * num_zqueue;
xstart = (my_node % voxel_section[X]) * num_xqueue;
xstop = MIN(xstart+num_xqueue,opc_len[X]);
ystart = ((my_node / voxel_section[X]) % voxel_section[Y]) * num_yqueue;
ystop = MIN(ystart+num_yqueue,opc_len[Y]);
zstart = (my_node / (voxel_section[X] * voxel_section[Y])) * num_zqueue;
zstop = MIN(zstart+num_zqueue,opc_len[Z]);
#ifdef SERIAL_PREPROC
zstart = 0;
zstop = opc_len[Z];
ystart = 0;
ystop = opc_len[Y];
xstart = 0;
xstop = opc_len[X];
#endif
for (outz=zstart; outz<zstop; outz++) {
for (outy=ystart; outy<ystop; outy++) {
for (outx=xstart; outx<xstop; outx++) {
inx = INSET + outx;
iny = INSET + outy;
inz = INSET + outz;
density = MAP(inz,iny,inx);
if (density > density_epsilon) {
grd_x = (float)((long)MAP(inz,iny,inx+1) - (long)MAP(inz,iny,inx-1));
grd_y = (float)((long)MAP(inz,iny+1,inx) - (long)MAP(inz,iny-1,inx));
grd_z = (float)((long)MAP(inz+1,iny,inx) - (long)MAP(inz-1,iny,inx));
magnitude = grd_x*grd_x+grd_y*grd_y+grd_z*grd_z;
/* If (magnitude*grd_divisor)**2 is small, skip voxel */
if (magnitude > nmag_epsilon) {
magnitude = .5*sqrt(magnitude);
/* For density * magnitude (d*m) operator: */
/* Set opacity of surface to the product of user-specified */
/* functions of local density and gradient magnitude. */
/* Detects both front and rear-facing surfaces. */
opacity = density_opacity[density] *
magnitude_opacity[(long)magnitude];
/* If opacity is small, skip shading and compositing of sample */
if (opacity > opacity_epsilon)
OPC(outz,outy,outx) = NINT(opacity*MAX_OPC);
}
}
else
OPC(outz,outy,outx) = MIN_OPC;
}
}
}
#ifndef SERIAL_PREPROC
BARRIER(Global->SlaveBarrier,num_nodes);
#endif
}