Type Type::get_function_returning(const ObjectList<Type>& type_list, const ObjectList<Type>& nonadjusted_type_list, bool has_ellipsis, ref_qualifier_t reference_qualifier) { int i; parameter_info_t *parameters_list; int num_parameters = type_list.size(); parameters_list = NEW_VEC(parameter_info_t, num_parameters + has_ellipsis); for (i=0; i<num_parameters; i++) { parameters_list[i].is_ellipsis = 0; parameters_list[i].type_info = type_list[i]._type_info; parameters_list[i].nonadjusted_type_info = nonadjusted_type_list[i]._type_info; } if (has_ellipsis) { num_parameters++; parameters_list[i].is_ellipsis = 1; parameters_list[i].type_info = get_ellipsis_type(); parameters_list[i].nonadjusted_type_info = NULL; } return (Type(get_new_function_type(_type_info, parameters_list, num_parameters, reference_qualifier))); }
int main() { // TestCase Group1: MemPool objMemPool; MemPool *pMemPool = &objMemPool; int32_t nCount = 10; char *pszArray = NEW_VEC(pMemPool, char, nCount); int32_t *pnArray = NEW_VEC(pMemPool, int32_t, nCount); float *pfArray = NEW_VEC(pMemPool, float, nCount); for (int i = 0; i < nCount; i++) { pszArray[i] = 'a' + i; pnArray[i] = i; pfArray[i] = 1.0 * i; } for (int i = 0; i < nCount; i++) { fprintf(stdout, "pszArray[%d]:\t%c\n", i, pszArray[i]); fprintf(stdout, "pnArray[%d]:\t%d\n", i, pnArray[i]); fprintf(stdout, "pfArray[%d]:\t%f\n", i, pfArray[i]); } pMemPool->reset(); // TestCase Group2: MemPool objMemPool2; MemPool *pMemPool2 = &objMemPool2; int32_t nCount2 = 10; MyClass *pMyClass = NEW(pMemPool2, MyClass); fprintf(stdout, "pMyClass:\t%d\n", pMyClass->getCount()); MyClass *pMyClass2 = NEW(pMemPool2, MyClass)(100); fprintf(stdout, "pMyClass2:\t%d\n", pMyClass2->getCount()); MyClass *pMyClassArray = NEW_ARRAY(pMemPool2, MyClass, nCount2); for (int i = 0; i < nCount2; i++) { fprintf(stdout, "pMyClassArray[%d]:\t%d\n", i, pMyClassArray[i].getCount()); } pMemPool2->reset(); // TestCase Group3: MemPool objMemPool3; MemPool *pMemPool3 = &objMemPool3; MemMonitor memMonitor(pMemPool3, 1); pMemPool3->setMonitor(&memMonitor); memMonitor.enableException(); int32_t nCount3 = 1; char *pszArray3 = NEW_VEC(pMemPool3, char, nCount3); if (!pszArray3) { printf("pszArray3 NEW_VEC Err!\n"); } nCount3 = 1024; int32_t *pnArray3 = NEW_VEC(pMemPool3, int32_t, nCount3); if (!pnArray3) { printf("pnArray3 NEW_VEC Err!\n"); } float *pfArray3 = NEW_VEC(pMemPool3, float, nCount3); if (!pfArray3) { printf("pfArray3 NEW_VEC Err!\n"); } for (int i = 0; i < nCount3; i++) { pszArray3[i] = 'a' + i; pnArray3[i] = i; pfArray3[i] = 1.0 * i; } for (int i = 0; i < nCount3; i++) { fprintf(stdout, "pszArray3[%d]:\t%c\n", i, pszArray3[i]); fprintf(stdout, "pnArray3[%d]:\t%d\n", i, pnArray3[i]); fprintf(stdout, "pfArray3[%d]:\t%f\n", i, pfArray3[i]); } pMemPool3->reset(); // TestCase Group4: MemPool objMemPool4; MemPool *pMemPool4 = &objMemPool4; MemMonitor memMonitor4(pMemPool4, 1); pMemPool4->setMonitor(&memMonitor4); memMonitor4.enableException(); int32_t nCountsz4 = 1024; char *pszArraysz4 = NEW_VEC(pMemPool4, char, nCountsz4); if (!pszArraysz4) { printf("pszArraysz4 is NULL\n"); } MyClass *pMyClass4 = NEW(pMemPool4, MyClass); if (!pMyClass4) { printf("pMyClass4 is NULL\n"); } fprintf(stdout, "pMyClass4:\t%d\n", pMyClass4->getCount()); int32_t nCountsz4_1 = 1024; char *pszArraysz4_1 = NEW_VEC(pMemPool4, char, nCountsz4_1); if (!pszArraysz4_1) { printf("pszArraysz4_1 is NULL\n"); } MyClass *pMyClass4_1 = NEW(pMemPool4, MyClass)(100); if (!pMyClass4_1) { printf("pMyClass4_1 is NULL\n"); } fprintf(stdout, "pMyClass4_1:\t%d\n", pMyClass4_1->getCount()); int32_t nCountsz4_2 = 1024; char *pszArraysz4_2 = NEW_VEC(pMemPool4, char, nCountsz4_2); if (!pszArraysz4_2) { printf("pszArraysz4_2 is NULL\n"); } int32_t nCount4_2 = 1; MyClass *pMyClassArray4_2 = NEW_ARRAY(pMemPool4, MyClass, nCount4_2); if (!pMyClassArray4_2) { printf("pMyClassArray4_2 is NULL\n"); } for (int i = 0; i < nCount4_2; i++) { fprintf(stdout, "pMyClassArray4_2[%d]:\t%d\n", i, pMyClassArray4_2[i].getCount()); } pMemPool4->reset(); return 0; }
/* LIB7_Poll: * * The version of the polling operation for systems that provide BSD select. */ static lib7_val_t LIB7_Poll (lib7_state_t *lib7_state, lib7_val_t poll_list, struct timeval *timeout) { fd_set rset, wset, eset; fd_set *rfds, *wfds, *efds; int maxFD, status, fd, flag; lib7_val_t l, item; /*printf("src/runtime/c-libs/posix-os/poll.c: Using 'select' implementation\n");*/ rfds = wfds = efds = NULL; maxFD = 0; for (l = poll_list; l != LIST_nil; l = LIST_tl(l)) { item = LIST_hd(l); fd = REC_SELINT(item, 0); flag = REC_SELINT(item, 1); if ((flag & READABLE_BIT) != 0) { /*int fd_flags = fcntl(fd,F_GETFL,0);*/ if (rfds == NULL) { rfds = &rset; FD_ZERO(rfds); } /*printf("src/runtime/c-libs/posix-os/poll.c: Will check fd %d for readability. fd flags x=%x O_NONBLOCK x=%x\n",fd,fd_flags,O_NONBLOCK);*/ FD_SET (fd, rfds); } if ((flag & WRITABLE_BIT) != 0) { if (wfds == NULL) { wfds = &wset; FD_ZERO(wfds); } /*printf("src/runtime/c-libs/posix-os/poll.c: Will check fd %d for writability.\n",fd);*/ FD_SET (fd, wfds); } if ((flag & OOBDABLE_BIT) != 0) { if (efds == NULL) { efds = &eset; FD_ZERO(efds); } /*printf("src/runtime/c-libs/posix-os/poll.c: Will check fd %d for oobdability.\n",fd);*/ FD_SET (fd, efds); } if (fd > maxFD) maxFD = fd; } /*printf("src/runtime/c-libs/posix-os/poll.c: maxFD d=%d timeout x=%x.\n",maxFD,timeout);*/ /* do { */ /* Backed out 2010-02-26 CrT: See discussion at bottom of src/runtime/c-libs/lib7-socket/connect.c */ status = select (maxFD+1, rfds, wfds, efds, timeout); /* } while (status < 0 && errno == EINTR); */ /* Restart if interrupted by a SIGALRM or SIGCHLD or whatever. */ /*printf("src/runtime/c-libs/posix-os/poll.c: result status d=%d.\n",status);*/ if (status < 0) return RAISE_SYSERR(lib7_state, status); else if (status == 0) return LIST_nil; else { lib7_val_t *resVec = NEW_VEC(lib7_val_t, status); int i; int resFlag; for (i = 0, l = poll_list; l != LIST_nil; l = LIST_tl(l)) { item = LIST_hd(l); fd = REC_SELINT(item, 0); flag = REC_SELINT(item, 1); resFlag = 0; if (((flag & READABLE_BIT) != 0) && FD_ISSET(fd, rfds)) { /*int fd_flags = fcntl(fd,F_GETFL,0);*/ /*printf("src/runtime/c-libs/posix-os/poll.c: fd d=%d is in fact readable. fd flags x=%x O_NONBLOCK x=%x\n",fd,fd_flags,O_NONBLOCK);*/ resFlag |= READABLE_BIT; } if (((flag & WRITABLE_BIT) != 0) && FD_ISSET(fd, wfds)) { /*printf("src/runtime/c-libs/posix-os/poll.c: fd d=%d is in fact writable.\n",fd);*/ resFlag |= WRITABLE_BIT; } if (((flag & OOBDABLE_BIT) != 0) && FD_ISSET(fd, efds)) { /*printf("src/runtime/c-libs/posix-os/poll.c: fd d=%d is in fact oobdable.\n",fd);*/ resFlag |= OOBDABLE_BIT; } if (resFlag != 0) { REC_ALLOC2 (lib7_state, item, INT_CtoLib7(fd), INT_CtoLib7(resFlag)); resVec[i++] = item; } } ASSERT(i == status); for (i = status-1, l = LIST_nil; i >= 0; i--) { item = resVec[i]; LIST_cons (lib7_state, l, item, l); } FREE(resVec); return l; } } /* end of LIB7_Poll */
static void read_heap ( inbuf_t* bp, lib7_heap_hdr_t* header, lib7_state_t* lib7_state, lib7_val_t* externs ) { heap_t* heap = lib7_state->lib7_heap; heap_arena_hdr_t *arenaHdrs, *p, *q; int arenaHdrsSize; int i, j, k; long prevSzB[NUM_ARENAS], size; bibop_t oldBIBOP; Addr_t addrOffset[MAX_NUM_GENS][NUM_ARENAS]; bo_region_reloc_t *boRelocInfo; addr_table_t *boRegionTable; /* Allocate a BIBOP for the imported * heap image's address space: */ #ifdef TWO_LEVEL_MAP # error two level map not supported #else oldBIBOP = NEW_VEC (aid_t, BIBOP_SZ); #endif /* Read in the big-chunk region descriptors * for the old address space: */ { int size; bo_region_info_t* boRgnHdr; boRegionTable = MakeAddrTable(BIBOP_SHIFT+1, header->numBORegions); size = header->numBORegions * sizeof(bo_region_info_t); boRgnHdr = (bo_region_info_t *) MALLOC (size); HeapIO_ReadBlock (bp, boRgnHdr, size); boRelocInfo = NEW_VEC(bo_region_reloc_t, header->numBORegions); for (i = 0; i < header->numBORegions; i++) { MarkRegion(oldBIBOP, (lib7_val_t *)(boRgnHdr[i].baseAddr), RND_HEAP_CHUNK_SZB(boRgnHdr[i].sizeB), AID_BIGCHUNK(1) ); oldBIBOP[BIBOP_ADDR_TO_INDEX(boRgnHdr[i].baseAddr)] = AID_BIGCHUNK_HDR(MAX_NUM_GENS); boRelocInfo[i].firstPage = boRgnHdr[i].firstPage; boRelocInfo[i].nPages = (boRgnHdr[i].sizeB - (boRgnHdr[i].firstPage - boRgnHdr[i].baseAddr)) >> BIGCHUNK_PAGE_SHIFT; boRelocInfo[i].chunkMap = NEW_VEC(bo_reloc_t *, boRelocInfo[i].nPages); for (j = 0; j < boRelocInfo[i].nPages; j++) { boRelocInfo[i].chunkMap[j] = NULL; } AddrTableInsert (boRegionTable, boRgnHdr[i].baseAddr, &(boRelocInfo[i])); } FREE (boRgnHdr); } /* Read the arena headers: */ arenaHdrsSize = header->numGens * NUM_CHUNK_KINDS * sizeof(heap_arena_hdr_t); arenaHdrs = (heap_arena_hdr_t *) MALLOC (arenaHdrsSize); HeapIO_ReadBlock (bp, arenaHdrs, arenaHdrsSize); for (i = 0; i < NUM_ARENAS; i++) { prevSzB[i] = heap->allocSzB; } /* Allocate the arenas and read in the heap image: */ for (p = arenaHdrs, i = 0; i < header->numGens; i++) { gen_t *gen = heap->gen[i]; /* Compute the space required for this generation, * and mark the oldBIBOP to reflect the old address space: */ for (q = p, j = 0; j < NUM_ARENAS; j++) { MarkRegion (oldBIBOP, (lib7_val_t *)(q->info.o.baseAddr), RND_HEAP_CHUNK_SZB(q->info.o.sizeB), gen->arena[j]->id); size = q->info.o.sizeB + prevSzB[j]; if ((j == PAIR_INDEX) && (size > 0)) size += 2*WORD_SZB; gen->arena[j]->tospSizeB = RND_HEAP_CHUNK_SZB(size); prevSzB[j] = q->info.o.sizeB; q++; } /* Allocate space for the generation: */ if (NewGeneration(gen) == FAILURE) { Die ("unable to allocated space for generation %d\n", i+1); } if (isACTIVE(gen->arena[ARRAY_INDEX])) { NewDirtyVector (gen); } /* Read in the arenas for this generation * and initialize the address offset table: */ for (j = 0; j < NUM_ARENAS; j++) { arena_t* ap = gen->arena[j]; if (p->info.o.sizeB > 0) { addrOffset[i][j] = (Addr_t)(ap->tospBase) - (Addr_t)(p->info.o.baseAddr); HeapIO_Seek (bp, (long)(p->offset)); HeapIO_ReadBlock(bp, (ap->tospBase), p->info.o.sizeB); ap->nextw = (lib7_val_t *)((Addr_t)(ap->tospBase) + p->info.o.sizeB); ap->oldTop = ap->tospBase; } else if (isACTIVE(ap)) { ap->oldTop = ap->tospBase; } if (verbosity > 0) say("."); p++; } /* Read in the big-chunk arenas: */ for (j = 0; j < NUM_BIGCHUNK_KINDS; j++) { Addr_t totSizeB; bigchunk_desc_t *freeChunk, *bdp; bigchunk_region_t *freeRegion; bigchunk_hdr_t *boHdrs; int boHdrSizeB, index; bo_region_reloc_t *region; if (p->info.bo.numBOPages > 0) { totSizeB = p->info.bo.numBOPages << BIGCHUNK_PAGE_SHIFT; freeChunk = BO_AllocRegion (heap, totSizeB); freeRegion = freeChunk->region; freeRegion->minGen = i; MarkRegion (BIBOP, (lib7_val_t *)freeRegion, HEAP_CHUNK_SZB( freeRegion->heap_chunk ), AID_BIGCHUNK(i)); BIBOP[BIBOP_ADDR_TO_INDEX(freeRegion)] = AID_BIGCHUNK_HDR(i); /* Read in the big-chunk headers */ boHdrSizeB = p->info.bo.numBigChunks * sizeof(bigchunk_hdr_t); boHdrs = (bigchunk_hdr_t *) MALLOC (boHdrSizeB); HeapIO_ReadBlock (bp, boHdrs, boHdrSizeB); /* Read in the big-chunks: */ HeapIO_ReadBlock (bp, (void *)(freeChunk->chunk), totSizeB); if (j == CODE_INDEX) { FlushICache ((void *)(freeChunk->chunk), totSizeB); } /* Set up the big-chunk descriptors * and per-chunk relocation info: */ for (k = 0; k < p->info.bo.numBigChunks; k++) { /* find the region relocation info for the chunk's region in * the exported heap. */ for (index = BIBOP_ADDR_TO_INDEX(boHdrs[k].baseAddr); !BO_IS_HDR(oldBIBOP[index]); index--) continue; region = LookupBORegion (boRegionTable, index); /* Allocate the big-chunk descriptor for * the chunk and link it into the list * of big-chunks for its generation. */ bdp = AllocBODesc (freeChunk, &(boHdrs[k]), region); bdp->next = gen->bigChunks[j]; gen->bigChunks[j] = bdp; ASSERT(bdp->gen == i+1); if (show_code_chunk_comments && (j == CODE_INDEX)) { /* Dump the comment string of the code chunk: */ char* namestring; if ((namestring = BO_GetCodeChunkTag(bdp))) { SayDebug ("[%6d bytes] %s\n", bdp->sizeB, namestring); } } } if (freeChunk != bdp) { /* There was some extra space left in the region: */ ADD_BODESC(heap->freeBigChunks, freeChunk); } FREE (boHdrs); } if (verbosity > 0) say("."); p++; } } repair_heap (heap, oldBIBOP, addrOffset, boRegionTable, externs); /* Adjust the run-time globals * that point into the heap: */ *PTR_LIB7toC(lib7_val_t, PervasiveStruct) = repair_word ( *PTR_LIB7toC(lib7_val_t, PervasiveStruct), oldBIBOP, addrOffset, boRegionTable, externs); runtimeCompileUnit = repair_word( runtimeCompileUnit, oldBIBOP, addrOffset, boRegionTable, externs ); #ifdef ASM_MATH MathVec = repair_word (MathVec, oldBIBOP, addrOffset, boRegionTable, externs); #endif /* Adjust the Lib7 registers to the new address space */ ASSIGN(Lib7SignalHandler, repair_word ( DEREF(Lib7SignalHandler), oldBIBOP, addrOffset, boRegionTable, externs) ); lib7_state->lib7_argument = repair_word ( lib7_state->lib7_argument, oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_fate = repair_word ( lib7_state->lib7_fate, oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_closure = repair_word ( lib7_state->lib7_closure, oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_program_counter = repair_word ( lib7_state->lib7_program_counter, oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_link_register = repair_word ( lib7_state->lib7_link_register, oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_exception_fate = repair_word ( lib7_state->lib7_exception_fate, oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_current_thread = repair_word ( lib7_state->lib7_current_thread, oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_calleeSave[0] = repair_word ( lib7_state->lib7_calleeSave[0], oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_calleeSave[1] = repair_word ( lib7_state->lib7_calleeSave[1], oldBIBOP, addrOffset, boRegionTable, externs ); lib7_state->lib7_calleeSave[2] = repair_word ( lib7_state->lib7_calleeSave[2], oldBIBOP, addrOffset, boRegionTable, externs ); /* Release storage: */ for (i = 0; i < header->numBORegions; i++) { bo_reloc_t *p; for (p = NULL, j = 0; j < boRelocInfo[i].nPages; j++) { if ((boRelocInfo[i].chunkMap[j] != NULL) && (boRelocInfo[i].chunkMap[j] != p)) { FREE (boRelocInfo[i].chunkMap[j]); p = boRelocInfo[i].chunkMap[j]; } } } FreeAddrTable (boRegionTable, FALSE); FREE (boRelocInfo); FREE (arenaHdrs); FREE (oldBIBOP); /* Reset the sweep_nextw pointers: */ for (i = 0; i < heap->numGens; i++) { gen_t *gen = heap->gen[i]; for (j = 0; j < NUM_ARENAS; j++) { arena_t *ap = gen->arena[j]; if (isACTIVE(ap)) ap->sweep_nextw = ap->nextw; } } } /* read_heap. */