static void push_in_progress(ptr_t p)
{
if (n_in_progress >= in_progress_size) {
if (in_progress_size == 0) {
in_progress_size = INITIAL_IN_PROGRESS;
in_progress_space = (ptr_t *)GET_MEM(in_progress_size * sizeof(ptr_t));
GC_add_to_our_memory((ptr_t)in_progress_space,
in_progress_size * sizeof(ptr_t));
} else {
ptr_t * new_in_progress_space;
in_progress_size *= 2;
new_in_progress_space = (ptr_t *)
GET_MEM(in_progress_size * sizeof(ptr_t));
GC_add_to_our_memory((ptr_t)new_in_progress_space,
in_progress_size * sizeof(ptr_t));
BCOPY(in_progress_space, new_in_progress_space,
n_in_progress * sizeof(ptr_t));
in_progress_space = new_in_progress_space;
/* FIXME: This just drops the old space. */
}
}
if (in_progress_space == 0)
ABORT("MAKE_BACK_GRAPH: Out of in-progress space: "
"Huge linear data structure?");
in_progress_space[n_in_progress++] = p;
}
static void push_in_progress(ptr_t p)
{
if (n_in_progress >= in_progress_size) {
ptr_t * new_in_progress_space;
if (NULL == in_progress_space) {
in_progress_size = ROUNDUP_PAGESIZE_IF_MMAP(INITIAL_IN_PROGRESS
* sizeof(ptr_t))
/ sizeof(ptr_t);
new_in_progress_space =
(ptr_t *)GET_MEM(in_progress_size * sizeof(ptr_t));
} else {
in_progress_size *= 2;
new_in_progress_space = (ptr_t *)
GET_MEM(in_progress_size * sizeof(ptr_t));
if (new_in_progress_space != NULL)
BCOPY(in_progress_space, new_in_progress_space,
n_in_progress * sizeof(ptr_t));
}
GC_add_to_our_memory((ptr_t)new_in_progress_space,
in_progress_size * sizeof(ptr_t));
# ifndef GWW_VDB
GC_scratch_recycle_no_gww(in_progress_space,
n_in_progress * sizeof(ptr_t));
# elif defined(LINT2)
/* TODO: implement GWW-aware recycling as in alloc_mark_stack */
GC_noop1((word)in_progress_space);
# endif
in_progress_space = new_in_progress_space;
}
if (in_progress_space == 0)
ABORT("MAKE_BACK_GRAPH: Out of in-progress space: "
"Huge linear data structure?");
in_progress_space[n_in_progress++] = p;
}
void enum_regular_address(dat_inst_t* d_inst, expr_p expr, int flag,
int curEq, worklist_p curTSnode, int curAddr) {
int dbg = 0;
int i;
saddr_p smem;
ts_p ts;
loop_t *lp;
int lb;
if (curEq < expr->varNum) {
ts = curTSnode->data;
lp = loops[expr->value[curEq].val];
while (curTSnode) {
ts = curTSnode->data;
if (ts->loop_id == lp->id) break;
else {
ts->lw = 0;
ts->up = max(lp->bound-1,0);
curTSnode = curTSnode->next;
}
}
lb = getLpBound(lp);
for (i=0; i<lb; i++) {
iterValue[lp->id] = i;
ts->lw = i;
ts->up = i;
enum_regular_address(d_inst, expr, flag, curEq+1, curTSnode->next,
curAddr+expr->coef[curEq]*i);
}
}
else {//record address
//if (dbg) {fprintf(dbgAddr,"\nGenerated %d",curAddr);}
if (curAddr < minAddr) minAddr = curAddr;
if (curAddr > maxAddr) maxAddr = curAddr;
if (cachedNode(GET_MEM(curAddr))) return;
lastNode = findBlkAddr(GET_MEM(curAddr), *enumAddrSet);
if (lastNode) {
smem = lastNode->data;
if (smem->blkAddr == GET_MEM(curAddr)) {
mergeTSset(smem->tsList, *enumTSset, -1);
}
else {
goto ADD_ADDR;
}
}
else {//add new node after lastNode
ADD_ADDR:
smem =createSAddr(GET_MEM(curAddr),getAddrD(d_inst),flag,*enumTSset);
addAfterNode(smem, &lastNode, enumAddrSet);
}
}
}
GC_INNER ptr_t GC_scratch_alloc(size_t bytes)
{
register ptr_t result = scratch_free_ptr;
bytes += GRANULE_BYTES-1;
bytes &= ~(GRANULE_BYTES-1);
scratch_free_ptr += bytes;
if (scratch_free_ptr <= GC_scratch_end_ptr) {
return(result);
}
{
word bytes_to_get = MINHINCR * HBLKSIZE;
if (bytes_to_get <= bytes) {
/* Undo the damage, and get memory directly */
bytes_to_get = bytes;
# ifdef USE_MMAP
bytes_to_get += GC_page_size - 1;
bytes_to_get &= ~(GC_page_size - 1);
# endif
result = (ptr_t)GET_MEM(bytes_to_get);
GC_add_to_our_memory(result, bytes_to_get);
scratch_free_ptr -= bytes;
GC_scratch_last_end_ptr = result + bytes;
return(result);
}
result = (ptr_t)GET_MEM(bytes_to_get);
GC_add_to_our_memory(result, bytes_to_get);
if (result == 0) {
if (GC_print_stats)
GC_printf("Out of memory - trying to allocate less\n");
scratch_free_ptr -= bytes;
bytes_to_get = bytes;
# ifdef USE_MMAP
bytes_to_get += GC_page_size - 1;
bytes_to_get &= ~(GC_page_size - 1);
# endif
result = (ptr_t)GET_MEM(bytes_to_get);
GC_add_to_our_memory(result, bytes_to_get);
return result;
}
scratch_free_ptr = result;
GC_scratch_end_ptr = scratch_free_ptr + bytes_to_get;
GC_scratch_last_end_ptr = GC_scratch_end_ptr;
return(GC_scratch_alloc(bytes));
}
}
static isc_result_t
table_fromwire(isccc_region_t *source, isccc_region_t *secret,
isc_uint32_t algorithm, isccc_sexpr_t **alistp)
{
char key[256];
isc_uint32_t len;
isc_result_t result;
isccc_sexpr_t *alist, *value;
isc_boolean_t first_tag;
unsigned char *checksum_rstart;
REQUIRE(alistp != NULL && *alistp == NULL);
checksum_rstart = NULL;
first_tag = ISC_TRUE;
alist = isccc_alist_create();
if (alist == NULL)
return (ISC_R_NOMEMORY);
while (!REGION_EMPTY(*source)) {
GET8(len, source->rstart);
if (REGION_SIZE(*source) < len) {
result = ISC_R_UNEXPECTEDEND;
goto bad;
}
GET_MEM(key, len, source->rstart);
key[len] = '\0'; /* Ensure NUL termination. */
value = NULL;
result = value_fromwire(source, &value);
if (result != ISC_R_SUCCESS)
goto bad;
if (isccc_alist_define(alist, key, value) == NULL) {
result = ISC_R_NOMEMORY;
goto bad;
}
if (first_tag && secret != NULL && strcmp(key, "_auth") == 0)
checksum_rstart = source->rstart;
first_tag = ISC_FALSE;
}
if (secret != NULL) {
if (checksum_rstart != NULL)
result = verify(alist, checksum_rstart,
(unsigned int)
(source->rend - checksum_rstart),
algorithm, secret);
else
result = ISCCC_R_BADAUTH;
} else
result = ISC_R_SUCCESS;
bad:
if (result == ISC_R_SUCCESS)
*alistp = alist;
else
isccc_sexpr_free(&alist);
return (result);
}
static int cachedNode(int blkAddr) {
saddr_p smem;
if (lastNode) {//blkAddr is previously generated addr
smem = lastNode->data;
if (smem->blkAddr == GET_MEM(blkAddr)) {
mergeTSset(smem->tsList, *enumTSset, -1);
return 1;
}
}
return 0;
}
static back_edges * new_back_edges(void)
{
if (0 == back_edge_space) {
back_edge_space = (back_edges *)
GET_MEM(MAX_BACK_EDGE_STRUCTS*sizeof(back_edges));
}
if (0 != avail_back_edges) {
back_edges * result = avail_back_edges;
avail_back_edges = result -> cont;
result -> cont = 0;
return result;
}
if (GC_n_back_edge_structs >= MAX_BACK_EDGE_STRUCTS - 1) {
ABORT("needed too much space for back edges: adjust "
"MAX_BACK_EDGE_STRUCTS");
}
return back_edge_space + (GC_n_back_edge_structs++);
}
/*** Detect possible AddrSet of scalar access and compute access scope ***/
int analyze_scalar_access(dat_inst_t *d_inst, inf_node_t* ib) {
int dbg = 0;
int pos;
int addr;
insn_t* insn;
loop_t *loop;
saddr_p memblk;
ts_p memTS;
worklist_p tsNode,orgTS, blkNode;
if (d_inst->addrExpr.varNum != 0) {
printf("\nERR: not scalar access");printDataRef(stdout, d_inst);
}
addr = d_inst->addrExpr.k;
tsNode = NULL;
orgTS = NULL;
loop = getIbLoop(ib);
while (loop!=NULL) {
if (dbg) {
fprintf(dbgAddr,"\n In loop L%d, lbound %d",loop->id,loop->bound-1);
fflush(dbgAddr);}
memTS = (ts_p) malloc(sizeof(ts_s));
memTS->loop_id = loop->id;
memTS->lw = 0;
memTS->up = max(loop->bound-1,0);
memTS->flag = 0;
memTS->flag |= RENEWABLE;
addAfterNode(memTS, &tsNode, &orgTS);
//addToWorkList( &(orgTS),memTS);
loop = loop->parent;
}
blkNode = NULL;
insn = (insn_t*)(d_inst->insn);
memblk = createSAddr(GET_MEM(addr),hexValue(insn->addr), 1, orgTS);
addAfterNode(memblk, &blkNode, &(d_inst->addr_set));
return 0;
}
static back_edges * new_back_edges(void)
{
if (0 == back_edge_space) {
size_t bytes_to_get = ROUNDUP_PAGESIZE_IF_MMAP(MAX_BACK_EDGE_STRUCTS
* sizeof(back_edges));
back_edge_space = (back_edges *)GET_MEM(bytes_to_get);
if (NULL == back_edge_space)
ABORT("Insufficient memory for back edges");
GC_add_to_our_memory((ptr_t)back_edge_space, bytes_to_get);
}
if (0 != avail_back_edges) {
back_edges * result = avail_back_edges;
avail_back_edges = result -> cont;
result -> cont = 0;
return result;
}
if (GC_n_back_edge_structs >= MAX_BACK_EDGE_STRUCTS - 1) {
ABORT("Needed too much space for back edges: adjust "
"MAX_BACK_EDGE_STRUCTS");
}
return back_edge_space + (GC_n_back_edge_structs++);
}
void handle_Control ( )
{
unsigned int usb_cnt=0;
if((EP_STATUS_OUT & 0x01)||(EP_STATUS_IN & 0x01)) // 8 byte setup data received
{
EP_STATUS_OUT = 0x01; // write 1 to clear
EP_STATUS_IN = 0x01;
EP_STATE[0] = EP_IDLE; // force EP_STATE[0] to EP_IDLE
system.usbp0_data.wait_out_report=0;
if (CNT0 == 8) // Make sure that EP 0 has an Out Packet of size 8 byte
{
// added on 2011.5.8 to fix usb set_report error.
if (EP0_ADDR_DEF==0x21 && EP0_ADDR_DEF_1 == 0x09 )
{
USBINT0 = 0xc0;
Set_Report();
system.usbp0_data.report_id=EP0_ADDR_DEF_2;
system.usbp0_data.report_type = EP0_ADDR_DEF_3;
set_ep_rdy(EP_0); // 1:Endpoint 0 ready for transfer USB data.
}
else if(EP0_ADDR_DEF==0x21 && EP0_ADDR_DEF_1 == 0x01 )
{ // Fix SET_CUR request error
SET_CUR();
}
else
{
fifo_Read (EP_0, 8, (UINT8 *) & setup);
// Get setup Packet off of Fifo,
// it is currently Big-Endian
// Compiler Specific - these next three
// statements swap the bytes of the
// setup packet words to Big Endian so
// they can be compared to other 16-bit
// values elsewhere properly
// USBINT0 = 0xc0;
// set_ep_rdy(EP_0); // 1:Endpoint 0 ready for transfer USB data.
setup.wValue.i = setup.wValue.c[MSB] + ((int)setup.wValue.c[LSB] << 8); // High byte and low byte exchange()
setup.wIndex.i = setup.wIndex.c[MSB] + ( (int)setup.wIndex.c[LSB] << 8);
setup.wLength.i = setup.wLength.c[MSB] + ( (int)setup.wLength.c[LSB] << 8);
// Intercept HID class - specific requests
// Class request.
// if( (setup.bmRequestType & ~ 0x80) == DSC_HID)
if((setup.bmRequestType & cRequestType) == cClassReq)
{
#if 0
switch (setup.bRequest)
{
case GET_REPORT:
Get_Report ( );
break;
case SET_REPORT:
Set_Report();
break;
case GET_IDLE:
Get_Idle ( );
break;
case SET_IDLE:
Set_Idle ( );
break;
case GET_PROTOCOL:
Get_Protocol ( );
break;
case SET_PROTOCOL:
Set_Protocol ( );
break;
default:
force_Stall ( ); // Send stall to host if invalid
break; // request
}
#endif
switch(setup.bRequest)
{
// bmRequestType, bRequest, bChannelNum.(CN), bControlSelect(CS, include volume, mute etc.), bInterfaceNO, bTerminal/unit ID, wLength.
// CTL: 21 01 00 02 00 05 02 00
// DO: 00 00
case cSET_CUR:
if(setup.wIndex.c[1] >= 3) // HID interface.
{
Get_Report();
}
else
SET_CUR();
break;
case cSET_MIN:
if(setup.wIndex.c[1] >= 3) // HID interface.
{
Get_Idle();
}
else
SET_MIN();
break;
case cSET_MAX:
SET_MAX();
break;
case cSET_RES:
SET_RES();
break;
case cSET_MEM:
SET_MEM();
break;
/*
case GET_REPORT:
Get_Report();
break;
*/
case SET_REPORT:
Set_Report();
break;
/*
case GET_IDLE:
Get_Idle ( );
break;
*/
case SET_IDLE:
Set_Idle ( );
break;
case cGET_CUR:
GET_CUR();
break;
case cGET_MIN:
GET_MIN();
break;
case cGET_MAX:
GET_MAX();
break;
case cGET_RES:
GET_RES();
break;
case cGET_MEM:
GET_MEM();
break;
case cGET_STAT:
GET_STAT();
break;
default:
force_Stall ( ); // Send stall to host if invalid
break; // request
}
}
else
{
// Standard request.
switch (setup.bRequest) // Call correct subroutine to handle
{ // each kind of standard request
case GET_STATUS:
Get_Status ( );
break;
case CLEAR_FEATURE:
Clear_Feature ( );
break;
case SET_FEATURE:
Set_Feature ( );
break;
case SET_ADDRESS:
Set_Address ( );
break;
case GET_DESCRIPTOR:
Get_Descriptor ( );
break;
case GET_CONFIGURATION:
Get_Configuration ( );
break;
case SET_CONFIGURATION:
Set_Configuration( );
break;
case GET_INTERFACE:
Get_Interface ( );
break;
case SET_INTERFACE: // 01 0b 00 00(wValue) 01 00(wIndex) 00 00
Set_Interface ( ); // wValue:Interface alternate setting(0x0 is zero bandwith alternate setting, 0x01 is normal isochronous operate)
break; // wIndex: Interface number of one of the audiostreaming interface.
default:
force_Stall ( ); // Send stall to host if invalid request
break;
}
}
}
}
else
{
force_Stall ( ); // if rec setup data is not 8 byte , protacal stall
}
}
else if (EP_STATE[0] == EP_SET_ADDRESS) // Handle Status Phase of Set Address
{
FUNCT_ADR = setup.wValue.c[LSB]; // set usb Address SFR
EP_STATE[0] = EP_IDLE;
}
else if (EP_STATE[0] == EP_WAIT_STATUS)
{
EP_STATE[0] = EP_IDLE;
wait_tx_status=0;
}
else if (EP_STATE[0] == EP_RX) // See if endpoint should transmit
{ // Out Token. PC->Device.
if (DATASIZE >= EP0_PACKET_SIZE)
{
fifo_Read(EP_0, EP0_PACKET_SIZE, (unsigned char * )DATAPTR);
// Advance data pointer
DATAPTR += EP0_PACKET_SIZE;
// Decrement data size
DATASIZE -= EP0_PACKET_SIZE;
// Increment data sent counter
DATASENT += EP0_PACKET_SIZE;
}
else
{
// read bytes from FIFO
// // Report type: 0x01 input, 0x02 output, 0x03 feature report.
if( system.usbp0_data.wait_out_report && (system.usbp0_data.report_type==PC_SET_REPORT_2) && (system.usbp0_data.report_id==PC_SET_REPORT_1) )
{
system.usbp0_data.wait_out_report=0;
DATAPTR = & EP0_ADDR_DEF;
if(PC_SET_REPORT_1 == DATAPTR[0])
{
DATAPTR++;
DATASIZE--;
}
for ( system.usbp0_data.report_cnt = 0; // read num = NO fifo_data;
system.usbp0_data.report_cnt< DATASIZE;
system.usbp0_data.report_cnt ++ )
{
system.usbp0_data.set_report_data[system.usbp0_data.report_cnt] = DATAPTR[system.usbp0_data.report_cnt];
}
system.usbp0_data.aceept = 1;
system.usbp0_data.reday_report_flag = 0;
set_report_status_phace=1;
}
else
{
fifo_Read (EP_0, DATASIZE, (UINT8 * ) DATAPTR);
// KEYBOARD_OUT_REPORT
if (system.usbp0_data.wait_out_report)
{
numlock_sta = system.usbp0_data.out_report[0] & 0x01;
system.usbp0_data.out_report_index = DATASIZE;
system.usbp0_data.wait_out_report=0;
set_report_status_phace=1;
}
}
set_Wait_Status ( ); // set Endpoint to EP_WAIT_STATUS
}
if ( (DATASENT == setup.wLength.i) && (set_report_status_phace==0) )
{
set_Wait_Status ( );
}
set_report_status_phace=0;
}
if (EP_STATE[0] == EP_TX) // See if endpoint should transmit
{ // In Token, device->PC
if ((DATASIZE == 0))// || (DATASENT == setup.wLength.i)) // when all data has been sent over
{
set_Wait_Status ( );
}
else
{
CFG_EP0_1 = 0xc0;
if (DATASIZE >= EP0_PACKET_SIZE)
{
// Break Data into multiple packets if larger than Max Packet
fifo_Write (EP_0, EP0_PACKET_SIZE, (unsigned char*)DATAPTR);
// Advance data pointer
DATAPTR += EP0_PACKET_SIZE;
// Decrement data size
DATASIZE -= EP0_PACKET_SIZE;
// Increment data sent counter
DATASENT += EP0_PACKET_SIZE;
}
else
{
// If data is less than Max Packet size or zero
fifo_Write (EP_0, DATASIZE, (unsigned char*)DATAPTR);
// Increment data sent counter
DATASENT += DATASIZE;
// Decrement data size
DATASIZE = 0;
USBINT0 = 0xc0;
EP_RDY = 0x01 ;
// when usb_reset and send ok inttrupt (USBINT0&0x48)!=0 // when setup come (EP_STATUS & 0x01) will set
while(((USBINT0 & 0x4C) == 0) && ((EP_STATUS_OUT & 0x01) == 0)); //wait usb_reset, suspend or sending end interrupt happend, wait setup come
if((USBINT0&0x40) !=0)
{
CFG_EP0_1 =0x40;
EP_RDY = 0x01 ;
USBINT0 = 0xc0;
EP_STATE[0]= EP_WAIT_STATUS;
}
wait_tx_status = 1;
system.usbp0_data.wait_out_report=0;
}
}
}
if (system.usbp0_data.wait_out_report==0 && wait_tx_status ==0)
{
USBINT0 = 0xc0;
// set_ep_rdy(EP_0); // set ready to receive or send next packet
EP_RDY = 0x01 ;
}
}
farlongtype SysFarCoreLeft (void)
{
indextype CoreBlks = 0;
addrtype CoreAddr[20];
counttype i = 0;
farlongtype AllocAmount = Core_PageSize;
static
sizetype SizeOfInt = sizeof(int);
if (FirstTry == False
|| FirstTry == True)
return (1024000L);
if (FirstTry == True)
{
FirstTry = False;
if (SizeOfInt <= 2)
return (1024000L);
while ((CoreAddr[i] = (addrtype )GET_MEM (1, AllocAmount)) != NULL)
{
Alloc_Amount += AllocAmount;
sprintf (Msg, TraceStr(7),
/* " Allocated %6u bytes @%x\n" */
AllocAmount, CoreAddr[i]);
SendMsg (0, Msg);
++i;
}
AllocAmount -= 100;
while ( (AllocAmount &&
(CoreAddr[i] = (addrtype )GET_MEM (1, AllocAmount)) == NULL))
{
AllocAmount -= 100;
}
if (CoreAddr[i])
{
Alloc_Amount += AllocAmount;
sprintf (Msg, TraceStr(8),
/* " Allocated %6u bytes @%x\n" */
AllocAmount, CoreAddr[i]);
SendMsg (0, Msg);
} else
--i;
if (Alloc_Amount)
{
CoreBlks = i;
while (i >= 0)
{
sprintf (Msg, TraceStr(9),
/* " De Allocate block[%2u] @ %x\n" */
i, CoreAddr[i]);
SendMsg (0, Msg);
FREE_MEM (CoreAddr[i]);
i--;
}
CoreFreeStoreSize = (Core_PageSize * CoreBlks) + AllocAmount;
sprintf (Msg, TraceStr(10),
/* " *** INFO *** Far Core Available = %lu\n" */
CoreFreeStoreSize);
SendMsg (0, Msg);
} else
SendMsg (0, " *** CORE *** CoreNoMore\n");
}
return (CoreFreeStoreSize);
}
addrtype VoidExtendCore (farlongtype *SizeInBytes)
{
lt64 *LongPtr = NullPtr;
addrtype CoreAddr = NullPtr;
addrtype EndCoreBlkAddr = NullPtr;
sizetype ByteAlignment = 0;
farlongtype FarSize = 0;
static
boolean FirstTime = False;
static
boolean FirstLimit = True;
VoidStatus = Env_Normal;
#ifdef __BCC__
sprintf (Msg, " Extend VOID [%6u] %8lu bytes; New Void =%8lu\n",
VoidBlksAllocated + 1, *SizeInBytes, VoidUsed);
TraceMsg (0, Msg);
#endif
#ifdef CORE_LIMIT
if (*SizeInBytes > CORE_LIMIT)
{
sprintf (Msg, TraceStr(0),
/* " Alloc from the VOID %8lu bytes;\n" */
*SizeInBytes);
TraceMsg (0, Msg);
return (CoreAddr);
}
#endif
#ifdef OLDWAY
if (*SizeInBytes % CoreBlk_GapSpace)
{
ByteAlignment = CoreBlk_GapSpace - (*SizeInBytes % CoreBlk_GapSpace);
*SizeInBytes += ByteAlignment;
}
#else
#ifdef CORE_CRC_CHECK
FarSize = *SizeInBytes + CORE_BLOCK_ALIGN + 4;
if (FarSize % CoreBlk_GapSpace)
{
ByteAlignment = CoreBlk_GapSpace - (FarSize % CoreBlk_GapSpace);
FarSize += ByteAlignment;
}
#else
FarSize = *SizeInBytes;
if (FarSize % CoreBlk_GapSpace)
{
ByteAlignment = CoreBlk_GapSpace - (FarSize % CoreBlk_GapSpace);
FarSize += ByteAlignment;
}
#endif /* CORE_CRC_CHECK */
#endif /* OLDWAY */
if ((FarSize + VoidUsed) > VOID_BOUNDARY)
{
if (FirstLimit)
SendMsg (0, "\n *** WARNING *** VOID_BOUNDARY EXCEEDED!!!\n");
else
SendMsg (0, "\n *** ERROR *** VOID_BOUNDARY EXCEEDED!!!\n");
sprintf (Msg, " BOUNDARY := %8d; RESERVE := %8d;\n",
VOID_BOUNDARY, VOID_RESERVE);
SendMsg (0, Msg);
if (FirstLimit)
VOID_BOUNDARY += VOID_RESERVE;
FirstLimit = False;
return (NullPtr);
}
if ((LongPtr = (lt64 *)GET_MEM (1, FarSize)) == NULL)
{
if (!FirstTry)
{
return (NullPtr);
} else {
FirstTry = False;
do
{
*SizeInBytes = *SizeInBytes - 256;
LongPtr = (lt64 *)GET_MEM (1, *SizeInBytes);
} while (*SizeInBytes >= 256 && LongPtr == NULL);
if (LongPtr)
if (sprintf (Msg, TraceStr(1),
/* " *** WARNING ... Partial Core Page = %lu\n" */
*SizeInBytes))
SendMsg (0, Msg);
}
}
if (! CoreFreeStoreSize && FirstTry)
SysFarCoreLeft();
else
CoreFreeStoreSize -= FarSize;
#ifdef CORE_CRC_CHECK
memset ((addrtype )LongPtr, 0x55, 4);
EndCoreBlkAddr = (addrtype )((char *)LongPtr + (FarSize - 4));
memset (EndCoreBlkAddr, 0x55, 4);
CoreAddr = (addrtype )((char *)LongPtr + CORE_BLOCK_ALIGN);
#else
CoreAddr = (addrtype )LongPtr;
#endif /* CORE_CRC_CHECK */
VoidAllocated += FarSize;
VoidUsed += FarSize;
if (VoidUsed > VoidMaxUsed)
VoidMaxUsed = VoidUsed;
VoidBlksAllocated++;
if (FirstTime)
{
VoidLowestAddr = CoreAddr;
FirstTime = False;
} else if (CoreAddr < VoidLowestAddr) {
VoidLowestAddr = CoreAddr;
}
if (StrucAlignment)
{
if ((farlongtype )CoreAddr % StrucAlignment)
{
sprintf (Msg, TraceStr(4),
/* " CoreMoreCore... Non Aligned Address= %8x\n" */
LongPtr);
TraceMsg (0, Msg);
sprintf (Msg, TraceStr(5),
/* " Core1Size = %8lu\n" */
Core1Size);
SendMsg (0, Msg);
VoidStatus = Core_NotInAlignment;
}
}
if ( DeBug )
{
sprintf(Msg, "Extend VOID [%6u] := %8lu bytes; VoidUsed := %8lu\n",
VoidBlksAllocated , *SizeInBytes, VoidUsed);
TraceMsg (0, Msg);
}
return (CoreAddr);
}
/*** Detect possible AddrSet of unpred. access and compute access scope ***/
int analyze_unpred_access(dat_inst_t *d_inst, inf_node_t* ib) {
int dbg = 0;
/* A[x] -> assume array A is global array
* AddrSet(A) -> obtained from symbol table
* Identifying access variable: compute addr.expr, ignoring unknown elem.
* Addr. Expression A[x] = A[0] + T*4, how reg. expression derive now
* Not necessary correct in all cases, or more aggressive optimization
* Work with array index A[x]
* Not work with pointer value
*/
int initAddr = -1, addr;
symbol_i *gVar, *var;
int i;
loop_t *loop;
saddr_p memblk,curblk;
ts_p memTS;
worklist_p tsNode, orgTS, blkNode;
insn_t *insn;
int foundRange;
expr_p exp;
//create access scope for all possible address
loop = getIbLoop(ib);
tsNode = NULL;orgTS = NULL;
while (loop!=NULL) {
memTS = malloc(sizeof(ts_s));
memTS->loop_id = loop->id;
memTS->lw = 0;
memTS->up = max(loop->bound-1,0);
memTS->flag = 0;
addAfterNode(memTS, &tsNode, &orgTS);
//addToWorkList( &orgTS,memTS);
loop = loop->parent;
}
curblk = NULL;
blkNode = NULL;
foundRange = 0;
exp = &(d_inst->addrExpr);
insn = (insn_t*)(d_inst->insn);
initAddr = exp->k;
//locate the symbol table segment
for (i=0; i<prog.num_vars; i++) {
gVar = &(prog.v_info[i]);
if (gVar->addr <= initAddr && initAddr < gVar->addr + gVar->size) {
foundRange = 1;
break;
}
}
if (foundRange) {//unpredictable access, but find global var
/*NOTE: stepSizeTable hts only 89 integer, but segment size = 1024*/
/*can set this ts some user constraint, hard code for now*/
if (strcmp(gVar->name,"stepsizeTable")==0) {
gVar->size = 89*4; /*a kind of user constraint*/
}
if (strcmp(gVar->name,"indexTable")==0) {
gVar->size = 16*4; /*a kind of user constraint*/
}
//Addr range of global var. too large --> consider unknown
if (gVar->size > CACHE_SIZE) goto UNKNOWN_RANGE;
if (dbg) {
fprintf(dbgAddr,"\n Global var: %s [%x,%x], array sa: %x, size %d",
gVar->name, gVar->addr,gVar->addr+gVar->size,initAddr,gVar->size);
fflush(dbgAddr);
}
for (addr = gVar->addr; addr < gVar->addr+gVar->size; addr+=4) {
if (curblk && GET_MEM(addr)==curblk->blkAddr) continue;
memblk = createSAddr(GET_MEM(addr),
hexValue(insn->addr),0,orgTS);
addAfterNode(memblk, &blkNode, &(d_inst->addr_set));
curblk = memblk;
}
}
else {//unpredictable access, unknown address range
UNKNOWN_RANGE:
if (dbg) {
fprintf(dbgAddr,"\nUnknown addr range");fflush(dbgAddr);
}
memblk = createSAddr(UNKNOWN_ADDR,hexValue(insn->addr),0,orgTS);
addAfterNode(memblk,&blkNode,&(d_inst->addr_set));
return 0;
}
return 0;
}
/* analyze data reference with regular access pattern */
int analyze_regular_access(dat_inst_t *d_inst, inf_node_t *ib) {
int dbg = 0;
int i,j,min, tmp;
int lpId, addr, flag;
insn_t *insn;
expr_p exp;
reg_t tmpReg;
ts_p ts;
loop_t *lp;
int lpIter[5];
worklist_p tsList, tsNode, addrSet;
initReg(&tmpReg);
exp = &(d_inst->addrExpr);
//check if it is really regular access (no unknown parameter)
for (i=0; i<exp->varNum; i++) {
if (exp->value[i].t==VALUE_PARA || exp->value[i].t==VALUE_UNDEF){
analyze_unpred_access(d_inst,ib);return;}
}
//Sort BIV loopID in ascending order
for (i=0; i<exp->varNum; i++) {
min = i;
for (j=i+1; j<exp->varNum; j++) {
if (exp->value[j].val <= exp->value[min].val) min = j;
#if 0
if (exp->coef[i] = 0 - exp->coef[j]) {
exp->value[i].val = max(exp->value[i].val,exp->value[j].val);
exp->coef[i] = absInt(exp->coef[i]);
exp->coef[j] = 0;
exp->value[j].val = 999;
}
#endif
}
if (i==min) continue;//exp->value[i] is already min
if (exp->value[min].val == exp->value[i].val) {
//min & i are two biv of the same loop --> merge
exp->coef[i] += exp->coef[min];
exp->value[min].val = 999;exp->coef[min] =0;
}
else {//swap min & i
cpyReg(&tmpReg, exp->value[i]);
cpyReg(&(exp->value[i]), exp->value[min]);
cpyReg(&(exp->value[min]), tmpReg);
tmp = exp->coef[i]; exp->coef[i]=exp->coef[min]; exp->coef[min]=tmp;
}
}
//Clear up merged register
while (exp->varNum>0) {
i = exp->varNum-1;
if (exp->value[i].val == 999) exp->varNum--;
else break;
}
/*To deal with j = i*/
if (dbg) {fprintf(dbgAddr,"\nSorted expr: ");printExpr(dbgAddr,exp);}
//create the temporal scope for memory blocks of d_inst
tsList = NULL; tsNode = NULL;
lp = loops[exp->value[0].val];//inner most loop
i = 0;
while (lp!=NULL) {
if (0) fprintf(dbgAddr,"\n In loop L%d, lbound %d",lp->id,lp->bound-1);
ts = (ts_p) malloc(sizeof(ts_s));
if (lp->id == exp->value[i].val) {
ts->loop_id = lp->id; ts->lw = 0; ts->up = 0; ts->flag = 0;i++;
}
else {
ts->loop_id = lp->id; ts->lw = 0; ts->up = lp->bound; ts->flag = 0;
}
addAfterNode(ts, &tsNode, &tsList);
//addToWorkList( &(orgTS),memTS);
lp = lp->parent;
}
if (dbg) {fprintf(dbgAddr,"\nTemporal scope: ");printTSset(dbgAddr,tsList);}
//enumerating possible memory blocks
addrSet = NULL; lastNode = NULL;
enumTSset = &tsList;
enumAddrSet = &addrSet;
flag = 0;
for (i=0; i<num_tcfg_loops; i++) iterValue[i]=-1;
minAddr = exp->k; maxAddr = 0;
enum_regular_address(d_inst, exp, flag, 0, tsList, exp->k);
d_inst->addr_set = addrSet;
if (dbg) {
fprintf(dbgAddr,"\nGenerated range: [%x, %x], %d elems",
minAddr, maxAddr, GET_MEM(maxAddr-minAddr));
//printSAddrSet(dbgAddr,d_inst->addr_set,1);
}
}
