mpw/toolbox/mm.cpp

1163 lines
20 KiB
C++
Raw Normal View History

2013-02-08 03:12:30 +00:00
#include "mm.h"
2013-02-16 23:51:28 +00:00
#include "toolbox.h"
2013-02-08 03:12:30 +00:00
#include <cpu/defs.h>
#include <cpu/CpuModule.h>
#include <cpu/fmem.h>
#include <string>
2013-02-08 03:49:20 +00:00
#include <deque>
#include <vector>
#include <map>
2013-02-08 03:12:30 +00:00
#include <mplite/mplite.h>
2013-05-13 02:36:22 +00:00
#include <macos/sysequ.h>
2013-05-19 01:44:02 +00:00
#include <macos/errors.h>
2013-02-08 03:12:30 +00:00
2013-02-16 23:51:28 +00:00
using ToolBox::Log;
2013-02-08 03:12:30 +00:00
namespace
{
mplite_t pool;
2013-02-08 03:49:20 +00:00
uint8_t *Memory;
uint32_t MemorySize;
// queue of free Handles
std::deque<uint32_t> HandleQueue;
// map of ptr -> size
std::map<uint32_t, uint32_t> PtrMap;
2013-02-15 04:08:56 +00:00
struct HandleInfo
{
uint32_t address;
uint32_t size;
2013-02-26 23:31:43 +00:00
bool locked;
bool purgeable;
2013-02-15 04:08:56 +00:00
HandleInfo(uint32_t a = 0, uint32_t s = 0) :
2013-02-26 23:31:43 +00:00
address(a), size(s), locked(false), purgeable(false)
2013-02-15 04:08:56 +00:00
{}
};
2013-02-08 03:49:20 +00:00
// map of handle -> size [? just use Ptr map?]
2013-02-15 04:08:56 +00:00
std::map<uint32_t, HandleInfo> HandleMap;
2013-02-08 03:49:20 +00:00
2013-02-08 04:45:29 +00:00
inline uint16_t SetMemError(uint16_t error)
{
2013-05-13 02:36:22 +00:00
memoryWriteWord(error, MacOS::MemErr);
2013-02-08 04:45:29 +00:00
return error;
}
2013-02-08 03:49:20 +00:00
bool alloc_handle_block()
{
2013-02-18 02:54:45 +00:00
const unsigned HandleCount = 128; // 512 bytes of handle blocks.
2013-02-08 03:49:20 +00:00
uint8_t *block = (uint8_t *)mplite_malloc(&pool,
sizeof(uint32_t) * HandleCount);
if (!block) return false;
uint32_t hh = block - Memory;
uint32_t end = hh + 128 * sizeof(uint32_t);
for ( ; hh < end; hh += sizeof(uint32_t))
{
HandleQueue.push_back(hh);
}
return true;
}
2013-02-08 03:12:30 +00:00
}
namespace MM
{
2013-02-18 02:54:45 +00:00
bool Init(uint8_t *memory, uint32_t memorySize, uint32_t reserved)
{
int ok;
Memory = memory;
MemorySize = memorySize;
ok = mplite_init(&pool,
memory + reserved,
memorySize - reserved,
32,
NULL);
if (ok != MPLITE_OK) return false;
// allocate a handle master block...
if (!alloc_handle_block()) return false;
return true;
}
namespace Native {
2013-02-18 02:54:45 +00:00
2013-07-05 17:56:06 +00:00
// debugger support.
// print info on an address.
void MemoryInfo(uint32_t address)
{
// 1. check if it's a pointer.
{
auto iter = PtrMap.find(address);
if (iter != PtrMap.end())
{
printf("Pointer $%08x Size: $%08x\n", iter->first, iter->second);
return;
}
}
// 2. check if it's contained in a pointer
for (const auto kv : PtrMap)
{
if (address < kv.first) continue;
if (address >= kv.first + kv.second) continue;
printf("Pointer $%08x Size: $%08x\n", kv.first, kv.second);
return;
}
// 2. check if it's a handle.
{
auto iter = HandleMap.find(address);
if (iter != HandleMap.end())
{
const HandleInfo &info = iter->second;
printf("Handle $%08x Pointer: $%08x Size: $%08x Flags: %c %c\n",
iter->first,
info.address,
info.size,
info.locked ? 'L' : ' ',
info.purgeable ? 'P' : ' '
);
return;
}
}
// 3. check if the address is within a handle.
{
for (const auto kv : HandleMap)
{
const HandleInfo &info = kv.second;
if (!info.address) continue;
uint32_t begin = info.address;
uint32_t end = info.address + info.size;
if (!info.size) end++;
if (address >= begin && address < end)
{
printf("Handle $%08x Pointer: $%08x Size: $%08x Flags: %c %c\n",
kv.first,
info.address,
info.size,
info.locked ? 'L' : ' ',
info.purgeable ? 'P' : ' '
);
return;
}
}
}
}
2013-02-18 02:54:45 +00:00
void PrintMemoryStats()
{
mplite_print_stats(&pool, std::puts);
2013-06-27 02:48:40 +00:00
for (const auto & kv : HandleMap)
{
const auto h = kv.first;
const auto & info = kv.second;
fprintf(stdout, "%08x %08x %08x %c %c\n",
h, info.address, info.size,
info.locked? 'L' : ' ', info.purgeable? 'P' : ' ');
}
2013-02-18 02:54:45 +00:00
}
2013-02-17 20:07:32 +00:00
uint16_t NewPtr(uint32_t size, bool clear, uint32_t &mcptr)
{
// native pointers.
mcptr = 0;
if (size == 0) return 0;
uint8_t *ptr = nullptr;
ptr = (uint8_t *)mplite_malloc(&pool, size);
if (!ptr)
{
2013-05-19 01:44:02 +00:00
return SetMemError(MacOS::memFullErr);
}
2013-02-17 20:07:32 +00:00
if (clear)
std::memset(ptr, 0, size);
mcptr = ptr - Memory;
PtrMap.emplace(std::make_pair(mcptr, size));
return SetMemError(0);
}
uint16_t DisposePtr(uint32_t mcptr)
{
auto iter = PtrMap.find(mcptr);
2013-05-19 01:44:02 +00:00
if (iter == PtrMap.end()) return SetMemError(MacOS::memWZErr);
PtrMap.erase(iter);
uint8_t *ptr = mcptr + Memory;
mplite_free(&pool, ptr);
return SetMemError(0);
}
uint16_t NewHandle(uint32_t size, bool clear, uint32_t &handle, uint32_t &mcptr)
{
uint8_t *ptr;
uint32_t hh;
handle = 0;
mcptr = 0;
if (!HandleQueue.size())
{
if (!alloc_handle_block())
{
2013-05-19 01:44:02 +00:00
return SetMemError(MacOS::memFullErr);
}
}
hh = HandleQueue.front();
HandleQueue.pop_front();
ptr = nullptr;
if (size)
{
ptr = (uint8_t *)mplite_malloc(&pool, size);
if (!ptr)
{
HandleQueue.push_back(hh);
2013-05-19 01:44:02 +00:00
return SetMemError(MacOS::memFullErr);
}
mcptr = ptr - Memory;
if (clear)
std::memset(ptr, 0, size);
}
// need a handle -> ptr map?
HandleMap.emplace(std::make_pair(hh, HandleInfo(mcptr, size)));
memoryWriteLong(mcptr, hh);
handle = hh;
return SetMemError(0);
}
uint16_t NewHandle(uint32_t size, bool clear, uint32_t &handle)
{
uint32_t ptr;
return NewHandle(size, clear, handle, ptr);
}
uint16_t DisposeHandle(uint32_t handle)
{
auto iter = HandleMap.find(handle);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
HandleInfo info = iter->second;
HandleMap.erase(iter);
2013-06-27 02:48:20 +00:00
if (info.address)
{
uint8_t *ptr = info.address + Memory;
2013-06-27 02:48:20 +00:00
mplite_free(&pool, ptr);
}
HandleQueue.push_back(handle);
return SetMemError(0);
}
2013-06-27 02:50:30 +00:00
uint16_t GetHandleSize(uint32_t handle, uint32_t &handleSize)
{
handleSize = 0;
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
handleSize = iter->second.size;
return SetMemError(0);
}
}
2013-02-08 03:49:20 +00:00
2013-02-08 04:44:58 +00:00
uint16_t BlockMove(uint16_t trap)
{
/*
* on entry:
* A0 Pointer to source
* A1 Pointer to destination
* D0 Number of bytes to copy
*
* on exit:
* A0 Address of the new block or NIL
* D0 Result code
*
*/
uint32_t source = cpuGetAReg(0);
uint32_t dest = cpuGetAReg(1);
uint32_t count = cpuGetDReg(0);
2013-02-16 23:51:28 +00:00
Log("%04x BlockMove(%08x, %08x, %08x)\n",
2013-02-08 04:44:58 +00:00
trap, source, dest, count);
// TODO -- 32-bit clean?
// TODO -- verify within MemorySize?
#if 0
if (source == 0 || dest == 0 || count == 0)
return 0;
#endif
std::memmove(Memory + dest, Memory + source, count);
return 0;
}
2013-02-15 05:08:22 +00:00
uint32_t CompactMem(uint16_t trap)
{
// todo -- add function to check pool for largest block?
/*
* on entry:
* D0: cbNeeded (long word)
*
* on exit:
* D0: function result (long word)
*
*/
uint32_t cbNeeded = cpuGetDReg(0);
2013-02-16 23:51:28 +00:00
Log("%04x CompactMem(%08x)\n", trap, cbNeeded);
2013-02-16 01:33:00 +00:00
2013-03-30 22:45:20 +00:00
2013-04-01 03:49:59 +00:00
SetMemError(0);
2013-03-30 22:45:20 +00:00
return mplite_maxmem(&pool);
}
uint32_t MaxMem(uint16_t trap)
{
// return largest contiguous free block size.
/*
* on entry:
* (nothing)
*
* on exit:
* D0: function result (long word)
*
*/
Log("%04x MaxMem()\n", trap);
2013-04-01 03:49:59 +00:00
SetMemError(0);
2013-03-30 22:45:20 +00:00
return mplite_maxmem(&pool);
2013-02-15 05:08:22 +00:00
}
2013-05-17 23:05:03 +00:00
uint32_t MaxBlock(uint16_t trap)
{
/*
* The MaxBlock function returns the maximum contiguous space, in bytes, that you
* could obtain after compacting the current heap zone. MaxBlock does not actually
* do the compaction.
*/
/*
* on entry:
* (nothing)
*
* on exit:
* D0: function result (long word)
*
*/
Log("%04x MaxBlock()\n", trap);
SetMemError(0);
return mplite_maxmem(&pool);
}
2013-03-30 22:45:20 +00:00
uint32_t FreeMem(uint16_t trap)
{
// total free memory.
/*
* on entry:
* (nothing)
*
* on exit:
* D0: function result (long word)
*
*/
Log("%04x FreeMem()\n", trap);
2013-04-01 03:49:59 +00:00
SetMemError(0);
2013-03-30 22:45:20 +00:00
return mplite_freemem(&pool);
}
2013-05-17 23:05:03 +00:00
2013-04-01 03:49:59 +00:00
uint16_t ReserveMem(uint16_t trap)
{
/*
* on entry:
* D0: cbNeeded (long word)
*
* on exit:
* D0: Result code.
*
*/
uint32_t cbNeeded = cpuGetDReg(0);
uint32_t available;
Log("%04x ReserveMem($%08x)\n", trap, cbNeeded);
available = mplite_maxmem(&pool);
// TODO -- if available < cbNeeded, purge handle and retry?
2013-05-19 01:44:02 +00:00
if (available < cbNeeded) return SetMemError(MacOS::memFullErr);
2013-04-01 03:49:59 +00:00
return SetMemError(0);
}
2013-03-30 22:45:20 +00:00
2013-02-19 23:28:29 +00:00
uint16_t MoveHHi(uint16_t trap)
{
/*
* on entry:
* A0: Handle to move
*
* on exit:
* D0: Result code.
*
*/
uint32_t theHandle = cpuGetAReg(0);
Log("%04x MoveHHi(%08x)\n", trap, theHandle);
// check if it's valid.
auto iter = HandleMap.find(theHandle);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
2013-02-19 23:28:29 +00:00
return SetMemError(0);
}
2013-02-15 05:08:22 +00:00
2013-06-27 02:50:53 +00:00
uint32_t StackSpace(uint16_t trap)
{
/*
* on entry:
*
* on exit:
* D0: Number of bytes between stack and heap
*
*/
uint32_t sp = cpuGetAReg(7);
2013-06-28 00:28:20 +00:00
Log("%04x StackSpace(%08x)\n", trap);
2013-06-27 02:50:53 +00:00
SetMemError(0);
// find the pointer base...
2013-06-28 00:28:20 +00:00
// todo -- call lower bound, then iter-- ?
2013-06-27 02:50:53 +00:00
for (const auto & iter : PtrMap)
{
if (sp >= iter.first && sp < iter.first + iter.second)
{
return sp - iter.first;
}
}
return 0;
}
2013-02-16 20:37:55 +00:00
#pragma mark Pointers
2013-02-16 20:37:55 +00:00
uint16_t NewPtr(uint16_t trap)
2013-02-11 01:19:11 +00:00
{
/*
* on entry:
2013-02-16 20:37:55 +00:00
* D0 Number of logical bytes requested
2013-02-11 01:19:11 +00:00
*
* on exit:
2013-02-16 20:37:55 +00:00
* A0 Address of the new block or NIL
2013-02-11 01:19:11 +00:00
* D0 Result code
*
*/
2013-02-16 20:37:55 +00:00
bool clear = trap & (1 << 9);
//bool sys = trap & (1 << 10);
2013-02-11 01:19:11 +00:00
2013-02-16 20:37:55 +00:00
uint32_t size = cpuGetDReg(0);
2013-02-11 01:19:11 +00:00
2013-02-16 23:51:28 +00:00
Log("%04x NewPtr(%08x)\n", trap, size);
2013-02-11 01:19:11 +00:00
2013-02-16 20:37:55 +00:00
// todo -- separate pools for sys vs non-sys?
// todo -- NewPtr(0) -- null or empty ptr?
2013-02-11 01:19:11 +00:00
uint32_t mcptr;
uint16_t error;
2013-02-17 20:07:32 +00:00
error = Native::NewPtr(size, clear, mcptr);
2013-02-11 01:19:11 +00:00
2013-02-16 20:37:55 +00:00
cpuSetAReg(0, mcptr);
return error; //SetMemError(error);
2013-02-15 04:08:56 +00:00
}
2013-02-16 20:37:55 +00:00
uint16_t DisposePtr(uint16_t trap)
2013-02-15 04:08:56 +00:00
{
/*
* on entry:
2013-02-16 20:37:55 +00:00
* A0 Pointer to the nonrelocatable block to be disposed of
2013-02-15 04:08:56 +00:00
*
* on exit:
* D0 Result code
*
*/
2013-02-16 20:37:55 +00:00
uint32_t mcptr = cpuGetAReg(0);
2013-02-15 04:08:56 +00:00
2013-02-16 23:51:28 +00:00
Log("%04x DisposePtr(%08x)\n", trap, mcptr);
2013-02-15 04:08:56 +00:00
uint16_t error;
error = Native::DisposePtr(mcptr);
2013-02-15 04:08:56 +00:00
return error; //SetMemError(error);
2013-02-11 01:19:11 +00:00
}
2013-02-16 20:37:55 +00:00
uint32_t GetPtrSize(uint16_t trap)
2013-02-08 03:12:30 +00:00
{
2013-02-08 04:44:58 +00:00
/*
* on entry:
2013-02-16 20:37:55 +00:00
* A0 pointer
2013-02-08 04:44:58 +00:00
*
2013-02-08 03:12:30 +00:00
* on exit:
2013-02-16 20:37:55 +00:00
* D0 size (32-bit) or error code
2013-02-08 04:44:58 +00:00
*
2013-02-08 03:12:30 +00:00
*/
2013-02-16 20:37:55 +00:00
uint32_t mcptr = cpuGetAReg(0);
2013-02-08 03:49:20 +00:00
2013-02-26 23:32:39 +00:00
Log("%08x GetPtrSize(%08x)\n", trap, mcptr);
2013-02-08 03:49:20 +00:00
2013-02-16 20:37:55 +00:00
auto iter = PtrMap.find(mcptr);
2013-02-08 03:49:20 +00:00
2013-05-19 01:44:02 +00:00
if (iter == PtrMap.end()) return SetMemError(MacOS::memWZErr);
2013-02-08 03:49:20 +00:00
2013-02-16 20:37:55 +00:00
return iter->second;
2013-02-08 03:12:30 +00:00
}
2013-02-16 01:33:00 +00:00
uint16_t SetPtrSize(uint16_t trap)
{
/*
* on entry:
* A0 pointer
* D0 new size
*
* on exit:
* D0 Result code
*
*/
uint32_t mcptr = cpuGetAReg(0);
uint32_t newSize = cpuGetDReg(0);
2013-02-16 23:51:28 +00:00
Log("%08x SetPtrSize(%08x, %08x)\n", trap, mcptr, newSize);
2013-02-16 01:33:00 +00:00
auto iter = PtrMap.find(mcptr);
2013-05-19 01:44:02 +00:00
if (iter == PtrMap.end()) return SetMemError(MacOS::memWZErr);
2013-02-16 01:33:00 +00:00
uint8_t *ptr = mcptr + Memory;
if (mplite_resize(&pool, ptr, newSize) < 0)
{
2013-05-19 01:44:02 +00:00
return SetMemError(MacOS::memFullErr);
2013-02-16 01:33:00 +00:00
}
2013-02-16 20:37:55 +00:00
// update the size.
iter->second = newSize;
2013-02-16 01:33:00 +00:00
return SetMemError(0);
}
2013-02-16 20:37:55 +00:00
#pragma mark Handles
2013-02-15 04:08:56 +00:00
uint16_t NewHandle(uint16_t trap)
{
/*
* on entry:
* D0 Number of logical bytes requested
*
* on exit:
* A0 Address of the new handle or NIL
* D0 Result code
*
*/
uint32_t hh = 0;
uint16_t error;
2013-02-15 04:08:56 +00:00
bool clear = trap & (1 << 9);
//bool sys = trap & (1 << 10);
uint32_t size = cpuGetDReg(0);
2013-02-16 23:51:28 +00:00
Log("%04x NewHandle(%08x)\n", trap, size);
2013-02-15 04:08:56 +00:00
error = Native::NewHandle(size, clear, hh);
2013-02-15 04:08:56 +00:00
cpuSetAReg(0, hh);
return error;
2013-02-15 04:08:56 +00:00
}
2013-02-16 20:37:55 +00:00
uint16_t DisposeHandle(uint16_t trap)
{
/*
* on entry:
* A0 Handle to be disposed of
*
* on exit:
* D0 Result code
*
*/
uint32_t hh = cpuGetAReg(0);
2013-02-16 23:51:28 +00:00
Log("%04x DisposeHandle(%08x)\n", trap, hh);
2013-02-16 20:37:55 +00:00
return Native::DisposeHandle(hh);
2013-02-16 20:37:55 +00:00
}
2013-03-04 02:54:53 +00:00
uint16_t EmptyHandle(uint16_t trap)
{
/*
* on entry:
* A0 Handle to be disposed of
*
* on exit:
* D0 Result code
*
*/
uint32_t hh = cpuGetAReg(0);
Log("%04x EmptyHandle(%08x)\n", trap, hh);
auto iter = HandleMap.find(hh);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
2013-03-04 02:54:53 +00:00
auto &info = iter->second;
if (info.address == 0) return SetMemError(0);
2013-05-19 01:44:02 +00:00
if (info.locked) return SetMemError(MacOS::memLockedErr); // ?
2013-03-04 02:54:53 +00:00
void *address = Memory + info.address;
mplite_free(&pool, address);
info.address = 0;
info.size = 0;
memoryWriteLong(0, hh);
return 0;
}
/*
* ReallocHandle (h: Handle; logicalSize: Size);
*
* ReallocHandle allocates a new relocatable block with a logical
* size of logicalSize bytes. It then updates handle h by setting
* its master pointer to point to the new block. The main use of
* this procedure is to reallocate space for a block that has
* been purged. Normally h is an empty handle, but it need not
* be: If it points to an existing block, that block is released
* before the new block is created.
*
* In case of an error, no new block is allocated and handle h is
* left unchanged.
*/
uint16_t ReallocHandle(uint16_t trap)
{
/*
* on entry:
* A0 Handle to be disposed of
* D0 Logical Size
*
* on exit:
* D0 Result code
*
*/
uint32_t hh = cpuGetAReg(0);
uint32_t logicalSize = cpuGetDReg(0);
Log("%04x ReallocHandle(%08x, %08x)\n", trap, hh, logicalSize);
auto iter = HandleMap.find(hh);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
2013-03-04 02:54:53 +00:00
auto& info = iter->second;
2013-05-19 01:44:02 +00:00
if (info.locked) return SetMemError(MacOS::memLockedErr);
2013-03-04 02:54:53 +00:00
if (info.address)
{
void *address = Memory + info.address;
mplite_free(&pool, address);
info.address = 0;
info.size = 0;
memoryWriteLong(0, hh);
}
// allocate a new block...
if (logicalSize == 0) return SetMemError(0);
void *address = mplite_malloc(&pool, logicalSize);
2013-05-19 01:44:02 +00:00
if (!address) return SetMemError(MacOS::memFullErr);
2013-03-04 02:54:53 +00:00
uint32_t mcptr = (uint8_t *)address - Memory;
info.size = logicalSize;
info.address = mcptr;
memoryWriteLong(mcptr, hh);
// lock? clear purged flag?
return 0;
}
2013-02-25 04:20:38 +00:00
uint32_t GetHandleSize(uint16_t trap)
{
/*
* on entry:
* A0 handle
*
* on exit:
* D0 size (32-bit) or error code
*
*/
uint32_t hh = cpuGetAReg(0);
2013-02-26 23:32:39 +00:00
Log("%08x GetHandleSize(%08x)\n", trap, hh);
2013-02-25 04:20:38 +00:00
auto iter = HandleMap.find(hh);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
2013-02-25 04:20:38 +00:00
return iter->second.size;
}
2013-02-26 23:31:43 +00:00
uint16_t SetHandleSize(uint16_t trap)
{
/*
* on entry:
* A0 pointer
* D0 new size
*
* on exit:
* D0 Result code
*
*/
uint32_t hh = cpuGetAReg(0);
uint32_t newSize = cpuGetDReg(0);
2013-06-27 02:49:27 +00:00
Log("%04x SetHandleSize(%08x, %08x)\n", trap, hh, newSize);
2013-02-26 23:31:43 +00:00
auto iter = HandleMap.find(hh);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
2013-02-26 23:31:43 +00:00
// todo -- if handle ptr is null, other logic?
// todo -- if locked, can't move.
auto &info = iter->second;
// 0 - no change in size.
if (info.size == newSize) return SetMemError(0);
uint32_t mcptr = info.address;
uint8_t *ptr = mcptr + Memory;
// 1. - resizing to 0.
if (!newSize)
{
2013-05-19 01:44:02 +00:00
if (info.locked) return SetMemError(MacOS::memLockedErr);
2013-02-26 23:31:43 +00:00
mplite_free(&pool, ptr);
info.address = 0;
info.size = 0;
2013-06-27 03:23:22 +00:00
memoryWriteLong(info.address, hh);
2013-02-26 23:31:43 +00:00
return SetMemError(0);
}
// 2. - resizing from 0.
2013-06-27 03:23:22 +00:00
if (!mcptr)
2013-02-26 23:31:43 +00:00
{
2013-06-27 03:23:22 +00:00
if (info.locked) return SetMemError(MacOS::memLockedErr);
2013-02-26 23:31:43 +00:00
ptr = (uint8_t *)mplite_malloc(&pool, newSize);
2013-05-19 01:44:02 +00:00
if (!ptr) return SetMemError(MacOS::memFullErr);
2013-02-26 23:31:43 +00:00
mcptr = ptr - Memory;
info.address = mcptr;
info.size = newSize;
2013-06-27 03:23:22 +00:00
memoryWriteLong(info.address, hh);
2013-02-26 23:31:43 +00:00
return SetMemError(0);
}
2013-06-27 02:49:27 +00:00
for (unsigned i = 0; i < 2; ++i)
2013-02-26 23:31:43 +00:00
{
2013-06-27 02:49:27 +00:00
// 3. - locked
if (info.locked)
2013-02-26 23:31:43 +00:00
{
2013-06-27 03:23:22 +00:00
if (mplite_resize(&pool, ptr, mplite_roundup(&pool, newSize)) == MPLITE_OK)
2013-06-27 02:49:27 +00:00
{
info.size = newSize;
return SetMemError(0);
}
2013-02-26 23:31:43 +00:00
}
2013-06-27 02:49:27 +00:00
else
{
2013-02-26 23:31:43 +00:00
2013-06-27 02:49:27 +00:00
// 4. - resize.
2013-02-26 23:31:43 +00:00
2013-06-27 03:23:22 +00:00
ptr = (uint8_t *)mplite_realloc(&pool, ptr, mplite_roundup(&pool, newSize));
2013-02-26 23:31:43 +00:00
2013-06-27 02:49:27 +00:00
if (ptr)
{
mcptr = ptr - Memory;
info.address = mcptr;
info.size = newSize;
2013-02-26 23:31:43 +00:00
2013-06-27 03:23:22 +00:00
memoryWriteLong(info.address, hh);
2013-06-27 02:49:27 +00:00
return SetMemError(0);
}
}
fprintf(stderr, "mplite_realloc failed.\n");
Native::PrintMemoryStats();
if (i > 0) return SetMemError(MacOS::memFullErr);
// purge...
for (auto & kv : HandleMap)
{
uint32_t handle = kv.first;
auto &info = kv.second;
if (handle == hh) continue;
if (info.size && info.purgeable && !info.locked)
{
mplite_free(&pool, Memory + info.address);
info.size = 0;
info.address = 0;
2013-02-26 23:31:43 +00:00
2013-06-27 02:49:27 +00:00
// also need to update memory
memoryWriteLong(0, handle);
}
}
}
2013-02-26 23:31:43 +00:00
2013-06-27 02:49:27 +00:00
return SetMemError(MacOS::memFullErr);
2013-02-26 23:31:43 +00:00
}
2013-02-25 04:20:38 +00:00
2013-02-16 20:37:55 +00:00
#pragma mark Handle attributes
// these are all nops for now.
2013-02-25 04:20:38 +00:00
uint16_t HPurge(uint16_t trap)
{
/*
* on entry:
* A0 Handle
*
* on exit:
* D0 Result code
*
*/
uint32_t hh = cpuGetAReg(0);
Log("%04x HPurge(%08x)\n", trap, hh);
auto iter = HandleMap.find(hh);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
2013-02-26 23:31:43 +00:00
iter->second.purgeable = true;
2013-02-25 04:20:38 +00:00
2013-06-30 17:10:41 +00:00
return SetMemError(0);
2013-02-25 04:20:38 +00:00
}
2013-02-16 20:37:55 +00:00
uint16_t HLock(uint16_t trap)
{
/*
* on entry:
* A0 Handle
*
* on exit:
* D0 Result code
*
*/
uint32_t hh = cpuGetAReg(0);
2013-02-16 23:51:28 +00:00
Log("%04x HLock(%08x)\n", trap, hh);
2013-02-16 20:37:55 +00:00
auto iter = HandleMap.find(hh);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
2013-02-16 20:37:55 +00:00
2013-02-26 23:31:43 +00:00
iter->second.locked = true;
2013-06-30 17:10:41 +00:00
return SetMemError(0);
2013-02-16 20:37:55 +00:00
}
uint16_t HUnlock(uint16_t trap)
{
/*
* on entry:
* A0 Handle
*
* on exit:
* D0 Result code
*
*/
uint32_t hh = cpuGetAReg(0);
2013-02-16 23:51:28 +00:00
Log("%04x HUnlock(%08x)\n", trap, hh);
2013-02-15 04:08:56 +00:00
2013-02-16 20:37:55 +00:00
auto iter = HandleMap.find(hh);
2013-05-19 01:44:02 +00:00
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
2013-02-16 20:37:55 +00:00
2013-02-26 23:31:43 +00:00
iter->second.locked = false;
2013-06-30 17:10:41 +00:00
return SetMemError(0);
2013-02-16 20:37:55 +00:00
}
2013-02-08 03:12:30 +00:00
2013-02-26 23:32:39 +00:00
#pragma mark - OS Utility Routines
2013-07-13 23:19:49 +00:00
uint16_t HandToHand(uint16_t trap)
{
/*
* on entry:
* A0 source Handle
*
* on exit:
* A0 destination Handle
* D0 Result code
*
*/
uint32_t srcHandle = cpuGetAReg(0);
Log("%04x HandToHand(%08x)\n", trap, srcHandle);
auto iter = HandleMap.find(srcHandle);
if (iter == HandleMap.end())
return SetMemError(MacOS::memWZErr);
auto const info = iter->second;
uint32_t destHandle;
uint32_t destPtr;
uint32_t d0 = Native::NewHandle(info.size, false, destHandle, destPtr);
if (d0 == 0)
{
std::memmove(memoryPointer(destPtr), memoryPointer(info.address), info.size);
}
cpuSetAReg(0, destHandle);
return d0; // SetMemError called by Native::NewHandle.
}
2013-02-26 23:32:39 +00:00
uint16_t PtrToHand(uint16_t trap)
{
/*
* on entry:
* A0 source Pointer
* D0 size
*
* on exit:
* A0 destination pointer
* D0 Result code
*
*/
uint32_t mcptr = cpuGetAReg(0);
uint32_t size = cpuGetDReg(0);
Log("%04x PtrToHand(%08x, %08x)\n", trap, mcptr, size);
uint32_t destHandle;
uint32_t destPtr;
uint32_t d0 = Native::NewHandle(size, false, destHandle, destPtr);
if (d0 == 0)
{
std::memmove(memoryPointer(destPtr), memoryPointer(mcptr), size);
}
cpuSetAReg(0, destHandle);
2013-06-30 17:10:41 +00:00
return d0; // SetMemError called by Native::NewHandle.
2013-02-26 23:32:39 +00:00
}
2013-02-25 22:33:26 +00:00
2013-07-13 23:19:49 +00:00
2013-02-25 22:33:26 +00:00
#pragma mark -
uint32_t StripAddress(uint16_t trap)
{
/*
* on entry:
* d0 Address to strip
*
* on exit:
* D0 Address that has been stripped.
*
*/
// TODO -- in 32-bit mode, this is a nop.
// have a --24 / --32 flag?
uint32_t address = cpuGetDReg(0);
Log("%04x StripAddress(%08x)\n", trap, address);
address &= 0x00ffffff;
return address;
}
2013-06-27 03:50:08 +00:00
#pragma mark - zone
2013-06-27 02:50:53 +00:00
uint16_t HandleZone(uint16_t trap)
{
// FUNCTION HandleZone (h: Handle): THz;
/*
* on entry:
* A0 Handle whose zone is to be found
*
* on exit:
* A0 Pointer to handles heap zone
* D0 Result code
*
*/
uint32_t h = cpuGetAReg(0);
Log("%04x HandleZone(%08x)\n", trap, h);
if (HandleMap.find(h) == HandleMap.end())
{
cpuSetAReg(0, 0);
return SetMemError(MacOS::memWZErr);
}
cpuSetAReg(0, 0);
return SetMemError(0);
}
2013-02-25 22:33:26 +00:00
2013-06-27 03:50:08 +00:00
uint16_t GetZone(uint16_t trap)
{
// FUNCTION GetZone: THz;
/*
* on entry:
*
* on exit:
* A0 Pointer to current heap zone
* D0 Result code
*/
Log("%04x GetZone()\n", trap);
cpuSetAReg(0, 0);
return 0;
}
uint16_t SetZone(uint16_t trap)
{
// PROCEDURE SetZone (hz: THz);
/*
* on entry:
* A0 Pointer to new current heap zone
*
* on exit:
* D0 Result code
*/
uint32_t THz = cpuGetAReg(0);
Log("%04x SetZone(%08x)\n", trap, THz);
return 0;
}
2013-02-08 03:12:30 +00:00
}