path: root/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c

#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);
}