PUBLIC void initmem()
{
(void)VMInit(NULL,(int)vmpagesize,1000);
codeseg = VMPage();
vmheap = VMPage();
codesize = 0;
}
/////////////////////////////////////////////////////////////////////
// IDolphinSmalltalk
STDMETHODIMP CDolphinSmalltalk::Initialise(HINSTANCE hInstance,
LPCSTR fileName, LPVOID imageData, UINT imageSize,
DWORD dwFlags)
{
HRESULT APIENTRY VMInit(LPCSTR szImageName, LPVOID, UINT, DWORD);
if (hInstance == NULL || imageData == NULL || imageSize == 0)
return E_INVALIDARG;
piVM = this;
Lock();
hApplicationInstance = hInstance;
HRESULT hr = VMInit(fileName, imageData, imageSize, dwFlags);
Unlock();
return hr;
}
dip_status DIPIMPENTRY( LoadInfo )( dig_fhandle fid, imp_image_handle *ii )
{
dip_status ds;
unsigned long off;
unsigned long size;
cv_directory_entry *cde;
cv_sst_global_types_header *hdr;
memset( ii, 0, sizeof( *ii ) );
ds = FindCV( fid, &off, &size );
if( ds != DS_OK )
return( ds );
ii->sym_fid = fid;
ii->bias = off;
ds = VMInit( ii, size );
if( ds != DS_OK )
return( ds );
ii->next_image = ImageList;
ImageList = ii;
ds = LoadDirectory( ii, off + CV_SIG_SIZE );
if( ds != DS_OK ) {
DCStatus( ds );
Cleanup( ii );
return( ds );
}
ds = LoadMapping( ii );
if( ds != DS_OK ) {
DCStatus( ds );
Cleanup( ii );
return( ds );
}
cde = FindDirEntry( ii, IMH_GBL, sstGlobalTypes );
if( cde != NULL ) {
hdr = VMBlock( ii, cde->lfo, sizeof( *hdr ) );
if( hdr == NULL ) {
Cleanup( ii );
return( DS_ERR|DS_FAIL );
}
ii->types_base = cde->lfo
+ offsetof(cv_sst_global_types_header, offType )
+ hdr->cType * sizeof( hdr->offType[0] );
}
ds = SetMADType( ii );
if( ds != DS_OK ) {
DCStatus( ds );
Cleanup( ii );
return( ds );
}
return( DS_OK );
}
/*
* Load debug info if it's in the HLL/CV format.
*/
dip_status DIGENTRY DIPImpLoadInfo( dig_fhandle h, imp_image_handle *ii )
{
dip_status rc;
/* Init the module handle. */
memset( ii, 0, sizeof( *ii ) );
ii->mad = MAD_X86; /* No known non-x86 support */
ii->sym_file = h;
ii->is_32bit = 1;
ii->format_lvl = HLL_LVL_NB04;
ii->next_image = ImageList;
ImageList = ii;
/* Read basic HLL and executable image bits. */
rc = FindHLL( ii );
if( rc == DS_OK ) {
rc = VMInit( ii, ii->size );
}
/* Make sure we've got segment mappings. (FIXME: scan module headers) */
if( rc == DS_OK && !ii->segments ) {
ii->seg_count = 2;
ii->segments = DCAlloc( sizeof( hllinfo_seg ) * ii->seg_count );
if( ii->segments != NULL ) {
memset( ii->segments, 0, sizeof( hllinfo_seg ) * ii->seg_count );
ii->segments[0].is_executable = 1;
ii->segments[0].map.segment = 1;
ii->segments[1].map.segment = 2;
ii->segments[0].size = ii->segments[1].size = 0x00400000; /* 4MB */
ii->segments[0].address = ii->segments[1].address = 0;
} else{
rc = DS_ERR | DS_NO_MEM;
}
}
/* Locate global types. If none, we've types per module. */
if( rc == DS_OK ) {
/* FIXME
hll_debug_dir *cde;
cde = FindDirEntry( ii, IMH_GBL, sstGlobalTypes );
if( cde != NULL ) {
hdr = VMBlock( ii, cde->lfo, sizeof( *hdr ) );
if( hdr == NULL ) {
Cleanup( ii );
return( DS_ERR | DS_FAIL );
}
ii->types_base = cde->lfo
+ offsetof( cv_sst_global_types_header, offType )
+ hdr->cType * sizeof( hdr->offType[0] );
}
*/
}
/* We're done - clean up on failure. */
if( rc != DS_OK ) {
DCStatus( rc );
Cleanup( ii );
}
return( rc );
}
/* VMChunkCreate -- create a chunk
*
* chunkReturn, return parameter for the created chunk.
* vmArena, the parent VMArena.
* size, approximate amount of virtual address that the chunk should reserve.
*/
static Res VMChunkCreate(Chunk *chunkReturn, VMArena vmArena, Size size)
{
Arena arena;
Res res;
Addr base, limit, chunkStructLimit;
VMStruct vmStruct;
VM vm = &vmStruct;
BootBlockStruct bootStruct;
BootBlock boot = &bootStruct;
VMChunk vmChunk;
void *p;
AVER(chunkReturn != NULL);
AVERT(VMArena, vmArena);
arena = VMArena2Arena(vmArena);
AVER(size > 0);
res = VMInit(vm, size, ArenaGrainSize(arena), vmArena->vmParams);
if (res != ResOK)
goto failVMInit;
base = VMBase(vm);
limit = VMLimit(vm);
res = BootBlockInit(boot, (void *)base, (void *)limit);
if (res != ResOK)
goto failBootInit;
/* Allocate and map the descriptor. */
/* See <design/arena/>.@@@@ */
res = BootAlloc(&p, boot, sizeof(VMChunkStruct), MPS_PF_ALIGN);
if (res != ResOK)
goto failChunkAlloc;
vmChunk = p;
/* Calculate the limit of the grain where the chunkStruct resides. */
chunkStructLimit = AddrAlignUp((Addr)(vmChunk + 1), ArenaGrainSize(arena));
res = vmArenaMap(vmArena, vm, base, chunkStructLimit);
if (res != ResOK)
goto failChunkMap;
vmChunk->overheadMappedLimit = chunkStructLimit;
/* Copy VM descriptor into its place in the chunk. */
VMCopy(VMChunkVM(vmChunk), vm);
res = ChunkInit(VMChunk2Chunk(vmChunk), arena, base, limit,
VMReserved(VMChunkVM(vmChunk)), boot);
if (res != ResOK)
goto failChunkInit;
BootBlockFinish(boot);
vmChunk->sig = VMChunkSig;
AVERT(VMChunk, vmChunk);
*chunkReturn = VMChunk2Chunk(vmChunk);
return ResOK;
failChunkInit:
VMUnmap(vm, VMBase(vm), chunkStructLimit);
failChunkMap:
failChunkAlloc:
failBootInit:
VMFinish(vm);
failVMInit:
return res;
}
