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); } }