#include "compiler/IroPointerAnalysis.h" #include "compiler/IroMalloc.h" #include "compiler/CError.h" #include "compiler/CInt64.h" // TODO: this should really be elsewhere (but where?) inline UInt32 gcd(UInt32 a, UInt32 b) { UInt32 chk; if (!a) return b; if (!b) return a; while (1) { chk = a % b; if (!chk) return b; a = b; b = chk; } } // #define IRO_DEBUG typedef struct ExtendedParamSet ExtendedParamSet; typedef struct LocationSet LocationSet; typedef struct LocationSetSet LocationSetSet; typedef struct ObjectSet ObjectSet; typedef struct PAHeapBlock PAHeapBlock; typedef struct PALocalVar PALocalVar; typedef struct PAMemoryBlock PAMemoryBlock; typedef struct ParamMapping ParamMapping; typedef struct ParamMappingFunction ParamMappingFunction; typedef struct PartialTransferFunction PartialTransferFunction; typedef struct PointsToEntry PointsToEntry; // typedef struct PointsToFunction PointsToFunction; typedef struct Stack Stack; typedef struct StackElement StackElement; typedef UInt32 uint32; void __assertion_failed(char *expr, char *filename, int line); #ifdef IRO_DEBUG #define IRO_ASSERT(expr) \ do { \ if (!(expr)) { \ __assertion_failed(#expr, __FILE__, __LINE__); \ } \ } while (0); #define IRO_DEBUG_CLEAR(obj, type) \ memset((obj), 0xFF, sizeof(type)) #else #define IRO_ASSERT(expr) ((void) 0) #define IRO_DEBUG_CLEAR(obj, type) ((void) 0) #endif #ifdef __MWERKS__ #pragma options align=mac68k #endif struct StackElement { Object *proc; PartialTransferFunction *ptf; ParamMappingFunction *map; IROLinear *funcCall; }; struct Stack { StackElement *top; Stack *next; }; struct ObjectSet { Object *proc; ObjectSet *otherProcs; }; struct ExtendedParam { ObjectSet *objectSet; uint32 x4; }; struct ExtendedParamSet { ExtendedParam *ep; ExtendedParamSet *otherEps; }; struct PAHeapBlock { IROLinear *x0; }; struct PALocalVar { Object *x0; char *x4; }; typedef enum { PAMEMORYBLOCKKIND_INVALID, PAMEMORYBLOCKKIND_1, PAMEMORYBLOCKKIND_EXTENDEDPARAM, PAMEMORYBLOCKKIND_LOCALVAR, PAMEMORYBLOCKKIND_HEAPBLOCK, PAMEMORYBLOCKKIND_INT, PAMEMORYBLOCKKIND_6 } PAMemoryBlockKind; struct PAMemoryBlock { PAMemoryBlockKind kind; union { ExtendedParam *ep; PALocalVar *localvar; PAHeapBlock *heapblock; CInt64 intval; void *x6; } u; }; struct LocationSet { PAMemoryBlock *block; Type *rtype; union { struct { CInt64 field; UInt32 stride; } known; struct { PAMemoryBlock *restriction; LocationSet *bitfieldOf; } unknown; } u; }; struct LocationSetSet { LocationSet *loc; LocationSetSet *otherLocs; UInt8 count; }; struct ParamMapping { IROLinear *actual; Object *formal; ExtendedParam *extended; }; struct ParamMappingFunction { ParamMapping *mapping; ParamMappingFunction *otherMappings; }; struct PointsToEntry { LocationSet *loc; LocationSetSet *locs; }; struct PointsToFunction { PointsToEntry *pte; PointsToFunction *otherPtes; }; struct PartialTransferFunction { PointsToFunction *initialPointsToFn; PointsToFunction *finalPointsToFn; LocationSetSet *funcModifies; LocationSet *returnLocation; Boolean x10; struct { IROLinear *nd; PartialTransferFunction *ptf; } context; }; struct PTFList { PartialTransferFunction *ptf; PTFList *otherPTFs; }; #ifdef __MWERKS__ #pragma options align=reset #endif // TODO: how many of these are actually in IroPointerAnalysis.c? static uint32 stExtendedParamNum; static PartialTransferFunction *stUnknownPTF; static uint32 stIndentationLevel; static UInt8 stTabs[0x2C]; // unused mystery object static Stack *stCallingContextStack; static ObjectList *stParamObjs; static jmp_buf stAbortPointerAnalysis; static Object stUnknown; static Object *stCurrentProc; static ExtendedParamSet *stExtParamSet; static PTFList *stPTFList; static uint32 stMaxPassCount; // TODO: stEvalProcActionParams static IRONode *stExceptionFNode; static PAMemoryBlock stDummyMemoryBlock = { PAMEMORYBLOCKKIND_1 }; static PAMemoryBlock *stUnknownMb = &stDummyMemoryBlock; static LocationSet stDummyLocationSet = { &stDummyMemoryBlock }; static LocationSet *stUnknownLs = &stDummyLocationSet; // forward decls inline StackElement *Stack_sub_48A5B0(Stack **stackPtr); inline void ObjectSet_RemoveAll(ObjectSet *procList); inline void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList); inline void LocationSet_Copy(LocationSet *dest, LocationSet *src); inline Boolean LocationSet_IsUnknown(LocationSet *ls); inline void LocationSetSet_RemoveAll(LocationSetSet *lss); inline void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src); inline void ParamMappingFunction_RemoveAll(ParamMappingFunction *pmf); inline void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *dest, ParamMappingFunction *src); inline void PointsToFunction_RemoveAll(PointsToFunction *pointsToFunc); inline void PointsToFunction_AddAllIGuess_sub_487D80(PointsToFunction *dest, PointsToFunction *src); inline void PTFList_RemoveAll(PTFList *ptfList); inline StackElement *StackElement_New(void) { StackElement *stackElement = IRO_malloc(sizeof(StackElement)); #line 103 IRO_ASSERT(stackElement != NULL); #ifdef IRO_DEBUG stackElement->proc = NULL; stackElement->ptf = NULL; stackElement->map = NULL; stackElement->funcCall = NULL; #endif return stackElement; } inline void StackElement_Delete(StackElement *stackElement) { #line 117 IRO_ASSERT(stackElement != NULL); IRO_ASSERT(stackElement->proc == NULL); IRO_ASSERT(stackElement->ptf == NULL); IRO_ASSERT(stackElement->map == NULL); IRO_ASSERT(stackElement->funcCall == NULL); IRO_DEBUG_CLEAR(stackElement, sizeof(StackElement)); IRO_free(stackElement); } inline void StackElement_Init(StackElement *stackElement, Object *proc, PartialTransferFunction *ptf, ParamMappingFunction *map, IROLinear *funcCall) { #line 131 IRO_ASSERT(stackElement != NULL); IRO_ASSERT(proc != NULL); IRO_ASSERT(ptf != NULL); IRO_ASSERT(map != NULL); IRO_ASSERT(funcCall != NULL); stackElement->proc = proc; stackElement->ptf = ptf; stackElement->map = map; stackElement->funcCall = funcCall; } inline void StackElement_Copy(StackElement *dest, StackElement *src) { #line 145 IRO_ASSERT(dest != NULL); IRO_ASSERT(src != NULL); StackElement_Init(dest, src->proc, src->ptf, src->map, src->funcCall); } inline void StackElement_Term(StackElement *stackElement) { #line 156 IRO_ASSERT(stackElement != NULL); #ifdef IRO_DEBUG stackElement->proc = NULL; stackElement->ptf = NULL; stackElement->map = NULL; stackElement->funcCall = NULL; #endif } inline void *StackElement_sub_48A780(StackElement *stackElement) { #line 213 IRO_ASSERT(stackElement != NULL); return stackElement->proc; } inline Boolean StackRelated_sub_48A760(void *key1, void *key2) { #line 220 IRO_ASSERT(key1 != NULL); IRO_ASSERT(key2 != NULL); return key1 == key2; } inline Object *StackElement_proc(StackElement *stackElement) { #line 228 IRO_ASSERT(stackElement != NULL); return stackElement->proc; } inline PartialTransferFunction *StackElement_ptf(StackElement *stackElement) { #line 235 IRO_ASSERT(stackElement != NULL); return stackElement->ptf; } inline ParamMappingFunction *StackElement_map(StackElement *stackElement) { #line 242 IRO_ASSERT(stackElement != NULL); return stackElement->map; } inline IROLinear *StackElement_funcCall(StackElement *stackElement) { #line 249 IRO_ASSERT(stackElement != NULL); return stackElement->funcCall; } inline Stack *Stack_New(void) { Stack *stack = IRO_malloc(sizeof(Stack)); #line 265 IRO_ASSERT(stack != NULL); #ifdef IRO_DEBUG stack->top = NULL; stack->next = NULL; #endif return stack; } inline void Stack_Delete(Stack *stack) { #line 277 IRO_ASSERT(stack != NULL); IRO_ASSERT(stack->top == NULL); IRO_ASSERT(stack->next == NULL); IRO_DEBUG_CLEAR(stack, sizeof(Stack)); IRO_free(stack); } inline void Stack_Init(Stack *stack) { #line 289 IRO_ASSERT(stack != NULL); stack->top = NULL; stack->next = NULL; } inline void Stack_Term(Stack **stackPtr) { StackElement *stackElement; #line 299 IRO_ASSERT(stackPtr != NULL); IRO_ASSERT(*stackPtr != NULL); while ((*stackPtr)->top) { stackElement = Stack_sub_48A5B0(stackPtr); StackElement_Term(stackElement); StackElement_Delete(stackElement); } } inline void Stack_sub_48A660(Stack **stackPtr, StackElement *stackElement) { StackElement *newElement; Stack *newStack; #line 315 IRO_ASSERT(stackPtr != NULL); IRO_ASSERT(*stackPtr != NULL); newElement = StackElement_New(); StackElement_Copy(newElement, stackElement); newStack = Stack_New(); newStack->top = newElement; newStack->next = *stackPtr; *stackPtr = newStack; } inline StackElement *Stack_Top(Stack **stackPtr) { #line 331 IRO_ASSERT(stackPtr != NULL); IRO_ASSERT(*stackPtr != NULL); return (*stackPtr)->top; } inline Stack *Stack_Next(Stack **stackPtr) { #line 343 IRO_ASSERT(stackPtr != NULL); IRO_ASSERT(*stackPtr != NULL); return (*stackPtr)->next; } inline StackElement *Stack_sub_48A5B0(Stack **stackPtr) { StackElement *stackElement; #line 357 IRO_ASSERT(stackPtr != NULL); IRO_ASSERT(*stackPtr != NULL); stackElement = (*stackPtr)->top; if (stackElement) { Stack *next = (*stackPtr)->next; (*stackPtr)->top = NULL; (*stackPtr)->next = NULL; Stack_Delete(*stackPtr); *stackPtr = next; } return stackElement; } inline StackElement *Stack_sub_48A710(Stack **stackPtr, void *key) { Stack *stack; #line 379 IRO_ASSERT(stackPtr != NULL); IRO_ASSERT(key != NULL); for (stack = *stackPtr; stack; stack = stack->next) { if (stack->top) { if (StackRelated_sub_48A760(StackElement_sub_48A780(stack->top), key)) return stack->top; } } return NULL; } inline ObjectSet *ObjectSet_New(void) { ObjectSet *procList; procList = IRO_malloc(sizeof(ObjectSet)); #line 439 IRO_ASSERT(procList != NULL); #ifdef IRO_DEBUG procList->proc = NULL; procList->otherProcs = NULL; #endif return procList; } inline void ObjectSet_Delete(ObjectSet *procList) { #line 451 IRO_ASSERT(procList != NULL); IRO_ASSERT(procList->proc == NULL); IRO_ASSERT(procList->otherProcs == NULL); IRO_DEBUG_CLEAR(procList, sizeof(ObjectSet)); IRO_free(procList); } inline void ObjectSet_Init(ObjectSet *procList) { #line 463 IRO_ASSERT(procList != NULL); procList->proc = NULL; procList->otherProcs = NULL; } inline void ObjectSet_Term(ObjectSet *procList) { #line 481 IRO_ASSERT(procList != NULL); ObjectSet_RemoveAll(procList); #ifdef IRO_DEBUG procList->proc = NULL; procList->otherProcs = NULL; #endif } inline void ObjectSet_ForEach(ObjectSet *procList, void (*action)(Object *, void *), void *refcon) { #line 528 IRO_ASSERT(procList != NULL); IRO_ASSERT(action != NULL); IRO_ASSERT(refcon == NULL || refcon != NULL); while (procList && procList->proc) { action(procList->proc, refcon); procList = procList->otherProcs; } } inline Object *ObjectSet_sub_485020(ObjectSet *procList, Object *proc) { #line 540 IRO_ASSERT(procList != NULL); IRO_ASSERT(proc != NULL); while (procList && procList->proc) { if (procList->proc == proc) return procList->proc; procList = procList->otherProcs; } return NULL; } inline Object *ObjectSet_FindFirst(ObjectSet *procList) { #line 552 IRO_ASSERT(procList != NULL); return procList->proc; } inline int ObjectSet_Count(ObjectSet *procList) { int count; #line 552 IRO_ASSERT(procList != NULL); count = 0; while (procList && procList->proc) { count++; procList = procList->otherProcs; } return count; } inline void ObjectSet_sub_486800(ObjectSet *procList, Object *proc) { ObjectSet *newProcList; #line 574 IRO_ASSERT(procList != NULL); IRO_ASSERT(proc != NULL); if (procList->proc) { newProcList = ObjectSet_New(); ObjectSet_Init(newProcList); newProcList->proc = procList->proc; newProcList->otherProcs = procList->otherProcs; procList->otherProcs = newProcList; } procList->proc = proc; } inline void ObjectSet_sub_4867D0(ObjectSet *procList, Object *proc) { #line 592 IRO_ASSERT(procList != NULL); IRO_ASSERT(proc != NULL); if (!ObjectSet_sub_485020(procList, proc)) ObjectSet_sub_486800(procList, proc); } inline void ObjectSet_Remove(ObjectSet *procList, Object *proc) { ObjectSet *prev; ObjectSet *tmp; #line 605 IRO_ASSERT(procList != NULL); IRO_ASSERT(proc != NULL); prev = NULL; while (procList && procList->proc) { if (procList->proc == proc) { if (!prev) { if (procList->otherProcs == NULL) { procList->proc = NULL; } else { tmp = procList->otherProcs; procList->proc = procList->otherProcs->proc; procList->otherProcs = procList->otherProcs->otherProcs; tmp->proc = NULL; tmp->otherProcs = NULL; ObjectSet_Term(tmp); ObjectSet_Delete(tmp); } } else { prev->otherProcs = procList->otherProcs; procList->proc = NULL; procList->otherProcs = NULL; ObjectSet_Term(procList); ObjectSet_Delete(procList); } return; } prev = procList; procList = procList->otherProcs; } } inline void ObjectSet_RemoveAll(ObjectSet *procList) { #line 645 IRO_ASSERT(procList != NULL); while (procList && procList->proc) ObjectSet_Remove(procList, procList->proc); } inline void ObjectSet_AddSetAction(Object *proc, void *refcon) { #line 655 IRO_ASSERT(proc != NULL); IRO_ASSERT(refcon != NULL); ObjectSet_sub_4867D0(refcon, proc); } inline void ObjectSet_SimpleAddSetAction(Object *proc, void *refcon) { #line 663 IRO_ASSERT(proc != NULL); IRO_ASSERT(refcon != NULL); ObjectSet_sub_486800(refcon, proc); } inline void ObjectSet_sub_48C590(ObjectSet *dest, ObjectSet *src) { #line 671 IRO_ASSERT(dest != NULL); IRO_ASSERT(src != NULL); if (dest->proc) ObjectSet_ForEach(src, ObjectSet_AddSetAction, dest); else ObjectSet_ForEach(src, ObjectSet_SimpleAddSetAction, dest); } inline void ObjectSet_RemoveSetAction(Object *proc, void *refcon) { #line 682 IRO_ASSERT(proc != NULL); IRO_ASSERT(refcon != NULL); ObjectSet_Remove(refcon, proc); } inline void ObjectSet_removeiter_sub_48C890(ObjectSet *dest, ObjectSet *src) { #line 690 IRO_ASSERT(dest != NULL); IRO_ASSERT(src != NULL); ObjectSet_ForEach(src, ObjectSet_RemoveSetAction, dest); } inline Boolean ObjectSet_sub_484FA0(ObjectSet *os1, ObjectSet *os2) { ObjectSet *scan; #line 700 IRO_ASSERT(os1 != NULL); IRO_ASSERT(os2 != NULL); if (os1 == os2) return 1; for (scan = os1; scan && scan->proc; scan = scan->otherProcs) { if (!ObjectSet_sub_485020(os2, scan->proc)) return 0; } for (scan = os2; scan && scan->proc; scan = scan->otherProcs) { if (!ObjectSet_sub_485020(os1, scan->proc)) return 0; } return 1; } inline ExtendedParam *ExtendedParam_New(void) { ExtendedParam *ep = IRO_malloc(sizeof(ExtendedParam)); #line 755 IRO_ASSERT(ep != NULL); #ifdef IRO_DEBUG ep->objectSet = NULL; #endif return ep; } inline void ExtendedParam_Delete(ExtendedParam *ep) { IRO_ASSERT(ep != NULL); IRO_ASSERT(ep->objectSet == NULL); IRO_DEBUG_CLEAR(ep, sizeof(ExtendedParam)); IRO_free(ep); } inline void ExtendedParam_Init(ExtendedParam *ep, Object *obj) { #line 777 IRO_ASSERT(ep != NULL); IRO_ASSERT(obj != NULL); IRO_ASSERT(obj->extParam == NULL); IRO_ASSERT(stExtendedParamNum < ((uint32) -1) / 2 - 1); ep->objectSet = ObjectSet_New(); ObjectSet_Init(ep->objectSet); ObjectSet_sub_4867D0(ep->objectSet, obj); obj->extParam = ep; ep->x4 = stExtendedParamNum++; } inline void ExtendedParam_TermAction(Object *obj, void *refcon) { obj->extParam = NULL; } inline void ExtendedParam_Term(ExtendedParam *ep) { IRO_ASSERT(ep != NULL); ObjectSet_ForEach(ep->objectSet, ExtendedParam_TermAction, NULL); ObjectSet_Term(ep->objectSet); ObjectSet_Delete(ep->objectSet); #ifdef IRO_DEBUG ep->objectSet = NULL; #endif } inline Boolean ExtendedParams_Equal(ExtendedParam *ep1, ExtendedParam *ep2) { #line 841 IRO_ASSERT(ep1 != NULL); IRO_ASSERT(ep2 != NULL); IRO_ASSERT(ep1->objectSet != NULL); IRO_ASSERT(ep2->objectSet != NULL); if (ep1 == ep2) return 1; return ep1->x4 == ep2->x4 && ObjectSet_sub_484FA0(ep1->objectSet, ep2->objectSet); } inline ExtendedParam *ExtendedParam_FindByObject(Object *obj) { #line 856 IRO_ASSERT(obj != NULL); return obj->extParam; } inline void ExtendedParam_sub_4867B0(ExtendedParam *ep, Object *obj) { #line 863 IRO_ASSERT(ep != NULL); IRO_ASSERT(ep->objectSet != NULL); IRO_ASSERT(obj != NULL); ObjectSet_sub_4867D0(ep->objectSet, obj); obj->extParam = ep; } inline void ExtendedParam_RemoveObjectSetAction(Object *object, void *refcon) { object->extParam = NULL; } inline void EP_sub_48C850(ExtendedParam *ep, ObjectSet *objSet) { #line 888 IRO_ASSERT(ep != NULL); IRO_ASSERT(ep->objectSet != NULL); IRO_ASSERT(objSet != NULL); ObjectSet_removeiter_sub_48C890(ep->objectSet, objSet); ObjectSet_ForEach(objSet, ExtendedParam_RemoveObjectSetAction, NULL); } inline ObjectSet *ExtendedParam_objectSet(ExtendedParam *ep) { #line 898 IRO_ASSERT(ep != NULL); return ep->objectSet; } inline uint32 ExtendedParam_sub_489110(ExtendedParam *ep) { #line 905 IRO_ASSERT(ep != NULL); return ep->x4; } inline ExtendedParamSet *AllocsExtParamSet_sub_4876C0(void) { ExtendedParamSet *epList = IRO_malloc(sizeof(ExtendedParamSet)); #line 924 IRO_ASSERT(epList != NULL); #ifdef IRO_DEBUG epList->ep = NULL; epList->otherEps = NULL; #endif return epList; } inline void FreesExtParamSet_sub_48CAE0(ExtendedParamSet *epList) { #line 936 IRO_ASSERT(epList != NULL); IRO_ASSERT(epList->ep == NULL); IRO_ASSERT(epList->otherEps == NULL); IRO_DEBUG_CLEAR(epList, sizeof(ExtendedParamSet)); IRO_free(epList); } inline void InitsExtParamSet_sub_4876A0(ExtendedParamSet *epList) { #line 948 IRO_ASSERT(epList != NULL); epList->ep = NULL; epList->otherEps = NULL; } inline void TermsExtParamSet_sub_48CB00(ExtendedParamSet *epList) { #line 966 IRO_ASSERT(epList != NULL); ExtendedParamSet_RemoveAll(epList); #ifdef IRO_DEBUG epList->ep = NULL; epList->otherEps = NULL; #endif } inline void MaybeWalkExtParamSet_sub_48CBE0(ExtendedParamSet *epList, void (*action)(ExtendedParam *, void *), void *refcon) { #line 1010 IRO_ASSERT(epList != NULL); IRO_ASSERT(action != NULL); while (epList && epList->ep) { action(epList->ep, refcon); epList = epList->otherEps; } } inline ExtendedParam *ExtParamSet_sub_4876D0(ExtendedParamSet *epList, ExtendedParam *ep) { #line 1022 IRO_ASSERT(epList != NULL); IRO_ASSERT(ep != NULL); while (epList && epList->ep) { if (epList->ep == ep) return epList->ep; epList = epList->otherEps; } return NULL; } inline void ExtParamSet_sub_487660(ExtendedParamSet *epList, ExtendedParam *ep) { #line 1056 IRO_ASSERT(epList != NULL); IRO_ASSERT(ep != NULL); if (epList->ep) { ExtendedParamSet *newSet = AllocsExtParamSet_sub_4876C0(); InitsExtParamSet_sub_4876A0(newSet); newSet->ep = epList->ep; newSet->otherEps = epList->otherEps; epList->otherEps = newSet; } epList->ep = ep; } inline void ExtParamSet_sub_487630(ExtendedParamSet *epList, ExtendedParam *ep) { #line 1076 IRO_ASSERT(epList != NULL); IRO_ASSERT(ep != NULL); if (!ExtParamSet_sub_4876D0(epList, ep)) ExtParamSet_sub_487660(epList, ep); } inline void ExtendedParamSet_Remove(ExtendedParamSet *epList, ExtendedParam *ep) { ExtendedParamSet *prev; ExtendedParamSet *tmp; #line 1089 IRO_ASSERT(epList != NULL); IRO_ASSERT(ep != NULL); prev = NULL; while (epList && epList->ep) { if (epList->ep == ep) { if (!prev) { if (epList->otherEps == NULL) { epList->ep = NULL; } else { tmp = epList->otherEps; epList->ep = epList->otherEps->ep; epList->otherEps = epList->otherEps->otherEps; tmp->ep = NULL; tmp->otherEps = NULL; TermsExtParamSet_sub_48CB00(tmp); FreesExtParamSet_sub_48CAE0(tmp); } } else { prev->otherEps = epList->otherEps; epList->ep = NULL; epList->otherEps = NULL; TermsExtParamSet_sub_48CB00(epList); FreesExtParamSet_sub_48CAE0(epList); } return; } prev = epList; epList = epList->otherEps; } } inline void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList) { #line 1129 IRO_ASSERT(epList != NULL); while (epList && epList->ep) ExtendedParamSet_Remove(epList, epList->ep); } inline PAHeapBlock *CreateUniqueHeapAlloc_sub_486420(void) { PAHeapBlock *hb = IRO_malloc(sizeof(PAHeapBlock)); #line 1225 IRO_ASSERT(hb != NULL); #ifdef IRO_DEBUG hb->parent = NULL; #endif return hb; } inline void InitUniqueHeapAlloc_sub_486410(PAHeapBlock *hb, IROLinear *nd) { #line 1247 IRO_ASSERT(hb != NULL); hb->x0 = nd; } inline Boolean PAHeapBlocks_Equal(PAHeapBlock *hb1, PAHeapBlock *hb2) { #line 1296 IRO_ASSERT(hb1 != NULL); IRO_ASSERT(hb2 != NULL); return (hb1 == hb2) || (hb1->x0 == hb2->x0); } inline PALocalVar *PALocalVar_New(void) { PALocalVar *local = IRO_malloc(sizeof(PALocalVar)); #line 1333 IRO_ASSERT(local != NULL); #ifdef IRO_DEBUG local->parent = NULL; local->nextSibling = NULL; #endif return local; } inline void PALocalVar_InitByObject(PALocalVar *local, Object *obj) { #line 1357 IRO_ASSERT(local != NULL); IRO_ASSERT(obj != NULL); local->x0 = obj; if (obj->name && obj->name->name) { local->x4 = IRO_malloc(strlen(obj->name->name) + 1); strcpy(local->x4, obj->name->name); } else { local->x4 = NULL; } } inline void PALocalVar_InitByName(PALocalVar *local, char *name) { #line 1372 IRO_ASSERT(local != NULL); IRO_ASSERT(name != NULL); local->x0 = NULL; local->x4 = IRO_malloc(strlen(name) + 1); strcpy(local->x4, name); } inline Boolean PALocalVars_Equal(PALocalVar *local1, PALocalVar *local2) { #line 1419 IRO_ASSERT(local1 == NULL || local1 != NULL); IRO_ASSERT(local2 == NULL || local2 != NULL); if (local1 == local2) return 1; if (!local1 || !local2) return 0; if (!local1->x0 || !local2->x0) { if (local1->x4) return local2->x4 && !strcmp(local1->x4, local2->x4); } return local1->x0 == local2->x0; } inline void PALocalVar_SetSth_sub_4847C0(PALocalVar *local, Object *obj) { #line 1436 IRO_ASSERT(local != NULL); IRO_ASSERT(obj == NULL || obj != NULL); local->x0 = obj; } inline Object *PALocalVar_Get0_sub_4847E0(PALocalVar *local) { #line 1444 IRO_ASSERT(local != NULL); return local->x0; } inline char *PALocalVar_Get4_sub_4847D0(PALocalVar *local) { #line 1451 IRO_ASSERT(local != NULL); return local->x4; } inline PAMemoryBlock *PAMemoryBlock_New(void) { PAMemoryBlock *mb = IRO_malloc(sizeof(PAMemoryBlock)); #line 1491 IRO_ASSERT(mb != NULL); #ifdef IRO_DEBUG mb->kind = PAMEMORYBLOCKKIND_INVALID; #endif return mb; } inline void PAMemoryBlock_Delete(PAMemoryBlock *mb) { #line 1502 IRO_ASSERT(mb != NULL); IRO_ASSERT(mb->kind == PAMEMORYBLOCKKIND_INVALID); IRO_free(mb); } inline void PAMemoryBlock_Init(PAMemoryBlock *mb, PAMemoryBlockKind kind, void *thing) { #line 1513 IRO_ASSERT(mb != NULL); IRO_ASSERT(thing == NULL || thing != NULL); mb->kind = kind; switch (mb->kind) { case PAMEMORYBLOCKKIND_EXTENDEDPARAM: mb->u.ep = (ExtendedParam *) thing; break; case PAMEMORYBLOCKKIND_LOCALVAR: mb->u.localvar = (PALocalVar *) thing; break; case PAMEMORYBLOCKKIND_HEAPBLOCK: mb->u.heapblock = (PAHeapBlock *) thing; break; case PAMEMORYBLOCKKIND_INT: mb->u.intval = *((CInt64 *) thing); break; case PAMEMORYBLOCKKIND_6: mb->u.x6 = (void *) thing; break; default: #line 1535 CError_FATAL(); } } inline void PAMemoryBlock_Term(PAMemoryBlock *mb) { #line 1552 IRO_ASSERT(mb != NULL); #ifdef IRO_DEBUG mb->kind = PAMEMORYBLOCKKIND_INVALID; #endif } inline Boolean MemoryBlocks_Equal(PAMemoryBlock *mb1, PAMemoryBlock *mb2) { #line 1657 IRO_ASSERT(mb1 == NULL || mb1 != NULL); IRO_ASSERT(mb2 == NULL || mb2 != NULL); if (mb1 == mb2) return 1; if (!mb1 || !mb2 || mb1->kind != mb2->kind) return 0; switch (mb1->kind) { case PAMEMORYBLOCKKIND_EXTENDEDPARAM: return ExtendedParams_Equal(mb1->u.ep, mb2->u.ep); case PAMEMORYBLOCKKIND_LOCALVAR: return PALocalVars_Equal(mb1->u.localvar, mb2->u.localvar); case PAMEMORYBLOCKKIND_HEAPBLOCK: return PAHeapBlocks_Equal(mb1->u.heapblock, mb2->u.heapblock); case PAMEMORYBLOCKKIND_INT: return CInt64_Equal(mb1->u.intval, mb2->u.intval); case PAMEMORYBLOCKKIND_6: return mb1->u.x6 == mb2->u.x6; default: #line 1684 CError_FATAL(); return 0; } } inline PAMemoryBlockKind PAMemoryBlock_kind(PAMemoryBlock *mb) { #line 1692 IRO_ASSERT(mb != NULL); return mb->kind; } inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) { #line 1699 IRO_ASSERT(mb != NULL); switch (mb->kind) { case PAMEMORYBLOCKKIND_EXTENDEDPARAM: return mb->u.ep; case PAMEMORYBLOCKKIND_LOCALVAR: return mb->u.localvar; case PAMEMORYBLOCKKIND_HEAPBLOCK: return mb->u.heapblock; case PAMEMORYBLOCKKIND_INT: return &mb->u.intval; case PAMEMORYBLOCKKIND_6: return mb->u.x6; default: #line 1719 CError_FATAL(); return NULL; } } inline LocationSet *LocationSet_New(void) { LocationSet *ls = IRO_malloc(sizeof(LocationSet)); #line 1767 IRO_ASSERT(ls != NULL); #ifdef IRO_DEBUG ls->block = NULL; ls->rtype = NULL; ls->u.known.field = cint64_zero; ls->u.known.stride = 0; #endif return ls; } inline void LocationSet_Delete(LocationSet *ls) { #line 1781 IRO_ASSERT(ls != NULL); IRO_ASSERT(ls != stUnknownLs); IRO_ASSERT(ls->block == NULL); IRO_ASSERT(CInt64_IsZero(&ls->u.known.field)); IRO_ASSERT(ls->u.known.stride == 0); IRO_ASSERT(ls->rtype == NULL); IRO_DEBUG_CLEAR(ls, sizeof(LocationSet)); IRO_free(ls); } inline void LocationSet_InitKnown(LocationSet *ls, PAMemoryBlock *block, CInt64 field, UInt32 stride, Type *rtype) { #line 1796 IRO_ASSERT(ls != NULL); IRO_ASSERT(ls != stUnknownLs); IRO_ASSERT(block != NULL); IRO_ASSERT(rtype == NULL || rtype != NULL); ls->block = block; ls->rtype = rtype; ls->u.known.field = field; ls->u.known.stride = stride; } inline void LocationSet_InitUnknown(LocationSet *ls, Type *rtype, PAMemoryBlock *restriction, LocationSet *bitfieldOf) { #line 1809 IRO_ASSERT(ls != NULL); IRO_ASSERT(ls != stUnknownLs); IRO_ASSERT(rtype == NULL || rtype != NULL); IRO_ASSERT(restriction == NULL || restriction != NULL); IRO_ASSERT(bitfieldOf == NULL || bitfieldOf != NULL); LocationSet_Copy(ls, stUnknownLs); ls->rtype = rtype; ls->u.unknown.restriction = restriction; if (bitfieldOf) { ls->u.unknown.bitfieldOf = LocationSet_New(); LocationSet_Copy(ls->u.unknown.bitfieldOf, bitfieldOf); } else { ls->u.unknown.bitfieldOf = NULL; } } inline void LocationSet_Copy(LocationSet *dest, LocationSet *src) { #line 1829 IRO_ASSERT(src != NULL); IRO_ASSERT(dest != NULL); dest->block = src->block; dest->rtype = src->rtype; if (!LocationSet_IsUnknown(src)) { dest->u.known.field = src->u.known.field; dest->u.known.stride = src->u.known.stride; } else { dest->u.unknown.restriction = src->u.unknown.restriction; if (src->u.unknown.bitfieldOf != NULL) { dest->u.unknown.bitfieldOf = LocationSet_New(); LocationSet_Copy(dest->u.unknown.bitfieldOf, src->u.unknown.bitfieldOf); } else { dest->u.unknown.bitfieldOf = NULL; } } } inline void LocationSet_Term(LocationSet *ls) { #line 1857 IRO_ASSERT(ls != NULL); IRO_ASSERT(ls != stUnknownLs); #ifdef IRO_DEBUG if (LocationSet_IsUnknown(ls) && ls->u.unknown.bitfieldOf) { LocationSet_Term(ls->u.unknown.bitfieldOf); LocationSet_Delete(ls->u.unknown.bitfieldOf); } ls->block = NULL; ls->rtype = NULL; ls->u.known.field = cint64_zero; ls->u.known.stride = 0; #endif } inline Boolean LocationSets_Overlap(LocationSet *ls1, Type *rtype1, LocationSet *ls2, Type *rtype2) { Boolean isUnknown1, isUnknown2; PAMemoryBlock *restriction1, *restriction2; #line 1974 IRO_ASSERT(ls1 != NULL); IRO_ASSERT(rtype1 == NULL || rtype1 != NULL); IRO_ASSERT(ls2 != NULL); IRO_ASSERT(rtype2 == NULL || rtype2 != NULL); if (ls1 == ls2) return 1; isUnknown1 = LocationSet_IsUnknown(ls1); if (isUnknown1) restriction1 = ls1->u.unknown.restriction; else restriction1 = NULL; isUnknown2 = LocationSet_IsUnknown(ls2); if (isUnknown2) restriction2 = ls2->u.unknown.restriction; else restriction2 = NULL; if ( (isUnknown1 && !restriction1) || (isUnknown2 && !restriction2) || (isUnknown1 && isUnknown2 && MemoryBlocks_Equal(restriction1, restriction2)) ) return 1; if (isUnknown1 || isUnknown2) return 0; if (MemoryBlocks_Equal(ls1->block, ls2->block)) { UInt32 size1; UInt32 size2; UInt32 i; CInt64 work; CInt64 longgcd; if (rtype1) size1 = rtype1->size; else size1 = -1; if (rtype2) size2 = rtype2->size; else size2 = -1; if (ls1->u.known.stride == ls2->u.known.stride) { CInt64 longsize1; CInt64 longsize2; CInt64_SetULong(&longsize1, size1); CInt64_SetULong(&longsize2, size2); return CInt64_Equal(ls1->u.known.field, ls2->u.known.field) || (CInt64_Less(ls1->u.known.field, ls2->u.known.field) && CInt64_Greater(CInt64_Add(ls1->u.known.field, longsize1), ls2->u.known.field)) || (CInt64_Less(ls2->u.known.field, ls1->u.known.field) && CInt64_Greater(CInt64_Add(ls2->u.known.field, longsize2), ls1->u.known.field)); } else { work = CInt64_Sub(ls1->u.known.field, ls2->u.known.field); if (CInt64_IsNegative(&work)) work = CInt64_Neg(work); CInt64_SetULong(&longgcd, gcd(ls1->u.known.stride, ls2->u.known.stride)); if (CInt64_Equal(CInt64_ModU(work, longgcd), cint64_zero)) return 1; if (size1 == -1) return 1; for (i = 1; i < size1; i++) { CInt64_SetLong(&work, i); work = CInt64_Add(work, ls1->u.known.field); work = CInt64_Sub(work, ls2->u.known.field); if (CInt64_IsNegative(&work)) work = CInt64_Neg(work); if (CInt64_Equal(CInt64_ModU(work, longgcd), cint64_zero)) return 1; } if (size2 == -1) return 1; for (i = 1; i < size2; i++) { CInt64_SetLong(&work, i); work = CInt64_Add(work, ls2->u.known.field); work = CInt64_Sub(work, ls1->u.known.field); if (CInt64_IsNegative(&work)) work = CInt64_Neg(work); if (CInt64_Equal(CInt64_ModU(work, longgcd), cint64_zero)) return 1; } return 0; } } return 0; } inline Boolean LocationSets_Equal(LocationSet *ls1, LocationSet *ls2) { #line 2080 IRO_ASSERT(ls1 != NULL); IRO_ASSERT(ls2 != NULL); return (ls1 == ls2) || ( (LocationSet_IsUnknown(ls1) && LocationSet_IsUnknown(ls2)) && (MemoryBlocks_Equal(ls1->u.unknown.restriction, ls2->u.unknown.restriction)) && ((ls1->u.unknown.bitfieldOf == ls2->u.unknown.bitfieldOf) || (ls1->u.unknown.bitfieldOf && ls2->u.unknown.bitfieldOf && LocationSets_Equal(ls1->u.unknown.bitfieldOf, ls2->u.unknown.bitfieldOf))) && ((ls1->rtype == ls2->rtype) || (ls1->rtype && ls2->rtype && ls1->rtype->size == ls2->rtype->size)) ) || ( (!LocationSet_IsUnknown(ls1) && !LocationSet_IsUnknown(ls2)) && (ls1->u.known.stride == ls2->u.known.stride) && ((ls1->rtype == ls2->rtype) || (ls1->rtype && ls2->rtype && ls1->rtype->size == ls2->rtype->size)) && CInt64_Equal(ls1->u.known.field, ls2->u.known.field) && MemoryBlocks_Equal(ls1->block, ls2->block) ); } inline Boolean LocationSets_LookupCompatible(LocationSet *ls1, LocationSet *ls2) { #line 2119 IRO_ASSERT(ls1 != NULL); IRO_ASSERT(ls2 != NULL); if ( (ls1 == ls2) || ( LocationSet_IsUnknown(ls1) && LocationSet_IsUnknown(ls2) && MemoryBlocks_Equal(ls1->u.unknown.restriction, ls2->u.unknown.restriction) && (ls1->rtype == ls2->rtype || (ls1->rtype && ls2->rtype && ls1->rtype->size == ls2->rtype->size)) )) return 1; if ( (!LocationSet_IsUnknown(ls1) && !LocationSet_IsUnknown(ls2)) && (ls1->rtype == ls2->rtype || (ls1->rtype && ls2->rtype && ls1->rtype->size == ls2->rtype->size)) && MemoryBlocks_Equal(ls1->block, ls2->block) ) { CInt64 work; CInt64 longgcd; if (ls1->u.known.stride == ls2->u.known.stride) return CInt64_Equal(ls1->u.known.field, ls2->u.known.field); work = CInt64_Sub(ls1->u.known.field, ls2->u.known.field); if (CInt64_IsNegative(&work)) work = CInt64_Neg(work); CInt64_SetULong(&longgcd, gcd(ls1->u.known.stride, ls2->u.known.stride)); return CInt64_Equal(CInt64_ModU(work, longgcd), cint64_zero); } return 0; } inline Boolean LocationSet_Contains(LocationSet *ls1, Type *rtype1, LocationSet *ls2, Type *rtype2) { Boolean unknown1; Boolean unknown2; PAMemoryBlock *restriction2; PAMemoryBlock *restriction1; CInt64 longsize1; CInt64 longsize2; #line 2168 IRO_ASSERT(ls1 != NULL); IRO_ASSERT(ls2 != NULL); IRO_ASSERT(rtype1 != NULL); IRO_ASSERT(rtype2 != NULL); if (ls1 == ls2) return 1; unknown1 = LocationSet_IsUnknown(ls1); if (unknown1) restriction1 = ls1->u.unknown.restriction; else restriction1 = NULL; unknown2 = LocationSet_IsUnknown(ls2); if (unknown2) restriction2 = ls2->u.unknown.restriction; else restriction2 = NULL; if (unknown1) return !restriction1 || (unknown2 && MemoryBlocks_Equal(restriction2, restriction1)); CInt64_SetULong(&longsize1, rtype1->size); CInt64_SetULong(&longsize2, rtype2->size); return !LocationSet_IsUnknown(ls2) && (ls1->u.known.stride == 0) && (ls2->u.known.stride == 0) && rtype1->size >= rtype2->size && CInt64_LessEqual(ls1->u.known.field, ls2->u.known.field) && CInt64_GreaterEqual(CInt64_Add(ls1->u.known.field, longsize1), CInt64_Add(ls2->u.known.field, longsize2)) && MemoryBlocks_Equal(ls1->block, ls2->block); } inline Boolean LocationSet_IsUnknown(LocationSet *ls) { #line 2233 IRO_ASSERT(ls != NULL); return (ls == stUnknownLs) || (ls->block == stUnknownMb); } inline Boolean LocationSet_sub_48AF30(LocationSet *ls) { return !LocationSet_IsUnknown(ls) && (ls->u.known.stride == 0) && CInt64_IsZero(&ls->u.known.field) && PAMemoryBlock_kind(ls->block) == PAMEMORYBLOCKKIND_LOCALVAR && !PAMemoryBlock_thing(ls->block); } inline void LocationSet_SetRtype(LocationSet *ls, Type *rtype) { #line 2263 IRO_ASSERT(ls != NULL); IRO_ASSERT(ls != stUnknownLs); IRO_ASSERT(rtype != NULL); ls->rtype = rtype; } inline void SetsLocationSetField_sub_4851B0(LocationSet *ls, CInt64 field) { #line 2272 IRO_ASSERT(ls != NULL); IRO_ASSERT(!LocationSet_IsUnknown(ls)); ls->u.known.field = field; } inline void SetsLocationSetStride_sub_4852D0(LocationSet *ls, SInt32 stride) { #line 2280 IRO_ASSERT(ls != NULL); IRO_ASSERT(!LocationSet_IsUnknown(ls)); ls->u.known.stride = stride; } inline PAMemoryBlock *LocationSet_block(LocationSet *ls) { #line 2298 IRO_ASSERT(ls != NULL); return ls->block; } inline Type *LocationSet_rtype(LocationSet *ls) { #line 2306 IRO_ASSERT(ls != NULL); IRO_ASSERT(ls != stUnknownLs); return ls->rtype; } inline CInt64 LocationSet_field(LocationSet *ls) { #line 2314 IRO_ASSERT(ls != NULL); IRO_ASSERT(!LocationSet_IsUnknown(ls)); return ls->u.known.field; } inline UInt32 LocationSet_stride(LocationSet *ls) { #line 2322 IRO_ASSERT(ls != NULL); IRO_ASSERT(!LocationSet_IsUnknown(ls)); return ls->u.known.stride; } inline PAMemoryBlock *LocationSet_restriction(LocationSet *ls) { #line 2330 IRO_ASSERT(ls != NULL); IRO_ASSERT(LocationSet_IsUnknown(ls)); return ls->u.unknown.restriction; } inline LocationSet *LocationSet_bitfieldOf(LocationSet *ls) { #line 2338 IRO_ASSERT(ls != NULL); IRO_ASSERT(LocationSet_IsUnknown(ls)); return ls->u.unknown.bitfieldOf; } inline LocationSetSet *LocationSetSet_New() { LocationSetSet *lss = IRO_malloc(sizeof(LocationSetSet)); #line 2356 IRO_ASSERT(lss != NULL); #ifdef IRO_DEBUG lss->loc = NULL; lss->otherLocs = NULL; lss->count = 0; #endif return lss; } inline void LocationSetSet_Delete(LocationSetSet *lss) { #line 2369 IRO_ASSERT(lss != NULL); IRO_ASSERT(lss->loc == NULL); IRO_ASSERT(lss->otherLocs == NULL); IRO_ASSERT(lss->count == 0); IRO_DEBUG_CLEAR(lss, sizeof(LocationSetSet)); IRO_free(lss); } inline void LocationSetSet_Init(LocationSetSet *lss) { #line 2382 IRO_ASSERT(lss != NULL); lss->loc = NULL; lss->otherLocs = NULL; lss->count = 0; } inline void LocationSetSet_Copy(LocationSetSet *dest, LocationSetSet *src) { #line 2391 IRO_ASSERT(dest != NULL); IRO_ASSERT(src != NULL); dest->loc = NULL; dest->otherLocs = NULL; dest->count = 0; LocationSetSet_AddSet(dest, src); } inline void LocationSetSet_Term(LocationSetSet *lss) { #line 2402 IRO_ASSERT(lss != NULL); LocationSetSet_RemoveAll(lss); #ifdef IRO_DEBUG lss->loc = NULL; lss->otherLocs = NULL; lss->count = 0; #endif } inline void LocationSetSet_ForEach(LocationSetSet *lss, void (*action)(LocationSet *, void *), void *refcon) { #line 2446 IRO_ASSERT(lss != NULL); IRO_ASSERT(action != NULL); IRO_ASSERT(refcon == NULL || refcon != NULL); while (lss && lss->loc) { action(lss->loc, refcon); lss = lss->otherLocs; } } inline LocationSet *LocationSetSet_Find(LocationSetSet *lss, LocationSet *ls) { #line 2458 IRO_ASSERT(lss != NULL); IRO_ASSERT(ls != NULL); while (lss && lss->loc) { if (LocationSets_Equal(lss->loc, ls)) return lss->loc; lss = lss->otherLocs; } return NULL; } inline LocationSet *LocationSetSet_FindUnknown(LocationSetSet *lss) { #line 2470 IRO_ASSERT(lss != NULL); if (!lss->loc) return stUnknownLs; while (lss && lss->loc) { if (LocationSet_IsUnknown(lss->loc)) return lss->loc; lss = lss->otherLocs; } return NULL; } inline LocationSet *LocationSetSet_FindFirst(LocationSetSet *lss) { #line 2498 IRO_ASSERT(lss != NULL); return lss->loc; } inline int LocationSetSet_Count(LocationSetSet *lss) { #line 2505 IRO_ASSERT(lss != NULL); return lss->count; } inline void LocationSetSet_RemoveAllWithMemoryBlock(LocationSetSet *lss, PAMemoryBlock *block) { LocationSetSet *first; LocationSetSet *prev; LocationSetSet *next; LocationSetSet *tmp; #line 2514 IRO_ASSERT(lss != NULL); IRO_ASSERT(block != NULL); first = lss; prev = NULL; while (lss && lss->loc) { next = lss->otherLocs; if (MemoryBlocks_Equal(block, lss->loc->block)) { if (lss->loc != stUnknownLs) { LocationSet_Term(lss->loc); LocationSet_Delete(lss->loc); } if (!prev) { if (lss->otherLocs == NULL) { lss->loc = NULL; prev = lss; } else { tmp = lss->otherLocs; lss->loc = lss->otherLocs->loc; lss->otherLocs = lss->otherLocs->otherLocs; tmp->loc = NULL; tmp->otherLocs = NULL; LocationSetSet_Term(tmp); LocationSetSet_Delete(tmp); prev = NULL; next = lss; } } else { prev->otherLocs = lss->otherLocs; lss->loc = NULL; lss->otherLocs = NULL; LocationSetSet_Term(lss); LocationSetSet_Delete(lss); prev = lss; } first->count--; } lss = next; } } inline void LocationSetSet_SimpleAdd(LocationSetSet *lss, LocationSet *ls) { #line 2572 IRO_ASSERT(lss != NULL); IRO_ASSERT(ls != NULL); if (!LocationSet_IsUnknown(ls) && lss->count < 4) { LocationSet *ls2; if (ls == stUnknownLs) { ls2 = stUnknownLs; } else { ls2 = LocationSet_New(); LocationSet_Copy(ls2, ls); } if (lss->loc) { LocationSetSet *lss2 = LocationSetSet_New(); LocationSetSet_Init(lss2); lss2->loc = lss->loc; lss2->otherLocs = lss->otherLocs; lss->otherLocs = lss2; } lss->loc = ls2; lss->count++; } else { LocationSet *ls2; LocationSetSet_RemoveAll(lss); ls2 = LocationSet_New(); if (LocationSet_IsUnknown(ls)) { LocationSet_Copy(ls2, ls); } else { LocationSet_Copy(ls2, stUnknownLs); if (ls->rtype) LocationSet_SetRtype(ls2, ls->rtype); } lss->loc = ls2; lss->count = 1; } } inline void LocationSetSet_Add(LocationSetSet *lss, LocationSet *ls) { #line 2622 IRO_ASSERT(lss != NULL); IRO_ASSERT(ls != NULL); if (!lss->loc || (!LocationSet_IsUnknown(lss->loc) && !LocationSetSet_Find(lss, ls))) { if (!LocationSet_IsUnknown(ls) && ls->u.known.stride) LocationSetSet_RemoveAllWithMemoryBlock(lss, ls->block); LocationSetSet_SimpleAdd(lss, ls); } } inline void LocationSetSet_AddUnknown(LocationSetSet *lss, Type *rtype, PAMemoryBlock *restriction, LocationSet *bitfieldOf) { LocationSet *ls; #line 2643 IRO_ASSERT(lss != NULL); IRO_ASSERT(rtype == NULL || rtype != NULL); IRO_ASSERT(restriction == NULL || restriction != NULL); IRO_ASSERT(bitfieldOf == NULL || bitfieldOf != NULL); ls = LocationSet_New(); LocationSet_InitUnknown(ls, rtype, restriction, bitfieldOf); LocationSetSet_Add(lss, ls); LocationSet_Term(ls); LocationSet_Delete(ls); } inline void LocationSetSet_Remove(LocationSetSet *lss, LocationSet *ls) { LocationSetSet *prev; LocationSetSet *first; LocationSetSet *tmp; #line 2659 IRO_ASSERT(lss != NULL); IRO_ASSERT(ls != NULL); first = lss; prev = NULL; while (lss && lss->loc) { if (LocationSets_Equal(lss->loc, ls)) { if (lss->loc != stUnknownLs) { LocationSet_Term(lss->loc); LocationSet_Delete(lss->loc); } if (!prev) { if (lss->otherLocs == NULL) { lss->loc = NULL; } else { tmp = lss->otherLocs; lss->loc = lss->otherLocs->loc; lss->otherLocs = lss->otherLocs->otherLocs; tmp->loc = NULL; tmp->otherLocs = NULL; LocationSetSet_Term(tmp); LocationSetSet_Delete(tmp); } } else { prev->otherLocs = lss->otherLocs; lss->loc = NULL; lss->otherLocs = NULL; LocationSetSet_Term(lss); LocationSetSet_Delete(lss); } first->count--; return; } prev = lss; lss = lss->otherLocs; } } inline void LocationSetSet_RemoveAll(LocationSetSet *lss) { #line 2707 IRO_ASSERT(lss != NULL); while (lss && lss->loc) LocationSetSet_Remove(lss, lss->loc); } inline void LocationSetSet_AddSetAction(LocationSet *ls, void *refcon) { #line 2717 IRO_ASSERT(ls != NULL); IRO_ASSERT(refcon != NULL); LocationSetSet_Add((LocationSetSet *) refcon, ls); } inline void LocationSetSet_SimpleAddSetAction(LocationSet *ls, void *refcon) { #line 2725 IRO_ASSERT(ls != NULL); IRO_ASSERT(refcon != NULL); LocationSetSet_SimpleAdd((LocationSetSet *) refcon, ls); } inline void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src) { #line 2733 IRO_ASSERT(dest != NULL); IRO_ASSERT(src != NULL); if (dest->count) LocationSetSet_ForEach(src, LocationSetSet_AddSetAction, dest); else LocationSetSet_ForEach(src, LocationSetSet_SimpleAddSetAction, dest); } inline void LocationSetSet_RemoveSetAction(LocationSet *ls, void *refcon) { #line 2744 IRO_ASSERT(ls != NULL); IRO_ASSERT(refcon != NULL); LocationSetSet_Remove((LocationSetSet *) refcon, ls); } inline void LocationSetSet_sub_488700(LocationSetSet *dest, LocationSetSet *src) { #line 2752 IRO_ASSERT(dest != NULL); IRO_ASSERT(src != NULL); LocationSetSet_ForEach(src, LocationSetSet_RemoveSetAction, dest); } inline Boolean LocationSetSets_Equal(LocationSetSet *lss1, LocationSetSet *lss2) { #line 2826 IRO_ASSERT(lss1 != NULL); IRO_ASSERT(lss2 != NULL); if (lss1 == lss2) return 1; if (LocationSetSet_Count(lss1) != LocationSetSet_Count(lss2)) return 0; while (lss1 && lss1->loc) { if (!LocationSetSet_Find(lss2, lss1->loc)) return 0; lss1 = lss1->otherLocs; } return 1; } inline ParamMapping *ParamMapping_New(void) { ParamMapping *pm = IRO_malloc(sizeof(ParamMapping)); #line 2885 IRO_ASSERT(pm != NULL); #ifdef IRO_DEBUG pm->actual = NULL; pm->formal = NULL; pm->extended = NULL; #endif return pm; } inline void ParamMapping_Delete(ParamMapping *pm) { #line 2898 IRO_ASSERT(pm != NULL); IRO_ASSERT(pm->actual == NULL); IRO_ASSERT(pm->formal == NULL); IRO_ASSERT(pm->extended == NULL); IRO_DEBUG_CLEAR(pm, sizeof(ParamMapping)); IRO_free(pm); } inline void ParamMapping_Init_PROBABLY(ParamMapping *pm, IROLinear *actual, Object *formal, ExtendedParam *extended) { #line 2911 IRO_ASSERT(pm != NULL); pm->actual = actual; pm->formal = formal; pm->extended = extended; } inline void ParamMapping_Copy(ParamMapping *dest, ParamMapping *src) { #line 2920 IRO_ASSERT(src != NULL); IRO_ASSERT(dest != NULL); dest->actual = src->actual; dest->formal = src->formal; dest->extended = src->extended; } inline void ParamMapping_Term(ParamMapping *pm) { #line 2933 IRO_ASSERT(pm != NULL); #ifdef IRO_DEBUG pm->actual = NULL; pm->formal = NULL; pm->extended = NULL; #endif } inline void ParamMapping_SetExtended(ParamMapping *pm, ExtendedParam *ep) { #line 2992 IRO_ASSERT(pm != NULL); pm->extended = ep; } inline IROLinear *ParamMapping_actual(ParamMapping *pm) { #line 2999 IRO_ASSERT(pm != NULL); return pm->actual; } inline ExtendedParam *ParamMapping_extended(ParamMapping *pm) { #line 3011 IRO_ASSERT(pm != NULL); return pm->extended; } inline ParamMappingFunction *ParamMappingFunction_New(void) { ParamMappingFunction *pmf = IRO_malloc(sizeof(ParamMappingFunction)); #line 3026 IRO_ASSERT(pmf != NULL); #ifdef IRO_DEBUG pmf->mapping = NULL; pmf->otherMappings = NULL; #endif return pmf; } inline void ParamMappingFunction_Delete(ParamMappingFunction *pmf) { #line 3039 IRO_ASSERT(pmf != NULL); IRO_ASSERT(pmf->mapping == NULL); IRO_ASSERT(pmf->otherMappings == NULL); IRO_DEBUG_CLEAR(pmf, sizeof(ParamMappingFunction)); IRO_free(pmf); } inline void ParamMappingFunction_Init(ParamMappingFunction *pmf) { #line 3050 IRO_ASSERT(pmf != NULL); pmf->mapping = NULL; pmf->otherMappings = NULL; } inline void ParamMappingFunction_Copy(ParamMappingFunction *dest, ParamMappingFunction *src) { #line 3058 IRO_ASSERT(src != NULL); IRO_ASSERT(dest != NULL); dest->mapping = NULL; dest->otherMappings = NULL; ParamMappingFunction_AddAllMaybe_sub_487C50(dest, src); } inline void ParamMappingFunction_Term(ParamMappingFunction *pmf) { #line 3068 IRO_ASSERT(pmf != NULL); ParamMappingFunction_RemoveAll(pmf); #ifdef IRO_DEBUG pmf->mapping = NULL; pmf->otherMappings = NULL; #endif } inline void pmf_sub_487C70(ParamMappingFunction *pmf, void (*action)(ParamMapping *, void *), void *refcon) { #line 3111 IRO_ASSERT(pmf != NULL); IRO_ASSERT(action != NULL); IRO_ASSERT(refcon == NULL || refcon != NULL); while (pmf && pmf->mapping) { action(pmf->mapping, refcon); pmf = pmf->otherMappings; } } inline ParamMapping *ParamMappingFunction_FindMappingByFormal(ParamMappingFunction *pmf, Object *formal) { #line 3123 IRO_ASSERT(pmf != NULL); IRO_ASSERT(formal != NULL); while (pmf && pmf->mapping) { if (pmf->mapping->formal == formal) return pmf->mapping; pmf = pmf->otherMappings; } return NULL; } inline void Pmf_Add_sub_486610(ParamMappingFunction *pmf, ParamMapping *mapping) { ParamMapping *existing; #line 3138 IRO_ASSERT(pmf != NULL); IRO_ASSERT(mapping != NULL); existing = ParamMappingFunction_FindMappingByFormal(pmf, mapping->formal); if (!existing) { existing = ParamMapping_New(); ParamMapping_Copy(existing, mapping); if (pmf->mapping) { ParamMappingFunction *newPMF = ParamMappingFunction_New(); ParamMappingFunction_Init(newPMF); newPMF->mapping = pmf->mapping; newPMF->otherMappings = pmf->otherMappings; pmf->otherMappings = newPMF; } pmf->mapping = existing; } else { existing->actual = mapping->actual; existing->extended = mapping->extended; } } inline void ParamMappingFunction_Remove(ParamMappingFunction *pmf, ParamMapping *mapping) { ParamMappingFunction *prev; ParamMappingFunction *tmp; #line 3170 IRO_ASSERT(pmf != NULL); IRO_ASSERT(mapping != NULL); prev = NULL; while (pmf && pmf->mapping) { if (pmf->mapping->formal == mapping->formal) { ParamMapping_Term(pmf->mapping); ParamMapping_Delete(pmf->mapping); if (!prev) { if (pmf->otherMappings == NULL) { pmf->mapping = NULL; } else { tmp = pmf->otherMappings; pmf->mapping = pmf->otherMappings->mapping; pmf->otherMappings = pmf->otherMappings->otherMappings; tmp->mapping = NULL; tmp->otherMappings = NULL; ParamMappingFunction_Term(tmp); ParamMappingFunction_Delete(tmp); } } else { prev->otherMappings = pmf->otherMappings; pmf->mapping = NULL; pmf->otherMappings = NULL; ParamMappingFunction_Term(pmf); ParamMappingFunction_Delete(pmf); } return; } prev = pmf; pmf = pmf->otherMappings; } } inline void ParamMappingFunction_RemoveAll(ParamMappingFunction *pmf) { #line 3213 IRO_ASSERT(pmf != NULL); while (pmf && pmf->mapping) ParamMappingFunction_Remove(pmf, pmf->mapping); } inline void ParamMappingFunction_AddFunctionAction(ParamMapping *mapping, void *refcon) { #line 3223 IRO_ASSERT(mapping != NULL); IRO_ASSERT(refcon != NULL); Pmf_Add_sub_486610((ParamMappingFunction *) refcon, mapping); } inline void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *dest, ParamMappingFunction *src) { #line 3231 IRO_ASSERT(dest != NULL); IRO_ASSERT(src != NULL); pmf_sub_487C70(src, ParamMappingFunction_AddFunctionAction, dest); } inline PointsToEntry *PointsToEntry_New(void) { PointsToEntry *pte = IRO_malloc(sizeof(PointsToEntry)); #line 3288 IRO_ASSERT(pte != NULL); #ifdef IRO_DEBUG pte->loc = NULL; pte->locs = NULL; #endif return pte; } inline void PointsToEntry_Delete(PointsToEntry *pte) { #line 3300 IRO_ASSERT(pte != NULL); IRO_ASSERT(pte->loc == NULL); IRO_ASSERT(pte->locs == NULL); IRO_DEBUG_CLEAR(pte, sizeof(PointsToEntry)); IRO_free(pte); } inline void PointsToEntry_Init(PointsToEntry *pte, LocationSet *loc, LocationSetSet *locs) { #line 3312 IRO_ASSERT(pte != NULL); IRO_ASSERT(loc != NULL); IRO_ASSERT(!LocationSet_IsUnknown(loc)); IRO_ASSERT(locs != NULL); pte->loc = LocationSet_New(); LocationSet_Copy(pte->loc, loc); pte->locs = LocationSetSet_New(); LocationSetSet_Copy(pte->locs, locs); } inline void PointsToEntry_Copy(PointsToEntry *dest, PointsToEntry *src) { #line 3325 IRO_ASSERT(src != NULL); IRO_ASSERT(dest != NULL); PointsToEntry_Init(dest, src->loc, src->locs); } inline void PointsToEntry_Term(PointsToEntry *pte) { #line 3333 IRO_ASSERT(pte != NULL); LocationSet_Term(pte->loc); LocationSet_Delete(pte->loc); LocationSetSet_Term(pte->locs); LocationSetSet_Delete(pte->locs); #ifdef IRO_DEBUG pte->loc = NULL; pte->locs = NULL; #endif } inline Boolean PointsToEntries_Equal(PointsToEntry *pte1, PointsToEntry *pte2) { #line 3381 IRO_ASSERT(pte1 != NULL); IRO_ASSERT(pte2 != NULL); if (pte1 == pte2) return 1; return LocationSets_Equal(pte1->loc, pte2->loc) && LocationSetSets_Equal(pte1->locs, pte2->locs); } inline LocationSet *PointsToEntry_loc(PointsToEntry *pte) { #line 3407 IRO_ASSERT(pte != NULL); return pte->loc; } inline LocationSetSet *PointsToEntry_locs(PointsToEntry *pte) { #line 3414 IRO_ASSERT(pte != NULL); return pte->locs; } inline PointsToFunction *PointsToFunction_New(void) { PointsToFunction *pointsToFunc = IRO_malloc(sizeof(PointsToFunction)); #line 3430 IRO_ASSERT(pointsToFunc != NULL); #ifdef IRO_DEBUG pointsToFunc->pte = NULL; pointsToFunc->otherPtes = NULL; #endif return pointsToFunc; } inline void PointsToFunction_Delete(PointsToFunction *pointsToFunc) { #line 3442 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(pointsToFunc->pte == NULL); IRO_ASSERT(pointsToFunc->otherPtes == NULL); IRO_DEBUG_CLEAR(pointsToFunc, sizeof(PointsToFunction)); IRO_free(pointsToFunc); } inline void PointsToFunction_Init(PointsToFunction *pointsToFunc) { #line 3454 IRO_ASSERT(pointsToFunc != NULL); pointsToFunc->pte = NULL; pointsToFunc->otherPtes = NULL; } inline void PointsToFunction_Copy(PointsToFunction *dest, PointsToFunction *src) { #line 3462 IRO_ASSERT(src != NULL); IRO_ASSERT(dest != NULL); dest->pte = NULL; dest->otherPtes = NULL; PointsToFunction_AddAllIGuess_sub_487D80(dest, src); } inline void PointsToFunction_Term(PointsToFunction *pointsToFunc) { #line 3472 IRO_ASSERT(pointsToFunc != NULL); PointsToFunction_RemoveAll(pointsToFunc); #ifdef IRO_DEBUG pointsToFunc->pte = NULL; pointsToFunc->otherPtes = NULL; #endif } inline void PointsToFunction_ForEach(PointsToFunction *pointsToFunc, void (*action)(PointsToEntry *, void *), void *refcon) { #line 3515 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(action != NULL); IRO_ASSERT(refcon == NULL || refcon != NULL); while (pointsToFunc && pointsToFunc->pte) { action(pointsToFunc->pte, refcon); pointsToFunc = pointsToFunc->otherPtes; } } inline PointsToEntry *PointsToFunction_FindByLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) { #line 3527 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(ls != NULL); while (pointsToFunc && pointsToFunc->pte) { if (LocationSets_Equal(pointsToFunc->pte->loc, ls)) return pointsToFunc->pte; pointsToFunc = pointsToFunc->otherPtes; } return NULL; } inline PointsToEntry *PointsToFunction_FindFirst(PointsToFunction *pointsToFunc) { #line 3539 IRO_ASSERT(pointsToFunc != NULL); return pointsToFunc->pte; } inline PointsToEntry *PointsToFunction_FindByLookupCompatibleLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) { #line 3546 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(ls != NULL); while (pointsToFunc && pointsToFunc->pte) { if (ls->u.known.stride) { if (LocationSets_Equal(pointsToFunc->pte->loc, ls)) return pointsToFunc->pte; } else if (LocationSets_LookupCompatible(pointsToFunc->pte->loc, ls)) { return pointsToFunc->pte; } pointsToFunc = pointsToFunc->otherPtes; } return NULL; } inline PointsToEntry *PointsToFunction_FindContainingLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls, Type *rtype) { #line 3565 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(ls != NULL); IRO_ASSERT(rtype != NULL); while (pointsToFunc && pointsToFunc->pte) { if (pointsToFunc->pte->locs->loc && !LocationSet_IsUnknown(pointsToFunc->pte->locs->loc)) { if (!pointsToFunc->pte->locs->otherLocs && LocationSet_Contains(pointsToFunc->pte->loc, pointsToFunc->pte->locs->loc->rtype, ls, rtype)) return pointsToFunc->pte; } pointsToFunc = pointsToFunc->otherPtes; } return NULL; } inline void PointsToFunction_RemoveOverlappingLocations(PointsToFunction *pointsToFunc, PointsToEntry *pte) { Type *rtype1; Type *rtype2; LocationSet *ls; PointsToFunction *prev; PointsToFunction *next; PointsToFunction *tmp; #line 3601 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(pte != NULL); IRO_ASSERT(pte->locs != NULL); if (pte->locs->loc && pte->locs->loc != stUnknownLs) rtype1 = pte->locs->loc->rtype; else rtype1 = NULL; ls = pte->loc; #line 3614 IRO_ASSERT(ls != NULL); prev = NULL; while (pointsToFunc && pointsToFunc->pte) { next = pointsToFunc->otherPtes; if (pointsToFunc->pte->locs->loc && pointsToFunc->pte->locs->loc != stUnknownLs) rtype2 = pointsToFunc->pte->locs->loc->rtype; else rtype2 = NULL; if (LocationSets_Overlap(ls, rtype1, pointsToFunc->pte->loc, rtype2)) { PointsToEntry_Term(pointsToFunc->pte); PointsToEntry_Delete(pointsToFunc->pte); if (!prev) { if (pointsToFunc->otherPtes == NULL) { pointsToFunc->pte = NULL; prev = pointsToFunc; } else { tmp = pointsToFunc->otherPtes; pointsToFunc->pte = pointsToFunc->otherPtes->pte; pointsToFunc->otherPtes = pointsToFunc->otherPtes->otherPtes; tmp->pte = NULL; tmp->otherPtes = NULL; PointsToFunction_Term(tmp); PointsToFunction_Delete(tmp); prev = NULL; next = pointsToFunc; } } else { prev->otherPtes = pointsToFunc->otherPtes; pointsToFunc->pte = NULL; pointsToFunc->otherPtes = NULL; PointsToFunction_Term(pointsToFunc); PointsToFunction_Delete(pointsToFunc); prev = pointsToFunc; } } pointsToFunc = next; } } inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFunc, PointsToEntry *pte) { Boolean flag; Boolean isKnown; SInt32 stride; PointsToFunction *next; LocationSet *loc; LocationSet *loc2; Type *rtype1; Type *rtype2; LocationSetSet *locs2; LocationSet *tmp; LocationSet *unknown; Boolean flag2; Boolean flag3; #line 3675 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(pte != NULL); IRO_ASSERT(pte->locs != NULL); IRO_ASSERT(PointsToFunction_FindByLookupCompatibleLocationSet(pointsToFunc, pte->loc) == NULL); IRO_ASSERT((unknown = LocationSetSet_FindFirst(pte->locs)) != NULL); IRO_ASSERT(LocationSet_IsUnknown(unknown)); IRO_ASSERT(LocationSet_bitfieldOf(unknown) == NULL); IRO_ASSERT(LocationSet_restriction(unknown) == NULL); if (pte->locs->loc && pte->locs->loc != stUnknownLs) rtype1 = pte->locs->loc->rtype; else rtype1 = NULL; loc = pte->loc; #line 3693 IRO_ASSERT(loc != NULL); isKnown = !LocationSet_IsUnknown(loc); if (isKnown) stride = LocationSet_stride(loc); flag = 0; while (pointsToFunc && pointsToFunc->pte) { next = pointsToFunc->otherPtes; locs2 = pointsToFunc->pte->locs; if (locs2->loc && locs2->loc != stUnknownLs) rtype2 = locs2->loc->rtype; else rtype2 = NULL; loc2 = pointsToFunc->pte->loc; flag2 = !(tmp = LocationSetSet_FindFirst(locs2)) || !LocationSet_IsUnknown(tmp) || LocationSet_bitfieldOf(tmp) || LocationSet_restriction(tmp); flag3 = LocationSets_Overlap(loc, rtype1, loc2, rtype2); if (!flag && flag3) flag = 1; if (flag3 && (flag2 || (isKnown && stride && LocationSet_stride(loc2) == 0))) return 1; pointsToFunc = next; } return !flag; } inline Boolean PointsToFunction_SimpleAdd(PointsToFunction *pointsToFunc, PointsToEntry *pte) { PointsToEntry *newPTE; #line 3741 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(pte != NULL); newPTE = PointsToEntry_New(); PointsToEntry_Copy(newPTE, pte); if (pointsToFunc->pte) { PointsToFunction *newPointsToFunc = PointsToFunction_New(); PointsToFunction_Init(newPointsToFunc); newPointsToFunc->pte = pointsToFunc->pte; newPointsToFunc->otherPtes = pointsToFunc->otherPtes; pointsToFunc->otherPtes = newPointsToFunc; } pointsToFunc->pte = newPTE; return 1; } inline Boolean PointsToFunction_Add(PointsToFunction *pointsToFunc, PointsToEntry *pte) { #line 3766 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(pte != NULL); if (!PointsToFunction_FindByLookupCompatibleLocationSet(pointsToFunc, pte->loc)) { LocationSet *ls; if (!(ls = LocationSetSet_FindFirst(pte->locs)) || !LocationSet_IsUnknown(ls) || LocationSet_bitfieldOf(ls) || LocationSet_restriction(ls) || ShouldAddNewPointsToEntryToFunction(pointsToFunc, pte)) { PointsToFunction_RemoveOverlappingLocations(pointsToFunc, pte); if (!LocationSet_IsUnknown(pte->loc) || pte->loc->rtype) PointsToFunction_SimpleAdd(pointsToFunc, pte); return 1; } } return 0; } inline Boolean PointsToFunction_AddWithoutChecking(PointsToFunction *pointsToFunc, PointsToEntry *pte) { LocationSet *ls; #line 3793 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(pte != NULL); if (!(ls = LocationSetSet_FindFirst(pte->locs)) || !LocationSet_IsUnknown(ls) || LocationSet_bitfieldOf(ls) || LocationSet_restriction(ls) || ShouldAddNewPointsToEntryToFunction(pointsToFunc, pte)) { PointsToFunction_RemoveOverlappingLocations(pointsToFunc, pte); if (!LocationSet_IsUnknown(pte->loc) || pte->loc->rtype) PointsToFunction_SimpleAdd(pointsToFunc, pte); return 1; } return 0; } inline void PointsToFunction_RemoveByLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) { PointsToFunction *prev; PointsToFunction *tmp; #line 3170 IRO_ASSERT(pointsToFunc != NULL); IRO_ASSERT(ls != NULL); IRO_ASSERT(!LocationSet_IsUnknown(ls)); prev = NULL; while (pointsToFunc && pointsToFunc->pte) { if (LocationSets_Equal(pointsToFunc->pte->loc, ls)) { PointsToEntry_Term(pointsToFunc->pte); PointsToEntry_Delete(pointsToFunc->pte); if (!prev) { if (pointsToFunc->otherPtes == NULL) { pointsToFunc->pte = NULL; } else { tmp = pointsToFunc->otherPtes; pointsToFunc->pte = pointsToFunc->otherPtes->pte; pointsToFunc->otherPtes = pointsToFunc->otherPtes->otherPtes; tmp->pte = NULL; tmp->otherPtes = NULL; PointsToFunction_Term(tmp); PointsToFunction_Delete(tmp); } } else { prev->otherPtes = pointsToFunc->otherPtes; pointsToFunc->pte = NULL; pointsToFunc->otherPtes = NULL; PointsToFunction_Term(pointsToFunc); PointsToFunction_Delete(pointsToFunc); } return; } prev = pointsToFunc; pointsToFunc = pointsToFunc->otherPtes; } } inline void PointsToFunction_RemoveAll(PointsToFunction *pointsToFunc) { #line 3862 IRO_ASSERT(pointsToFunc != NULL); while (pointsToFunc && pointsToFunc->pte) PointsToFunction_RemoveByLocationSet(pointsToFunc, pointsToFunc->pte->loc); } inline void PointsToFunction_AddFunctionAction(PointsToEntry *pte, void *refcon) { #line 3872 IRO_ASSERT(pte != NULL); IRO_ASSERT(refcon != NULL); PointsToFunction_Add((PointsToFunction *) refcon, pte); } inline void PointsToFunction_SimpleAddFunctionAction(PointsToEntry *pte, void *refcon) { #line 3880 IRO_ASSERT(pte != NULL); IRO_ASSERT(refcon != NULL); PointsToFunction_SimpleAdd((PointsToFunction *) refcon, pte); } inline void PointsToFunction_AddAllIGuess_sub_487D80(PointsToFunction *dest, PointsToFunction *src) { #line 3888 IRO_ASSERT(dest != NULL); IRO_ASSERT(src != NULL); if (dest->pte) PointsToFunction_ForEach(src, PointsToFunction_AddFunctionAction, dest); else PointsToFunction_ForEach(src, PointsToFunction_SimpleAddFunctionAction, dest); } inline void PointsToFunction_SortByExtendedParamNum(PointsToFunction *pointsToFunc) { UInt32 value1; UInt32 value2; PointsToFunction *scan; while (pointsToFunc && pointsToFunc->pte) { value1 = 0; if (pointsToFunc->pte->loc && pointsToFunc->pte->loc->block) { PAMemoryBlock *block = pointsToFunc->pte->loc->block; if (block->kind == PAMEMORYBLOCKKIND_EXTENDEDPARAM && block->u.ep) { value1 = 2 * (block->u.ep->x4) + 1; } else if (block->kind == PAMEMORYBLOCKKIND_LOCALVAR && block->u.localvar) { if (block->u.localvar->x0 && block->u.localvar->x0->extParam) value1 = 2 * block->u.localvar->x0->extParam->x4; } } for (scan = pointsToFunc->otherPtes; scan && scan->pte; scan = scan->otherPtes) { value2 = 0; if (scan->pte->loc && scan->pte->loc->block) { PAMemoryBlock *block = scan->pte->loc->block; if (block->kind == PAMEMORYBLOCKKIND_EXTENDEDPARAM && block->u.ep) { value2 = 2 * (block->u.ep->x4) + 1; } else if (block->kind == PAMEMORYBLOCKKIND_LOCALVAR && block->u.localvar) { if (block->u.localvar->x0 && block->u.localvar->x0->extParam) value2 = 2 * block->u.localvar->x0->extParam->x4; } } if (value2 < value1) { LocationSet *saveloc; LocationSetSet *savelocs; saveloc = pointsToFunc->pte->loc; savelocs = pointsToFunc->pte->locs; pointsToFunc->pte->loc = scan->pte->loc; pointsToFunc->pte->locs = scan->pte->locs; scan->pte->loc = saveloc; scan->pte->locs = savelocs; } } pointsToFunc = pointsToFunc->otherPtes; } } inline Boolean PointsToFunctions_Equal(PointsToFunction *pointsToFunc1, PointsToFunction *pointsToFunc2) { PointsToFunction *scan; PointsToEntry *pte; #line 3968 IRO_ASSERT(pointsToFunc1 != NULL); IRO_ASSERT(pointsToFunc2 != NULL); if (pointsToFunc1 == pointsToFunc2) return 1; for (scan = pointsToFunc1; scan && scan->pte; scan = scan->otherPtes) { pte = PointsToFunction_FindByLocationSet(pointsToFunc2, scan->pte->loc); if (!pte || !PointsToEntries_Equal(pte, scan->pte)) return 0; } for (scan = pointsToFunc2; scan && scan->pte; scan = scan->otherPtes) { pte = PointsToFunction_FindByLocationSet(pointsToFunc1, scan->pte->loc); if (!pte || !PointsToEntries_Equal(pte, scan->pte)) return 0; } return 1; } inline Boolean PointsToFunctions_Match(PointsToFunction *pointsToFunc1, PointsToFunction *pointsToFunc2) { return 1; } inline PartialTransferFunction *PartialTransferFunction_New() { PartialTransferFunction *ptf = IRO_malloc(sizeof(PartialTransferFunction)); #line 4110 IRO_ASSERT(ptf != NULL); #ifdef IRO_DEBUG ptf->initialPointsToFn = NULL; ptf->finalPointsToFn = NULL; ptf->funcModifies = NULL; ptf->context.nd = NULL; ptf->context.ptf = NULL; ptf->returnLocation = NULL; #endif return ptf; } inline void PartialTransferFunction_Delete(PartialTransferFunction *ptf) { #line 4126 IRO_ASSERT(ptf != NULL); IRO_ASSERT(ptf->initialPointsToFn == NULL); IRO_ASSERT(ptf->finalPointsToFn == NULL); IRO_ASSERT(ptf->funcModifies == NULL); IRO_ASSERT(ptf->context.nd == NULL); IRO_ASSERT(ptf->context.ptf == NULL); IRO_ASSERT(ptf->returnLocation == NULL); IRO_DEBUG_CLEAR(ptf, sizeof(PartialTransferFunction)); IRO_free(ptf); } inline void PartialTransferFunction_Init(PartialTransferFunction *ptf, IROLinear *contextNd, PartialTransferFunction *contextPTF) { #line 4142 IRO_ASSERT(ptf != NULL); IRO_ASSERT(contextNd != NULL); IRO_ASSERT(contextPTF != NULL); ptf->initialPointsToFn = PointsToFunction_New(); PointsToFunction_Init(ptf->initialPointsToFn); ptf->finalPointsToFn = PointsToFunction_New(); PointsToFunction_Init(ptf->finalPointsToFn); ptf->funcModifies = LocationSetSet_New(); LocationSetSet_Init(ptf->funcModifies); LocationSetSet_AddUnknown(ptf->funcModifies, NULL, NULL, NULL); ptf->returnLocation = NULL; ptf->x10 = 0; ptf->context.nd = contextNd; ptf->context.ptf = contextPTF; } inline void PartialTransferFunction_Copy(PartialTransferFunction *dest, PartialTransferFunction *src) { #line 4164 IRO_ASSERT(src != NULL); IRO_ASSERT(dest != NULL); dest->initialPointsToFn = PointsToFunction_New(); PointsToFunction_Copy(dest->initialPointsToFn, src->initialPointsToFn); dest->finalPointsToFn = PointsToFunction_New(); PointsToFunction_Copy(dest->finalPointsToFn, src->finalPointsToFn); dest->funcModifies = LocationSetSet_New(); LocationSetSet_Copy(dest->funcModifies, src->funcModifies); if (src->returnLocation) { dest->returnLocation = LocationSet_New(); LocationSet_Copy(dest->returnLocation, src->returnLocation); } else { dest->returnLocation = NULL; } dest->x10 = src->x10; dest->context = src->context; } inline void PartialTransferFunction_Term(PartialTransferFunction *ptf) { #line 4190 IRO_ASSERT(ptf != NULL); PointsToFunction_Term(ptf->initialPointsToFn); PointsToFunction_Delete(ptf->initialPointsToFn); PointsToFunction_Term(ptf->finalPointsToFn); PointsToFunction_Delete(ptf->finalPointsToFn); LocationSetSet_Term(ptf->funcModifies); LocationSetSet_Delete(ptf->funcModifies); if (ptf->returnLocation) { PAMemoryBlock_Term(ptf->returnLocation->block); PAMemoryBlock_Delete(ptf->returnLocation->block); LocationSet_Term(ptf->returnLocation); LocationSet_Delete(ptf->returnLocation); ptf->returnLocation = NULL; } #ifdef IRO_DEBUG ptf->initialPointsToFn = NULL; ptf->finalPointsToFn = NULL; ptf->funcModifies = NULL; ptf->context.nd = NULL; ptf->context.ptf = NULL; #endif } inline PointsToFunction *PartialTransferFunction_initialPointsToFn(PartialTransferFunction *ptf) { #line 4221 IRO_ASSERT(ptf != NULL); return ptf->initialPointsToFn; } inline PointsToFunction *PartialTransferFunction_finalPointsToFn(PartialTransferFunction *ptf) { #line 4227 IRO_ASSERT(ptf != NULL); return ptf->finalPointsToFn; } inline LocationSetSet *PTF_sub_48D750(PartialTransferFunction *ptf) { #line 4233 IRO_ASSERT(ptf != NULL); return ptf->funcModifies; } inline LocationSet *PartialTransferFunction_returnLocation(PartialTransferFunction *ptf) { #line 4249 IRO_ASSERT(ptf != NULL); if (!ptf->returnLocation) { PAMemoryBlock *block; LocationSet *ls; block = PAMemoryBlock_New(); PAMemoryBlock_Init(block, PAMEMORYBLOCKKIND_LOCALVAR, NULL); ls = LocationSet_New(); LocationSet_InitKnown(ls, block, cint64_zero, 0, TYPE(&void_ptr)); ptf->returnLocation = ls; } return ptf->returnLocation; } inline IROLinear *PTF_sub_48B980(PartialTransferFunction *ptf) { #line 4265 IRO_ASSERT(ptf != NULL); return ptf->context.nd; } inline PartialTransferFunction *PTF_sub_48B970(PartialTransferFunction *ptf) { #line 4271 IRO_ASSERT(ptf != NULL); return ptf->context.ptf; } inline void PartialTransferFunction_sub_48A610(PartialTransferFunction *ptf, Boolean value) { #line 4298 IRO_ASSERT(ptf != NULL); ptf->x10 = (value != 0) ? 1 : 0; } inline PTFList *PTFList_New(void) { PTFList *ptfList = IRO_malloc(sizeof(PTFList)); #line 4393 IRO_ASSERT(ptfList != NULL); #ifdef IRO_DEBUG ptfList->ptf = NULL; ptfList->otherPTFs = NULL; #endif return ptfList; } inline void PTFList_Delete(PTFList *ptfList) { #line 4405 IRO_ASSERT(ptfList != NULL); IRO_ASSERT(ptfList->ptf == NULL); IRO_ASSERT(ptfList->otherPTFs == NULL); IRO_DEBUG_CLEAR(ptfList, sizeof(PTFList)); IRO_free(ptfList); } inline void PTFList_Init(PTFList *ptfList) { #line 4417 IRO_ASSERT(ptfList != NULL); ptfList->ptf = NULL; ptfList->otherPTFs = NULL; } inline void PTFList_Term(PTFList *ptfList) { #line 4435 IRO_ASSERT(ptfList != NULL); PTFList_RemoveAll(ptfList); #ifdef IRO_DEBUG ptfList->ptf = NULL; ptfList->otherPTFs = NULL; #endif } inline void PTFList_ForEach(PTFList *ptfList, void (*action)(PartialTransferFunction *, void *), void *refcon) { #line 4478 IRO_ASSERT(ptfList != NULL); IRO_ASSERT(action != NULL); IRO_ASSERT(refcon == NULL || refcon != NULL); while (ptfList && ptfList->ptf) { action(ptfList->ptf, refcon); ptfList = ptfList->otherPTFs; } } inline PartialTransferFunction *PTFList_sub_48A0F0(PTFList *ptfList, PartialTransferFunction *ptf) { #line 4490 IRO_ASSERT(ptfList != NULL); IRO_ASSERT(ptf != NULL); while (ptfList && ptfList->ptf) { if (ptfList->ptf == ptf) return ptfList->ptf; ptfList = ptfList->otherPTFs; } return NULL; } inline PartialTransferFunction *PTFList_FindFirst(PTFList *ptfList) { #line 4502 IRO_ASSERT(ptfList != NULL); return ptfList->ptf; } inline void PTFList_sub_48A080(PTFList *ptfList, PartialTransferFunction *ptf) { #line 4511 IRO_ASSERT(ptfList != NULL); IRO_ASSERT(ptf != NULL); if (ptfList->ptf) { PTFList *newList = PTFList_New(); PTFList_Init(newList); newList->ptf = ptfList->ptf; newList->otherPTFs = ptfList->otherPTFs; ptfList->otherPTFs = newList; } ptfList->ptf = ptf; } inline void PTFList_sub_48A050(PTFList *ptfList, PartialTransferFunction *ptf) { #line 4529 IRO_ASSERT(ptfList != NULL); IRO_ASSERT(ptf != NULL); if (!PTFList_sub_48A0F0(ptfList, ptf)) PTFList_sub_48A080(ptfList, ptf); } inline void PTFList_Remove(PTFList *ptfList, PartialTransferFunction *ptf) { PTFList *prev; PTFList *tmp; #line 4542 IRO_ASSERT(ptfList != NULL); IRO_ASSERT(ptf != NULL); prev = NULL; while (ptfList && ptfList->ptf) { if (ptfList->ptf == ptf) { if (!prev) { if (ptfList->otherPTFs == NULL) { ptfList->ptf = NULL; } else { tmp = ptfList->otherPTFs; ptfList->ptf = ptfList->otherPTFs->ptf; ptfList->otherPTFs = ptfList->otherPTFs->otherPTFs; tmp->ptf = NULL; tmp->otherPTFs = NULL; PTFList_Term(tmp); PTFList_Delete(tmp); } } else { prev->otherPTFs = ptfList->otherPTFs; ptfList->ptf = NULL; ptfList->otherPTFs = NULL; PTFList_Term(ptfList); PTFList_Delete(ptfList); } return; } prev = ptfList; ptfList = ptfList->otherPTFs; } } inline void PTFList_RemoveAll(PTFList *ptfList) { #line 4582 IRO_ASSERT(ptfList != NULL); while (ptfList && ptfList->ptf) PTFList_Remove(ptfList, ptfList->ptf); }