Bool TractCheck(Tract tract)
{
if (TractHasPool(tract)) {
CHECKU(Pool, TractPool(tract));
CHECKL(AddrIsArenaGrain(TractBase(tract), TractArena(tract)));
}
if (TractHasSeg(tract)) {
CHECKL(TraceSetCheck(TractWhite(tract)));
CHECKU(Seg, (Seg)TractP(tract));
} else {
CHECKL(TractWhite(tract) == TraceSetEMPTY);
}
return TRUE;
}
int main(void)
{
#ifndef GD_LEGACY_API
return 77; /* skip */
#else
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "data RAW UINT8 11\n";
int fd, error, r = 0;
unsigned int spf;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
spf = GetSamplesPerFrame(filedir, "data", &error);
unlink(format);
rmdir(filedir);
CHECKU(spf, 11);
return r;
#endif
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *data = "dirfile/data";
const char *format_data = "data RAW UINT8 1\n";
int fd, r = 0;
size_t n;
const size_t len = strlen(data);
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
fd = open(data, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, 0666);
write(fd, data, len);
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
n = gd_nframes64(D);
gd_close(D);
unlink(data);
unlink(format);
rmdir(filedir);
CHECKU(n, len);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
uint8_t val = 0;
int error, r = 0;
DIRFILE *D;
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);
gd_add_const(D, "data", GD_UINT8, GD_UINT8, &val, 0);
val = 23;
gd_put_constant(D, "data", GD_UINT8, &val);
error = gd_error(D);
gd_close(D);
/* check */
val = 0;
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
gd_get_constant(D, "data", GD_UINT8, &val);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKU(val, 23);
CHECKI(error,GD_E_OK);
return r;
}
Bool ThreadCheck(Thread thread)
{
CHECKS(Thread, thread);
CHECKU(Arena, thread->arena);
CHECKL(thread->serial < thread->arena->threadSerial);
CHECKL(RingCheck(&thread->arenaRing));
return TRUE;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format1 = "dirfile/format1";
const char *format2 = "dirfile/format2";
const char *format_data = "INCLUDE format1 pre post\n";
const char *format1_data = "INCLUDE format2 \"\" POST\n";
const char *format2_data = "data RAW UINT8 11\n";
int fd, r = 0;
DIRFILE *D;
unsigned int spf, spf1, spf2;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
fd = open(format1, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format1_data, strlen(format1_data));
close(fd);
fd = open(format2, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format2_data, strlen(format2_data));
close(fd);
D = gd_open(filedir, GD_RDONLY);
spf = gd_spf(D, "data");
spf1 = gd_spf(D, "predatapost");
spf2 = gd_spf(D, "predataPOSTpost");
gd_close(D);
unlink(format2);
unlink(format1);
unlink(format);
rmdir(filedir);
CHECKU(spf, 0);
CHECKU(spf1, 0);
CHECKU(spf2, 11);
return r;
}
Bool MessageCheck(Message message)
{
CHECKS(Message, message);
CHECKU(Arena, message->arena);
CHECKL(MessageTypeCheck(message->type));
CHECKU(MessageClass, message->class);
CHECKL(RingCheck(&message->queueRing));
return TRUE;
}
Bool ThreadCheck(Thread thread)
{
CHECKS(Thread, thread);
CHECKU(Arena, thread->arena);
CHECKL(thread->serial < thread->arena->threadSerial);
CHECKD_NOSIG(Ring, &thread->arenaRing);
CHECKL(BoolCheck(thread->alive));
CHECKD(PThreadext, &thread->thrextStruct);
return TRUE;
}
Bool ThreadCheck(Thread thread)
{
CHECKS(Thread, thread);
CHECKU(Arena, thread->arena);
CHECKL(thread->serial < thread->arena->threadSerial);
CHECKD_NOSIG(Ring, &thread->arenaRing);
CHECKL(BoolCheck(thread->alive));
CHECKL(BoolCheck(thread->forking));
CHECKL(MACH_PORT_VALID(thread->port));
return TRUE;
}
Bool MessageCheck(Message message)
{
CHECKS(Message, message);
CHECKU(Arena, message->arena);
CHECKD(MessageClass, message->class);
CHECKL(RingCheck(&message->queueRing));
/* postedClock is uncheckable for clocked message types, */
/* but must be 0 for unclocked message types: */
CHECKL(MessageIsClocked(message) || (message->postedClock == 0));
return TRUE;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *data = "dirfile/data";
const char *table = "dirfile/table";
const char *format_data = "linterp LINTERP data ./table\ndata RAW UINT8 1\n";
unsigned char c = 0;
unsigned char data_data[64];
int fd, i, n, error, r = 0;
DIRFILE *D;
FILE *t;
rmdirfile();
mkdir(filedir, 0777);
for (fd = 0; fd < 64; ++fd)
data_data[fd] = (unsigned char)fd;
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
fd = open(data, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, 0666);
write(fd, data_data, 64);
close(fd);
t = fopen(table, "wt");
for (i = 0; i < 10; ++i)
fprintf(t, "%i %i\n", i * 6, i * 12);
fclose(t);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
n = gd_getdata(D, "linterp", 5, 0, 1, 0, GD_UINT8, &c);
error = gd_error(D);
gd_close(D);
unlink(table);
unlink(data);
unlink(format);
rmdir(filedir);
CHECKI(error, 0);
CHECKI(n, 1);
CHECKU(c, 10);
return r;
}
ATTRIBUTE_UNUSED
static Bool SACCheck(SAC sac)
{
Index i, j;
Bool b;
Size prevSize;
mps_sac_t esac;
CHECKS(SAC, sac);
esac = ExternalSACOfSAC(sac);
CHECKU(Pool, sac->pool);
CHECKL(sac->classesCount > 0);
CHECKL(sac->classesCount > sac->middleIndex);
CHECKL(BoolCheck(esac->_trapped));
CHECKL(esac->_middle > 0);
/* check classes above middle */
prevSize = esac->_middle;
for (j = sac->middleIndex + 1, i = 0; j < sac->classesCount; ++j, i += 2) {
CHECKL(prevSize < esac->_freelists[i]._size);
b = sacFreeListBlockCheck(&(esac->_freelists[i]));
if (!b)
return b;
prevSize = esac->_freelists[i]._size;
}
/* check overlarge class */
CHECKL(prevSize < esac->_freelists[i]._size);
b = sacFreeListBlockCheck(&(esac->_freelists[i]));
if (!b)
return b;
CHECKL(esac->_freelists[i]._size == SizeMAX);
CHECKL(esac->_freelists[i]._count == 0);
CHECKL(esac->_freelists[i]._count_max == 0);
CHECKL(esac->_freelists[i]._blocks == NULL);
/* check classes below middle */
prevSize = esac->_middle;
for (j = sac->middleIndex, i = 1; j > 0; --j, i += 2) {
CHECKL(prevSize > esac->_freelists[i]._size);
b = sacFreeListBlockCheck(&(esac->_freelists[i]));
if (!b)
return b;
prevSize = esac->_freelists[i]._size;
}
/* check smallest class */
CHECKL(prevSize > esac->_freelists[i]._size);
CHECKL(esac->_freelists[i]._size == 0);
b = sacFreeListBlockCheck(&(esac->_freelists[i]));
return b;
}
static Bool EPVMSaveCheck(EPVMSave save)
{
CHECKS(EPVMSave, save);
CHECKU(EPVM, save->epvm);
CHECKL(save->level <= save->epvm->maxSaveLevel);
CHECKL(save->size <= PoolManagedSize(EPVM2Pool(save->epvm)));
if (save->level > save->epvm->saveLevel) /* nothing at this level */
CHECKL(save->size == 0);
CHECKL(SizeIsAligned(save->size,
ArenaAlign(PoolArena(EPVM2Pool(save->epvm)))));
CHECKL(BoolCheck(save->smallStringSeg));
CHECKL(BoolCheck(save->smallObjectSeg));
CHECKL(RingCheck(&save->segRing));
return TRUE;
}
Bool EPVMSegCheck(EPVMSeg epvmSeg)
{
Seg seg;
CHECKS(EPVMSeg, epvmSeg);
CHECKL(AMSSegCheck(&epvmSeg->amsSegStruct));
seg = EPVMSeg2Seg(epvmSeg);
CHECKU(EPVMSave, epvmSeg->save);
CHECKL(epvmSeg->save->size >= SegSize(seg));
/* buffers only on the current save level */
if (SegBuffer(seg) != NULL)
CHECKL(EPVMCurrentSave(EPVMSegEPVM(epvmSeg)) == epvmSeg->save);
/* See design.mps.poolepvm.protection.format and */
/* d.m.p.protection.hack. */
AVER(SegSummary(seg) == RefSetUNIV || SegSummary(seg) == RefSetEMPTY);
return TRUE;
}
Bool ChunkCheck(Chunk chunk)
{
CHECKS(Chunk, chunk);
CHECKU(Arena, chunk->arena);
CHECKL(chunk->serial < chunk->arena->chunkSerial);
/* Can't use CHECKD_NOSIG because TreeEMPTY is NULL. */
CHECKL(TreeCheck(&chunk->chunkTree));
CHECKL(ChunkPagesToSize(chunk, 1) == ChunkPageSize(chunk));
CHECKL(ShiftCheck(ChunkPageShift(chunk)));
CHECKL(chunk->base != (Addr)0);
CHECKL(chunk->base < chunk->limit);
/* check chunk structure is at its own base: see .chunk.at.base. */
CHECKL(chunk->base == (Addr)chunk);
CHECKL((Addr)(chunk+1) <= chunk->limit);
CHECKL(ChunkSizeToPages(chunk, ChunkSize(chunk)) == chunk->pages);
/* check that the tables fit in the chunk */
CHECKL(chunk->allocBase <= chunk->pages);
CHECKL(chunk->allocBase >= chunk->pageTablePages);
CHECKD_NOSIG(BT, chunk->allocTable);
/* check that allocTable is in the chunk overhead */
CHECKL((Addr)chunk->allocTable >= chunk->base);
CHECKL(AddrAdd((Addr)chunk->allocTable, BTSize(chunk->pages))
<= PageIndexBase(chunk, chunk->allocBase));
/* check they don't overlap (knowing the order) */
CHECKL(AddrAdd((Addr)chunk->allocTable, BTSize(chunk->pages))
<= (Addr)chunk->pageTable);
CHECKL(chunk->pageTable != NULL);
CHECKL((Addr)chunk->pageTable >= chunk->base);
CHECKL((Addr)&chunk->pageTable[chunk->pageTablePages]
<= PageIndexBase(chunk, chunk->allocBase));
CHECKL(NONNEGATIVE(INDEX_OF_ADDR(chunk, (Addr)chunk->pageTable)));
/* check there's enough space in the page table */
CHECKL(INDEX_OF_ADDR(chunk, AddrSub(chunk->limit, 1)) < chunk->pages);
CHECKL(chunk->pageTablePages < chunk->pages);
/* Could check the consistency of the tables, but not O(1). */
return TRUE;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data =
"raw1 RAW UINT8 1\n"
"META raw1 linterp1 LINTERP raw2 table\n"
"META raw1 linterp2 LINTERP raw3 table\n"
"META raw1 linterp3 LINTERP raw4 table\n"
"META raw1 const CONST UINT8 1\n"
"META raw1 string STRING value\n"
"META raw1 string2 STRING value\n"
"raw2 RAW UINT8 1\n"
"raw3 RAW UINT8 1\n"
"raw4 RAW UINT8 1\n"
"const CONST UINT8 1\n"
"string STRING value\n"
"string2 STRING value\n";
int fd, error, r = 0;
unsigned int nfields;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
nfields = gd_nmvectors(D, "raw1");
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, 0);
CHECKU(nfields, 3);
return r;
}
Bool FormatCheck(Format format)
{
CHECKS(Format, format);
CHECKU(Arena, format->arena);
CHECKL(format->serial < format->arena->formatSerial);
CHECKD_NOSIG(Ring, &format->arenaRing);
CHECKL(AlignCheck(format->alignment));
/* TODO: Define the concept of the maximum alignment it is possible to
request from the MPS, document and provide an interface to it, and then
check that this alignment is not greater than that, as well as all other
alignments. */
CHECKL(FUNCHECK(format->scan));
CHECKL(FUNCHECK(format->skip));
CHECKL(FUNCHECK(format->move));
CHECKL(FUNCHECK(format->isMoved));
CHECKL(FUNCHECK(format->pad));
CHECKL(FUNCHECK(format->class));
return TRUE;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *data = "dirfile/data";
const char *format_data = "FRAMEOFFSET 1\ndata RAW UINT8 1\n";
unsigned char c;
unsigned char data_data[256];
int fd, n, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
for (fd = 0; fd < 256; ++fd)
data_data[fd] = (unsigned char)fd;
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
fd = open(data, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, 0666);
write(fd, data_data, 256);
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
n = gd_getdata(D, "data", 5, 0, 1, 0, GD_UINT8, &c);
error = gd_error(D);
gd_close(D);
unlink(data);
unlink(format);
rmdir(filedir);
CHECKI(error, 0);
CHECKI(n, 1);
CHECKU(c, 4);
return r;
}
Bool PoolCheck(Pool pool)
{
PoolClass klass;
/* Checks ordered as per struct decl in <code/mpmst.h#pool> */
CHECKS(Pool, pool);
CHECKC(AbstractPool, pool);
/* Break modularity for checking efficiency */
CHECKL(pool->serial < ArenaGlobals(pool->arena)->poolSerial);
klass = ClassOfPoly(Pool, pool);
CHECKD(PoolClass, klass);
CHECKU(Arena, pool->arena);
CHECKD_NOSIG(Ring, &pool->arenaRing);
CHECKD_NOSIG(Ring, &pool->bufferRing);
/* Cannot check pool->bufferSerial */
CHECKD_NOSIG(Ring, &pool->segRing);
CHECKL(AlignCheck(pool->alignment));
/* Normally pool->format iff PoolHasAttr(pool, AttrFMT), but during
pool initialization the class may not yet be set. */
CHECKL(!PoolHasAttr(pool, AttrFMT) || pool->format != NULL);
return TRUE;
}
Bool BufferCheck(Buffer buffer)
{
CHECKS(Buffer, buffer);
CHECKC(Buffer, buffer);
CHECKL(buffer->serial < buffer->pool->bufferSerial); /* .trans.mod */
CHECKU(Arena, buffer->arena);
CHECKU(Pool, buffer->pool);
CHECKL(buffer->arena == buffer->pool->arena);
CHECKD_NOSIG(Ring, &buffer->poolRing);
CHECKL(BoolCheck(buffer->isMutator));
CHECKL(buffer->fillSize >= 0.0);
CHECKL(buffer->emptySize >= 0.0);
CHECKL(buffer->emptySize <= buffer->fillSize);
CHECKL(buffer->alignment == buffer->pool->alignment);
CHECKL(AlignCheck(buffer->alignment));
/* If any of the buffer's fields indicate that it is reset, make */
/* sure it is really reset. Otherwise, check various properties */
/* of the non-reset fields. */
if (buffer->mode & BufferModeTRANSITION) {
/* nothing to check */
} else if ((buffer->mode & BufferModeATTACHED) == 0
|| buffer->base == (Addr)0
|| buffer->ap_s.init == (Addr)0
|| buffer->ap_s.alloc == (Addr)0
|| buffer->poolLimit == (Addr)0) {
CHECKL((buffer->mode & BufferModeATTACHED) == 0);
CHECKL(buffer->base == (Addr)0);
CHECKL(buffer->initAtFlip == (Addr)0);
CHECKL(buffer->ap_s.init == (Addr)0);
CHECKL(buffer->ap_s.alloc == (Addr)0);
CHECKL(buffer->ap_s.limit == (Addr)0);
/* Nothing reliable to check for lightweight frame state */
CHECKL(buffer->poolLimit == (Addr)0);
} else {
/* The buffer is attached to a region of memory. */
/* Check consistency. */
CHECKL(buffer->mode & BufferModeATTACHED);
/* These fields should obey the ordering */
/* base <= init <= alloc <= poolLimit */
CHECKL((mps_addr_t)buffer->base <= buffer->ap_s.init);
CHECKL(buffer->ap_s.init <= buffer->ap_s.alloc);
CHECKL(buffer->ap_s.alloc <= (mps_addr_t)buffer->poolLimit);
/* Check that the fields are aligned to the buffer alignment. */
CHECKL(AddrIsAligned(buffer->base, buffer->alignment));
CHECKL(AddrIsAligned(buffer->initAtFlip, buffer->alignment));
CHECKL(AddrIsAligned(buffer->ap_s.init, buffer->alignment));
CHECKL(AddrIsAligned(buffer->ap_s.alloc, buffer->alignment));
CHECKL(AddrIsAligned(buffer->ap_s.limit, buffer->alignment));
CHECKL(AddrIsAligned(buffer->poolLimit, buffer->alignment));
/* If the buffer isn't trapped then "limit" should be the limit */
/* set by the owning pool. Otherwise, "init" is either at the */
/* same place it was at flip (.commit.before) or has been set */
/* to "alloc" (.commit.after). Also, when the buffer is */
/* flipped, initAtFlip should hold the init at flip, which is */
/* between the base and current init. Otherwise, initAtFlip */
/* is kept at zero to avoid misuse (see */
/* request.dylan.170429.sol.zero_). */
/* .. _request.dylan.170429.sol.zero: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170429 */
if (BufferIsTrapped(buffer)) {
/* .check.use-trapped: This checking function uses BufferIsTrapped, */
/* So BufferIsTrapped can't do checking as that would cause an */
/* infinite loop. */
if (buffer->mode & BufferModeFLIPPED) {
CHECKL(buffer->ap_s.init == buffer->initAtFlip
|| buffer->ap_s.init == buffer->ap_s.alloc);
CHECKL(buffer->base <= buffer->initAtFlip);
CHECKL(buffer->initAtFlip <= (Addr)buffer->ap_s.init);
}
/* Nothing special to check in the logged mode. */
} else {
CHECKL(buffer->initAtFlip == (Addr)0);
}
}
return TRUE;
}
int main(void)
{
#if defined HAVE_GETCWD || defined HAVE__GETCWD
#ifdef HAVE__GETCWD
#define getcwd _getcwd
#endif
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format1 = "dirfile/format1";
const char *format2 = "dirfile/format2";
const char *format_data1 = "INCLUDE ";
const char *format_data2 = "/dirfile/format1\n";
const char *format1_data = "INCLUDE format2\n";
const char *format2_data = "data RAW UINT8 11\n";
int cwd_size = 2048;
char *ptr, *cwd = NULL;
int fd, r = 0;
DIRFILE *D;
unsigned int spf;
rmdirfile();
mkdir(filedir, 0777);
do {
ptr = (char*)realloc(cwd, cwd_size *= 2);
if (ptr == NULL) {
fprintf(stderr, "out of memory for cwd!\n");
exit(1);
}
} while (!getcwd(cwd = ptr, cwd_size));
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data1, strlen(format_data1));
gd_pathwrite(fd, cwd);
write(fd, format_data2, strlen(format_data2));
close(fd);
fd = open(format1, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format1_data, strlen(format1_data));
close(fd);
fd = open(format2, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format2_data, strlen(format2_data));
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
spf = gd_spf(D, "data");
gd_close(D);
unlink(format2);
unlink(format1);
unlink(format);
rmdir(filedir);
CHECKU(spf, 11);
free(cwd);
return r;
#else
return 77;
#endif
}