void valgrindFreeObject(MM_GCExtensionsBase *extensions, uintptr_t baseAddress)
{
int objSize;
if (MM_ForwardedHeader((omrobjectptr_t)baseAddress).isForwardedPointer())
{
/* In scavanger an object may act as pointer to another object(it's replica in another region).
In this case, getConsumedSizeInBytesWithHeader returns some junk value.
So instead we calculate the size of the object (replica) it is pointing to
and use it for freeing original object.
*/
omrobjectptr_t fwObject = MM_ForwardedHeader((omrobjectptr_t)baseAddress).getForwardedObject();
objSize = (int)((GC_ObjectModel)extensions->objectModel).getConsumedSizeInBytesWithHeader(fwObject);
}
else
{
objSize = (int)((GC_ObjectModel)extensions->objectModel).getConsumedSizeInBytesWithHeader((omrobjectptr_t)baseAddress);
}
#if defined(VALGRIND_REQUEST_LOGS)
VALGRIND_PRINTF_BACKTRACE("Clearing an object at 0x%lx of size %d\n", baseAddress, objSize);
#endif /* defined(VALGRIND_REQUEST_LOGS) */
VALGRIND_CHECK_MEM_IS_DEFINED(baseAddress, objSize);
VALGRIND_MEMPOOL_FREE(extensions->valgrindMempoolAddr, baseAddress);
MUTEX_ENTER(extensions->memcheckHashTableMutex);
hashTableRemove(extensions->memcheckHashTable, &baseAddress);
MUTEX_EXIT(extensions->memcheckHashTableMutex);
}
int32_t
GCConfigTest::removeObjectFromRootTable(const char *name)
{
OMRPORT_ACCESS_FROM_OMRVM(exampleVM->_omrVM);
int32_t rt = 0;
RootEntry searchEntry;
RootEntry *rEntryPtr = NULL;
searchEntry.name = name;
rEntryPtr = (RootEntry *)hashTableFind(exampleVM->rootTable, &searchEntry);
if (NULL == rEntryPtr) {
rt = 1;
omrtty_printf("%s:%d Failed to find root object %s in root table.\n", __FILE__, __LINE__, name);
goto done;
}
if (0 != hashTableRemove(exampleVM->rootTable, rEntryPtr)) {
rt = 1;
omrtty_printf("%s:%d Failed to remove root object %s from root table!\n", __FILE__, __LINE__, name);
goto done;
}
#if defined(OMRGCTEST_DEBUG)
omrtty_printf("Remove object(%s) from root table.\n", name);
#endif
done:
return rt;
}
void eliminateItem(int key, int value) {
struct LRUItem * tailItem = mTailItem;
if (key != tailItem->key) {
// Remove a key
hashTableRemove(tailItem->key);
// Add a key
hashTableAdd(key, tailItem);
tailItem->key = key;
}
tailItem->value = value;
struct LRUItem * newTailItem = tailItem->prev;
if (newTailItem) {
newTailItem->next = NULL;
// Record the last used item
mTailItem = newTailItem;
}
tailItem->prev = NULL;
// To avoid their own point to themselves.
if (tailItem != mHeadItem) {
tailItem->next = mHeadItem;
// Record the recent used item
mHeadItem->prev = tailItem;
mHeadItem = tailItem;
}
else tailItem->next = NULL;
}
static struct pptoken ppUndefLine(struct phase4 *p4){
struct pptoken nameToken;
struct macro_entry *macroEntry;
int found;
if(p4->lookAhead[0].name == PPTN_HASH){
eat(p4);
} else {
fprintf(stderr, "undef line didn't begin with '#'\n");
exit(1);
}
if(p4->lookAhead[0].name == PPTN_UNDEF){
eat(p4);
} else {
fprintf(stderr, "undef line didn't have 'undef' keyword\n");
exit(1);
}
if(p4->lookAhead[0].name == PPTN_IDENTIFIER){
nameToken = eat(p4);
} else {
fprintf(stderr, "undef expected identifier");
exit(1);
}
hashTableRemove(p4->symbolTable, nameToken.lexeme, (void**)¯oEntry, &found);
if(found){
freePPTokenList(macroEntry->replacementList);
free(macroEntry);
}
if(p4->lookAhead[0].name == PPTN_NEWLINE){
fprintf(stderr, "UNDEF %s\n", nameToken.lexeme);
return eat(p4);
} else {
fprintf(stderr, "undef line contained extra tokens\n");
exit(1);
}
}
static void
mpeg2PmtDeactivate(Mpeg2Pmt mpeg2Pmt, unsigned pn,
Mpeg2PmtCurrentNextIndicator cni)
{
Mpeg2PmtTsProgramMapSection *pmsp;
Mpeg2PmtStream *streamp;
pmsp = (Mpeg2PmtTsProgramMapSection*) hashTableRemove(mpeg2Pmt->pmtTable[cni], pn);
if (pmsp != NULL) {
for (streamp = pmsp->streamList;
streamp != NULL; streamp = streamp->next) {
unsigned ePid = MPEG2_PMT_STREAM_HEADER_ELEMENTARY_PID(
&streamp->streamHeader);
(void) MMP_CONTEXT_DELETEPIPE(streamp->cop, ePid);
}
mpeg2PmtDescListFree(pmsp->descList);
mpeg2PmtStreamListFree(pmsp->streamList);
free(pmsp);
}
}
int32_t
GCConfigTest::removeObjectFromObjectTable(const char *name)
{
OMRPORT_ACCESS_FROM_OMRVM(exampleVM->_omrVM);
int32_t rt = 1;
ObjectEntry *foundEntry = find(name);
if (NULL == foundEntry) {
omrtty_printf("%s:%d Failed to find object %s in object table.\n", __FILE__, __LINE__, name);
goto done;
}
if (0 != hashTableRemove(exampleVM->objectTable, foundEntry)) {
omrtty_printf("%s:%d Failed to remove object %s from object table!\n", __FILE__, __LINE__, name);
goto done;
}
#if defined(OMRGCTEST_DEBUG)
omrtty_printf("Remove object %s(%p[0x%llx]) from object table.\n", name, foundEntry->objPtr, *(foundEntry->objPtr));
#endif
rt = 0;
done:
return rt;
}
omr_error_t
OMR_MethodDictionary::getEntries(OMR_VMThread *vmThread, void **methodArray, size_t methodArrayCount,
OMR_SampledMethodDescription *methodDescriptions, char *nameBuffer, size_t nameBytes,
size_t *firstRetryMethod, size_t *nameBytesRemaining)
{
omr_error_t rc = OMR_ERROR_NONE;
if (0 == omrthread_monitor_enter(_lock)) {
OMR_SampledMethodDescription *currentMthDesc = methodDescriptions;
size_t firstRetryMethodLocal = 0;
size_t nameBytesAvailable = nameBytes;
size_t nameBytesRemainingLocal = 0;
char *nameBufferPos = nameBuffer;
/*
* Collect method descriptions until we encounter a description that can't fit into
* the available nameBuffer. At this point, flip to RETRY mode: Stop collecting names,
* and only count the remaining space required.
*/
for (size_t i = 0; i < methodArrayCount; i++) {
OMR_MethodDictionaryEntry searchEntryHdr; /* NOTE This is only an entry header, and can't hold any propertyValues */
OMR_MethodDictionaryEntry *entry = NULL;
searchEntryHdr.key = methodArray[i];
entry = (OMR_MethodDictionaryEntry *)hashTableFind(_hashTable, &searchEntryHdr);
if (NULL == entry) {
currentMthDesc->reasonCode = OMR_ERROR_NOT_AVAILABLE;
} else {
size_t nameBytesNeeded = countEntryNameBytesNeeded(entry);
if (OMR_ERROR_RETRY == rc) {
/* In RETRY mode. Only count the remaining space needed. */
currentMthDesc->reasonCode = OMR_ERROR_RETRY;
nameBytesRemainingLocal += nameBytesNeeded;
} else if (nameBytesNeeded <= nameBytesAvailable) {
/* The description fits in nameBuffer. */
currentMthDesc->reasonCode = OMR_ERROR_NONE;
copyEntryNameBytes(entry, currentMthDesc, nameBufferPos);
nameBufferPos += nameBytesNeeded;
nameBytesAvailable -= nameBytesNeeded;
/* To minimize the size of the method dictionary,
* delete entries that are successfully retrieved.
*/
_currentBytes -= nameBytesNeeded;
cleanupEntryStrings(entry, this);
if (0 != hashTableRemove(_hashTable, entry)) {
rc = OMR_ERROR_INTERNAL;
currentMthDesc->reasonCode = OMR_ERROR_INTERNAL;
if (NULL != firstRetryMethod) {
*firstRetryMethod = i;
}
break;
}
_currentBytes -= _sizeofEntry;
} else {
/* Just ran out of space in nameBuffer. Flip to RETRY mode. */
rc = OMR_ERROR_RETRY;
firstRetryMethodLocal = i;
currentMthDesc->reasonCode = OMR_ERROR_RETRY;
nameBytesRemainingLocal += nameBytesNeeded;
}
}
currentMthDesc = (OMR_SampledMethodDescription *)((uintptr_t)currentMthDesc + sizeof(OMR_SampledMethodDescription) + sizeof(const char *) * _numProperties);
}
if (OMR_ERROR_RETRY == rc) {
if (NULL != firstRetryMethod) {
*firstRetryMethod = firstRetryMethodLocal;
}
if (NULL != nameBytesRemaining) {
*nameBytesRemaining = nameBytesRemainingLocal;
}
}
omrthread_monitor_exit(_lock);
} else {
rc = OMR_ERROR_INTERNAL;
}
return rc;
}
